集合

注意：

这里说的集合是包括集合和数组（Array,List,Map,Set）
所有的集合类都继承与Iteratble[T]
可变的集合和对应的类库：scala.collection.mutable.Set/Map/ArrayBuffer/ListBuffer
可变的集合和对应的类库：scala.collection.immutable./Set/Map/List (scala.Array)
对于Set和Map集合，因为可变的和不可变的名称都是相同的，而scala中默认是表示不可变的，所以要表示可变的时候加上包名mutable:mutable.Set[Int]()

Array和ArrayBuffer

Array

array创建方式一：通过new的方式创建，指定数组的数据类型和长度（如果数据类型不是固定的用Any）

    val arr2 = new Array[Int](5)
 // arr2: Array[Int] = Array(0, 0, 0, 0, 0)   默认值为0
    // 依据下标索引进行赋值
    arr2(1) = 100
    arr2(3) = 50

　　 2.array创建的方式二：通过指定值的方式创建，创建方式在Scala语言中很常见，底层是通过new创建类的实例对象

    val arr: Array[Int] = Array(1, 2, 3, 4, 5, 6)
    // 获取数组中元素，使用下标的方式获取，从0开始
    println(s"First Element = ${arr(0)}")
    println(s"Length = ${arr.length}, Size = ${arr.size}")
    // 修改数组中某个下标元素的值
    arr(4) = 100
    // 循环遍历数组中元素
    for(item <- arr) println(item)
    arr.foreach(item => println(item))

ArrayBuffer

ArrayBuffer的创建：是通过new的方式创建

 1  val buffer = new ArrayBuffer[Int]()
 2     // 向可变的数组中加入元素
 3     buffer += 2
 4     buffer += 120
 5     // 可以向可变数组中加入多个元素，比如list或不可变数组
 6     buffer ++= Array(44, 55, 66)
 7     /**
 8       * 在实际的开发中，如果对可变数组中的数据进行操作，建议将可变数组转化为不可变数组
 9       */
10     val array = buffer.toArray
11     // 将数组中元素合为一个字符串，指定各个元素之间的分隔符
12     array.mkString(",")
13     array.mkString("< ", ", ", " >")

List和ListBuffer

List

List集合的创建方式一：通过指定值的方式创建

// 创建不可变的列表List
    val list = List(1, 2, 3, 4, 5, 6, 7, 8)
         // List 的组成：head(list的第一个元素)+tail(是一个List，除了头部元素以外的其他元素组成的List集合)   
    println(s"head: ${list.head}")
    println(s"tail: ${list.tail}")
    // TODO: 如果List只有一个元素，head为元素 tail为空集合List()/Nil（空的List集合，可使用 Nil 表示）
    val list2 = List(1000)
    println(s"head: ${list2.head}")
    println(s"tail: ${list2.tail}")

List集合的创建方式二：使用尾部添加头部的方式创建，使用方法.::()或者简写成：：

  // TODO ->    1 :: List(2, 3) = List(2, 3).::(1) = List(1, 2, 3)
  //注意：.::和::都是 list集合的方法，不过::运算符从右往左运算，.::运算符从左往右运算
    val list3: List[Int] = 2 :: 1 :: Nil  // 此运算从右向左
    // 将list中元素转化为字符串
    println(list3.mkString(", "))

ListBuffer

ListBuffer的创建方式：底层还是通过new的方式创建的

 // 创建ListBuffer实例对象
    val listBuffer = ListBuffer[Int]()
    // 向可变的ListBuffer中添加元素
    listBuffer += 1
    listBuffer += 2
    listBuffer ++= List(3, 4, 5)
    listBuffer += (6, 7, 8)
    // 同样，如果对可变的list集合进行操作，建议将其转换为不可变的list列表
    val list5 = listBuffer.toList
    println(list5.mkString("<", ", ", ">"))
    // 判断列表是否为空
    println(list5.isEmpty)
    // 判断某个元素是否在列表中
    println(list5.contains(9))

Set和mutable.Set

存放的数据：唯一无序，可以用来去重
set的可变与不可以变的名称相同，默认的不可变的集合，要用可变的集合需要在前面加上包名mutable

Set

Set集合的创建方式：

 // 创建不可变的Set集合
    val set: Set[Int] = Set(1, 1, 1, 1, 4, 3, -4, -10, 8, 2, 2) // 会进行去重得到set: Set[Int] = Set(1, -4, 2, -10, 3, 8, 4)
    println(set.mkString("|"))
    println(s"max = ${set.max}")
    println(s"min = ${set.min}")

mutable.Set

mutable.Set集合的创建方式：

    val set2 = mutable.Set[Int]()
    // 添加元素
    set2 += 1
    set2 ++= Set(2, 3, 4) // 不可变的Set
    set2 ++= List(5, 6, 7)
    //将可变的Set集合转换为不可变的Set集合
    set2.toSet.foreach(println(_))
    // 将Set转换为List
    set2.toList.foreach(println)

