scala集合

scala中的大部分集合类位于scala.collection、scala.collection.immutable、scala.collection.mutable中。
immutable中的类关系图如下：

mutable中的类关系图如下：

1.Array

scala数组支持变长和不可变长数组;

1.1 不可变长度数组创建如下：

  //创建空数组
  val arr = new Array[String](2)
  //创建数组时直接赋值数组元素
  val arr1 = Array("1","2","3")

  //更新数组元素
  arr1.update(1, "+")
  println(arr1(1))
  //获取除了前n个元素之外的数据
  arr1.drop(2)
  arr.update(0, "4")
  arr(1) = "5"
  //合并两个数组的数据
  var arr3 = concat(arr, arr1)
  println()
  for (x <- arr3){
    print(" " + x)
  }
  //创建某个范围内的数组(参数分别为开始数字,结束数字,距离差,距离差不传默认为1)
  val arrRange = range(5, 20, 2)
  println()
  for (x <- arrRange){
    print(" " + x)
  }

其中range和concat方法需要引入Array._依赖。结果输出如下：

+
4 5 1 + 3
5 7 9 11 13 15 17 19

1.2 可变数组的创建ArrayBuffer

使用ArrayBuffer需要引用scala.collection.mutable.ArrayBuffer包

    val arr2 = ArrayBuffer(1,2,6)
    //向数组中添加一个元素
    arr2 += 5
    //删除一个元素
    arr2 -= 1
    //追加一个数组
    arr2 ++= Array(4,8,9)
    //删除一个数组
    arr2 --= Array(4, 8)
    //删除 remove(从第几个开始,删除几个);remove(从第几个开始)
    arr2.remove(1, 1)
    //添加 insert(从第几个开始,插入的数据),插入的数据可以是多个
    arr2.insert(3,1,7,9)
    //获取最大值
    println("max:" + arr2.max)
    //获取最小值
    println("min:" + arr2.min)
    //获取和
    println("sum:" + arr2.sum)

    //遍历数组方式1
    println("遍历数组方式1:")
    for (i <- arr2) {
      print(i)
    }

    println("\n遍历数组方式2:")
    //遍历数组方式2
    for (i <- 0 to arr2.length-1) {
      print(arr2(i))
    }

    println("\n遍历数组方式3:")
    //遍历数组方式3
    for (i <- 0 until arr2.length) {
      print(arr2(i))
    }

    //遍历数组方式4(indices(表示数组的下标))
    println("\n遍历数组方式4:")
    for (i <- arr2.indices) {
      print(arr2(i))
    }

输出结果：

max:9
min:1
sum:45
遍历数组方式1:
25417989
遍历数组方式2:
25417989
遍历数组方式3:
25417989
遍历数组方式4:
25417989

如果数组中的元素均为自然数，可以使用sorted函数进行排序，使用reverse进行倒序。

2.Set

set集合中的元素不可以重复。immutable中有HashSet，TreeSet，BitSet，ListSet，SortedSet，以及mutable.LinkedHashSet。当然也可以直接使用Set。可以使用的方法有：

代码	释义
xs contains x	测试 x 是否是 xs 的元素。
xs(x)	与 xs contains x 相同。
xs subsetOf ys	测试 xs 是否是 ys 的子集
xs + x	包含 xs 中所有元素以及 x 的集合
xs + (x, y, z)	包含 xs 中所有元素及附加元素的集合
xs ++ ys	包含 xs 中所有元素及 ys 中所有元素的集合
xs - x	包含 xs 中除x以外的所有元素的集合
xs - x	包含 xs 中除去给定元素以外的所有元素的集合
xs – ys	集合内容为：xs 中所有元素，去掉 ys 中所有元素后剩下的部分
xs.empty	与 xs 同类的空集合
xs & ys	集合 xs 和 ys 的交集
xs intersect ys	等同于 xs & ys
xs | ys	集合 xs 和 ys 的并集
xs union ys	等同于 xs
xs &~ ys	集合 xs 和 ys 的差集
xs diff ys	等同于 xs &~ ys

mutable.Set中的Set操作：

代码	释义
xs += x	把元素 x 添加到集合 xs 中。该操作有副作用，它会返回左操作符，这里是 xs 自身
xs += (x, y, z)	添加指定的元素到集合 xs 中，并返回 xs 本身。（同样有副作用）
xs ++= ys	添加集合 ys 中的所有元素到集合 xs 中，并返回 xs 本身。（表达式有副作用）
xs add x	把元素 x 添加到集合 xs 中，如集合 xs 之前没有包含 x，该操作返回 true，否则返回 false。
xs -= x	从集合 xs 中删除元素 x，并返回 xs 本身。（表达式有副作用）
xs -= (x, y, z)	从集合 xs 中删除指定的元素，并返回 xs 本身。（表达式有副作用）
xs --= ys	从集合 xs 中删除所有属于集合 ys 的元素，并返回 xs 本身。（表达式有副作用）
xs remove x	从集合 xs 中删除元素 x 。如之前 xs 中包含了 x 元素，返回 true，否则返回 false
xs retain p	只保留集合 xs 中满足条件 p 的元素
xs.clear()	删除集合 xs 中的所有元素

如果我们需要创建有序集合，可以使用SortedSet或者immutable中的Treeset。
另外scala中还有一种BitSet，它是由单字或多字的紧凑位实现的非负整数的集合。其内部使用 Long 型数组来表示。第一个 Long 元素表示的范围为0到63，第二个范围为64到127，以此类推。

3.List

scala中支持的List有：List，LinkedList，其都属于LinearSeq的子类。操作的方法与Set基本差不多。

4.map

scala中支持的map有：map,HashMap,SortedMap,ListMap等。创建及常见方法实例如下：

var map = Map('1' -> 3, '3'->4)
//向map中添加元素
map += ('5'-> 3)
//根据key获取元素
map.get('5')
//判断value = 4 在map中是否存在
map exists( x => x._2 == 4)
//判断key = '1' 在map中是否存在
map exists(x => x._1 == '1')
//获取所有的key
val keys = map.keySet

5.其他集合操作

5.1 exists

exists用于判断某个元素在集合中是否存在；

//判断key = '1' 在map中是否存在
val existiMap = map exists(x => x._1 == '1')
 //判断'4'是否在集合中存在
 val existiList = list.exists(x => x =='4')

其中x指代集合中的元素，如果是map类型，x._1代表key，x._2代表value；如果集合中的元素为对象，还可以通过x._2.属性获取对象的具体属性。

5.2 filter

filter通过过滤来选择指定的元素，其使用语法与exists类似，只是关键字不一样。

 //过滤掉值为'4'的元素
 list.filter(x => x =='4')

5.3 take

take用于获取集合中的第几个元素

5.4 groupBy

groupBy用于按照特定分区函数将某一个集合进行区分。