【Scala篇】--Scala中集合数组,list,set,map,元祖

一、前述

Scala在常用的集合的类别有数组，List，Set，Map，元祖。

二、具体实现

数组

  1、创建数组

• new Array[Int](10)

赋值：arr(0) = xxx

Array[String](“s1”,”s2”,”s3”)

   /**
     * 创建数组两种方式：
     * 1.new Array[String](3)
     * 2.直接Array
     */

    //创建类型为Int 长度为3的数组
    val arr1 = new Array[Int](3)
    //创建String 类型的数组，直接赋值
    val arr2 = Array[String]("s100","s200","s300")
    //赋值
    arr1(0) = 100
    arr1(1) = 200
    arr1(2) = 300

2、数组遍历

  /**
     * 遍历两种方式
     */
    for(i <- arr1){
    	  println(i)
    }
    arr1.foreach(i => {
      println(i)
    })

    for(s <- arr2){
      println(s)
    }
    arr2.foreach {
      x => println(x)
    }

 创建二维数组（相当于数组中的每元素是一个数组）

/**
     * 创建二维数组和遍历
     */
    val arr3 = new Array[Array[String]](3)
    arr3(0)=Array("1","2","3")
    arr3(1)=Array("4","5","6")
    arr3(2)=Array("7","8","9")
    for(i <- 0 until arr3.length){
      for(j <- 0 until arr3(i).length){
        print(arr3(i)(j)+"	")
      }
      println()
    }

    var count = 0
    for(arr <- arr3 ;i <- arr){
      if(count%3 == 0){
        println()
      }
      print(i+"	")
      count +=1
    }

    arr3.foreach { arr  => {
      arr.foreach { println }
    }}

    val arr4 = Array[Array[Int]](Array(1,2,3),Array(4,5,6))
    arr4.foreach { arr => {
      arr.foreach(i => {
        println(i)
      })
    }}
    println("-------")
    for(arr <- arr4;i <- arr){
      println(i)
    }

备注：数组方法
1    
def apply( x: T, xs: T* ): Array[T]
创建指定对象 T 的数组, T 的值可以是 Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean。
2    
def concat[T]( xss: Array[T]* ): Array[T]
合并数组
3    
def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit
复制一个数组到另一个数组上。相等于 Java's System.arraycopy(src, srcPos, dest, destPos, length)。
4    
def empty[T]: Array[T]
返回长度为 0 的数组
5    
def iterate[T]( start: T, len: Int )( f: (T) => T ): Array[T]
返回指定长度数组，每个数组元素为指定函数的返回值。
以上实例数组初始值为 0，长度为 3，计算函数为a=>a+1：
scala> Array.iterate(0,3)(a=>a+1)
res1: Array[Int] = Array(0, 1, 2)
6    
def fill[T]( n: Int )(elem: => T): Array[T]
返回数组，长度为第一个参数指定，同时每个元素使用第二个参数进行填充。
7    
def fill[T]( n1: Int, n2: Int )( elem: => T ): Array[Array[T]]
返回二数组，长度为第一个参数指定，同时每个元素使用第二个参数进行填充。
8    
def ofDim[T]( n1: Int ): Array[T]
创建指定长度的数组
9    
def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]]
创建二维数组
10    
def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]]
创建三维数组
11    
def range( start: Int, end: Int, step: Int ): Array[Int]
创建指定区间内的数组，step 为每个元素间的步长
12    
def range( start: Int, end: Int ): Array[Int]
创建指定区间内的数组
13    
def tabulate[T]( n: Int )(f: (Int)=> T): Array[T]
返回指定长度数组，每个数组元素为指定函数的返回值，默认从 0 开始。
以上实例返回 3 个元素：
scala> Array.tabulate(3)(a => a + 5)
res0: Array[Int] = Array(5, 6, 7)
14    
def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]]
返回指定长度的二维数组，每个数组元素为指定函数的返回值，默认从 0 开始。

15

Array.concate：合并数组

16

Array.fill(5)(“bjsxt”)：创建初始值的定长数组

list集合

1、创建list

val list = List(1,2,3,4)

Nil长度为0的list

 //创建
    val list = List(1,2,3,4,5)

    //遍历
    list.foreach { x => println(x)}
