集合

集合

注意：

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

Array和ArrayBuffer

Array

1. 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 

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

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

    List和ListBuffer

List

1. 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}") 

2. 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

1.  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

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

Set

1. 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

1. 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

1. 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

1. 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

元祖

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

二元组

1. 定义：元组中的元素个数为2（key——value对就是二元组）
2. 二元组特有的创建方法：val tup = "hadoop"->88
3. 二元组就是Key/Value对，所以Map集合中元素的数据类型就是二元组

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

   集合的合并和拉链操作

集合的合并

1. 集合的合并：将两个集合进行合成元素为二元组的新集合，可以实现list和Map之间的转换
2. zip :可以将两个集合中下标对应的元素组成一个元组，然后组成一个新的集合
3. 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

集合的拉链

1. 集合的拉链操作：将单个的集合转变成元素为二元组的集合，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对象的相互转换

1. scala中可以直接调用java中的类，得到java对象，使用可以使用对应的方法(语法为scala的语法)
2. 作用：相互转换之后，不同的实例可以调用不同的方法。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)