scala系列3-集合

概述: scala同时支持不可变集合和可变集合，不可变集合可以安全的并发访问

   两个主要的包: 不可变集合: scala.collection.immutable
    		   可变集合:    scala.collection.mutable

​

1. 定义数组

   var arr1 = new Array[String](3)
   arr1(0) = "zhangsan"
   arr1(1) = "lis"
   arr1(2) = "wangwu"    
   
   var arr2 = Array(1,2,3)   //省略new，底层通过伴生对象的apply方法构建Array对象
   

2. 获取元素

   //根据下标获取
   arr1(0)
   
   //遍历
   for (elem <- arr1) {
       println(elem)
   }
   
   //求数组长度
   arr1.length  // 或者 arr1.size 
   

1. 定义数组

   var arrayBuffer = new ArrayBuffer[Int]()
   

2. 增删改元素

   //添加元素
   arrayBuffer += 1
   arrayBuffer.append(2)
   //修改元素  根据下标修改指定位置元素
   arrayBuffer(1) = 5
   //删除元素  根据下标删除指定位置元素
   arrayBuffer.remove(1)
   

3. 获取元素

   //根据下标获取
   arrayBuffer(0)
   
   //遍历
   for (elem <- arrayBuffer) {
       println(elem)
    }
   

4. 小结

   arr1.toBuffer   //定长数组转可变数组
   arr2.toArray    //可变数组转定长数组
   
   注意：arr1.toBuffer 返回结果才是一个可变数组，arr1本身没有变化
        arr2.toArray  返回结果才是一个定长数组，arr2本身没有变化
   

​ 介绍：元组也是可以理解为一个容器，可以存放各种相同或不同类型的数据

1. 构建元组对象

   val t1 = ("zhangsan",12,"lisi",11.2)
   

   元组是不可变的，最多可以存储22个元素

2. 访问元组中的元素

   println(t1._1)    //输出：zhangsan
   println(t1._2)    //输出：12
   

3. 遍历元组

   for (elem <- t1.productIterator) {
         println(elem)
   }
   

​ 介绍：Scala中的List和Java List不一样，在Java中List是一个接口，真正存放数据是ArrayList,而Scala的List可以直接存方数据。默认情况下scala的List是不可变的，List属于序列Seq。

1. 构建List对象

   val list1 = List(1,2,3,4)   
   
   val list1 = Nil    //空集合  空null
   

2. 访问List中元素

   //根据下标获取
   list1(0)
   

3. 添加

   向列表中增加元素，会返回新的列表/集合对象。

   注意：scala中List元素追加形式非常独特，和Java不一样

   //通过 :+ 和 +: 给list追加元素(本身list集合并没有变化)
   val list2: List[Int] = list1:+10
   println(list2)     //输出结果: List(1, 2, 3, 4, 10)
   
   val list3: List[Int] = 20+:list1
   println(list3)    //输出结果: List(20, 1, 2, 3, 4)
   
   //符号::表示向集合(新建)中添加元素
   //运算时,集合对象一定要放置在最右边，且运算规则是，从右至左
   //:::运算符是将集合中的每一个元素加入到集合中去
   val list1 = List(1,2,3,4)
   var list5 = 6::7::list1::Nil
   //分析过程
   //1). List()  2). List(List(1,2,3,4)) 
   //3). List(7,List(1,2,3,4))  4). List(6,7,List(1,2,3,4)) 
   println(list5)			//输出结果: List(6, 7, List(1, 2, 3, 4))
   
   var list6= 6::7::list1:::Nil
   println(list6)			//输出结果: List(6, 7, 1, 2, 3, 4)
   

​ 介绍：ListBuffer是可变的list集合，可以添加，删除元素，ListBuffer属于序列

1. 创建ListBuffer对象

   var listBuffer = ListBuffer[Int](1,2,3)
   或者
   var listBuffer = new ListBuffer[Int]
   

2. 增删元素

   //向集合中添加一个元素
   var listBuffer2 = new ListBuffer[Int]()
   listBuffer2 += 4
   listBuffer2.append(5)
   println(listBuffer2)			//输出结果: ListBuffer(4, 5)
   
   //向集合中添加另外一个集合
   var listBuffer = ListBuffer[Int](1,2,3)
   listBuffer ++= listBuffer2
   println(listBuffer)			    // 输出结果：ListBuffer(1, 2, 3, 4, 5)
   
   //根据下标移除数据
   var listBuffer = ListBuffer[Int](1,2,3)
   listBuffer.remove(0)
   println(listBuffer)			    // 输出结果：ListBuffer(2, 3)
   
   //根据下边修改数据
   var listBuffer = ListBuffer[Int](1,2,3)
   listBuffer(0) = 10
   println(listBuffer)			    // 输出结果 ListBuffer(10, 2, 3)	
   