//    list.foreach { println}
    //filter
    val list1  = list.filter { x => x>3 }
    list1.foreach { println}

    //count
    val value = list1.count { x => x>3 }
    println(value)

    //map
    val nameList = List(
    		"hello bjsxt",
    		"hello xasxt",
    		"hello shsxt"
        )
    val mapResult:List[Array[String]] = nameList.map{ x => x.split(" ") }
    mapResult.foreach{println}    

    //flatmap
    val flatMapResult : List[String] = nameList.flatMap{ x => x.split(" ") }
    flatMapResult.foreach { println }

 备注：List方法总结

1    def +(elem: A): List[A]
前置一个元素列表
2    def ::(x: A): List[A]
在这个列表的开头添加的元素。
3    def :::(prefix: List[A]): List[A]
增加了一个给定列表中该列表前面的元素。
4    def ::(x: A): List[A]
增加了一个元素x在列表的开头
5    def addString(b: StringBuilder): StringBuilder
追加列表的一个字符串生成器的所有元素。
6    def addString(b: StringBuilder, sep: String): StringBuilder
追加列表的使用分隔字符串一个字符串生成器的所有元素。
7    def apply(n: Int): A
选择通过其在列表中索引的元素
8    def contains(elem: Any): Boolean
测试该列表中是否包含一个给定值作为元素。
9    def copyToArray(xs: Array[A], start: Int, len: Int): Unit
列表的副本元件阵列。填充给定的数组xs与此列表中最多len个元素，在位置开始。
10    def distinct: List[A]
建立从列表中没有任何重复的元素的新列表。
11    def drop(n: Int): List[A]
返回除了第n个的所有元素。
12    def dropRight(n: Int): List[A]
返回除了最后的n个的元素
13    def dropWhile(p: (A) => Boolean): List[A]
丢弃满足谓词的元素最长前缀。
14    def endsWith[B](that: Seq[B]): Boolean
测试列表是否使用给定序列结束。
15    def equals(that: Any): Boolean
equals方法的任意序列。比较该序列到某些其他对象。
16    def exists(p: (A) => Boolean): Boolean
测试谓词是否持有一些列表的元素。
17    def filter(p: (A) => Boolean): List[A]
返回列表满足谓词的所有元素。
18    def forall(p: (A) => Boolean): Boolean
测试谓词是否持有该列表中的所有元素。
19    def foreach(f: (A) => Unit): Unit
应用一个函数f以列表的所有元素。
20    def head: A
选择列表的第一个元素
21    def indexOf(elem: A, from: Int): Int
经过或在某些起始索引查找列表中的一些值第一次出现的索引。
22    def init: List[A]
返回除了最后的所有元素
23    def intersect(that: Seq[A]): List[A]
计算列表和另一序列之间的多重集交集。
24    def isEmpty: Boolean
测试列表是否为空
25    def iterator: Iterator[A]
创建一个新的迭代器中包含的可迭代对象中的所有元素
26    def last: A
返回最后一个元素
27    def lastIndexOf(elem: A, end: Int): Int
之前或在一个给定的最终指数查找的列表中的一些值最后一次出现的索引
28    def length: Int
返回列表的长度
29    def map[B](f: (A) => B): List[B]
通过应用函数以g这个列表中的所有元素构建一个新的集合
30    def max: A
查找最大的元素
31    def min: A
查找最小元素
32    def mkString: String
显示列表的字符串中的所有元素
33    def mkString(sep: String): String
显示的列表中的字符串中使用分隔串的所有元素
34    def reverse: List[A]
返回新列表，在相反的顺序元素
35    def sorted[B >: A]: List[A]
根据排序对列表进行排序
36    def startsWith[B](that: Seq[B], offset: Int): Boolean
测试该列表中是否包含给定的索引处的给定的序列
37    def sum: A
概括这个集合的元素
38    def tail: List[A]
返回除了第一的所有元素
39    def take(n: Int): List[A]
返回前n个元素
40    def takeRight(n: Int): List[A]
返回最后n个元素
41    def toArray: Array[A]
列表以一个数组变换
42    def toBuffer[B >: A]: Buffer[B]
列表以一个可变缓冲器转换
43    def toMap[T, U]: Map[T, U]
此列表的映射转换
44    def toSeq: Seq[A]
列表的序列转换
45    def toSet[B >: A]: Set[B]
列表到集合变换
46    def toString(): String
列表转换为字符串

常用方法：

• filter:过滤元素
• count:计算符合条件的元素个数
• map：对元素操作
• flatmap ：压扁扁平,先map再flat

