Scala---集合(数组，Map，元组（Tuple），Zip拉链）详解

scala的集合分为了两类，一类是可变的集合（集合可以执行增删改查操作），另一类是不可变集合（集合元素在初始化的时候确定，后续只能进行查，有的可以进行修改，有的不可以）。二者可能名称一样，但是在不同的包下面，对应的包为：scala.collection.mutable和scala.collection.immutable。scala默认使用的集合，或者默认导入的包是immutable。（说明：这里提到的可变或者不可变，指的是容器内部的内容 ，以及容器的长度可变或者不可变。）

一、数组

1、不可变数组Array

	//第一种方式
    val array = new Array[Int](5)//数字就是数组的个数
    
    //赋值
     array(1)=10
     println(array.toBuffer)//ArrayBuffer(0, 10, 0, 0, 0)

     //删除
     //调用drop，原数组保持不变，返回一个新的数组
     //drop从左往右删除n个
     val arr1 = array.drop(3)
     println(arr1.toBuffer) //ArrayBuffer(0, 0)
     println(array.toBuffer) //ArrayBuffer(0, 10, 0, 0, 0)

	//toBuffer方法可以将数组变成数组缓冲，在Scala中，Buffer是可变的，而Array是不可变的。这就是为什么我们需要使用toBuffer方法来转换Array为Buffer的原因
    val buffer=array.toBuffer
    buffer+=6
    println(buffer)//ArrayBuffer(0, 10, 0, 0, 0, 6)
    
     //查看数组长度
     println(array.length)
     println(array.size)

     //判断数组当中是否包含某个元素
     println(array.contains(10))

     //创建定长数组的第二种方法
     //调用apply方法进行创建
     val arr2 = Array[Int](5,2)//数字就是数组的元素
     println(arr2.toBuffer)//ArrayBuffer(5, 2)
     println(arr2(0))//5

     //第三种创建方式
     val array3 = Array(1,3,4,"rr")

     //数组的拼接
     val array4 = Array(1,3,4,"rr")
     //mkString
     println(array4.mkString) //134rr
     println(array4.mkString("*")) //1*3*4*rr
     println(array4.mkString("[", "-", "]"))  //[1-3-4-rr]

2、可变数组ArrayBuffer

    //变长数组的创建
    //第一种方式
    val arr=new ArrayBuffer[Int]()

    //增加元素
    arr.append(1,2,3)
    println(arr)//ArrayBuffer(1, 2, 3)

    //在指定位置添加元素
    arr.insert(2,6,7)
    println(arr)//ArrayBuffer(1, 2, 6, 7, 3)

    //删除指定位置元素
    arr.remove(2)
    println(arr)//ArrayBuffer(1, 2, 7, 3)
    
    //drop删除n个元素后返回一个新数组
    val arr1 = arr.drop(4)
    println(arr1)//ArrayBuffer()

    //删除指定位置多个元素
    arr.remove(1,3)
    println(arr)//ArrayBuffer(1)

    //改元素
    arr(0)=2
    println(arr)//ArrayBuffer(2)

    //第二种创建方式
    val arr2 = ArrayBuffer[Int](1,2,3,4)
    println(arr2)//ArrayBuffer(1, 2, 3, 4)

    //第三种创建方式
    val arr3 = ArrayBuffer(1,"ff")
    arr3.append(2,"df")
    println(arr3)//ArrayBuffer(1, ff, 2, df)

    //判断数组当中是否包含某个元素
    println(arr3.contains(9))

    //查看数组的长度
    println(arr3.size)
    println(arr3.length)

    //拼接
    println(arr3.mkString)
    println(arr3.mkString("-"))
    println(arr3.mkString("[", "=", "]"))

3、定长数组与变长数组相互转换

	//定长数组转换成变长数组
    val arr = Array(1,2,3,4)
    val buffer = arr.toBuffer
    println(buffer)

    //添加元素
    buffer.append(6,7,8)
    println(buffer)//ArrayBuffer(1, 2, 3, 4, 6, 7, 8)

    //删除元素
    buffer.remove(3)
    println(buffer)//ArrayBuffer(1, 2, 3, 6, 7, 8)

    //将变长数组转换成定长数组
    val arr1=buffer.toArray

4、数组遍历

	val arr=Array(1,2,3,4,5)
    //遍历第一种方式
    for(i<-arr){
      println(i)
    }

    //第二种遍历方式
    for(i<- 0 to arr.length-1){
      println(arr(i))
    }

    //第三种遍历方式
    for(i<- Range(0,arr.length)){
      println(arr(i))
    }

	//第四种
    for(i<- 0 until(arr.length)){
      println(arr(i))
    }

    //scala当中的遍历
    arr.foreach((x:Int)=>println(x))
    //进行简化
    arr.foreach(x=>println(x))
    arr.foreach(println(_))
    arr.foreach(println)
  }

5、数组的常用函数