Map和mutable.Map

集合中的元素就是一个Key-value对也就是一个二元组

Map

Map集合的创建方式：通过指点值的方式创建

    //TODO 1.Create immutable map
    // 指点元素为key-value对
    val map1 = Map("key" -> "value","name"->123)
    // 指点元素为二元组
    val map2 = Map(("key","value"),("age",12),("",3))
    
    //TODO 2. 获取集合中的元素
//    map(key) ： 不推荐使用，当且仅当key存在，不存在就会报错
//    map.get(key)： 返回值两种类型：如果key存在就返回Some(value); 如果key不存在就返None，不会报错
//    map.getOrElse(key, dafualeValue)： 建议使用此种方式

    println(map1.get("weigh"))
    println(map1.getOrElse("weigh","不存在该key"))
    println(map1("weigh"))

mutable.Map

mutable.Map的创建方式：

   //创建可变的集合：
    val map3 = mutable.Map[String, Int] ()
    val mapbuffer = mutable.Map[Any,Any]()
    // 添加一个元素
    mapbuffer += 1->2
    val touple= (2,3)
    mapbuffer += touple
    // 添加多个元素
    mapbuffer ++= Map((3,4),(5,6))
    //将可变的Map转换为不可变的Map
     val map4 = map3.toMap

元祖

元组的定义：用()将数据括起来就是元祖，和Python中的元祖类似　　　　val tuple= (1001, 45.34, "Spark")
元组中元素的获取：第N个元素：tuple._N(第一个元素的下标是1) 　　val first = tuple._1
元组的数据类型可以是任意的，当然可以是元组，此时元组的嵌套
元组个数:元组中最多有22个元素
每个元组对应于一个类:一元组 -> Tuple1, 二元组 -> Tuple2,三元组 -> Tuple3,......二十二元组 -> Tupl22

二元组

定义：元组中的元素个数为2（key——value对就是二元组）
二元组特有的创建方法：val tup = "hadoop"->88

二元组就是Key/Value对，所以Map集合中元素的数据类型就是二元组

//    swap: 针对二元组仅有的方法，将key和value进行互换
    val tu1 = ("name","king")
    println(tu1.swap) 
//    2. 二元组特有的创建方法：
    val tup = "hadoop"->88

集合的合并和拉链操作

集合的合并

集合的合并：将两个集合进行合成元素为二元组的新集合，可以实现list和Map之间的转换
zip :可以将两个集合中下标对应的元素组成一个元组，然后组成一个新的集合

unzip: 将元素为二元组的集合分解成为两个集合，其中一个集合的值为key，另一个集合的值为value

  val list1 = List(1, 2, 3, 4, 5)
    val list2 = List("A", "B", "C", "D", "E")
    val zipList: List[(Int, String)] = list1.zip(list2)
    // 可以将一个List[(Key, Value)]拆分为两个List
    val (keys, values) = zipList.unzip
    val map = Map(11 -> "A", 22 -> "BB", 33 -> "CC")
    val map1 = map.unzip

集合的拉链

集合的拉链操作：将单个的集合转变成元素为二元组的集合，key为原先集合的值，value为原先集合的下标

 val lt = List("AA", "BB", "CC", "DD", "EE")
  val zipIndexList: List[(String, Int)] = lt.zipWithIndex
　// List((AA,0), (BB,1), (CC,2), (DD,3), (EE,4))
  println(zipIndexList)

Java对象和Scala对象的相互转换

scala中可以直接调用java中的类，得到java对象，使用可以使用对应的方法(语法为scala的语法)

作用：相互转换之后，不同的实例可以调用不同的方法。scala对象转换为java对象可以使用java方法

  //  导入对应的包：import java.unit
    import java.util
    //  创建对应的实例对象：
    val hashMap = new util.HashMap[String, Int]()
    //   调用对应的方法：
    hashMap.put("spark", 1244)
    // TODO：将Java中HashMap集合转换为Scala中Map集合实例对象
    //  导入对应的包:import scala.collection.JavaConverters._
    import scala.collection.JavaConverters._
    import scala.collection._
    //  将Java中HashMap集合转换为Scala中Map集合实例对象：调用asScala方法
    val map1:mutable.Map[String, Int] = hashMap.asScala
    map1.foreach(println(_))
    // TODO: 将Scala中列表转换为Java中列表
    val list: List[String] = List("aa", "bb", "cc", "dd")
    // 用于需要导入
    // import scala.collection.JavaConverters._
    // 将Scala中Map集合转换为Java中HashMap集合实例对象：asJava
    val lst: util.List[String] = list.asJava
    println(lst)