set集合

     1、创建set

注意：set集合会自动去重

//创建
    val set1 = Set(1,2,3,4,4)
    val set2 = Set(1,2,5)
    //遍历
    //注意：set会自动去重
    set1.foreach { println}
   for(s <- set1){
      println(s)
    }
    println("*******")
   /**
    * 方法举例
    */

   //交集
   val set3 = set1.intersect(set2)
   set3.foreach{println}
   val set4 = set1.&(set2)
   set4.foreach{println}
   println("*******")
   //差集
   set1.diff(set2).foreach { println }
   set1.&~(set2).foreach { println }
   //子集
   set1.subsetOf(set2)

   //最大值
   println(set1.max)
   //最小值
   println(set1.min)
   println("****")

   //转成数组，list
   set1.toArray.foreach{println}
   println("****")
   set1.toList.foreach{println}

   //mkString
   println(set1.mkString)
   println(set1.mkString("\t"))

 Set常用方法：

• 交集：intersect ,&
• 差集: diff ,&~
• 子集:subsetOf
• 最大:max
• 最小:min
• 转成数组，toList
• 转成字符串：mkString(“~”)

Set方法：

1   
def +(elem: A): Set[A]
为集合添加新元素，x并创建一个新的集合，除非元素已存在
2   
def -(elem: A): Set[A]
移除集合中的元素，并创建一个新的集合
3   
def contains(elem: A): Boolean
如果元素在集合中存在，返回 true，否则返回 false。
4   
def &(that: Set[A]): Set[A]
返回两个集合的交集
5   
def &~(that: Set[A]): Set[A]
返回两个集合的差集
6   
def +(elem1: A, elem2: A, elems: A*): Set[A]
通过添加传入指定集合的元素创建一个新的不可变集合
7   
def ++(elems: A): Set[A]
合并两个集合
8   
def -(elem1: A, elem2: A, elems: A*): Set[A]
通过移除传入指定集合的元素创建一个新的不可变集合
9   
def addString(b: StringBuilder): StringBuilder
将不可变集合的所有元素添加到字符串缓冲区
10   
def addString(b: StringBuilder, sep: String): StringBuilder
将不可变集合的所有元素添加到字符串缓冲区，并使用指定的分隔符
11   
def apply(elem: A)
检测集合中是否包含指定元素
12   
def count(p: (A) => Boolean): Int
计算满足指定条件的集合元素个数
13   
def copyToArray(xs: Array[A], start: Int, len: Int): Unit
复制不可变集合元素到数组
14   
def diff(that: Set[A]): Set[A]
比较两个集合的差集
15   
def drop(n: Int): Set[A]]
返回丢弃前n个元素新集合
16   
def dropRight(n: Int): Set[A]
返回丢弃最后n个元素新集合
17   
def dropWhile(p: (A) => Boolean): Set[A]
从左向右丢弃元素，直到条件p不成立
18   
def equals(that: Any): Boolean
equals 方法可用于任意序列。用于比较系列是否相等。
19   
def exists(p: (A) => Boolean): Boolean
判断不可变集合中指定条件的元素是否存在。
20   
def filter(p: (A) => Boolean): Set[A]
输出符合指定条件的所有不可变集合元素。
21   
def find(p: (A) => Boolean): Option[A]
查找不可变集合中满足指定条件的第一个元素
22   
def forall(p: (A) => Boolean): Boolean
查找不可变集合中满足指定条件的所有元素
23   
def foreach(f: (A) => Unit): Unit
将函数应用到不可变集合的所有元素
24   
def head: A
获取不可变集合的第一个元素
25   
def init: Set[A]
返回所有元素，除了最后一个
26   
def intersect(that: Set[A]): Set[A]
计算两个集合的交集
27   
def isEmpty: Boolean
判断集合是否为空
28   
def iterator: Iterator[A]
创建一个新的迭代器来迭代元素
29   
def last: A
返回最后一个元素
30   
def map[B](f: (A) => B): immutable.Set[B]
通过给定的方法将所有元素重新计算
31   
def max: A
查找最大元素
32   
def min: A
查找最小元素
33   
def mkString: String
集合所有元素作为字符串显示
34   
def mkString(sep: String): String
使用分隔符将集合所有元素作为字符串显示
35   
def product: A
返回不可变集合中数字元素的积。
36   
def size: Int
返回不可变集合元素的数量
37   
def splitAt(n: Int): (Set[A], Set[A])
把不可变集合拆分为两个容器，第一个由前 n 个元素组成，第二个由剩下的元素组成
38   
def subsetOf(that: Set[A]): Boolean
如果集合A中含有子集B返回 true，否则返回false
39   
def sum: A
返回不可变集合中所有数字元素之和
40   
def tail: Set[A]
返回一个不可变集合中除了第一元素之外的其他元素
41   
def take(n: Int): Set[A]
返回前 n 个元素
42   
def takeRight(n: Int):Set[A]
返回后 n 个元素
43   
def toArray: Array[A]
将集合转换为数组
44   
def toBuffer[B >: A]: Buffer[B]
返回缓冲区，包含了不可变集合的所有元素
45   
def toList: List[A]
返回 List，包含了不可变集合的所有元素
46   
def toMap[T, U]: Map[T, U]
返回 Map，包含了不可变集合的所有元素
47   
def toSeq: Seq[A]
返回 Seq，包含了不可变集合的所有元素
48   
def toString(): String
返回一个字符串，以对象来表示

