Scala语言基础（二）集合

Scala中的数组

Scala中数组按是否定长分为定长数组和变长数组

定长数组

元素个数确定，只能修改元素，不支持增加删除元素；

object ArrayTest01 {
  def main(args: Array[String]): Unit = {
    //定义定长数组
    val a = new Array[Int](10)//对应Java  int[] a = new int[10];
    val b = new Array[String](5)
    val c = Array("Tom","Jack","Rose")//对应Java  String[] c = {"Tom","Jack","Rose"};
  }
}

注意：
当使用关键字new时，小括号里面的参数表示数组的长度，否则只是定义了一个只有一个元素的定长数组（其实是调用了Array.apply(3），传入一个元素3），这个元素就是该参数：

变长数组

 //变长数组
    val d = ArrayBuffer[Int]()
    //向数组中添加元素
    d +=1
    d +=2
    d +=3
    //一次加多个元素
    d += (10,13,15)

    for(i <- 0 until d.length){println(d(i))}

    //去掉左后两个元素
    d.trimEnd(2)

    //把ArrayBuffer转换为Array
    d.toArray

数组的常用操作

求最值

import scala.collection.mutable.ArrayBuffer

object HelloWorld {
  def main(args: Array[String]): Unit = {
    val array = Array(10,3,5,7,9)

    //最大值
    val max = array.max
    println("max = "+max)

    //最小值
    val min = array.min
    println("min = " +min)

    //求和
    val sum = array.sum
    println("sum = " + sum)

    var array2 = ArrayBuffer(3,7,1,18,8,3)

    //for(i <- 0 until array2.length){println(array2(i))}
    for(j <- array2.sortWith(_ < _)){print(j+"\t")}//1	3	3	7	8	18	升序排序
    println()
    for(k <- array.sortWith(_ < _)){print(k+"\t")}//3	5	7	9	10	没有进行排序
  }
}

向集合中追加元素

当定义边长数组使，需要导包，否则会报错：

一次追加一个元素

一次追加多个元素

追加数组

不同类型的集合也能相互追加

总结：
+= 表示追加一个或多个元素；
++= 表示追加另一个集合里面的所有元素。

指定索引插入元素

可以一次插入一个元素，也可以一次插入多个元素，insert的第一个参数为插入集合的索引位置：

删除元素

remove的参数表示：第一个参数表示删除元素的起始索引，第二个元素表示删除元素的个数：

定长数组和变长数组之间的转换

定长 ->边长

变长 -> 定长

将集合转换成一个字符串

当mkString方法只有一个参数时，表示是个元素的连接符；
当mkString方法有三个参数时，中间参数是连接符，两边参数是开始和末尾加入的符号：

map方法

map：不停的从b获得元素交给函数func1作为输入参数，func1执行完毕后得到一个新的结果，map会初始化一个新的和b同类型的定长数组，将func1执行的结果作为元素添加到新数组中：
其中func函数传入的数据类型必须和b的数据类型一致，否则会报错
求集合中元素个数

此外，参数函数只能定义一个参数，而返回值是什么类型的是没有限制的。

reduce

通过reduce求最小值

通过reduce求最和

解释：给定两个参数x,y，一个是临时变量，一个是循环从集合b中获取一个元素作为值的变量，这样根据定义的函数逻辑，没获得集合中的一个元素后根据参数函数逻辑处理后的值赋值给临时变量，最终得到一个元素。
注意：
1，既然是聚合，必定是接收多个参数，返回较少的值，一般就是接收两个参数，返回一个值
2，参数函数的参数类型要和要处理集合元素的类型一致
3，参数函数的返回值类型必须和参数的输入类型一致（因为相当于每次取出集合中一个元素作为参数函数的一个参数，上一次参数返回值作为另一个参数，就是说参数函数的输出还会作为输入，所以输出类型必须和输出类型一致）

Scala中的集合

包括Seq,Set,Map三大类，包含：Tuple\Stack\Queue等数据结构；
集合有两个比较重要概念：
可变（mutable）：当前集合中的元素可以更改
不可变（immutable）：当前这个集合中的元素不可以更改
可参考文章

List

不可变的序列
1.通过import scala.collection.immutable._导入

2.在Scala中列表要么是空（Nil表示空列表）要么是一个head元素加上一个tail列表；
例如： 9 :: List(5,2) 其中 ::操作符是将给定的头和为创建一个新的列表，而且 ::操作符是从右向左结合的，如 9 :: 5 :: Nil 相当于9 :: (5::(2::Nill))

3.操作
向List中添加一个元素
根据List集合特点，就是头元素+尾列表，头元素当然在前面了

也可以通过特殊操作符控制插入元素的位置（尾部或头部）

总结：单个值必须与“+”相邻，值在右面就是将元素添加到尾部，值在左边就是将值添加到头部。

在Scala中，操作符也可以看成方法，如下图，to可以当做方法来使用：

而同理，“:+”也可以像方法一样使用：

总结：单个值必须与“+”相邻，值在右面就是将元素添加到尾部，值在左边就是将值添加到头部。

将两个list拼接成一个新的list

两个集合是不能相加的，报错：需要Sting类型

而传入一个String类型的数值后，相当于凭借成了一个字符串类

两个list拼接 “++”等价于“++：”，但是不能使用“：++”

也可以使用下面的方法，将b插入a的前面

判断列表是否为空

取出头，尾元素和尾队列

获取处最后一个元素的前面所有元素
感觉和tail操作相反

倒序列表

drop方法
参数表示丢弃几个元素（从前往后）

take方法
从一个列表中取子列表，参数取几个元素

splitAt方法
发现下面这种方法不能进行正常切割，因为这样的通过下面这种方法定义出来的是不可变列表，应该有方法强制分隔，现在还不知道

scala> val c = List(1.to(10))
c:List[scala.collection.immutable.Range.Inclusive] = List(Range(1, 2, 3, 4, 5,6,7,8,9,10))

scala> c.splitAt(4)
res48:(List[scala.collection.immutable.Range.Inclusive], List[scala.collection.immutable.Range.Inclusive]) = (List(Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)),List())

而重新定义一个新的列表，便可以进行切割了

将列表分隔成立元素为2个列表的元组，可以通过下面方法查看元组的元素

zip方法
将两个元素个数相同的列表的元素一一对应组合成元组，然后将元组放到一个新的列表中

然后可以将其转换成Map

mkString方法
将列表中的元素转换成字符串

Set

主要用于去重，求交集、并集、差集
immutable

如下图两个集合
求交集

求并集

求差集

mutable
当只使用“+”时，元集合是不会变的，当使用“+=”才会在元集合中添加元素：

一次增加多个元素

“++=”：在原来集合基础上添加一个集合

add添加一个元素

remove删除一个元素
“-=”删除一个元素

Map

构建一个Map
访问

Map中有三种类型:Option,Some,None,其中Option是父类，其他是子类，Some表示有值，None表示无值，这样可以避免使用下标时抛出无值的异常。
还有一个更好的方法getOrElse(),有传入键所对应的值，就会返回，否则返回默认值：

定义可变Map，向其中添加元素

删除元素

Tuple

定义一个元组，元组中可以包含任意类型的值，定义之后不能改变

注意似乎不能定义一个元素的元组

访问元组里面的元素
特殊用法：
总结：
（1）List,Set定义之后类型就确定了，所有元素都是同一类型，且随着时间的迁移，这些集合中的元素有可能会增加，删除，更改
（2）Tuple能组合多个不同类型的值在一起，形成一个不可变的一个数据的整体