3. 访问ListBuffer中的元素

   //根据下标获取指定位置的元素
   listBuffer(0)  
   
   //遍历
   var listBuffer = ListBuffer[Int](1,2,3)
   for (elem <- listBuffer) {
         println(elem)
   }
   

​ 介绍：scala中的Map和java类似，也是一个散列表，它存储的内容也是键值对(k-v)映射,scala
​ 中不可变的Map是有序的，可变的Map是无序的

​ Scala中有可变的Map(scala.collection.mutable.Map)

​ 不可变Map(scala.collection.immutable.Map)

1. 构建Map对象，map中存储的元素本质是一个tuple

   val map1 = Map("a1"->"zhangsan","a2"->"lisi")   	   //不可变
   println(map1)
   
   val map2 = mutable.Map("a1"->"zhangsan","a2"->"lisi")   //可变
   println(map2)
   
   val map3 = new mutable.HashMap[String,String]()         //创建空的Map
   

2. 添加 & 修改

   val map2 = mutable.Map("a1"->"zhangsan","a2"->"lisi")
   //key不存在，执行添加。否则是修改
   map2("a3") = "wangwu"
   map2.put("a4","zhaoliu")
   

3. 取值

   //创建一个map
   val map2 = mutable.Map("a1"->"zhangsan","a2"->"lisi")
   
   ①. map("key")
   作用：如果key存在，则返回对应的值
        如果key不存在,则抛出异常[java.util.NoSuchElementException]
   	注意:在java中，如果key不存在则返回null
   例如：map2("a1")   输出:zhangsan
        map2("x1")   抛出异常
   
   ②. map.get("key")
   作用：map集合中的get方法会返回Option对象,如果key存在是Some，否则是None
   例如：map2.get("a1")   输出:Some(zhangsan)
        map2.get("x1")   输出:None
   
   ③. map.get("key").getOrElse([默认值])
   作用：如果是Some，getOrElse可以返回key对应的value，否则返回默认值
        如果getOrElase没有给定默认值，则返回() (()是Unit的唯一实例)
   例如：map2.get("a1").getOrElse（）   输出:zhangsan
        map2.get("x1").getOrElse（）   输出:()
        map2.get("x1").getOrElse（null）   输出:null
   简写：map2.getOrElse("key",null)
   
   ④. map.contains("key")
   作用： 判断key是否存在，存在返回true，否则返回false
   
   使用技巧：如果我们确定map有这个key，应当使用map(key)
           如果不能确定，则先使用map.contains(key)判断
           如果只是期望获取一个值，可以使用map.getOrElse(key,默认值)
   

4. 删除

   方式1：map -= (key,key)   // -= 这种形式可以一次删除多个key-value
   
   方式2：map.remove(key)
   
   注意： 如果key存在则删除，不存在也不会报错
   

5. 遍历

   键值对遍历
   方式1：k,v是两个变量，接收map遍历获取的key-value
   for ((k,v) <- map) {
         println(k +"t" + v)
   }
   方式2：elem获取map遍历出的元祖，elem可以通过操作元祖的形式获取key-value
   for (elem <- map) {
       println(elem._1 + "t" + elem._2)
   }
   
   键遍历
   for (elem <- map.keys) {
         println(elem)
   }
   
   值遍历
   for (elem <- map.values) {
         println(elem)
   }
   

​ 介绍：Set存储的元素不允许重复，且不保留顺序，默认是以哈希Set实现

1. 构建Set对象

   import scala.collection.mutable
   
   val set1 = Set(1,3,2)             //不可变
   
   val set2 = mutable.Set(1,3,2)     //可变
   

2. 向集合中添加、删除元素

   //三种向集合添加元素的方式
   val set2 = mutable.Set(1,2,3)     //可变
   set2.add(4)
   set2 += 5
   set2.+=(6)
   
   //两种从集合中移出元素的方式
   set2 -= 2
   set2.remove(3)
   

3. 集合遍历

   for (elem <- set2) {
         println(elem)
   }