map集合

1. map创建

Map（1 –>”bjsxt’）

Map((1,”bjsxt”))

注意：创建map时，相同的key被后面的相同的key顶替掉，只保留一个

2、获取map的值

map.get(“1”).get

map.get(100).getOrElse(“no value”)：如果map中没有对应项，赋值为getOrElse传的值。

  //获取值
    println(map.get("1").get)
    val result = map.get(8).getOrElse("no value")
    println(result)

 3、遍历map

for,foreach

 //map遍历
    for(x <- map){
      println("====key:"+x._1+",value:"+x._2)
    }
    map.foreach(f => {
      println("key:"+ f._1+" ,value:"+f._2)
    })

4、遍历key

map.keys

    //遍历key
    val keyIterable = map.keys
    keyIterable.foreach { key => {
      println("key:"+key+", value:"+map.get(key).get)
    } }
    println("---------")

 5、遍历value

map.values

 //遍历value
    val valueIterable = map.values
    valueIterable.foreach { value => {
      println("value: "+ value)
    } }

 6、合并map

++  例：map1.++(map2)  --map1中加入map2

++:  例：map1.++:(map2) –map2中加入map1

注意：合并map会将map中的相同key的value替换

 //合并map
    val map1 = Map(
      (1,"a"),
      (2,"b"),
      (3,"c")
    )
    val map2 = Map(
      (1,"aa"),
      (2,"bb"),
      (2,90),
      (4,22),
      (4,"dd")
    )
    map1.++:(map2).foreach(println)

 7、map中的方法举例

filter:过滤，留下符合条件的记录

count:统计符合条件的记录数

contains：map中是否包含某个key

exist：符合条件的记录存在不存在

 /**
     * map方法
     */
    //count
    val countResult  = map.count(p => {
      p._2.equals("shsxt")
    })
    println(countResult)

    //filter
    map.filter(_._2.equals("shsxt")).foreach(println)

    //contains
    println(map.contains(2))

    //exist
    println(map.exists(f =>{
      f._2.equals("xasxt")

    }))

 map 方法：
1   
def ++(xs: Map[(A, B)]): Map[A, B]
返回一个新的 Map，新的 Map xs 组成
2   
def -(elem1: A, elem2: A, elems: A*): Map[A, B]
返回一个新的 Map, 移除 key 为 elem1, elem2 或其他 elems。
3   
def --(xs: GTO[A]): Map[A, B]
返回一个新的 Map, 移除 xs 对象中对应的 key
4   
def get(key: A): Option[B]
返回指定 key 的值
5   
def iterator: Iterator[(A, B)]
创建新的迭代器，并输出 key/value 对
6   
def addString(b: StringBuilder): StringBuilder
将 Map 中的所有元素附加到StringBuilder，可加入分隔符
7   
def addString(b: StringBuilder, sep: String): StringBuilder
将 Map 中的所有元素附加到StringBuilder，可加入分隔符
8   
def apply(key: A): B
返回指定键的值，如果不存在返回 Map 的默认方法