val arr = Array(1,2,3,4,5,0,8,6,9,7)
    //求数组的和
    println(arr.sum)//45

    //求数组当中的最大值
    println(arr.max)//9

    //求数组中的最小值
    println(arr.min)//0

    //正序输出
    println(arr.sorted.toBuffer)//ArrayBuffer(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

    //倒序输出
    println(arr.sorted.reverse.toBuffer)//ArrayBuffer(9, 8, 7, 6, 5, 4, 3, 2, 1, 0)

    //从左侧开始删除n个元素
    println(arr.drop(3).toBuffer)//ArrayBuffer(4, 5, 0, 8, 6, 9, 7)

    //从右侧开始删除n个元素
    println(arr.dropRight(4).toBuffer)//ArrayBuffer(1, 2, 3, 4, 5, 0)

    //从左侧开始删除到第一个不满足条件的元素后面就不再判断
    println(arr.dropWhile(x => x < 5).toBuffer)//ArrayBuffer(5, 0, 8, 6, 9, 7)

    //获取数组当中前n个元素
    println(arr.take(6).toBuffer)//ArrayBuffer(1, 2, 3, 4, 5, 0)

    //获取数组当中后n个元素
    println(arr.takeRight(4).toBuffer)//ArrayBuffer(8, 6, 9, 7)

    //从左往右获取元素，遇到第一个不符合条件的就断开
    println(arr.takeWhile(x => x < 5).toBuffer)//ArrayBuffer(1, 2, 3, 4)

    //获取数组当中的头部元素
    println(arr.head)//1

    //获取尾部元素
    println(arr.last)//7

    //获取数组当中的尾部元素，除了第一个其他都是尾部元素
    println(arr.tail.toBuffer)//ArrayBuffer(2, 3, 4, 5, 0, 8, 6, 9, 7)

二、Map

k-v键值对的集合，k不能重复

1、不可变Map

	//创建map集合
    val map = Map[String,Int]("xiaox"->11,("haha"->22),("xixi",33))
    println(map)//Map(xiaox -> 11, haha -> 22, xixi -> 33)

    //删除元素
    //返回一个新的集合，原集合不会改变
    val map1=map.drop(1)
    println(map1)//Map(haha -> 22, xixi -> 33)

    //查询元素
    println(map("haha"))//22
    //如果key在map中存在返回Some，意思就是存在，反之返回None
    println(map.get("xixi"))//Some(33)
    //如果key在map中存在返回Some，意思就是存在，反之返回第二个参数
    println(map.getOrElse("hha",44))//44

    //查询集合长度
    println(map.size)

    //查询集合中是否包含某个元素
    println(map.contains("xixi"))

2、可变Map

 	//默认创建的是不可变的集合，想要变成可变集合，需要导包
    import scala.collection.mutable._
    //创建map集合
    val map = Map("zhangs"->11,"xiaox"->22)
    println(map)

    //改变元素的value值
    map("zhangs")=33
    println(map)

    //增加元素第一种
    map.put("haha",18)
    println(map)

    //增加元素第二种
    map+=("xixi"->20)
    println(map)

    //增加元素第三种
    map+=(("ttt",44))
    println(map)

    //删除元素
    map.remove("ttt")
    println(map)

    //查询元素
    println(map("haha"))
    println(map.get("xixi"))
    println(map.getOrElse("zhang",999))

3、map集合的遍历

val map = Map[String,Int]("xiaox"->11,("haha"->22),("xixi",33))
    println(map)

    //第一种方式
    for((k,v)<-map){
      println(s"$k---$v")
    }

    //第二种方式
    for(i<-map){
      println(i)
    }

    //第三种，只要key
    for(i<-map.keys){
      println(i)
    }

    //第四种只要values
    for(i<-map.values){
      println(i)
    }

    //foreach遍历
    map.foreach(println)
    map.foreach(x=>println(x._1))//打印key
    map.foreach(x=>println(x._2))//打印values
    map.keys.foreach((k:String)=>println(k))
    map.keys.foreach(println)
    map.values.foreach((v:Int)=>println(v))
    map.values.foreach(println)

三、元组（Tuple）

元组是不同类型的值的聚集。元组的值是通过将单个的值包含在圆括号中构成的。例如：(1, 3.14, “Fred”)是一个元组,最长可以容纳22个元素

//创建元组
    val tuple = new Tuple2[String,Int]("hello",4)
    //创建元组第二种
    val tuple1=(1,"hhh",3.4,true)

    //获取元组中指定元素
    println(tuple._2)//4
    println(tuple1._3)//3.4

    //如果想让元组当中元素下角标从0开始，需要调用方法，默认从1开始
    println(tuple1.productElement(3))

    //获取元组的长度
    println(tuple.productArity)//2

    //元组遍历
    for(i<-tuple1.productIterator){
      println(i)
    }

    tuple.productIterator.foreach(println)

四、Zip拉链操作

zip操作，就是将两个单列的集合，组合成双列的集合，集合中的每一组元素就是上述学习过的tuple。在组合两个集合的时候，集合元素两两一一对应，如果两个集合的长度不一致，将超过的部分,或者没有匹配上的部分进行裁剪，丢弃。

	//拉链测试
    //创建数组
    val arr1 = Array("lufei","xiangkesi","luojie","sabo","heihuzi")
    val arr2 = Array(13,23,34,21,77,99,55)

    //zip:进行拉链操作
    val res=arr1.zip(arr2)
    println(res.toBuffer)//ArrayBuffer((lufei,13), (xiangkesi,23), (luojie,34), (sabo,21), (heihuzi,77))

    //zipAll  第二个参数是左边数组如果空缺就补全”haha“,第三个参数是如果右边数组空缺就补全111
    val resul = arr1.zipAll(arr2,"haha",111)
    println(resul.toBuffer)//ArrayBuffer((lufei,13), (xiangkesi,23), (luojie,34), (sabo,21), (heihuzi,77), (haha,99), (haha,55))

    //zipWithIndex  给调用的数组右边补上索引
    println(arr1.zipWithIndex.toBuffer)//ArrayBuffer((lufei,0), (xiangkesi,1), (luojie,2), (sabo,3), (heihuzi,4))