Scala基础应用（6）- 常用对象，集合等

Scala基础应用（6）- 常用对象，集合等

本章主要讲解一些常用对象和集合类

1. 序列化(Ordered特质)

例子：
class Rational(n: Int, d: Int) extends Ordered[Rational] {
def compare(that: Rational) =
(this.number * that.denom) - (that.number * this.denom)
}

2. 数组 (Array)

声明数组变量

var aArray: Array[类型] = new Array[类型] (数组大小)
var aArray = new Array[类型] (数组大小)
var aArray = Array(初始值1, 初始值2, ...)

例子:
var aArray : Array[String] = new Array[String] (10)
for (i <- 0 to 9)
aArray(i) = i.toString

var aArray1 = new Array[String] (10)
for (i <- 0 to (aArray1.length -1))
aArray(i) = i.toString

var aArray2 = Array("0", "1")  // 实际上执行的是Array.apply("0", "1")
for (a <- aArray2)
println (a)

var emptyArray: Array[Nothing] = Array()
var dimArray: Array[Array[String]] = Array (
Array("One", "Two"),
Array("Threee"),
Array("Four", "Five")
)

多维数组

Scala不直接支持多维数组，但提供多种方法实现任意维度的数组

var multipleArray = Array.ofDim[Int](3,3)
for (i <- 0 to 2; j <- 0 to 2)
multipleArray(i)(j) = i * j

连接数组

var array1 = Array("one", "two")
var array2 = Array("three")

var combinedArray = Array.concat(array1, array2)

范围数字数组 (只支持数字 Int)

var numberArray1 = Array.range(0, 100, 2)  // 其中2为步进值
var numberArray2 = Array.range(0, 100)     // 缺省步进值为1

3. 列表 (List)

变量声明与数组相同，上面数组声明部分将Array改成List都可以工作, 但List不可变，即使用var声明是没有意义的

Nil 为空列表

连接列表

var aList1 = List("One", "Two")
var aList2 = List("Three")
var aString = "Four"
var aList4 = List("Five", "Six")

var combinedList0 = List.concat(aList1, aList2)
var combinedList1 = aList1 ::: aList2
var combinedList2 = aString :: aList4
var combinedList3 = "First" :: Nil
var combinedList4 = "First" :: ("Second" :: Nil)

列表头: head, 列表尾: tail

统一列表: List.fill(次数)(值)

制成表格列表: List.tabulate(元素数量，维度) (函数) // 维度缺省为1

val square = List.tabulate(5) (n => n * n)
val dim = List.tabulate(4, 5) (_ * _)
val dim2 = List.tabulate(4,5) ((x, y) => x * y) // 也上面等同

反序: aList.reverse

4. 集 (Set)

5. 映射 (Map)

6. 元组 (Tuple)

7. Option

8. 迭代(Iterator)

9. 集合可变与不可变层级图

集合层级图



可变集合层级图



不可变集合层级图

10. 附表

Array

序号	声明	说明
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的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]	返回一个包含一个函数的重复应用到初始值的数组。
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 iterate[T]( start: T, len: Int)( f: (T) => T ): Array[T]	返回一个包含一个函数的重复应用到初始值的数组。
9	def ofDim[T]( n1: Int ): Array[T]	创建数组给出的尺寸。
10	def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]]	创建了一个2维数组
11	def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]]	创建3维数组
12	def range( start: Int, end: Int, step: Int ): Array[Int]	返回包含一些整数间隔等间隔值的数组。
13	def range( start: Int, end: Int ): Array[Int]	返回包含的范围内增加整数序列的数组。
14	def tabulate[T]( n: Int )(f: (Int)=> T): Array[T]	返回包含一个给定的函数的值超过从0开始的范围内的整数值的数组。
15	def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]]	返回一个包含给定函数的值超过整数值从0开始范围的二维数组。

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	列表转换为字符串

Tuple

序号	声明	说明
1

Set

序号	声明	说明
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

Map

序号	声明	说明
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

Option

序号	声明	说明
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Iterator

序号	声明	说明
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50