10   
def clone(): Map[A, B]
从一个 Map 复制到另一个 Map
11   
def contains(key: A): Boolean
如果 Map 中存在指定 key，返回 true，否则返回 false。
12   
def copyToArray(xs: Array[(A, B)]): Unit
复制集合到数组
13   
def count(p: ((A, B)) => Boolean): Int
计算满足指定条件的集合元素数量
14   
def default(key: A): B
定义 Map 的默认值，在 key 不存在时返回。
15   
def drop(n: Int): Map[A, B]
返回丢弃前n个元素新集合
16   
def dropRight(n: Int): Map[A, B]
返回丢弃最后n个元素新集合
17   
def dropWhile(p: ((A, B)) => Boolean): Map[A, B]
从左向右丢弃元素，直到条件p不成立
18   
def empty: Map[A, B]
返回相同类型的空 Map
19   
def equals(that: Any): Boolean
如果两个 Map 相等(key/value 均相等)，返回true，否则返回false
20   
def exists(p: ((A, B)) => Boolean): Boolean
判断集合中指定条件的元素是否存在
21   
def filter(p: ((A, B))=> Boolean): Map[A, B]
返回满足指定条件的所有集合
22   
def filterKeys(p: (A) => Boolean): Map[A, B]
返回符合指定条件的的不可变 Map
23   
def find(p: ((A, B)) => Boolean): Option[(A, B)]
查找集合中满足指定条件的第一个元素
24   
def foreach(f: ((A, B)) => Unit): Unit
将函数应用到集合的所有元素
25   
def init: Map[A, B]
返回所有元素，除了最后一个
26   
def isEmpty: Boolean
检测 Map 是否为空
27   
def keys: Iterable[A]
返回所有的key/p>
28   
def last: (A, B)
返回最后一个元素
29   
def max: (A, B)
查找最大元素
30   
def min: (A, B)
查找最小元素
31   
def mkString: String
集合所有元素作为字符串显示
32   
def product: (A, B)
返回集合中数字元素的积。
33   
def remove(key: A): Option[B]
移除指定 key
34   
def retain(p: (A, B) => Boolean): Map.this.type
如果符合满足条件的返回 true
35   
def size: Int
返回 Map 元素的个数
36   
def sum: (A, B)
返回集合中所有数字元素之和
37   
def tail: Map[A, B]
返回一个集合中除了第一元素之外的其他元素
38   
def take(n: Int): Map[A, B]
返回前 n 个元素
39   
def takeRight(n: Int): Map[A, B]
返回后 n 个元素
40   
def takeWhile(p: ((A, B)) => Boolean): Map[A, B]
返回满足指定条件的元素
41   
def toArray: Array[(A, B)]
集合转数组
42   
def toBuffer[B >: A]: Buffer[B]
返回缓冲区，包含了 Map 的所有元素
43   
def toList: List[A]
返回 List，包含了 Map 的所有元素
44   
def toSeq: Seq[A]
返回 Seq，包含了 Map 的所有元素
45   
def toSet: Set[A]
返回 Set，包含了 Map 的所有元素
46   
def toString(): String
返回字符串对象

元组

1. 元组定义

与列表一样，与列表不同的是元组可以包含不同类型的元素。元组的值是通过将单个的值包含在圆括号中构成的。

2. 创建元组与取值

val  tuple = new Tuple（1） 可以使用new

val tuple2  = Tuple（1,2） 可以不使用new，也可以直接写成val tuple3 =（1,2,3）

取值用”._XX” 可以获取元组中的值

注意：tuple最多支持22个参数

    //创建，最多支持22个
    val tuple = new Tuple1(1)
    val tuple2 = Tuple2("zhangsan",2)
    val tuple3 = Tuple3(1,2,3)
    val tuple4 = (1,2,3,4)
    val tuple18 = Tuple18(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18)
    val tuple22 = new Tuple22(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22)

    //使用
    println(tuple2._1 + "\t"+tuple2._2)
    val t = Tuple2((1,2),("zhangsan","lisi"))
    println(t._1._2)

 3、元祖遍历

tuple.productIterator得到迭代器，进而遍历

   //遍历
    val tupleIterator = tuple22.productIterator
    while(tupleIterator.hasNext){
      println(tupleIterator.next())
    }

4、swap,toString方法

注意：swap元素翻转，只针对二元组
    /**
     * 方法
     */
    //翻转，只针对二元组
    println(tuple2.swap)

    //toString
    println(tuple3.toString())

 备注：一般针对集合的遍历基本都是foreach ,for方法！！！！！

