Scala——定义使用元组，Map，并将Java数据类型转换为Scala数据类型

元组的定义与使用

object TupleDemo {
  def main(args: Array[String]): Unit = {
    val arr: Array[Any] = Array(10,9.85,"hadoop")
    val first = arr(0)
    //转换数据类型
    val intValue = first.asInstanceOf[Int]
    println(intValue)

    //元组
    val tuple3 = (10,9.85,"hadoop")//3个元素，3元组
    println(s"first=${tuple3._1},Second=${tuple3._2}")

    //二元组 -》（key,value）
    val tuple2: (Int, Double) = (1,2.0)
    println(s"key=${tuple2._1},Value=${tuple2._2}")

    //元组可以嵌套
    val xx: (Int, (String, Int)) = (1,("xxpppp",900))
    println(s"${xx._2._1}")

    //swap:key和Value交换
    val  t2: (Double, Int) = tuple2.swap

    //创建二元组的第二种方式
    val tup: (String, String) = "name"->"zhangsan" //隐形转换
  }
}

Map的定义与使用

package com.huadian.bigdata.collection

/**
  * Scala中Map集合的基本使用
  *   Map集合中数据类型 就是 二元组/key-value对
  */
object MapDemo {
  def main(args: Array[String]): Unit = {
    //创建一个不可变的map
    val map1: Map[String, Any] = Map("name"->"zhangsan","age"->18)

    //创建一个不可变Map 第二种方式
    val map2: Map[String, String] = Map(("name","zhagnsan"),("age","18"))

    //将Map集合转成列表List
    val list: List[(String, String)] = map2.toList
    println( list.mkString(","))

    //获取Map中元素
    //方式一：map(key)
    println(s"name->${map1("name")}")

    //方式一：map.get(key)
    val name = map1.get("name1") //Option
    println(s"name->$name")

    //方式三：
    val name2 = map1.getOrElse("name1","xxxx")
    println(s"name->$name2")

    //遍历Map的元素
    for( (key,value) <- map1 ){
      println(s"$key -> $value")
    }
    println("===============================")
//    map1.foreach((x)=>{
//      println(s"${x._1} -> ${x._2}")
//    })
    map1.foreach(x=>println(s"${x._1} -> ${x._2}"))

    //只需要遍历Key
    for( (key,_) <- map1 ){
      println(s"$key ")
    }
    for( (_,value) <- map1 ){
      println(s"$value ")
    }

    println("==========可变集合============")
    import scala.collection.mutable

    val map3: mutable.Map[String, Int] = mutable.Map[String,Int]()
    map3 += "A" ->1
    map3 ++= Map("B"->2,"C"->3)

    //转换为不可变的Map
    val map4 = map3.toMap
    map4.foreach(println)

    //map中是否 存在元素 满足p函数
    //返回一个布尔类型，是否存在
    val isExists = map4.exists(tuple2=>tuple2._2 %2==0)


  }
}

Java数据类型转换为Scala数据类型

import java.util

import scala.collection.mutable

object ConvertorScalaDemo {
  def main(args: Array[String]): Unit = {
    //定义Java中Map实例对象
    val hashMap: util.HashMap[String, Int] = new util.HashMap[String,Int]()
    hashMap.put("spark",1)
    hashMap.put("hadoop",11)
    hashMap.put("java",111)


    //导包,让自动转换，
    import scala.collection.JavaConverters._
    val map: mutable.Map[String, Int] = hashMap.asScala
    map.foreach(tuple => println(s"${tuple._1} -> ${tuple._2}"))


  }
}