Scala Set 常用方法
下表列出了 Scala Set 常用的方法：
序号    方法及描述
1    
def +(elem: A): Set[A]
为集合添加新元素，x并创建一个新的集合，除非元素已存在
2    
def -(elem: A): Set[A]
移除集合中的元素，并创建一个新的集合
3    
def contains(elem: A): Boolean
如果元素在集合中存在，返回 true，否则返回 false。
4    
def &(that: Set[A]): Set[A]
返回两个集合的交集
5    
def &~(that: Set[A]): Set[A]
返回两个集合的差集
6    
def +(elem1: A, elem2: A, elems: A*): Set[A]
通过添加传入指定集合的元素创建一个新的不可变集合
7    
def ++(elems: A): Set[A]
合并两个集合
8    
def -(elem1: A, elem2: A, elems: A*): Set[A]
通过移除传入指定集合的元素创建一个新的不可变集合
9    
def addString(b: StringBuilder): StringBuilder
将不可变集合的所有元素添加到字符串缓冲区
10    
def addString(b: StringBuilder, sep: String): StringBuilder
将不可变集合的所有元素添加到字符串缓冲区，并使用指定的分隔符
11    
def apply(elem: A)
检测集合中是否包含指定元素
12    
def count(p: (A) => Boolean): Int
计算满足指定条件的集合元素个数
13    
def copyToArray(xs: Array[A], start: Int, len: Int): Unit
复制不可变集合元素到数组
14    
def diff(that: Set[A]): Set[A]
比较两个集合的差集
15    
def drop(n: Int): Set[A]]
返回丢弃前n个元素新集合
16    
def dropRight(n: Int): Set[A]
返回丢弃最后n个元素新集合
17    
def dropWhile(p: (A) => Boolean): Set[A]
从左向右丢弃元素，直到条件p不成立
18    
def equals(that: Any): Boolean
equals 方法可用于任意序列。用于比较系列是否相等。
19    
def exists(p: (A) => Boolean): Boolean
判断不可变集合中指定条件的元素是否存在。
20    
def filter(p: (A) => Boolean): Set[A]
输出符合指定条件的所有不可变集合元素。
21    
def find(p: (A) => Boolean): Option[A]
查找不可变集合中满足指定条件的第一个元素
22    
def forall(p: (A) => Boolean): Boolean
查找不可变集合中满足指定条件的所有元素
23    
def foreach(f: (A) => Unit): Unit
将函数应用到不可变集合的所有元素
24    
def head: A
获取不可变集合的第一个元素
25    
def init: Set[A]
返回所有元素，除了最后一个
26    
def intersect(that: Set[A]): Set[A]
计算两个集合的交集
27    
def isEmpty: Boolean
判断集合是否为空
28    
def iterator: Iterator[A]
创建一个新的迭代器来迭代元素
29    
def last: A
返回最后一个元素
30    
def map[B](f: (A) => B): immutable.Set[B]
通过给定的方法将所有元素重新计算
31    
def max: A
查找最大元素
32    
def min: A
查找最小元素
33    
def mkString: String
集合所有元素作为字符串显示
34    
def mkString(sep: String): String
使用分隔符将集合所有元素作为字符串显示
35    
def product: A
返回不可变集合中数字元素的积。
36    
def size: Int
返回不可变集合元素的数量
37    
def splitAt(n: Int): (Set[A], Set[A])
把不可变集合拆分为两个容器，第一个由前 n 个元素组成，第二个由剩下的元素组成
38    
def subsetOf(that: Set[A]): Boolean
如果集合A中含有子集B返回 true，否则返回false
39    
def sum: A
返回不可变集合中所有数字元素之和
40    
def tail: Set[A]
返回一个不可变集合中除了第一元素之外的其他元素
41    
def take(n: Int): Set[A]
返回前 n 个元素
42    
def takeRight(n: Int):Set[A]
返回后 n 个元素
43    
def toArray: Array[A]
将集合转换为数组
44    
def toBuffer[B >: A]: Buffer[B]
返回缓冲区，包含了不可变集合的所有元素
45    
def toList: List[A]
返回 List，包含了不可变集合的所有元素
46    
def toMap[T, U]: Map[T, U]
返回 Map，包含了不可变集合的所有元素
47    
def toSeq: Seq[A]
返回 Seq，包含了不可变集合的所有元素
48    
def toString(): String
返回一个字符串，以对象来表示