Scala Array算子大全

ScalaOperator

​ 本文介绍了 scala 中的算子及其具体用法以及实例，结尾还有一些多个算子结合使用的案例，以供大家参考

image-20210912135819760

数据备用：

//运行结果:
1
2
3
4
5
6
var arr1 = Array(1,2,3,4,5,6,7,8,9,10)
var arr2 = Array(Array(1,2,3),Array(4,5,6))
var arr3 = Array(Array(Array(1,2,3),Array(4,5,6)),Array(Array(4,5,6),Array(7,8,9)))
var arr4 = Array(("weiWei","male"),("yaoYao","male"),("nanNan","female"),("yangYang","male"),("qunQun","female"))
var arr5 = Array(("weiWei","male",27),("yaoYao","male",15),("nanNan","female",7),("yangYang","male",45),("qunQun","female",18))
var arrStandBy = Array(1,3,5,7,9,10,12,13)

[TOC]

!=

​ :关系运算符中的不等于，很简单，再次不做赘述

##

​ :nauseated_face:不知道干啥的

++

​ ：返回两个集合的并集
$$
val\ newArr = arr ++ sub
$$

1
2
3
4
5
var arr_test = arr1 ++ arrStandBy
println(arr_test.foreach(a => print(s"${a}\t")))
运行结果:
1	2	3	4	5	6	7	8	9	10	1	3	5	7	9	10	12	13

++:

​ ：返回两个集合的并集
$$
val\ newArr = arr ++: sub
$$

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
// 1.都是immutable或都是mutbale时:++ 和 ++: 作用一样（并集）
val arrTest1 = Array(10,11,12)
val arrTest2 = Array("a","b","c")

// 类型同样的并集
val value1 = arr1 ++ arrTest1
value1.foreach(a=>print(s"${a}\t"))
println()
// 类型不一样的并集
val value2= arr1++arrTest2
value2.foreach(a=>print(s"${a}\t"))
println()

//2.一个是immutable另一个是mutbale时
//		++ 结果类型为immutable还是mutable由++前面决定
//		++: 结果类型为immutable还是mutable由++:后面决定
val arrTest3 = scala.collection.mutable.ListBuffer(10,11,12)
val ints: Array[Int] = arr1 ++ arrTest3
ints.foreach(a=>print(s"${a}\t"))
println()
val ints1: ListBuffer[Int] = arrTest3 ++ arr1
ints1.foreach(a=>print(s"${a}\t"))
println()
val value3: scala.collection.mutable.ListBuffer[Int] = arr1 ++: arrTest3
value3.foreach(a=>print(s"${a}\t"))
println()
val value4: Array[Int] = arrTest3 ++: arr1
value4.foreach(a=>print(s"${a}\t"))
//运行结果:
1	2	3	4	5	6	7	8	9	10	10	11	12	
1	2	3	4	5	6	7	8	9	10	a	b	c	
1	2	3	4	5	6	7	8	9	10	10	11	12	
10	11	12	1	2	3	4	5	6	7	8	9	10	
1	2	3	4	5	6	7	8	9	10	10	11	12	
10	11	12	1	2	3	4	5	6	7	8	9	10

+:

​ ：在数组前面添加一个元素，并返回新的数组对象
$$
val\ newArr = elem +: arr
$$

1
2
3
4
5
var arrTest1 = 0 +: arr1
arrTest1.foreach(a=>print(s"${a}\t"))
//运行结果:
0	1	2	3	4	5	6	7	8	9	10

->

​ : 返回一个Tuple2的元祖
$$
val\ tuple: (Array[T], T) = arr -> value:Any
$$

1
2
3
4
5
val tuple: (Array[Int], String) = arr1 -> "arr1"
println(tuple.toString())
//运行结果:
([I@7f63425a,arr1)

/:

​ ：对序列中的每个元素进行二元运算，需要初始值 （默认从左边开始运算）
$$
val\ value:B = (initval:T/:arr)(f:(T,T)=>B)
$$

1
2
3
4
println((0/:arr1)(_ + _))
// 运行结果:
55

:+

​ ：在数组后面添加一个元素，并返回新的数组对象
$$
val\ newArr = arr :+ elem
$$

1
2
3
4
5
var arrTest1 = arr1 :+ 11
arrTest1.foreach(a=>print(s"${a}\t"))
//运行结果:
1	2	3	4	5	6	7	8	9	10	11

:\

​ ：从右边开始对序列中的每个元素进行二元运算，需要初始值
$$
val\ value:B = arr:\value()
$$

1
2
3
4
println((arr1:\0)(_ + _))
// 运行结果:
55

==

​ ：判断两个对象值是否相等
$$
val\ bool:Boolean = arr1 == arr2
$$

1
2
3
4
5
6
7
8
val arrTest = arr1.clone
println(arr1 == arr1)
println(arr1 == arr2)
println(arr1 == arrTest)
// 运行结果:
true
false
false

addString

​ ：1、参数为builder时：返回一个将数组中的元素逐个添加到builder后的字符串

​ ：2、参数为builder，seq时：返回一个将数组中的元素逐个添加到builder，并且用指定seq分割符将各个元素分割后的字符串

​ ：3、参数为builder，start，seq，end时：返回一个将数组中的元素逐个添加到 builder，在首尾各加指定的 start 和 end 字符串，并且用指定 seq 分隔符将各个元素分隔后的字符串
$$
var\ str:string = arr.addString (builder:stringBuilder[,start:string,sep:string,end:String])
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
val builder = new StringBuilder

//参数为 builder
val str1 = arr1.addString(builder)
println(str1)
builder.clear()//清空builder

//参数为builder，seq
val str2 = arr1.addString(builder, "-")
println(str2)
builder.clear()//清空builder

//参数为builder，start，seq，end
val str3 = arr1.addString(builder,"[", "-","]")
println(str3)
//运行结果:
12345678910
1-2-3-4-5-6-7-8-9-10
[1-2-3-4-5-6-7-8-9-10]

aggregate

​ ：aggregate是柯里化方法（将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数）， aggregate 方法是一个聚合函数，接受多个输入，并按照一定的规则运算以后输出一个结果值
$$
val\ value:B = arr.par.aggregate(initVal:B)(map:(T,T)=>B,reduce:(B,B)=>B)
$$

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
51
52
53
54
55
56
57
58
59
60
61
var mapAdd = (x:Int,y:Int)=>{
    var z = x+y
    println(s"map:${x} + ${y} = ${z}")
    z
}

var reduceAdd = (x:Int,y:Int)=>{
    var z = x+y
    println(s"re:${x} + ${y} = ${z}")
    z
}

val i: Int = arr1.aggregate(0)(_ + _, _ + _)
println(i)
println("***********************************")

val j: Int = arr1.aggregate(0)(mapAdd, reduceAdd)
// 没有走reduceAdd
println(j)
println("***********************************")

val k: Int = arr1.par.aggregate(0)(mapAdd, reduceAdd)
// 走reduceAdd
println(k)

//运行结果:
55
***********************************
map:0 + 1 = 1
map:1 + 2 = 3
map:3 + 3 = 6
map:6 + 4 = 10
map:10 + 5 = 15
map:15 + 6 = 21
map:21 + 7 = 28
map:28 + 8 = 36
map:36 + 9 = 45
map:45 + 10 = 55
55
***********************************
map:0 + 9 = 9
map:0 + 7 = 7
map:0 + 10 = 10
map:0 + 6 = 6
map:0 + 8 = 8
map:0 + 5 = 5
map:0 + 1 = 1
re:9 + 10 = 19
re:6 + 7 = 13
map:0 + 4 = 4
map:0 + 2 = 2
map:0 + 3 = 3
re:1 + 2 = 3
re:4 + 5 = 9
re:8 + 19 = 27
re:13 + 27 = 40
re:3 + 9 = 12
re:3 + 12 = 15
re:15 + 40 = 55
55

andThen

​ :柯里化方法andThen，f1 与 f2 只有【一个参数】，且类型相同，f1 的输出为 f2 的输入，先调用 f1，再调用 f2
$$
val\ f3 = fl andThen f2
$$

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
val f1 = (x:Int) => x+3
val f2 = (x:Int) => x*3
val f3 = (x:Int) => x-3

val fat = f1 andThen f2 andThen f3      // 先执行f1后执行f2后执行f3
val fcp = f1 compose  f2 compose f3     // 先执行f3后执行f2后执行f1
println(fat(3))
println(fcp(3))

// andThen前面的方法是def时，需要加"_"
def f4(x:Int) = x*3
def f5(x:Int) = x-3

val fdefat = f4 _ andThen f5
val fdefcp = f4 _ compose f5
println(fdefat(3))
println(fdefcp(3))

// andThen在数组中的应用:下标不存在报错，下标存在就把对应元素传入偏函数中，输出偏函数的结果
val i: Int = arr1.andThen(x => {
    if (x % 2 == 0) x else x + 2
})(2)
println(i)

val j: Int = arr1.andThen(x => {
    if (x % 2 == 0) x else x + 2
})(3)
println(j)

//运行结果:
15
3
6
0
5
4

apply

​ ：返回序列中参数下标对应的元素,下标不存在，则会下标越界
$$
val\ v:T = arr.apply (index : Int)
$$

1
2
3
4
5
println(arr1.apply(1))
println(arr1.apply(11))
//运行结果:
2
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 11

applyOrElse

​ ：接受两个参数，参数1：序列的下标；参数2：回调函数。如果参数1的下标值合法（未越界），则返回序列中下标对应的元素，否则返回参数1 经过回调函数后的值（回调函数的输入类型需与调用参数类型一致），就相当于if-else分支调用函数。
$$
val\ v:T = arr.applyorElse(index:Int,f:index(Int)=>T)
$$

1
2
3
4
5
6
println(arr1.applyOrElse(1,(x:Int)=> x*2))
println(arr1.applyOrElse(11,(x:Int)=> x*2))
//运行结果:
2
22

array

​ ：返回一个数组的同类型元素数组
$$
val arr: Array[T]= arr.array
$$

1
2
3
4
val array: Array[Int] = arr1.array
array.foreach(a=>print(s"${a}\t"))
//运行结果:
1	2	3	4	5	6	7	8	9	10

asInstanceOf

     ：首先，需要使用isInstanceOf 判断对象是否为指定类的对象，如果是的话，则可以使用 asInstanceOf 将对象转换为指定类型；

  • 注意：p.isInstanceOf[XX] 判断 p 是否为 XX 对象的实例；p.asInstanceOf[XX] 把 p 转换成 XX 对象的实例

  • 注意：如果没有用isInstanceOf 先判断对象是否为指定类的实例，就直接用 asInstanceOf 转换，则可能会抛出异常；

  • 注意：如果对象是 null，则isInstanceOf 一定返回 false， asInstanceOf 一定返回 null；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Person3 {}
class Student3 extends Person3
object Student3 {

  def main(args: Array[String]) {
    val p: Person3 = new Student3
    var s: Student3 = null
    //如果对象是 null，则 isInstanceOf 一定返回 false
    println(s.isInstanceOf[Student3])
    // 判断 p 是否为 Student3 对象的实例
    if (p.isInstanceOf[Student3]) {
      //把 p 转换成 Student3 对象的实例
      s = p.asInstanceOf[Student3]
    }
    println(s.isInstanceOf[Student3])
  }

//运行结果:
false
true

canEqual

​ ：判断两个值是否能比较（基本都能比较）
$$
val\ bool:Boolean = arr1.canEqual(arr2)
$$

1
2
3
4
5
6
7
8
9
10
println(arr1.canEqual(arr2))
println(arr1.canEqual(1))
println("1".canEqual(1.0))
println(arr1.canEqual("1"))

//运行结果:
true
true
true
true

clone

​ ：克隆创建一个数组的副本，复制数组的值,但不会引用地址；就是说是浅克隆，不是深克隆。
$$
val\ arrCopy:Array[T] = arr.clone
$$

1
2
3
4
5
6
7
8
9
val arr_demo: Array[Int] = arr1.clone()
arr_demo.foreach(x =>print(s"${x}\t"))
println()
println(arr_demo == arr1)
println(arr_demo.equals(arr1))
//运行结果:
1	2	3	4	5	6	7	8	9	10
false
false

collect

​ ：提取序列中所有满足偏函数条件的元素，组成新的数组返回
$$
val\ arr:[Array[B]] = arr.collect(PartialFunction[T,B]:T=>B)
$$

1
2
3
4
5
6
7
8
9
val pf:PartialFunction[Int, Int] = (x:Int) => x match {
    case x if(x%2==1) => x
}
arr1.collect(pf).foreach(a => print(s"${a}\t"))
println()
arr1.collect({case x if(x%2 == 0) => x}).foreach(a => print(s"${a}\t"))
//运行结果:
1	3	5	7	9	
2	4	6	8	10

collectFirst

​ ：提取序列中第一个满足偏函数条件的元素
$$
val\ arr:[Array[B]] = arr.collectFirst(PartialFunction[T,B]:T=>B)
$$

1
2
3
4
5
6
7
8
9
10
val pf:PartialFunction[Int, Int] = (x:Int) => x match {
    case x if(x%2==1) => x
}
arr1.collectFirst(pf).foreach(a => print(s"${a}\t"))
println()
arr1.collectFirst({case x if(x%2 == 0) => x}).foreach(a => print(s"${a}\t"))
//运行结果:
1	
2

combinations

​ ：combinations 表示组合，这个排列组合会选出所有包含字符不一样的组合，但不考虑顺序，对于 “abc”、“cba”，视为相同组合，参数 n 表示序列长度，就是几个字符为一组
$$
var\ iter:Iterator[Array[T]] = arr.combinations(size:Int)
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
val arrTest= Array(1,2,3,4)
val iter1: Iterator[Array[Int]] = arrTest.combinations(2)
val iter2: Iterator[Array[Int]] = arrTest.combinations(3)
iter1.foreach(x=>println(x.mkString(",")))
println("***************************")
iter2.foreach(x=>println(x.mkString(",")))
//运行结果:
1,2
1,3
1,4
2,3
2,4
3,4
***************************
1,2,3
1,2,4
1,3,4
2,3,4

companion

​ : 返回一个以目标数组对应的可变类型为类型，以参数为元素的集合
$$
val\ ints:mutable.IndexedSeq[T] = arr.companion(T)
$$

1
2
3
4
5
val ints: mutable.IndexedSeq[Int] = arr1.companion(3, 4, 5)
println(ints)
//运行结果:
ArrayBuffer(3, 4, 5)

compose

​ :柯里化方法compose，f1 与 f2 只有【一个参数】，且类型相同，f1 的输出为 f2 的输入，先调用 f2，再调用 f1
$$
val\ f3 = fl compose f2
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
val f1 = (x:Int) => x+3
val f2 = (x:Int) => x*3
val f3 = (x:Int) => x-3

val fat = f1 andThen f2 andThen f3      // 先执行f1后执行f2后执行f3
val fcp = f1 compose  f2 compose f3     // 先执行f3后执行f2后执行f1
println(fat(3))
println(fcp(3))

// andThen前面的方法是def时，需要加"_"
def f4(x:Int) = x*3
def f5(x:Int) = x-3

val fdefat = f4 _ andThen f5
val fdefcp = f4 _ compose f5
println(fdefat(3))
println(fdefcp(3))
//运行结果:
15
3
6
0

contains

​ ：判断序列中是否包含指定对象
$$
val\ bool:Boolean = arr.contains(elem:Int)
$$

1
2
3
4
5
6
println(arr1.contains(5))
println(arr1.contains(11))
//运行结果:
true
false

containsSlice

​ ：判断当前序列中是否包含另一个序列(数量和顺序相等)
$$
val\ bool:Boolean = arr.containsSlice(sub:GenSeq)
$$

1
2
3
4
5
6
println(arr1.containsSlice(Array(4,5,6)))
println(arr1.containsSlice(Array(4,6,5)))
//运行结果:
true
false

copyToArray

​ ：1、参数只有SeqArray时：将当前数组Array元素全部复制到另一个数组SeqArray中，默认从Array第一个下标开始，返回新的Array数组（原Array数组会改变）

​ ：2、参数只有SeqArray，start时：将当前数组Array元素全部复制到另一个数组SeqArray中，从Array的start下标开始，返回新的Array数组（原Array数组会改变）

​ ：3、参数为SeqArray，start，len时：将当前数组Array元素全部复制到另一个数组SeqArray中，从Array的start下标开始，复制Array数组的前 len 个元素，返回新的数组（原Array数组会改变）

​ ：【理解】：参数的SeqArray数组的元素数量 >= Array 数组元素数量，做copyToArray算子操作是，应该是小数组.copyToArray（大数组），从而返回二者结合后新的数组，反之的话，返回的仍然是大数组，无意义。
$$
val\ arr:Array[T] = Array.copyToArray(SeqArr:Array[T][,start:Int,len:Int])
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
val arrTest = Array(0,0,0,0,0)

//参数:SeqArray
arrTest.copyToArray(arr1)
arr1.foreach(a=> print(s"${a}\t"))
//运行结果:
0	0	0	0	0	6	7	8	9	10	

//参数:SeqArray,start
arrTest.copyToArray(arr1,3)
arr1.foreach(a=> print(s"${a}\t"))
//运行结果:
1	2	3	0	0	0	0	0	9	10	

//参数:SeqArray,start,len
arrTest.copyToArray(arr1,3,3)
arr1.foreach(a=> print(s"${a}\t"))
//运行结果:
1	2	3	0	0	0	7	8	9	10	

//以上程序依次执行，不要同时执行，因为第一次操作后，arr1数组元素已改变，使得同时执行的结果不一致

copyToBuffer

​ ：将数组中的元复制到Buffer中
$$
val\ buffer:ArrayBuffer[T] = copyToBuffer(mutable.Buffer[T])
$$

1
2
3
4
5
6
val arrBuffTest: ArrayBuffer[Int] = new ArrayBuffer[Int]
arrBuffTest.append(0,0)
arr1.copyToBuffer(arrBuffTest)
arrBuffTest.foreach(a=> print(s"${a}\t"))
//运行结果:
0	0	1	2	3	4	5	6	7	8	9	10

corresponds

​ ：两个序列中是否所有参数按照索引顺序和参数序列符合参数函数特征

​ 当条件为对应位置元素是否相同时，和sameElements一样
$$
val\ bool:Boolean = arr.corresponds(sub:GenSeq)(p:Int=>Boolean)
$$

1
2
3
4
5
6
7
8
println(arr1.corresponds(Array.range(1,11))(_==_))
println(arr1.corresponds(Array.range(1,10))(_!=_))
println(arr1.corresponds(Array.range(2,12))(_<_))
//运行结果:
true
false
true

count

​ ：统计符合条件的元素个数
$$
val\ value : Int = arr.count(f:T=>Boolean)
$$

1
2
3
4
5
6
println(arr1.count(_>1))
println(arr1.count(_%2==0))
//运行结果:
9
5

deep

​ ：将集合的元素类型转换为Any，集合的类型不变
$$
val\ arr:mutable.IndexedSeq[T] = arr.deep
$$

1
2
3
4
5
6
7
println(arr1.getClass.getTypeName)
val deep: IndexedSeq[Any] = arr1.deep
println(deep.getClass.getTypeName)
//运行结果:
int[]
scala.collection.mutable.ArrayLike$$anon$1

diff

​ ：返回当前数组与另一个数组的差集，（即将当前数组中没有在另一个数组中出现的元素返回）
$$
val\ newArr = arr diff sub
$$

1
2
3
4
5
6
7
8
9
10
// arrStandByTest中有两个（1,3），只能消除一次
var arrTest1 = arrStandByTest.diff(arr1)
arrTest1.foreach(a=>print(s"${a}\t"))
println()
var arrTest2 = arr1.diff(arrStandByTest)
arrTest2.foreach(a=>print(s"${a}\t"))
//运行结果:
1	3	12	13	
2	4	6	8

distinct

​ :去除当前集合中重复的元素，只保留一个
$$
val\ newArr[T] = arr.distinct
$$

1
2
3
4
5
val arrTest = Array(1,1,2,2,3,3,4,5)
arrTest.distinct.foreach(x=>print(s"${x}\t"))
//运行结果:
1	2	3	4	5

drop

​ ：将当前数组中（从左边开始）前 n 个元素去除，返回一个新数组
$$
val\ newArr = arr.drop(n:Int)
$$

1
2
3
4
5
6
7
8
var arrTest1 = arr1.drop(1)
arrTest1.foreach(a=>print(s"${a}\t"))
println()
var arrTest2 = arr1.drop(5)
arrTest2.foreach(a=>print(s"${a}\t"))
//运行结果:
2	3	4	5	6	7	8	9	10	
6	7	8	9	10

dropRight

​ ：将当前数组中（从右边开始）后 n 个元素去除，返回一个新数组
$$
val\ newArr = arr.dropRight(n:Int)
$$

1
2
3
4
5
6
7
8
9
var arrTest1 = arr1.dropRight(1)
arrTest1.foreach(a=>print(s"${a}\t"))
println()
var arrTest2 = arr1.dropRight(5)
arrTest2.foreach(a=>print(s"${a}\t"))
//运行结果:
1	2	3	4	5	6	7	8	9	
1	2	3	4	5

dropWhile

​ ：返回从左侧第一个满足条件的元素开始删除到第一个不满足条件的元素结束的副本（若第一个元素不满足条件，则不删除）
$$
val\ newArr = arr.dropWhile(f:Int=>Boolean)
$$

1
2
3
4
5
6
7
8
9
var arrTest1 = arr1.dropWhile(_%2==1)
arrTest1.foreach(a=>print(s"${a}\t"))
println()
var arrTest2 = arr1.dropWhile(_%2==0)
arrTest2.foreach(a=>print(s"${a}\t"))
//运行结果:
2	3	4	5	6	7	8	9	10	
1	2	3	4	5	6	7	8	9	10

elemManifest

​ : 返回集合元素的类型，该方法过期了
$$
val\ typeOf[T] = arr.elemManifest
$$

1
2
3
4
5
6
7
8
9
val arrTest = Array(1,2,3,"a","b","c")
println(arr1.elemManifest)
println(arr2.elemManifest)
println(arrTest.elemManifest)
//运行结果:
Int
Array[Int]
java.lang.Object

elemTag

​ : 返回集合元素的类型
$$
val\ typeOf[T] = arr.elemTag
$$

1
2
3
4
5
6
7
8
9
val arrTest = Array(1,2,3,"a","b","c")
println(arr1.elemTag)
println(arr2.elemTag)
println(arrTest.elemTag)
//运行结果:
Int
Array[int]
Object

endsWith

​ ：判断当前序列是否以某个序列结尾
$$
val\ bool:Boolean = arr.endsWith(sub:GenSeq)
$$

1
2
3
4
5
6
println(arr1.endsWith(Array(9,10)))
println(arr1.endsWith(Array(8,9)))
//运行结果:
true
false

ensuring

​ :scala里，断言使用assert函数，检查使用ensuring函数，如果条件不成立，它们将会抛出AssertionError。它们都在Predef中定义。你可以使用JVM的-ea和-da命令行标志来开放和禁止断言以及检查。

eq

​ :判断两个对象引用地址是否相同
$$
val\ bool:Boolean = arr1.eq(arr2)
$$

1
2
3
4
5
6
7
8
9
val arrTest = arr1.clone
println(arr1.eq(arr1))
println(arr1.eq(arr2))
println(arr1.eq(arrTest))
//运行结果:
true
false
false

equals

​ :判断两个对象地址是否相同
$$
val\ bool:Boolean = arr1.equals(arr2)
$$

1
2
3
4
5
6
7
8
9
val arrTest = arr1.clone
println(arr1.equals(arr1))
println(arr1.equals(arr2))
println(arr1.equals(arrTest))
//运行结果:
true
false
false

exists

​ ：判断当前数组是否包含符合条件的元素
$$
val\ bool:Boolean = arr.exists(p:Int=>Boolean)
$$

1
2
3
4
5
6
println(arr1.exists(_<5))
println(arr1.exists(_>11))
//运行结果:
true
false

filter

​ ：提取集合中所有满足条件的元素,组成新的数组返回

$$
val \ arr:[Array[T]] = arr.filter(f:T=>Boolean)
$$

1
2
3
4
5
6
7
arr1.filter(_%2 == 0).foreach(a=>print(s"${a}\t"))
println()
arr1.filter(_%2 == 1).foreach(a=>print(s"${a}\t"))
//运行结果:
2	4	6	8	10	
1	3	5	7	9

filterNot

​ ：提取序列中所有不满足条件的元素，组成新的数组返回
$$
val\ arr:[Array[T]] = arr.filterNot(f:T=>Boolean)
$$

1
2
3
4
5
6
arr1.filterNot(_%2 == 0).foreach(a=>print(s"${a}\t"))
println()
arr1.filterNot(_%2 == 1).foreach(a=>print(s"${a}\t"))
//运行结果:
1	3	5	7	9	
2	4	6	8	10

find

​ ：提取序列中第一个符合函数条件的元素，如果有，返回Option（用Some包装），没有则返回None
$$
val\ arr:[Array[T]] = arr.find(f:T=>Boolean)
$$

1
2
3
4
5
6
println(arr1.find(_%2 == 0))
println(Array(1,1,1,1).find(_%2 == 0))
//运行结果:
Some(2)
None

flatMap

​ ：将多维集合降维后做map处理(map+flatten) ===>先降维，将多维数组的所有元素组合在一起，再将序列中的元素进行一些变形操作后，形成一个一维数组返回
$$
var\ tarr:Array[B] = darr.flatMap(f:T=>B)
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
var arrTest1 = arr2.flatMap(_.map(_+1))
arrTest1.foreach(a=>print(s"${a}\t"))
println()
// 相当于下面的两个操作
var arrTest2 = arr2.flatten
arrTest2.foreach(a=>print(s"${a}\t"))
println()
var arrTest3 = arrTest2.map(_+1)
arrTest3.foreach(a=>print(s"${a}\t"))
//运行结果:
2	3	4	5	6	7	
1	2	3	4	5	6	
2	3	4	5	6	7

flatten

​ ：扁平化(降维)，将多维数组的所有元素组合在一起，形成一个一维数组返回（一次flatten只能降一维）
$$
val\ tarr:Array[T] = darr.flatten
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
var arrTest1 = arr2.flatten
arrTest1.foreach(a=>print(s"${a}\t"))
println()
var arrTest2 = arr3.flatten
arrTest2.foreach(a=>print(s"${a}\t"))
println()
var arrTest3 = arr3.flatten.flatten
arrTest3.foreach(a=>print(s"${a}\t"))
//运行结果:
1	2	3	4	5	6	
[I@614c5515	[I@77b52d12	[I@2d554825	[I@68837a77	
1	2	3	4	5	6	4	5	6	7	8	9

fold

​ ：对序列中的每个元素进行二元运算，需要初始值 （默认从左边开始运算）
$$
val\ value:B = arr.fold(initval:T)(f:(T,T)=>B)
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
println(arr1.fold(0)(_ + _))
//fold流程如下
arr1.fold(0)((x:Int,y:Int) =>{
    println(s"$x + $y = ${x+y}")
    x+y
})
//运行结果:
55
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10 + 5 = 15
15 + 6 = 21
21 + 7 = 28
28 + 8 = 36
36 + 9 = 45
45 + 10 = 55

foldLeft

​ ：从左边开始对序列中的每个元素进行二元运算，需要初始值
$$
val\ value:B = arr.foldLeft(initval:T)(f:(T,T)=>B)
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
println(arr1.foldLeft(0)(_ + _))
//foldLeft流程如下
arr1.foldLeft(0)((x:Int,y:Int) =>{
    println(s"$x + $y = ${x+y}")
    x+y
})
//运行结果:
55
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10 + 5 = 15
15 + 6 = 21
21 + 7 = 28
28 + 8 = 36
36 + 9 = 45
45 + 10 = 55

foldRight

​ ：从右边开始对序列中的每个元素进行二元运算，需要初始值
$$
val\ value:B = arr.foldRight(initval:T)(f:(T,T)=>B)
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
println(arr1.foldRight(0)(_ + _))
//foldRight流程如下
arr1.foldRight(0)((x:Int,y:Int) =>{
    println(s"$x + $y = ${x+y}")
    x+y
})
//运行结果:
55
10 + 0 = 10
9 + 10 = 19
8 + 19 = 27
7 + 27 = 34
6 + 34 = 40
5 + 40 = 45
4 + 45 = 49
3 + 49 = 52
2 + 52 = 54
1 + 54 = 55

forall

​ ：检测序列中的元素是否都满足条件 p，如果序列为空，则返回 true
$$
val\ bool:Boolean = arr.forall(p:Int=>Boolean)
$$

1
2
3
4
5
6
println(arr1.forall(_>0))
println(arr1.forall(_>5))
//运行结果:
true
false

foreach

​ : 遍历序列中的元素，进行 f 操作
$$
val\T:Unit = arr1.foreach(f:(T) =>Unit)
$$

1
2
3
4
arr1.foreach(x=>print(s"${x}\t"))
//运行结果:
1	2	3	4	5	6	7	8	9	10

formatted

​ ：使用formatted可设置保留小数的位数，采用四舍五入
$$
val\ T:Double = T.formatted(T:Double)
$$

1
2
3
4
5
6
7
8
9
val a = 520.345678
println(a.formatted("%.2f"))
println(a.formatted("%.3f"))
println(a.formatted("%.4f"))
//运行结果:
520.35
520.346
520.3457

genericBuilder

​ :返回一个以目标数组对应的可变类型为类型的空集合
$$
val\ builder: mutable.Builder[Nothing, mutable.IndexedSeq[Nothing]] = arr.genericBuilder
$$

1
2
3
4
5
val builder: mutable.Builder[Nothing, mutable.IndexedSeq[Nothing]] = arr1.genericBuilder
println(builder)
//运行结果:
ArrayBuffer()

getClass

​ : 返回对象的类名称
$$
val\ typeClassNameOfT = T.getClass
$$

1
2
3
4
5
6
7
8
9
10
println(arr1.getClass)
println("arr1".getClass)
println(1.getClass)
println(1.0.getClass)
//运行结果:
class [I
class java.lang.String
int
double

groupBy

​ ：按条件分组，条件由 f 匹配，返回值是 Map 类型，每个 key 对应一个数组
$$
var\ iter:[(K,Array[T])] = arr.groupBy(key:K)
$$

1
2
3
4
5
6
7
8
9
10
11
12
var iterTest = arr4.groupBy(_._1)
println(iterTest.getClass.getName)
iterTest.foreach(a=>println(a))
iterTest.foreach(a=>a._2.foreach(i=>print(s"${i}\t")))
//运行结果:
scala.collection.immutable.HashMap$HashTrieMap
(nanNan,[Lscala.Tuple2;@366e2eef)
(qunQun,[Lscala.Tuple2;@35fb3008)
(yaoYao,[Lscala.Tuple2;@7225790e)
(weiWei,[Lscala.Tuple2;@54a097cc)
(yangYang,[Lscala.Tuple2;@36f6e879)
(nanNan,female)	(qunQun,female)	(yaoYao,male)	(weiWei,male)	(yangYang,male)

grouped

​ ：按指定数量分组，每组有 size 个元素，返回一个迭代器
$$
var\ iter:Iterator[Array[T]] = arr.grouped(size:Int)
$$

1
2
3
4
5
6
7
8
9
10
var iteratorTest = arr1.grouped(2)
//返回名
println(iteratorTest.getClass.getName)
var arrTest = iteratorTest.toArray
println(arrTest.foreach(a=>print(s"${a}\t")))
println(arrTest.flatten.foreach(a=>print(s"${a}\t")))
//运行结果:
scala.collection.Iterator$$anon$10
[I@4157f54e	[I@15975490	[I@6b143ee9	[I@1936f0f5	[I@6615435c
1	2	3	4	5	6	7	8	9	10

hasDefiniteSize

​ ：检测序列是否存在有限的长度，对应 Stream 这样的流数据则返回 false
$$
val\ bool:Boolean = arr.hasDefiniteSize
$$

1
2
3
4
5
6
println(arr1.hasDefiniteSize)
println(arr1.toStream.hasDefiniteSize)
//运行结果:
true
false

hashCode

​ : 返回对象的hashcode值
$$
val\ T:Int = T.hashcode
$$

1
2
3
4
5
6
println(arr1.hashCode())
println(arr2.hashCode())
//运行结果:
142666848
398887205

​ ： 返回序列的第一个元素，如果序列为空，将引发错误
$$
val\ v:T = arr.head
$$

1
2
3
4
5
6
println(arr1.head)
println(Array().head)
//运行结果:
1
Exception in thread "main" java.util.NoSuchElementException: next on empty iterator

headOption

​ ： 返回序列的第一个元素的 Option 类型对象，如果序列为空，则返回 None
$$
val\ v:Option[T] = arr.headOption
$$

1
2
3
4
5
println(arr1.headOption)
println(Array().headOption)
//运行结果:
Some(1)
None

indexOf

​ ：参数为只有值 v 时：返回元素 v 在序列第一次出现的索引，没有则返回 -1

​ ：参数为值 v，start是：返回从元素 v 在序列中，自 start 索引开始第一次出现的位置，每有则返回 -1
$$
val\ ix:Int = arr.indexOf(v:T[,start:Int])
$$

1
2
3
4
5
6
7
8
9
10
11
val arrTest = Array(0, 1, 1, 3, 3)
println(arrTest.indexOf(10))
println(arrTest.indexOf(1))
println(arrTest.indexOf(3,3))
println(arrTest.indexOf(3,4))
//运行结果:
-1
1
3
4

indexOfSlice

​ ：参数为只有值 SeqArr 时：返回序列 SeqArr 在序列第一次出现的索引，没有则返回 -1

​ ：参数为值 SeqArr，start是：返回从序列 SeqArr 在序列中，自 start 索引开始第一次出现的位置，每有则返回 -1
$$
val\ ix:Int = arr.indexOfSlice(SeqArr:GenSeq[,start:Int])
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
val arrTest = Array(0, 1, 1, 3, 3)
val arrTest01 = Array(1,0)
val arrTest02 = Array(1,1)
val arrTest03 = Array(3)
println(arrTest.indexOfSlice(arrTest01))
println(arrTest.indexOfSlice(arrTest02))
println(arrTest.indexOfSlice(arrTest03,3))
println(arrTest.indexOfSlice(arrTest03,4))
//运行结果:
-1
1
3
4

indexWhere

​ ：参数为只有条件 f 时：返回在 arr 序列中第一个满足条件 f 的元素的索引 ，没有则返回 -1

​ ：参数为条件 f，起始位置 start 时：返回在 arr 序列中第一个满足条件 f 的元素的索引，自 start 索引开始，没有则返回 -1
$$
val\ ix:Int = arr.indexWhere(f:T=>Boolean[,start:Int])
$$

1
2
3
4
5
6
7
8
9
10
11
12
println(arrStandBy.indexWhere(_%2==1))
println(arrStandBy.indexWhere(_%2==0))
println(arrStandBy.indexWhere(_%3==10))
println(arrStandBy.indexWhere(_%2==0,5))
println(arrStandBy.indexWhere(_%2==0,6))
//运行结果:
0
5
-1
5
6

indices

​ ：返回当前序列的索引集合

1
2
3
4
5
6
7
8
9
10
println(arr1.indices)
arr1.indices.toArray.foreach(a=>print(s"${a}\t"))
println()
println(arrStandBy.indices)
arrStandBy.indices.toArray.foreach(a=>print(s"${a}\t"))
//运行结果:
Range 0 until 10
0	1	2	3	4	5	6	7	8	9	
Range 0 until 8
0	1	2	3	4	5	6	7

init

​ ：提取序列中除了最后一个元素之外的所有元素，组成新的数组返回
$$
val\ arr:Array[Int] = arr.init
$$

1
2
3
4
5
6
arr1.init.foreach(a => print(s"${a}\t"))
println()
arrStandBy.init.foreach(a => print(s"${a}\t"))
//运行结果:
1	2	3	4	5	6	7	8	9	
1	3	5	7	9	10	12

inits

​ ：对集合中的元素进行 init 递归操作，该操作的返回值中， 第一个值是当前序列的副本，最后一个值为空，每一步都进行 init 操作，上一步的结果作为下一步的操作对象，并封装成迭代器返回
$$
val\ arr:Iterator[mutalbe.wrappedArray[T]] = arr.inits
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
arr1.inits.foreach(a =>println(a.mkString(",")))
//运行结果:
1,2,3,4,5,6,7,8,9,10
1,2,3,4,5,6,7,8,9
1,2,3,4,5,6,7,8
1,2,3,4,5,6,7
1,2,3,4,5,6
1,2,3,4,5
1,2,3,4
1,2,3
1,2
1


intersect

​ ：返回两个集合取交集的结果
$$
val\ newArr = arr intersect sub
$$

1
2
3
4
5
6
7
8
9
var arrTest1 = arr1.intersect(arrStandBy)
arrTest1.foreach(a=>print(s"${a}\t"))
println()
var arrTest2 = arrStandBy.intersect(arr1)
arrTest2.foreach(a=>print(s"${a}\t"))
//运行结果:
1	3	5	7	9	10	
1	3	5	7	9	10

isDefinedAt

​ ：判断序列中是否存在指定索引
$$
val\ bool:Boolean = arr.isDefinedAt(index:Int)
$$

1
2
3
4
5
6
println(arr1.isDefinedAt(9))
println(arr1.isDefinedAt(10))
//运行结果:
true
false

isEmpty

​ ：判断序列是否为空
$$
val\ bool:Boolean = arr.isEmpty
$$

1
2
3
4
5
6
println(arr1.isEmpty)
println(Array().isEmpty)
//运行结果:
false
true

isInstanceOf

     ：首先，需要使用isInstanceOf 判断对象是否为指定类的对象，如果是的话，则可以使用 asInstanceOf 将对象转换为指定类型；

  • 注意：p.isInstanceOf[XX] 判断 p 是否为 XX 对象的实例；p.asInstanceOf[XX] 把 p 转换成 XX 对象的实例

  • 注意：如果没有用isInstanceOf 先判断对象是否为指定类的实例，就直接用 asInstanceOf 转换，则可能会抛出异常；

  • 注意：如果对象是 null，则isInstanceOf 一定返回 false， asInstanceOf 一定返回 null；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Person3 {}
class Student3 extends Person3
object Student3 {

  def main(args: Array[String]) {
    val p: Person3 = new Student3
    var s: Student3 = null
    //如果对象是 null，则 isInstanceOf 一定返回 false
    println(s.isInstanceOf[Student3])
    // 判断 p 是否为 Student3 对象的实例
    if (p.isInstanceOf[Student3]) {
      //把 p 转换成 Student3 对象的实例
      s = p.asInstanceOf[Student3]
    }
    println(s.isInstanceOf[Student3])
  }

//运行结果:
false
true

isTraversableAgain

​ :判断序列是否可以反复遍历，该方法是 GenTraversableOnce 中的方法，对于 Traversables 一般返回 true，对于 Iterators 返回 false，除非被复写 或者说判断是否为迭代器（只能遍历一次）
$$
val\ bool:Boolean = arr.isTraversableAgain
$$

1
2
3
4
5
6
println(arr1.isTraversableAgain)
println(arr1.toIterator.isTraversableAgain)
//运行结果:
true
false

iterator

​ :Scala Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法。

​ 迭代器 it 的两个基本操作是 next 和 hasNext。

1
2
3
4
5
6
7
val iterator: Iterator[Int] = arr1.toIterator
println(iterator.next())
println(iterator.hasNext)
//运行结果:
1
true

last

​ ：返回序列的最后一个元素，如果序列为空，将引发错误
$$
val\ v:T = arr.last
$$

1
2
3
4
5
println(arr1.last)
println(Array().last)
//运行结果:
10
Exception in thread "main" java.util.NoSuchElementException: next on empty iterator

lastIndexOf

​ ：参数为只有值 v 时：返回元素 v 在序列 arr 最后一次出现的索引，没有则返回 -1

​ ：参数为值 v，end是：返回从元素 v 在序列中，自 end索引之前【包括end索引】最后一次出现的位置，每有则返回 -1
$$
val\ ix:Int = arr.lastIndexOf(v:T[,end:Int])
$$

1
2
3
4
5
6
7
8
9
10
11
val arrTest = Array(0, 1, 1, 3, 3)
println(arrTest.lastIndexOf(10))
println(arrTest.lastIndexOf(1))
println(arrTest.lastIndexOf(3,3))
println(arrTest.lastIndexOf(3,4))
//运行结果:
-1
2
3
4

lastIndexOfSlice

​ ：参数为只有值 SeqArr 时：返回序列 SeqArr 在序列最后一次出现的索引，没有则返回 -1

​ ：参数为值 SeqArr，end是：返回从序列 SeqArr 在序列中，自 end 索引之前【包括end 索引】最后一次出现的位置，没有则返回 -1
$$
val\ ix:Int = arr.lastIndexOfSlice(arr:GenSeq[,end: Int])
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
val arrTest = Array(0, 1, 1, 3, 3)
val arrTest01 = Array(1,0)
val arrTest02 = Array(1,3)
val arrTest03 = Array(3)
println(arrTest.lastIndexOfSlice(arrTest01))
println(arrTest.lastIndexOfSlice(arrTest02))
println(arrTest.lastIndexOfSlice(arrTest03,3))
println(arrTest.lastIndexOfSlice(arrTest03,4))
//运行结果:
-1
2
3
4

lastIndexWhere

​ ：参数为只有条件 f 时：返回在 arr 序列中追后一个满足条件 f 的元素的索引 ，没有则返回 -1

​ ：参数为条件 f，结束位置 end 时：返回在 arr 序列中最后一个满足条件 f 的元素的索引，在 end索引之前【包括 end 索引】，没有则返回 -1
$$
val ix:Int = arr.lastIndexWhere(f:T=>Boolean[,end:Int])
$$

1
2
3
4
5
6
7
8
9
10
11
12
println(arrStandBy.lastIndexWhere(_%2==1))
println(arrStandBy.lastIndexWhere(_%2==0))
println(arrStandBy.lastIndexWhere(_%3==10))
println(arrStandBy.lastIndexWhere(_%2==0,5))
println(arrStandBy.lastIndexWhere(_%2==0,6))
//运行结果:
7
6
-1
5
6

lastOption

​ ：返回序列的最后一个元素的 Option 类型对象，如果序列为空，则返回 None
$$
val\ v:Option[T] = arr.lastOption
$$

1
2
3
4
5
println(arr1.lastOption)
println(Array().lastOption)
//运行结果:
Some(10)
None

length

​ ：获取集合的（长度）大小，同size
$$
val\ len:Int = arr.length
$$

1
2
3
4
5
6
println(arr1.length)
println(arr2.length)
//运行结果:
10
2

lengthCompare

​ ：比较序列的长度和参数 len，返回序列的长度减去 len 的结果
$$
val\ dif:Int = arr.lengthCompare(len:Int)
$$

1
2
3
4
5
6
7
8
println(arr1.lengthCompare(8))
println(arr1.lengthCompare(10))
println(arr1.lengthCompare(12))
//运行结果:
2
0
-2

lift

​ ：提取集合对应下标的值，返回Option类型（有值用some包装，没有返回None）
$$
val\ f:Int=>T = arr.lift
$$

1
2
3
4
5
6
println(arr1.lift(2))
println(arr1.lift(22))
//运行结果:
Some(3)
None

map

​ ：将序列中的元素进行一些变形操作后。再次返回新的集合（集合操作前后类型相同）
$$
val\ tarr:Array[B] = arr.map(f:T=>B)
$$

1
2
3
4
5
6
7
arr1.map(a=>print(s"${a+1}\t"))
println()
arr1.map(a=>print(s"${a-1}\t"))
//运行结果:
2	3	4	5	6	7	8	9	10	11	
0	1	2	3	4	5	6	7	8	9

max

​ ：返回序列中最大的元素
$$
val\ value:T = arr.max
$$

1
2
3
4
5
6
println(arr1.max)
println(arr2.flatten.max)
//运行结果:
10
6

maxBy

​ ：返回序列中符合条件的第一个元素（如果所有元素都不满足，返回第一个元素）
$$
val\ value:T = arr.maxBy(_.?)=>T:Tuple | class
$$

1
2
3
4
5
6
7
8
println(arr1.maxBy(_>=5))
println(arr1.maxBy(_%2==0))
println(arr1.maxBy(_>11))
//运行结果:
5
2
1

min

​ ：返回序列中最小的元素
$$
val\ value:T = arr.min
$$

1
2
3
4
5
6
println(arr1.min)
println(arr2.flatten.min)
//运行结果:
1
1

minBy

​ ：返回序列中不符合条件的第一个元素（没有满足条件的就返回第一个值）
$$
val\ value:T = arr.minBy(_. ?)=>T:Tuple | class
$$

1
2
3
4
5
6
7
8
println(arr1.minBy(_<=5))
println(arr1.minBy(_%2==1))
println(arr1.minBy(_>11))
//运行结果:
6
2
1

mkString

​ ：当参数为 seq 时：返回一个用指定分隔符 seq ，将 arr 中各个元素分隔后的组成的字符串

​ ：当参数为 start，seq，end 时：返回一个用指定分隔符 seq 将 arr 中各个元素分隔，并在首尾各加上指定的 start 和 end 字符串后 组成的字符串
$$
var\ str:string = arr.mkString([start:string,] sep:string[, end:string])
$$

1
2
3
4
5
6
7
8
9
10
11
//参数为 seq
val str1 = arr1.mkString("-")
println(str1)

//参数为 start，seq，end 
val str2 = arr1.mkString("[","-","]")
println(str2)
//运行结果:
1-2-3-4-5-6-7-8-9-10
[1-2-3-4-5-6-7-8-9-10]

ne

​ :判断两个对象引用地址是否不相同
$$
val\ bool:Boolean = arr.ne(arr2)
$$

1
2
3
4
5
6
println(arr1.ne(arr1))
println(arr1.ne(arr2))
//运行结果:
false
true

nonEmpty

​ ：判断序列是否不为空
$$
val\ bool:Boolean = arr.nonEmpty
$$

1
2
3
4
5
6
println(arr1.nonEmpty)
println(Array().nonEmpty)
//运行结果:
true
false

notify

​ ：关于Scala的并发支持的相关问题将在后面的博客统一介绍

notifyAll

​ ：关于Scala的并发支持的相关问题将在后面的博客统一介绍

orElse

​ ：提取根据参数（偏函数规则）提取数组元素
$$
val\ f:PartialFunction[T,B] = arr.orElse (f:PartialFunction[T,B])
$$

1
2
3
4
5
6
7
8
9
10
val pf: PartialFunction[Int, Any] = arr1.orElse({
    case ix if (ix >= 0 && ix < arr1.length) => Some(arr1(ix))
    case _ => None
})
println(pf(5))
println(pf(10))
//运行结果:
6
None

padTo

​ ：返回一个填充后的序列，如果当前序列长度 >= len，则返回当前序列，反之则产生相应 len 长的序列，多于的索引位置填充默认值 elem
$$
val\ arr:Array[T] = arr.padTo(len:Int,elem:T)
$$

1
2
3
4
5
6
7
arr1.padTo(10,0).foreach(a=>print(s"${a}\t"))
println()
arr1.padTo(15,0).foreach(a=>print(s"${a}\t"))
//运行结果:
1	2	3	4	5	6	7	8	9	10	
1	2	3	4	5	6	7	8	9	10	0	0	0	0	0

par

​ ：返回一个并行实现，产生的并行序列不能被修改，其作用相当于hashcode进行分区
$$
val\ parr:ParArray[T]= arr.par
$$

1
2
3
4
5
val par: ParArray[Int] = arr1.par
par.foreach(a=> print(s"${a}\t"))
//运行结果:
3	4	1	10	7	2	5	9	6	8

partition

​ ：按条件将序列拆分成两个数组，满足条件的放到第一个数组，其余的放到第二个数组，返回的是包含这两个数组的元组
$$
var\ arr:(Array[T],Array[T]) = arr.partition(f:T=>Boolean)
$$

1
2
3
4
5
6
7
8
var arrTest = arr1.partition(_%2==1)
arrTest._1.foreach(a=>print(s"${a}\t"))
println()
arrTest._2.foreach(a=>print(s"${a}\t"))
//运行结果:
1	3	5	7	9	
2	4	6	8	10

patch

​ ：批量替换，从原序列的 from 处开始，后面的 replaced 个元素，将被替换成序列 sub
$$
val\ newArr = arr.patch(from:Int,sub:GenSeq, replaceLen:Int)
$$

1
2
3
4
5
var arrTest = arr1.patch(3,arrStandBy,5)
arrTest.foreach(a=>print(s"${a}\t"))
//运行结果:
1	2	3	1	3	5	7	9	10	12	13	9	10

permutations

​ :permutations 表示排列，这个排列组合会选出所有排列顺序不同的字符组合，permutations 与 combinations 不同的是，相同的组合考虑排列，对于 “abc”、“cba”，视为不同的组合
$$
var\ iter:Iterator[Array[T]] = arr.permutations
$$

1
2
3
4
5
6
7
8
9
10
11
val arrTest = Array("a","b","c")
val per: Iterator[Array[String]] = arrTest.permutations
per.toList.foreach(a=>println(s"${a.mkString(",")}"))
//运行结果:
a,b,c
a,c,b
b,a,c
b,c,a
c,a,b
c,b,a

prefixLength

​ ：由第一个索引开始，返回序列中满足条件的元素数量，直到第一个不满足的结束（若第一个元素就不符合条件，则返回0）
$$
val\ len:Int = arr.prefixLength (f:Int=>Boolean)
$$

1
2
3
4
5
6
println(arr1.prefixLength(_>2))
println(arr1.prefixLength(_<=2))
//运行结果:
0
2

product

​ :返回所有元素乘积的值
$$
val\ value:Int = arr.product
$$

1
2
3
4
5
6
7
val arrTest = Array(1,2,3)
println(arrTest.product)
println(arr1.product)
//运行结果:
6
3628800

reduce

​ ：对序列中的每个元素进行二元运算，不需要初始值（默认从左边开始运算）,当序列为空时，会报异常
$$
val\ value:B = arr.reduce(f:(T,T)=>B)
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
println(arr1.reduce(_ + _))
// reduce 的流程如下
arr1.reduce((x:Int,y:Int) =>{
    println(s"$x + $y = ${x+y}")
    x+y
})
//运行结果:
55
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10 + 5 = 15
15 + 6 = 21
21 + 7 = 28
28 + 8 = 36
36 + 9 = 45
45 + 10 = 55

reduceLeft

​ ：从左边开始对序列中的每个元素进行二元运算，不需要初始值, 当序列为空时，会报异常
$$
val\ value:B = arr.reduceLeft(f:(T,T)=>B)
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
println(arr1.reduceLeft(_ + _))
//reduceLeft流程如下
arr1.reduceLeft((x:Int,y:Int) =>{
    println(s"$x + $y = ${x+y}")
    x+y
})
//运行结果:
55
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10 + 5 = 15
15 + 6 = 21
21 + 7 = 28
28 + 8 = 36
36 + 9 = 45
45 + 10 = 55

reduceLeftOption

​ ：从左边开始对序列中的每个元素进行二元运算，不需要初始值，返回用Some封装后的结果
$$
val\ value:B = arr.reduceLeftOption(f:(T,T)=>B)
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
println(arr1.reduceLeftOption(_ + _))
//reduceLeftOption流程如下
arr1.reduceLeftOption((x:Int,y:Int) =>{
    println(s"$x + $y = ${x+y}")
    x+y
})
//运行结果:
Some(55)
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10 + 5 = 15
15 + 6 = 21
21 + 7 = 28
28 + 8 = 36
36 + 9 = 45
45 + 10 = 55

reduceOption

​ : 同 reduceLeftOption，计算Option，返回 Option,序列不为空,返回some，为空返回none
$$
val\ value:B = arr.reduceOption(f:(T,T)=>B)
$$

1
2
3
4
5
6
7
8
val arrTest1: Array[Int] = Array(1, 2, 3)
val arrTest2: Array[Int]  = Array()
println(arrTest1.reduceOption(_+_))
println(arrTest2.reduceOption(_-_))
//运行结果:
Some(6)
None

reduceRight

​ ：从右边开始对序列中的每个元素进行二元运算，不需要初始值, 当序列为空时，会报异常
$$
val\ value:B = arr.reduceRight (f:(T,T)=>B)
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
println(arr1.reduceRight(_ + _))
//reduceRight流程如下
arr1.reduceRight((x:Int,y:Int) =>{
    println(s"$x + $y = ${x+y}")
    x+y
})
//运行结果:
55
9 + 10 = 19
8 + 19 = 27
7 + 27 = 34
6 + 34 = 40
5 + 40 = 45
4 + 45 = 49
3 + 49 = 52
2 + 52 = 54
1 + 54 = 55

reduceRightOption

​ ：从右边开始对序列中的每个元素进行二元运算，不需要初始值，返回用Some封装后的结果
$$
val\ value:B = arr.reduceRightOption(f:(T,T)=>B)
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
println(arr1.reduceRightOption(_ + _))
//reduceRightOption流程如下
arr1.reduceRightOption((x:Int,y:Int) =>{
    println(s"$x + $y = ${x+y}")
    x+y
})
//运行结果:
Some(55)
9 + 10 = 19
8 + 19 = 27
7 + 27 = 34
6 + 34 = 40
5 + 40 = 45
4 + 45 = 49
3 + 49 = 52
2 + 52 = 54
1 + 54 = 55

repr

​ ：返回一个序列本身一模一样的副本, 复制序列的值与引用地址，属于深克隆
$$
val\ arr:mutable.wrappedArray[T] = arr.repr
$$

1
2
3
4
5
6
val repr: Array[Int] = arr1.repr
println(repr.equals(arr1))
println(repr == arr1)
//运行结果:
true
true

reverse

​ ：返回将原序列反转后的序列
$$
val\ arr : Array[T]= arr.reverse
$$

1
2
3
4
5
val reverse: Array[Int] = arr1.reverse
reverse.foreach(a=>print(s"${a}\t"))
//运行结果:
10	9	8	7	6	5	4	3	2	1

reverseIterator

​ ：返回将原序列反转后的序列迭代器
$$
val\ arr : Iterator[T]= arr.reverseIterator
$$

1
2
3
4
val iterator: Iterator[Int] = arr1.reverseIterator
iterator.foreach(a=>print(s"${a}\t"))
//运行结果:
10	9	8	7	6	5	4	3	2	1

reverseMap

​ ：将序列中的元素进行一些变形操作后。再次返回新的集合(数据顺序相反)
$$
val\ tarr:Array[B] = darr.reverseMap(f:T=>B)
$$

1
2
3
4
var arrTest = arr1.reverseMap(_+1)
arrTest.foreach(a=>print(s"${a}\t"))
//运行结果:
11	10	9	8	7	6	5	4	3	2

runWith

​ ：第二个参数为下标，不存在返回false,下表存在则将下标下的元素传入偏函数中
$$
val\ bool:Boolean = arr.runWith(f:PartialFunction)(index:Int)
$$

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
// 偏函数
var pf:PartialFunction[Int,Option[String]] = (x:Int) => x match {
    case i if i%3==0 => Some("three")
    case i if i%7==0 => Some("seven")
    case i => None
}

pf.runWith(println)(5) //=> 输出 None			返回false
pf.runWith(println)(6) //=> 输出 Some(three)	返回true
//以第二参数下标提取序列元素，作为第一参数函数的入口
//下表存在，且元素符合函数规则返回true
//下表存在，且元素不符合函数规则报异常
//下标不存在返回false
val boo1: Boolean = arr1.runWith(x => x match {
    case x if x % 2 == 0 => x
})(17)
println(boo1)

val boo2: Boolean = arr1.runWith(x => x match {
    case x if x % 2 == 0 => x
})(3)
println(boo2)

//运行结果:
None
Some(three)
false
true

sameElements

​ ：判断两个序列是否顺序和对应位置上的元素都一样
$$
val\ bool:Boolean = arr.sameElements(sub:GenSeq)
$$

1
2
3
4
5
println(arr1.corresponds(Array.range(1,11))(_==_))
println(arr1.corresponds(Array.range(2,12))(_==_))
//运行结果:
true
false

scan

​ ：对序列中的每个元素进行二元运算，需要初始值 （默认从左边开始运算） ==>同fold
$$
val\ value:Array[B] = arr.scan(initVal:T)(f:(T,T)=>B)
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
arr1.scan(0)(_+_).foreach(a=>print(s"${a}\t"))
//scan运行流程如下
println()
arr1.scan(0)((x:Int,y:Int) =>{
    println(s"$x + $y = ${x+y}")
    x+y
})
//运行结果:
0	1	3	6	10	15	21	28	36	45	55	
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10 + 5 = 15
15 + 6 = 21
21 + 7 = 28
28 + 8 = 36
36 + 9 = 45
45 + 10 = 55

scanLeft

​ ：从左边开始对序列中的每个元素进行二元运算，需要初始值 ==>同foldLeft
$$
val\ value:Array[B] = arr.scanLeft(initVal:T)(f:(T, T)=>B)
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
arr1.scanLeft(0)(_+_).foreach(a=>print(s"${a}\t"))
//scanLeft运行流程如下
println()
arr1.scanLeft(0)((x:Int,y:Int) =>{
    println(s"$x + $y = ${x+y}")
    x+y
})
//运行结果:
0	1	3	6	10	15	21	28	36	45	55	
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10 + 5 = 15
15 + 6 = 21
21 + 7 = 28
28 + 8 = 36
36 + 9 = 45
45 + 10 = 55

scanRight

​ ：从右边开始对序列中的每个元素进行二元运算，需要初始值 ==>同foldRight
$$
val\ value:Array[B] = arr.scanRight(initVal:T)(f:(T,T)=>B)
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
arr1.scanRight(0)(_+_).foreach(a=>print(s"${a}\t"))
//scanRight运行流程如下
println()
arr1.scanRight(0)((x:Int,y:Int) =>{
    println(s"$x + $y = ${x+y}")
    x+y
})
//运行结果:
55	54	52	49	45	40	34	27	19	10	0	
10 + 0 = 10
9 + 10 = 19
8 + 19 = 27
7 + 27 = 34
6 + 34 = 40
5 + 40 = 45
4 + 45 = 49
3 + 49 = 52
2 + 52 = 54
1 + 54 = 55

segmentLength

​ ：从序列的指定pos开始向后查找，返回满足条件的连续元素的长度[ 到第一个不满足条件的元素则结束 ]
$$
val\ len:Int = arr.segmentLength(f:Int=>Boolean,pos:Int)
$$

1
2
3
4
5
6
println(arr1.segmentLength(_>6,1))
println(arr1.segmentLength(_>=6,5))
//运行结果:
0
5

seq

​ ：scala中的一种集合，具体如下图：

image-20210912115113028

size

​ ：获取集合的大小（长度）,同length
$$
val\ size:Int = arr.size
$$

1
2
3
4
5
6
println(arr1.size)
println(arr2.size)
//运行结果:
10
2

slice

​ ：提取从from（inclusive）至unitil（exclusive）之间的所有元素（取集合中从from开始至unitil-1结束的所有元素），组成新的数组返回
$$
val\ arr:[Array[T]] = arr.slice(from:Int,until:Int)
$$

1
2
3
4
5
6
arr1.slice(0,5).foreach(a => print(s"${a}\t"))
println()
arr1.slice(1,7).foreach(a => print(s"${a}\t"))
//运行结果:
1	2	3	4	5	
2	3	4	5	6	7

sliding

​ ：从第一个元素开始，每个元素和它后面的 size个元素组成一个数组，返回一个迭代器，当剩余元素个数不够 size 时，则结束。该方法可以设置步长 step，每一组元素组合完后，下一组从上一组起始元素位置 + step 后的位置处开始（当size == step 时，作用和 grouped 一样）
$$
var\ iter:Iterator[Array[T]] = arr.sliding(size:Int[,step:Int default 1])
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//sliding(size)
var iteratorTest = arr1.sliding(2)
println(iteratorTest.getClass.getName)
var arrTest = iteratorTest.toArray
println(arrTest.foreach(a=>print(s"${a}\t")))
println(arrTest.flatten.foreach(a=>print(s"${a}\t")))
println("==============")
//sliding(size,step)
var iteratorTest1 = arr1.sliding(2,3)
println(iteratorTest1.getClass.getName)
var arrTest1 = iteratorTest1.toArray
println(arrTest1.foreach(a=>print(s"${a}\t")))
println(arrTest1.flatten.foreach(a=>print(s"${a}\t")))
//运行结果:
scala.collection.Iterator$$anon$10
[I@4157f54e	[I@15975490	[I@6b143ee9	[I@1936f0f5	[I@6615435c	[I@4909b8da	[I@3a03464	[I@2d3fcdbd	[I@617c74e5	
1	2	2	3	3	4	4	5	5	6	6	7	7	8	8	9	9	10
==============
scala.collection.Iterator$$anon$10
[I@6276ae34	[I@7946e1f4	[I@3c09711b	[I@5cc7c2a6
1	2	4	5	7	8	10

sortBy

​ ：返回一个使用指定的排序规则后的序列
$$
val\ arr:Array[T] = arr.sortBy(f:T=>T)
$$

1
2
3
4
5
6
7
8
val ArrayTest: Array[Int] = Array(3, 56, 78, 5, 3, 67, 8, 45, 2)
ArrayTest.sortBy(a => a).foreach(a=>print(s"${a}\t"))
println()
ArrayTest.sortBy(b=> -b).foreach(a=>print(s"${a}\t"))
//运行结果:
2	3	3	5	8	45	56	67	78	
78	67	56	45	8	5	3	3	2

sortWith

​ ：返回一个使用自定义排序规则后的序列
$$
val\ arr:Array[T] = arr.sortWith(f:(T1,T2)=>Boolean)
$$

1
2
3
4
5
6
7
8
val ArrayTest: Array[Int] = Array(3, 56, 78, 5, 3, 67, 8, 45, 2)
ArrayTest.sortWith(_ < _).foreach(a=>print(s"${a}\t"))
println()
ArrayTest.sortWith(_ > _ ).foreach(a=>print(s"${a}\t"))
//运行结果:
2	3	3	5	8	45	56	67	78	
78	67	56	45	8	5	3	3	2

sorted

​ ：返回一个使用升序排序规则后的序列
$$
val\ arr:Array[T]= arr.sorted
$$

1
2
3
4
5
val ArrayTest: Array[Int] = Array(3, 56, 78, 5, 3, 67, 8, 45, 2)
ArrayTest.sorted.foreach(a=>print(s"${a}\t"))
//运行结果:
2	3	3	5	8	45	56	67	78

span

​ ：返回一个两个数组的元祖：将序列 arr 拆分成两个数组，从第一个元素开始，到第一个不满足条件 f 的元素位置，将这些元素放 到第一个数组中，其余的放到第二个数组中
$$
val\ tp2 : (Array [T] ,Array[T]) = arr.span(f:T=>Boolean).
$$

1
2
3
4
5
6
7
arr1.span(_<=5)._1.foreach(a=>print(s"${a}\t"))
println()
arr1.span(_<=5)._2.foreach(a=>print(s"${a}\t"))
//运行结果:
1	2	3	4	5	
6	7	8	9	10

splitAt

​ ：返回一个两个数组的元祖：从指定位置 index 开始【不是索引，下标从1开始】，index 之前【包括 index 】的元素放入第一个数 组中，其余的放入第二个数组中
$$
val\ tp2 : (Array[T],Array[T]) = arr.splitAt(index : Int)
$$

1
2
3
4
5
6
arr1.splitAt(5)._1.foreach(a=>print(s"${a}\t"))
println()
arr1.splitAt(5)._2.foreach(a=>print(s"${a}\t"))
//运行结果:
1	2	3	4	5	
6	7	8	9	10

startsWith

​ ：判断序列是否以某个序列开始,若指定偏移量，则判断序列从指定偏移处是否以某个序列开始
$$
val\ bool:Boolean = arr.startsWith(sub:GenSeq[,offset:Int])
$$

1
2
3
4
5
6
7
8
9
10
println(arr1.startsWith(Array(1,2)))
println(arr1.startsWith(Array(2,3)))
println(arr1.startsWith(Array(2,3),1))
println(arr1.startsWith(Array(2,3),2))
//运行结果:
true
false
true
false

stringPrefix

​ ：返回 toString 结果的前缀
$$
val\ value:String = arr.stringPrefix
$$

1
2
3
4
5
6
println(arr1.stringPrefix)
println(arr1.toString)
//运行结果:
[I
[I@71be98f5

sum

​ ：序列求和
$$
val\ value:T = arr.sum
$$

1
2
3
4
println(arr1.sum)
//运行结果:
55

synchronized

​ ：关于Scala的并发支持的相关问题将在后面的博客统一介绍

tail

​ ：提取序列中除了第一个元素之外的所有元素，组成新的数组返回
$$
val\ arr:Array[Int] = arr.tail
$$

1
2
3
4
5
6
7
arr1.tail.foreach(a => print(s"${a}\t"))
println()
arrStandBy.tail.foreach(a => print(s"${a}\t"))
//运行结果:
2	3	4	5	6	7	8	9	10	
3	5	7	9	10	12	13

tails

​ ：对集合中的元素进行 tail 迭代操作，该操作的返回值中， 第一个值是当前序列的副本，最后一个值为空，每一步都进行tail 操作，上一步的结果作为下一步的操作对象，并封装成迭代器返回
$$
val\ arr:Iterator[mutalbe.wrappedArray[T]] = arr.tails
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
arr1.tails.foreach(a =>println(a.mkString(",")))
//运行结果:
1,2,3,4,5,6,7,8,9,10
2,3,4,5,6,7,8,9,10
3,4,5,6,7,8,9,10
4,5,6,7,8,9,10
5,6,7,8,9,10
6,7,8,9,10
7,8,9,10
8,9,10
9,10
10


take

​ ：返回当前序列中，前 size 个元素组成的序列（从左边取 size个元素）
$$
val \ \ arr:[Array[T]] = arr.take(size:Int)
$$

1
2
3
4
5
6
arr1.take(5).foreach(a=>print(s"${a}\t"))
println()
arr1.take(20).foreach(a=>print(s"${a}\t"))
//运行结果:
1	2	3	4	5	
1	2	3	4	5	6	7	8	9	10

takeRight

​ ：返回当前序列中，后 size 个元素组成的序列（从右边取 size 个元素）
$$
val \ arr:[Array[T]] = arr.takeRight(size:Int)
$$

1
2
3
4
5
6
arr1.takeRight(5).foreach(a=>print(s"${a}\t"))
println()
arr1.takeRight(20).foreach(a=>print(s"${a}\t"))
//运行结果:
6	7	8	9	10	
1	2	3	4	5	6	7	8	9	10

takeWhile

​ ：返回当前序列中，从下标 0 开始取，从第一个满足条件开始到第一个不满足条件结束（也就是说：若第一个元素（下标为0）不符合，则返回空，一个也匹配不上）

1
2
3
4
5
6
7
arrStandBy.takeWhile(_%2 == 0).foreach(a=>print(s"${a}\t"))
println()
arrStandBy.takeWhile(_%2 == 1).foreach(a=>print(s"${a}\t"))
//运行结果:
(空结果，因为第一个不匹配)
1	3	5	7	9

to

​ :常用于循环语句中（左闭右闭），与之相反的util（左闭右开）

​ :序列中的to使用，会将序列转换为Vector类型

1
2
3
4
5
6
7
8
9
10
11
12
for(i <- 1 to 10){
    print(s"${i}\t")
}
println()
for(i <- 1 until 10){
    print(s"${i}\t")
}
println(arr1.to)
//运行结果:
1	2	3	4	5	6	7	8	9	10	
1	2	3	4	5	6	7	8	9	
Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

toArray

​ ：返回一个将序列转换为Array的数组，从而进行Array的操作
$$
val\ arr:Array[T]= arr.toArray
$$

1
2
3
4
5
6
ArrayBuffer(1, 2, 3, 4, 5)
ArrayBuffer(1, 2, 3, 4, 5).toArray
//将上面的两个对象获取类型查看类型【直接 .var】
val arrBuffTest: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 5)
val arrayTest: Array[Int] = arrBuffTest.toArray
//阔以看出原本的ArrayBuffer类型转换为Array，这样的转换，显然无意义，具体看业务执行，例如将Map转换为Array

toBuffer

​ ：返回一个将序列转换为Buffer的可变集合，从而进行Buffer的操作
$$
val\ arr:mutable.Buffer[T]= arr.toBuffer
$$

1
2
3
4
arr1.toBuffer
//将上面的对象获取类型查看其类型【直接 .var】
val buffer: mutable.Buffer[Int] = arr1.toBuffer
//阔以看出原本的Array类型转换为Buffer

toIndexedSeq

​ :scala中的 Trait Seq 有两个子trait LinearSeq 和 IndexedSeq。这些都没有增加新的函数，但是每个都提供了不同的执行特征：linear 序列包括有效head和tail方法, 然而一个indexed 序列 包含有效的apply,length,(如果可变)update方法。 频繁调用linear序列的是 scala.collection.immutable.List and scala.collection.immutable.Stream ，频繁调用indexed序列的 scala.Array and scala.collection.mutable.ArrayBuffer .Vector提供了一个令人感兴趣的折中，在indexed和linear,他能有效的确保稳定的index和linear访问的时间总开销 。 因此，他是一个非常好的混合访问模式。
$$
val\ seq: immutable.IndexedSeq[T] = arr.toIndexedSeq
$$

1
2
3
4
5
val seq: immutable.IndexedSeq[Int] = arr1.toIndexedSeq
println(seq)
//运行结果:
Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

toIterable

​ :把集合或迭代器转化为可重复遍历的集合,作用与toTraversable类似
$$
val\ iterable: Iterable[T] = arr.toIterable
$$

1
2
3
4
5
6
7
8
9
10
val iterable: Iterable[Int] = arr1.toIterable
iterable.foreach(a=>print(s"${a}\t"))
println()
iterable.foreach(a=>print(s"${a}\t"))
println()
iterable.foreach(a=>print(s"${a}\t"))
//运行结果:
1	2	3	4	5	6	7	8	9	10	
1	2	3	4	5	6	7	8	9	10	
1	2	3	4	5	6	7	8	9	10

toIterator

​ :把集合或序列转换为迭代器
$$
val\ iterator: Iterator[Int] = arr.toIterator
$$

1
val iterator: Iterator[Int] = arr1.toIterator

toList

​ :把集合或序列转换为列表
$$
val\ list: List[Int] = arr.toList
$$

1
val list: List[Int] = arr1.toList

toMap

​ ：将序列转转换成 Map 类型，需要被转化序列中包含的元素是 Tuple2 类型，Tuple2 类型意思是：元组必须是2元的，以元组的第一个元素做键，第二个元素做值
$$
val\ arr : Map[K,V]= arr.toMap
$$

1
2
3
4
5
6
val map: Map[String, String] = arr4.toMap
println(map.toString)
println(map("nanNan"))
//运行结果:
Map(nanNan -> female, qunQun -> female, yaoYao -> male, weiWei -> male, yangYang -> male)
female

toSeq

​ :把集合或序列转换为seq(scala数据类型的一种)
$$
val\ seq: Seq[Int] = arr.toSeq
$$

1
val seq: Seq[Int] = arr1.toSeq

toSet

​ ：返回一个将arr 元素去重后的 set 序列
$$
val arr: set[T] = arr.toSet
$$

1
2
3
4
5
6
7
8
val arrTest = Array(1, 1, 2, 2, 3, 3, 4, 4)
arrTest.toSet.foreach(println)
//运行结果:
1
2
3
4

toStream

​ :将对象转化为数据流
$$
val\ stream: Stream[T] = arr.toStream
$$

1
2
3
4
val stream1: Stream[Int] = arr1.toStream
println(stream1)
//运行结果:
Stream(1, ?)

toString

​ :将对象转化为字符串，返回对象的地址名称，常与其他方法连用
$$
val\ string: String = arr.toString
$$

1
2
3
4
val string: String = arr1.toString
println(string)
//运行结果:
[I@548c4f57

toTraversable

​ :把集合或迭代器转化为可重复遍历的集合,作用与toIterable类似
$$
val\ traversable: Traversable[Int] = arr1.toTraversable
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
val iterator = arr1.toIterator
iterator.foreach(a=>print(s"${a}\t"))
println
iterator.foreach(a=>print(s"${a}\t"))  //没了，只能遍历一次
println
iterator.foreach(a=>print(s"${a}\t"))  //没了，只能遍历一次
println
val traversable: Traversable[Int] = arr1.toTraversable
traversable.foreach(a=>print(s"${a}\t"))
println()
traversable.foreach(a=>print(s"${a}\t"))
println()
traversable.foreach(a=>print(s"${a}\t"))
//运行结果:
1	2	3	4	5	6	7	8	9	10	


1	2	3	4	5	6	7	8	9	10	
1	2	3	4	5	6	7	8	9	10	
1	2	3	4	5	6	7	8	9	10

toVector

​ :将集合转化为Vector类型
$$
val\ vector: Vector[T] = arr.toVector
$$

1
2
3
4
5
val vector: Vector[Int] = arr1.toVector
println(vector)
//运行结果:
Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

transform

​ ： 将序列中的元素进行一些变形操作后。再次返回新的集合（集合操作前后类型相同,原集合数据改变）
$$
var\ tarr:Array[B] = darr.transform (f:T=>B)
$$

1
2
3
4
5
6
7
8
9
10
11
12
arr1.foreach(a=>print(s"${a}\t"))
println()
arr1.transform(a=>a+1)
arr1.foreach(a=>print(s"${a}\t"))
println()
arr1.transform(_-1)
arr1.foreach(a=>print(s"${a}\t"))
//运行结果:
1	2	3	4	5	6	7	8	9	10	
2	3	4	5	6	7	8	9	10	11	
1	2	3	4	5	6	7	8	9	10

transpose

​ ：矩阵转换，二维数组行列转换，先二维数组的子数组的同下标的元素放在同一个数组中
$$
val\ arr2d2:Array [Array[T]] = arr2d1.transpose
$$

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
arr2
.transpose
.map(t => {
    t.foreach(
        a => print(s"${a}\t")
    )
    println()
})
println("===================")
Array(Array(1,2,3),Array(4,5,6),Array(7,8))
.transpose
.map(t => {
    t.foreach(
        a=>print(s"${a}\t")
    )
    println()
})
//运行结果:
1	4	
2	5	
3	6	
===================
1	4	7	
2	5	8	
3	6

union

​ ：返回两个集合的并集
$$
val\ newArr = arr union sub
$$

1
2
3
4
var arr_test = arr1 union arrStandBy
println(arr_test.foreach(a => print(s"${a}\t")))
//运行结果:
1	2	3	4	5	6	7	8	9	10	1	3	5	7	9	10	12	13

unzip

​ ：将数据元素均为二元元祖的数组，每个元祖的第一个元素组成一个数组，第二个元素组成一个数组，返回一个包含这两个数组的元 祖 tuple2
$$
var\ tp2 : Tuple [Array[T],Array[T]] = arr[Array [tuple2] ].unzip
$$

1
2
3
4
5
6
7
val unzip1: (Array[String], Array[String]) = arr4.unzip
unzip1._1.foreach(a=>print(s"${a}\t"))
println()
unzip1._2.foreach(a=>print(s"${a}\t"))
//运行结果:
weiWei	yaoYao	nanNan	yangYang	qunQun	
male	male	female	male	female

unzip3

​ ：将数据元素均为三元元祖的数组，每个元祖的第一个元素组成一个数组，第二个元素组成一个数组，第三个元素组成一个数组，返 回一个包含这三个数组的元祖 tuple3
$$
var\ tp3:Tuple3[Array[T] ,Array[T],Array[T]] = arr[Array[Tuple3] ].unzip3
$$

1
2
3
4
5
6
7
8
9
10
val unzip: (Array[String], Array[String], Array[Int]) = arr5.unzip3
unzip._1.foreach(a=>print(s"${a}\t"))
println()
unzip._2.foreach(a=>print(s"${a}\t"))
println()
unzip._3.foreach(a=>print(s"${a}\t"))
//运行结果:
weiWei	yaoYao	nanNan	yangYang	qunQun	
male	male	female	male	female	
27	15	7	45	18

update

​ ：更新集合中对应下标的元素
$$
arr.update(index,newV)
$$

1
2
3
4
arr1.update(0,10)
arr1.foreach((a) => print(s"${a}\t"))
//运行结果:
10	2	3	4	5	6	7	8	9	10

updated

​ ：更新集合中对应下标的元素，并返回替换后的数组
$$
val\ arr:[Array[T]] = arr.updated(index,newV)
$$

1
2
3
4
5
6
var arr_test = arr1.updated(0,10)
println(arr_test.getClass.getTypeName)
arr_test.foreach(a => print(s"${a}\t"))
//运行结果:
int[]
10	2	3	4	5	6	7	8	9	10

view

​ ：无参数时：返回全部

​ ：一个参数时：和apply一样，取下标对应的值

​ ：两个参数时：返回当前序列中从 from 到 until 之间的可变序列，不包括 until 处的元素,允许下标越界
$$
val\ value:mutable.IndexedSeqView[T, Array[T]] = arr.view(from: Int, until: Int)
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
val view: AnyRef with mutable.IndexedSeqView[Int, Array[Int]] = arr1.view
println(view)
view.foreach(a=>print(s"${a}\t"))
println()
val i: Int = arr1.view(1)
println(i)
val value: mutable.IndexedSeqView[Int, Array[Int]] = arr1.view(1, 8)
println(value)
value.foreach(a=>print(s"${a}\t"))
//运行结果:
SeqView(...)
1	2	3	4	5	6	7	8	9	10	
2
SeqViewS(...)
2	3	4	5	6	7	8

wait

​ ：关于Scala的并发支持的相关问题将在后面的博客统一介绍

withFilter

​ :根据条件 f 过滤元素,不生成新的集合,filter算子是生成新的集合，但是通常都做赋值处理，这样生不生成新集合，意义不大
$$
val \ arr:[Array[T]] = arr.withFilter(f:T=>Boolean)
$$

1
2
3
4
5
6
7
arr1.withFilter(_%2 == 0).foreach(a=>print(s"${a}\t"))
println()
arr1.withFilter(_%2 == 1).foreach(a=>print(s"${a}\t"))
//运行结果:
2	4	6	8	10	
1	3	5	7	9

zip

​ ：返回一个将两个序列同下标位置上的元素组成的一个数组元祖【两个序列的长度必须相同】
$$
val\ arr:Array((T,B)) = arr1[T].zip(arr2[B])
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
val arrTest = Array('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J')
val tuples: Array[(Int, Char)] = arr1.zip(arrTest)
tuples
.foreach(
    a=>println(s"${a.toString}")
)
//运行结果:
(1,A)
(2,B)
(3,C)
(4,D)
(5,E)
(6,F)
(7,G)
(8,H)
(9,I)
(10,J)

zipAll

​ ：返回一个将两个序列同下标位置上的元素组成的一个数组元祖，允许两个序列的长度不同，短的序列自动填充指定元素，若当前 序列 arrThis 短，不足的元素填充 thisElem，比较的序列 arrThat 短，不足的元素填充 thatElem
$$
val\ arr:Array ((T,B)) = arrThis[T].zipAll(arrThat[B],thisElem:T,thatElem:B)
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
val arrTest1 = Array('A', 'B', 'C', 'D', 'E')
val arrTest2 = Array('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J','K','L','M','N','O')
val tuples1: Array[(Int, Char)] = arr1.zipAll(arrTest1,0,'X')
tuples1
.foreach(
    a=>print(s"${a.toString}")
)
println()
val tuples2: Array[(Int, Char)] = arr1.zipAll(arrTest2,0,'X')
tuples2
.foreach(
    a=>print(s"${a.toString}")
)
//运行结果:
(1,A)(2,B)(3,C)(4,D)(5,E)(6,X)(7,X)(8,X)(9,X)(10,X)
(1,A)(2,B)(3,C)(4,D)(5,E)(6,F)(7,G)(8,H)(9,I)(10,J)(0,K)(0,L)(0,M)(0,N)(0,O)

zipWithIndex

​ ：返回一个序列中的每个元素和它的索引组成一个元组数组 tuple2
$$
var\ tp2:Array((T,Int)) = arr.zipWithIndex
$$

1
2
3
4
5
val index: Array[(Int, Int)] = arr1.zipWithIndex
index.foreach(a=>print(s"${a.toString}\t"))
//运行结果:
(1,0)	(2,1)	(3,2)	(4,3)	(5,4)	(6,5)	(7,6)	(8,7)	(9,8)	(10,9)

→

​ :nauseated_face:不知道干啥的

代码实现

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
import scala.collection.{immutable, mutable}
import scala.collection.mutable.{ArrayBuffer, ListBuffer}
import scala.collection.parallel.mutable.ParArray

object StudySelf {
  def main(args: Array[String]): Unit = {
    var arr1 = Array(1,2,3,4,5,6,7,8,9,10)
    var arr2 = Array(Array(1,2,3),Array(4,5,6))
    var arr3 = Array(Array(Array(1,2,3),Array(4,5,6)),Array(Array(4,5,6),Array(7,8,9)))
    var arr4 = Array(("weiWei","male"),("yaoYao","male"),("nanNan","female"),("yangYang","male"),("qunQun","female"))
    var arr5 = Array(("weiWei","male",27),("yaoYao","male",15),("nanNan","female",7),("yangYang","male",45),("qunQun","female",18))
    var arrStandBy = Array(1,3,5,7,9,10,12,13)

//******************************提取元素**********************************************

    //1、head ： 返回序列的第一个元素，如果序列为空，将引发错误  >>> val v:T = arr.head
/*
    println(arr1.head)
    println(Array().head)
*/

    //2、headOption ： 返回序列的第一个元素的 Option 类型对象，如果序列为空，则返回 None >>> val v:Option[T] = arr.headOption
/*
    println(arr1.headOption)
    println(Array().headOption)
*/

    //3、last ： 返回序列的最后一个元素，如果序列为空，将引发错误  >>> val v:T = arr.last
/*
    println(arr1.last)
    println(Array().last)
*/

    //4、lastOption ： 返回序列的最后一个元素的 Option 类型对象，如果序列为空，则返回 None >>> val v:Option[T] = arr.lastOption
/*
    println(arr1.lastOption)
    println(Array().lastOption)
*/

    //5、index ：返回序列中参数下标对应的元素,下标不存在，则会下标越界 >>> val v:T = arr(index : Int)
/*
    println(arr1(1))
    println(arr1(11))
*/

    //6、apply ：返回序列中参数下标对应的元素,下标不存在，则会下标越界 >>> val v:T = arr.apply (index : Int)
/*
    println(arr1.apply(1))
    println(arr1.apply(11))

    2
    Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 11
*/

    //7、applyOrElse ：接受两个参数，参数1：序列的下标；参数2：回调函数。如果参数1的下标值合法（未越界），则返回序列中下标对应的元素，否则返回参数1 经过回调函数后的值（回调函数的输入类型需与调用参数类型一致），就相当于if-else分支调用函数。 >>> val v:T = arr.applyorElse(index:Int,f:index(Int)=>T)
/*
    println(arr1.applyOrElse(1,(x:Int)=> x*2))
    println(arr1.applyOrElse(11,(x:Int)=> x*2))
*/

    //8、take ： 返回当前序列中，前 size 个元素组成的序列（从左边取 size个元素）  >>>  val arr:[Array[T]] = arr.take(size:Int)
/*
    arr1.take(5).foreach(a=>print(s"${a}\t"))
    println()
    arr1.take(20).foreach(a=>print(s"${a}\t"))
*/

    //9、takeRight ： 返回当前序列中，后 size 个元素组成的序列（从右边取 size 个元素）  >>>   val arr:[Array[T]] = arr.takeRight(size:Int)
/*
    arr1.takeRight(5).foreach(a=>print(s"${a}\t"))
    println()
    arr1.takeRight(20).foreach(a=>print(s"${a}\t"))
*/

    //10、takeWhile ： 返回当前序列中，从下标 0 开始取，从从第一个满足条件开始到第一个不满足条件结束  >>>   val arr:[Array[T]] = arr.takeWhile(f:T=>Boolean)
/*
    arrStandBy.takeWhile(_%2 == 0).foreach(a=>print(s"${a}\t"))
    println()
    arrStandBy.takeWhile(_%2 == 1).foreach(a=>print(s"${a}\t"))
*/

    //11、filter ：  提取集合中所有满足条件的元素,组成新的数组返回 >>>   val arr:[Array[T]] = arr.filter(f:T=>Boolean)
/*
    arr1.filter(_%2 == 0).foreach(a=>print(s"${a}\t"))
    println()
    arr1.filter(_%2 == 1).foreach(a=>print(s"${a}\t"))
*/

    //12、filterNot ： 提取集合中所有不满足条件的元素，组成新的数组返回  >>>   val arr:[Array[T]] = arr.filterNot(f:T=>Boolean)
/*
    arr1.filterNot(_%2 == 0).foreach(a=>print(s"${a}\t"))
    println()
    arr1.filterNot(_%2 == 1).foreach(a=>print(s"${a}\t"))
*/

    //13、collect ： 提取序列中所有满足偏函数条件的元素，组成新的数组返回  >>>   val arr:[Array[B]] = arr.collect(PartialFunction[T,B]:T=>B)
/*
    val pf:PartialFunction[Int, Int] = (x:Int) => x match {
      case x if(x%2==1) => x
    }
    arr1.collect(pf).foreach(a => print(s"${a}\t"))
    println()
    arr1.collect({case x if(x%2 == 0) => x}).foreach(a => print(s"${a}\t"))
*/

    //14、collectFirst ： 提取序列中第一个满足偏函数条件的元素  >>>   val arr:[Array[B]] = arr.collectFirst(PartialFunction[T,B]:T=>B)
/*
    val pf:PartialFunction[Int, Int] = (x:Int) => x match {
      case x if(x%2==1) => x
    }
    arr1.collectFirst(pf).foreach(a => print(s"${a}\t"))
    println()
    arr1.collectFirst({case x if(x%2 == 0) => x}).foreach(a => print(s"${a}\t"))
*/

    //15、find ： 提取序列中第一个符合函数条件的元素，如果有，返回Option（用Some包装），没有则返回None  >>>   val arr:[Array[T]] = arr.find(f:T=>Boolean)
/*
    println(arr1.find(_%2 == 0))
    println(Array(1,1,1,1).find(_%2 == 0))
*/

    //16、slice ：   >>>   val arr:[Array[T]] = arr.slice(from:Int,until:Int)
/*
    arr1.slice(0,5).foreach(a => print(s"${a}\t"))
    println()
    arr1.slice(1,7).foreach(a => print(s"${a}\t"))
*/

    //17、init ： 提取序列中除了最后一个元素之外的所有元素，组成新的数组返回  >>>   val arr:Array[Int] = arr.init
/*
    arr1.init.foreach(a => print(s"${a}\t"))
    println()
    arrStandBy.init.foreach(a => print(s"${a}\t"))
*/

    //18、inits ： 对集合中的元素进行 init 递归操作，该操作的返回值中， 第一个值是当前序列的副本，最后一个值为空，每一步都进行 init 操作，上一步的结果作为下一步的操作对象，并封装成迭代器返回  >>>   val arr:Iterator[mutalbe.wrappedArray[T]] = arr.inits
/*
    arr1.inits.foreach(a =>println(a.mkString(",")))

*/

    //19、tail ： 提取序列中除了第一个元素之外的所有元素，组成新的数组返回  >>>   val arr:Array[Int] = arr.tail
/*
    arr1.tail.foreach(a => print(s"${a}\t"))
    println()
    arrStandBy.tail.foreach(a => print(s"${a}\t"))
*/

    //20、tails ： 对集合中的元素进行 tail 迭代操作，该操作的返回值中， 第一个值是当前序列的副本，最后一个值为空，每一步都进行tail 操作，上一步的结果作为下一步的操作对象，并封装成迭代器返回  >>>   val arr:Iterator[mutalbe.wrappedArray[T]] = arr.tails
/*
    arr1.tails.foreach(a =>println(a.mkString(",")))

*/


    //21、lift ： 提取集合对应下标的值，返回Option类型（有值用some包装，没有返回None）  >>>   val f:Int=>T = arr.lift
/*
    println(arr1.lift(2))
    println(arr1.lift(22))
*/

    //22、orElse ： 提取根据参数（偏函数规则）提取数组元素  >>>   val f:PartialFunction[T,B] = arr.orElse (f:PartialFunction[T,B])
/*
    val pf: PartialFunction[Int, Any] = arr1.orElse({
      case ix if (ix >= 0 && ix < arr1.length) => Some(arr1(ix))
      case _ => None
    })
    println(pf(5))
    println(pf(10))
*/


//******************************修改操作**********************************************
    //23、update ： 更新集合中对应下标的元素  >>>   Unit arr.update(index:Int,newV:T)
/*
    arr1.update(0,10)
    arr1.foreach((a) => print(s"${a}\t"))
*/

    //24、updated ： 更新集合中对应下标的元素，并返回替换后的数组  >>>   val arr:Array[T] = arr.updated(index:Int,newV:T)
/*
    var arr_test = arr1.updated(0,10)
    println(arr_test.getClass.getTypeName)
    arr_test.foreach(a => print(s"${a}\t"))
*/

    //25、++ ： 并集  >>>   val newArr = arr ++ sub
/*
    var arr_test = arr1 ++ arrStandBy
    println(arr_test.foreach(a => print(s"${a}\t")))
*/

    //26、union ： 并集  >>>   val newArr = arr union sub
/*
    var arr_test = arr1 union arrStandBy
    println(arr_test.foreach(a => print(s"${a}\t")))
    println(arr_test.foreach(a => s"${a}\t"))
    println(arr_test.foreach(a => print(a)))
    println(arr_test.foreach(println))
*/

    //27、intersect ： 交集  >>>   val newArr = arr intersect sub
/*
    var arrTest1 = arr1.intersect(arrStandBy)
    arrTest1.foreach(a=>print(s"${a}\t"))
    println()
    var arrTest2 = arrStandBy.intersect(arr1)
    arrTest2.foreach(a=>print(s"${a}\t"))
*/

    //28、diff ： 差集  >>>   val newArr = arr diff sub
/*
    var arrStandByTest = Array(1,1,3,3,5,7,9,10,12,13)
    // arrStandByTest中有两个（1,3），只能消除一次
    var arrTest1 = arrStandByTest.diff(arr1)
    arrTest1.foreach(a=>print(s"${a}\t"))
    println()
    var arrTest2 = arr1.diff(arrStandByTest)
    arrTest2.foreach(a=>print(s"${a}\t"))
*/

    //29、:+ ：   >>>   val newArr = arr :+ elem
/*
    var arrTest1 = arr1 :+ 11
    arrTest1.foreach(a=>print(s"${a}\t"))
*/

    //30、+: ：   >>>   val newArr = elem +: arr
/*
    var arrTest1 = 0 +: arr1
    arrTest1.foreach(a=>print(s"${a}\t"))
*/

    //31、drop ：   >>>   val newArr = arr.drop(n:Int)
/*    var arrTest1 = arr1.drop(1)
    arrTest1.foreach(a=>print(s"${a}\t"))
    println()
    var arrTest2 = arr1.drop(5)
    arrTest2.foreach(a=>print(s"${a}\t"))*/

    //32、dropRight ：   >>>   val newArr = arr.dropRight(n:Int)
/*
    var arrTest1 = arr1.dropRight(1)
    arrTest1.foreach(a=>print(s"${a}\t"))
    println()
    var arrTest2 = arr1.dropRight(5)
    arrTest2.foreach(a=>print(s"${a}\t"))
*/

    //33、dropWhile ：   >>>   val newArr = arr.dropWhile(f:Int=>Boolean)
/*
    var arrTest1 = arr1.dropWhile(_%2==1)
    arrTest1.foreach(a=>print(s"${a}\t"))
    println()
    var arrTest2 = arr1.dropWhile(_%2==0)
    arrTest2.foreach(a=>print(s"${a}\t"))
*/

    //34、patch ：   >>>   val newArr = arr.patch(from:Int,sub:GenSeq, replaceLen:Int)
/*
    var arrTest = arr1.patch(3,arrStandBy,5)
    arrTest.foreach(a=>print(s"${a}\t"))
*/


//******************************逐个迭代处理**********************************************
    //38、map ： 将序列中的元素进行一些变形操作后。再次返回新的集合（集合操作前后类型相同,原集合数据不变）  >>>   val tarr:Array[B] = arr.map(f:T=>B)
/*
    arr1.map(a=>print(s"${a+1}\t"))
    println()
    arr1.map(a=>print(s"${a-1}\t"))
*/

    //39、transform ： 将序列中的元素进行一些变形操作后。再次返回新的集合（集合操作前后类型相同,原集合数据改变） >>>   var tarr:Array[B] = darr.transform (f:T=>B)
/*
        arr1.foreach(a=>print(s"${a}\t"))
        println()
        arr1.transform(a=>a+1)
        arr1.foreach(a=>print(s"${a}\t"))
        println()
        arr1.transform(_-1)
        arr1.foreach(a=>print(s"${a}\t"))
*/

    //40、reverseMap ： 将序列中的元素进行一些变形操作后。再次返回新的集合(数据顺序相反)  >>>   val tarr:Array[B] = darr.reverseMap(f:T=>B)
/*
    var arrTest = arr1.reverseMap(_+1)
    arrTest.foreach(a=>print(s"${a}\t"))
*/

    //41、flatten ：   >>>   val tarr:Array[T] = darr.flatten
/*
    var arrTest1 = arr2.flatten
    arrTest1.foreach(a=>print(s"${a}\t"))
    println()
    var arrTest2 = arr3.flatten
    arrTest2.foreach(a=>print(s"${a}\t"))
    println()
    var arrTest3 = arr3.flatten.flatten
    arrTest3.foreach(a=>print(s"${a}\t"))
*/

    //42、flatMap ：   >>>   var tarr:Array[B] = darr.flatMap(f:T=>B)
/*
    var arrTest1 = arr2.flatMap(_.map(_+1))
    arrTest1.foreach(a=>print(s"${a}\t"))
    println()
    // 相当于下面的两个操作
    var arrTest2 = arr2.flatten
    arrTest2.foreach(a=>print(s"${a}\t"))
    println()
    var arrTest3 = arrTest2.map(_+1)
    arrTest3.foreach(a=>print(s"${a}\t"))
*/


    //******************************分组**********************************************
    //43、par ：   >>>   val parr:ParArray[T]= arr.par
/*
    val par: ParArray[Int] = arr1.par
    par.foreach(a=> print(s"${a}\t"))
*/




    //44、partition ： 按条件将序列拆分成两个数组，满足条件的放到第一个数组，其余的放到第二个数组，返回的是包含这两个数组的元组  >>>   var arr:(Array[T],Array[T]) = arr.partition(f:T=>Boolean)
/*
    var arrTest = arr1.partition(_%2==1)
    arrTest._1.foreach(a=>print(s"${a}\t"))
    println()
    arrTest._2.foreach(a=>print(s"${a}\t"))
*/

    //45、grouped ： 按指定数量分组，每组有 size 个元素，返回一个迭代器  >>>   var iter:Iterator[Array[T]] = arr.grouped(size:Int)=>size:item size per group => sliding (n, n)
/*
    var iteratorTest = arr1.grouped(2)
    println(iteratorTest.getClass.getName)
    var arrTest = iteratorTest.toArray
    println(arrTest.foreach(a=>print(s"${a}\t")))
    println(arrTest.flatten.foreach(a=>print(s"${a}\t")))
*/

    //46、sliding ：   >>>   var iter:Iterator[Array[T]] = arr.sliding(size:Int[,step:Int default 1])
/*
    //sliding(size)
    var iteratorTest = arr1.sliding(2)
    println(iteratorTest.getClass.getName)
    var arrTest = iteratorTest.toArray
    arrTest.foreach(a=>print(s"${a}\t"))
    println("*********")
    arrTest.foreach(a=>print(s"${a}\t"))
    arrTest.flatten.foreach(a=>print(s"${a}\t"))
    println("==============")
    //sliding(size,step)
    var iteratorTest1 = arr1.sliding(2,3)
    println(iteratorTest1.getClass.getName)
    var arrTest1 = iteratorTest1.toArray
    arrTest1.foreach(a=>print(s"${a}\t"))
    arrTest1.flatten.foreach(a=>print(s"${a}\t"))*/

    //47、groupBy ：   >>>   var iter:[(K,Array[T])] = arr.groupBy(key:K)
/*
    var iterTest = arr4.groupBy(_._1)
    println(iterTest.getClass.getName)
    iterTest.foreach(a=>println(a))
    iterTest.foreach(a=>a._2.foreach(i=>print(s"${i}\t")))
*/



//******************************聚合**********************************************
    //48、reduce ： 对序列中的每个元素进行二元运算，不需要初始值  >>>   val value:B = arr.reduce(f:(T,T)=>B)
/*
    println(arr1.reduce(_ + _))
    arr1.reduce((x:Int,y:Int) =>{
      println(s"$x + $y = ${x+y}")
      x+y
    })
*/

    //49、reduceLeft ：   >>>   val value:B = arr.reduceLeft(f:(T,T)=>B)
/*
    println(arr1.reduceLeft(_ + _))
    arr1.reduceLeft((x:Int,y:Int) =>{
      println(s"$x + $y = ${x+y}")
      x+y
    })
*/

    //50、reduceLeftOption ：   >>>   val value:B = arr.reduceLeftOption(f:(T,T)=>B)
/*
    println(arr1.reduceLeftOption(_ + _))
    arr1.reduceLeftOption((x:Int,y:Int) =>{
      println(s"$x + $y = ${x+y}")
      x+y
    })
*/

    //51、reduceRight ：   >>>   val value:B = arr.reduceRight (f:(T,T)=>B)
/*
    println(arr1.reduceRight(_ + _))
    //reduceRight流程如下
    arr1.reduceRight((x:Int,y:Int) =>{
      println(s"$x + $y = ${x+y}")
      x+y
    })
*/

    //52、reduceRightOption ：   >>>   val value:B = arr.reduceRightOption(f:(T,T)=>B)
/*
    println(arr1.reduceRightOption(_ + _))
    //reduceRight流程如下
    arr1.reduceRightOption((x:Int,y:Int) =>{
      println(s"$x + $y = ${x+y}")
      x+y
    })
*/

    //53、fold ：   >>>   val value:B = arr.fold(initVal:T)(f:(T,T)=>B) => /:
/*
    // fold
    println(arr1.fold(0)(_ + _))
    //fold流程如下
    arr1.fold(0)((x:Int,y:Int) =>{
      println(s"$x + $y = ${x+y}")
      x+y
    })

    // /:
    println((0/:arr1)(_ + _))
*/

    //53、foldLeft ：   >>>   val value:B = arr.foldLeft(initVal:T)(f:(T,T)=>B) => /:
/*
    println(arr1.foldLeft(0)(_ + _))
    //foldLeft流程如下
    arr1.foldLeft(0)((x:Int,y:Int) =>{
      println(s"$x + $y = ${x+y}")
      x+y
    })
*/


    //54、foldRight ：   >>>   val value:B = arr.foldRight(initVal:T)(f:(T,T)=>B) => :\
/*
    // foldRight
    println(arr1.foldRight(0)(_ + _))
    //foldRight流程如下
    arr1.foldRight(0)((x:Int,y:Int) =>{
      println(s"$x + $y = ${x+y}")
      x+y
    })

    // :\
    println((arr1:\0)(_ + _))
*/

    //55、scan ：   >>>   val value:Array[B] = arr.scan(initVal:T)(f:(T,T)=>B)
/*
    arr1.scan(0)(_+_).foreach(a=>print(s"${a}\t"))
    //scan运行流程如下
    println()
    arr1.scan(0)((x:Int,y:Int) =>{
      println(s"$x + $y = ${x+y}")
      x+y
    })
*/

    //56、scanLeft ：   >>>   val value:Array[B] = arr.scanLeft(initVal:T)(f:(T, T)=>B)
/*
    arr1.scanLeft(0)(_+_).foreach(a=>print(s"${a}\t"))
    //scanLeft运行流程如下
    println()
    arr1.scanLeft(0)((x:Int,y:Int) =>{
      println(s"$x + $y = ${x+y}")
      x+y
    })
*/

    //57、scanRight ：   >>>   val value:Array[B] = arr.scanRight(initVal:T)(f:(T,T)=>B)
/*
    arr1.scanRight(0)(_+_).foreach(a=>print(s"${a}\t"))
    //scanRight运行流程如下
    println()
    arr1.scanRight(0)((x:Int,y:Int) =>{
      println(s"$x + $y = ${x+y}")
      x+y
    })
*/

    //58、aggregate ：   >>>   val value:B = arr.par.aggregate(initVal:B)(map:(T,T)=>B,reduce:(B,B)=>B)
/*
    var mapAdd = (x:Int,y:Int)=>{
      var z = x+y
      println(s"map:${x} + ${y} = ${z}")
      z
    }

    var reduceAdd = (x:Int,y:Int)=>{
      var z = x+y
      println(s"re:${x} + ${y} = ${z}")
      z
    }

    val i: Int = arr1.aggregate(0)(_ + _, _ + _)
    println(i)
    println("***********************************")

    val j: Int = arr1.aggregate(0)(mapAdd, reduceAdd)
    // 没有走reduceAdd
    println(j)
    println("***********************************")

    val k: Int = arr1.par.aggregate(0)(mapAdd, reduceAdd)
    // 走reduceAdd
    println(k)
*/



    //59、sum ：   >>>   val value:T = arr.sum
/*
    println(arr1.sum)
*/

    //60、count ： 统计符合条件的元素个数  >>>   val value : Int = arr.count(f:T=>Boolean)
/*
    println(arr1.count(_>1))
    println(arr1.count(_%2==0))
*/

    //61、min ：   >>>   val value:T = arr.min
/*
    println(arr1.min)
    println(arr2.flatten.min)
*/

    //62、max ：   >>>   val value:T = arr.max
/*
    println(arr1.max)
    println(arr2.flatten.max)
*/

    //63、minBy ：   >>>   val value:T = arr.minBy(_. ?)=>T:Tuple | class
/*
    println(arr1.minBy(_<=5))
    println(arr1.minBy(_%2==1))
    println(arr1.minBy(_>11))
*/

    //64、maxBy ：   >>>   val value:T = arr.maxBy(_.?)=>T:Tuple | class
/*
    println(arr1.maxBy(_>=5))
    println(arr1.maxBy(_%2==0))
    println(arr1.maxBy(_>11))
*/

//******************************验证**********************************************
    //65、isEmpty ：   >>>   val bool:Boolean = arr.isEmpty
/*
    println(arr1.isEmpty)
    println(Array().isEmpty)
*/

    //66、nonEmpty ：   >>>   val bool:Boolean = arr.nonEmpty
/*
    println(arr1.nonEmpty)
    println(Array().nonEmpty)
*/

    //67、exists ：   >>>   val bool:Boolean = arr.exists(p:Int=>Boolean)
/*
    println(arr1.exists(_<5))
    println(arr1.exists(_>11))
*/

    //68、contains ：   >>>   val bool:Boolean = arr.contains(elem:Int)
/*
    println(arr1.contains(5))
    println(arr1.contains(11))
*/

    //69、containsSlice ：   >>>   val bool:Boolean = arr.containsSlice(sub:GenSeq)
/*
    println(arr1.containsSlice(Array(4,5,6)))
    println(arr1.containsSlice(Array(4,6,5)))
*/

    //70、forall ：   >>>   val bool:Boolean = arr.forall(p:Int=>Boolean)
/*
    println(arr1.forall(_>0))
    println(arr1.forall(_>5))
*/

    //71、corresponds ：   >>>   val bool:Boolean = arr.corresponds(sub:GenSeq)(p:Int=>Boolean)
/*
    println(arr1.corresponds(Array.range(1,11))(_==_))
    println(arr1.corresponds(Array.range(1,10))(_!=_))
    println(arr1.corresponds(Array.range(2,12))(_<_))
*/

    //72、sameElements ：   >>>   val bool:Boolean = arr.sameElements(sub:GenSeq)
/*
    println(arr1.corresponds(Array.range(1,11))(_==_))
    println(arr1.corresponds(Array.range(2,12))(_==_))
*/


    //73、startsWith ：   >>>   val bool:Boolean = arr.startsWith(sub:GenSeq)
/*
    println(arr1.startsWith(Array(1,2)))
    println(arr1.startsWith(Array(2,3)))
    println(arr1.startsWith(Array(2,3),1))
    println(arr1.startsWith(Array(2,3),2))
*/

    //74、endsWith ：   >>>   val bool:Boolean = arr.endsWith(sub:GenSeq)
/*
    println(arr1.endsWith(Array(9,10)))
    println(arr1.endsWith(Array(8,9)))
*/


//******************************大小**********************************************
    //75、length ：   >>>   val len:Int = arr.length
/*
    println(arr1.length)
    println(arr2.length)
*/

    //76、size ：   >>>   val len:Int = arr.size
/*
    println(arr1.size)
    println(arr2.size)
*/

    //77、prefixLength ：   >>>   val len:Int = arr.prefixLength (f:Int=>Boolean)
/*
    println(arr1.prefixLength(_>2))
    println(arr1.prefixLength(_<=2))
*/

    //78、segmentLength ：   >>>   val len:Int = arr.segmentLength(f:Int=>Boolean,pos:Int)
/*
    println(arr1.segmentLength(_>6,1))
    println(arr1.segmentLength(_>=6,5))
    println(arr1.segmentLength(_>=7,6))
*/

    //79、lengthCompare ：   >>>   val dif:Int = arr.lengthCompare(len:Int)
/*
    println(arr1.lengthCompare(8))
    println(arr1.lengthCompare(10))
    println(arr1.lengthCompare(12))
*/



//******************************转变**********************************************
    //80、copyToArray ：   >>>   val arr:Array[T] = copyToArray(arr:Array[T][,start:Int,len:Int])
/*
        val arrTest = Array(0,0,0,0,0)

        //参数:SeqArray

        arrTest.copyToArray(arr1)
        arr1.foreach(a=> print(s"${a}\t"))
        //运行结果:
        0	0	0	0	0	6	7	8	9	10

        //参数:SeqArray,start
        arrTest.copyToArray(arr1,3)
        arr1.foreach(a=> print(s"${a}\t"))
        //运行结果:
        1	2	3	0	0	0	0	0	9	10

        //参数:SeqArray,start,len
        arrTest.copyToArray(arr1,3,3)
        arr1.foreach(a=> print(s"${a}\t"))
        //运行结果:
        1	2	3	0	0	0	7	8	9	10
    */

    //81、copyToBuffer ：   >>>  val Buffer:ArrayBuffer[T] = copyToBuffer(mutable.Buffer[T])
/*
    val arrBuffTest: ArrayBuffer[Int] = new ArrayBuffer[Int]
    arrBuffTest.append(0,0)
    arr1.copyToBuffer(arrBuffTest)
    arrBuffTest.foreach(a=> print(s"${a}\t"))
*/

    //82、toArray ：   >>>   val arr:Array[T]= arr.toArray
/*
    val arrBuffTest: mutable.Buffer[Int] = mutable.Buffer[Int]
    arrBuffTest.append(1, 2, 3, 4, 5)
    println(arrBuffTest.genericBuilder.getClass.getName)
    val arrayTest: Array[Int] = arrBuffTest.toArray
    println(arr1.genericBuilder.getClass.getName)
*/

    //83、toBuffer ：   >>>   val arr:mutable.Buffer[T]= arr.toBuffer
/*
    val buffer: mutable.Buffer[Int] = arr1.toBuffer

*/

    //86、array ：   >>>   val arr: Array[T]= arr.array
/*
    val array: Array[Int] = arr1.array
    array.foreach(a=>print(s"${a}\t"))
*/

    //87、clone ：   >>>   val arr: Array[T]= arr.clone
/*
    val arr_demo: Array[Int] = arr1.clone()
    arr_demo.foreach(x =>print(s"${x}\t"))
    println()
    println(arr_demo == arr1)
    println(arr_demo.equals(arr1))
*/


    //88、deep ：   >>>   val arr:mutable.IndexedSeq[T] = arr.deep
/*
    println(arr1.getClass.getTypeName)
    val deep: IndexedSeq[Any] = arr1.deep
    println(deep.getClass.getTypeName)
*/

    //89、repr ：   >>>   val arr:mutable.wrappedArray[T] = arr.repr
/*
    val repr: Array[Int] = arr1.repr
    println(repr.equals(arr1))
    println(repr == arr1)
*/

    //90、seq ：   >>>   val arr:mutable.IndexedSeq[T] = arr.seq
/*
    val ints = Array(1, 2, 3, 4, 5)
    val ints1: Seq[Int] = Seq(1, 2, 3, 4)
*/


    //91、toMap ：   >>>   val arr : Map[K,V]= arr.toMap
/*
    val map: Map[String, String] = arr4.toMap
    println(map.toString)
    println(map("nanNan"))
*/



    //92、toSet ：   >>>   val arr: set[T] = arr.toSet
/*
    val arrTest = Array(1, 1, 2, 2, 3, 3, 4, 4)
    arrTest.toSet.foreach(println)
*/

    //93、toIterator ：   >>>   val arr: Iterator[T]= arr.toIterator
    //94、toStream ：   >>>   val arr : stream[T]= arr.toStream
    //95、padTo ：   >>>   val arr:Array[T] = arr.padTo(len:Int,elem:T)
/*
    arr1.padTo(10,0).foreach(a=>print(s"${a}\t"))
    println()
    arr1.padTo(15,0).foreach(a=>print(s"${a}\t"))
*/

    //96、span ：   >>>   val tp2 : (Array [T] ,Array[T]) = arr.span(f:T=>Boolean)
/*
    arr1.span(_<=5)._1.foreach(a=>print(s"${a}\t"))
    println()
    arr1.span(_<=5)._2.foreach(a=>print(s"${a}\t"))
*/

    //97、splitAt ：   >>>   val tp2 : (Array[T],Array[T]) = arr.splitAt(index : Int)
/*
    arr1.splitAt(5)._1.foreach(a=>print(s"${a}\t"))
    println()
    arr1.splitAt(5)._2.foreach(a=>print(s"${a}\t"))
*/

    //98、transpose ：   >>>   val arr2d2:Array [Array[T]] = arr2d1.transpose
/*
    arr2
    .transpose
    .map(t => {
      t.foreach(
        a => print(s"${a}\t")
      )
      println()
    })
    println("===================")
    Array(Array(1,2,3),Array(4,5,6),Array(7,8))
      .transpose
      .map(t => {
        t.foreach(
          a=>print(s"${a}\t")
        )
        println()
      })
*/

    //99、zip ：   >>>   val arr : Array ((T,B))= arr1[T].zip (arr2[B])
/*
    val arrTest = Array('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J')
    val tuples: Array[(Int, Char)] = arr1.zip(arrTest)
    tuples
    .foreach(
      a=>println(s"${a.toString}")
    )
*/

    //100、zipAll ：   >>>   val arr:Array ((T,B)) = arr1[T].zipAll(arr2[B],thisElem:T,thatElem:B)
/*
    val arrTest1 = Array('A', 'B', 'C', 'D', 'E')
    val arrTest2 = Array('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J','K','L','M','N','O')
    val tuples1: Array[(Int, Char)] = arr1.zipAll(arrTest1,0,'X')
    tuples1
      .foreach(
        a=>print(s"${a.toString}")
      )
    println()
    val tuples2: Array[(Int, Char)] = arr1.zipAll(arrTest2,0,'X')
    tuples2
      .foreach(
        a=>print(s"${a.toString}")
      )
*/

    //101、unzip ：   >>>   var tp2 : Tuple [Array[T],Array[T]] = arr[Array [tuple2] ].unzip
/*
    val unzip1: (Array[String], Array[String]) = arr4.unzip
    unzip1._1.foreach(a=>print(s"${a}\t"))
    println()
    unzip1._2.foreach(a=>print(s"${a}\t"))
*/

    //102、unzip3 ：   >>>   var tp3:Tuple3[Array[T] ,Array[T],Array[T]] = arr[Array[Tuple3] ].unzip3
/*
    val unzip: (Array[String], Array[String], Array[Int]) = arr5.unzip3
    unzip._1.foreach(a=>print(s"${a}\t"))
    println()
    unzip._2.foreach(a=>print(s"${a}\t"))
    println()
    unzip._3.foreach(a=>print(s"${a}\t"))
*/

    //103、zipWithIndex ：   >>>   var tp2 : Array ( (T,Int)) = arr.zipWithIndex;
/*
    val index: Array[(Int, Int)] = arr1.zipWithIndex
    index.foreach(a=>print(s"${a.toString}\t"))
*/


    //******************************顺序(排序）**********************************************
    //104、reverse ：   >>>   val arr : Array[T]= arr.reverse
/*
    val reverse: Array[Int] = arr1.reverse
    reverse.foreach(a=>print(s"${a}\t"))
*/

    //105、reverseIterator ：   >>>   val arr : Iterator[T]= arr.reverseIterator
/*
    val iterator: Iterator[Int] = arr1.reverseIterator
    iterator.foreach(a=>print(s"${a}\t"))
*/

    //106、sorted ：   >>>   val arr:Array[T]= arr.sorted
/*
    val ArrayTest: Array[Int] = Array(3, 56, 78, 5, 3, 67, 8, 45, 2)
    ArrayTest.sorted.foreach(a=>print(s"${a}\t"))
*/

    //107、sortBy ：   >>>   val arr:Array[T] = arr.sortBy(f:T=>T)
/*
    val ArrayTest: Array[Int] = Array(3, 56, 78, 5, 3, 67, 8, 45, 2)
    ArrayTest.sortBy(a => a).foreach(a=>print(s"${a}\t"))
    println()
    ArrayTest.sortBy(b=> -b).foreach(a=>print(s"${a}\t"))
*/

    //108、sortWith ：   >>>   val arr:Array[T] = arr.sortWith(f:(T1,T2)=>Boolean)
/*
    val ArrayTest: Array[Int] = Array(3, 56, 78, 5, 3, 67, 8, 45, 2)
    ArrayTest.sortWith(_ < _).foreach(a=>print(s"${a}\t"))
    println()
    ArrayTest.sortWith(_ > _ ).foreach(a=>print(s"${a}\t"))
*/


//******************************拼接字符串**********************************************
    //109、addString ：   >>>   var str:string = arr.addString (builder:stringBuilder [ , sep:string] )
/*
    val builder = new StringBuilder
    val str1: StringBuilder = arr1.addString(builder)
    println(str1)
    //清空builder
    builder.clear()
    val str2: StringBuilder = arr1.addString(builder, "-")
    println(str2)
    //清空builder
    builder.clear()
    val str3: StringBuilder = arr1.addString(builder,"[", "-","]")
    println(str3)
*/

    //110、addString ：   >>>   var str:string = arr.addString (builder:stringBuilder,start:string , sep:string,end:String)
/*
    val builder = new StringBuilder
    val str1: StringBuilder = arr1.addString(builder)
    println(str1)
    //清空builder
    builder.clear()
    val str2: StringBuilder = arr1.addString(builder, "-")
    println(str2)
    //清空builder
    builder.clear()
    val str3: StringBuilder = arr1.addString(builder,"[", "-","]")
    println(str3)
*/

    //111、mkString ：   >>>   var str: String = arr.mkString (sep : string)
/*
    val str1 = arr1.mkString("-")
    println(str1)

    val str2 = arr1.mkString("[","-","]")
    println(str2)
*/

    //112、mkString ：   >>>   var str:string = arr.mkString(start:string, sep:string, end:string)
/*
    val str1 = arr1.mkString("-")
    println(str1)

    val str2 = arr1.mkString("[","-","]")
    println(str2)
*/


//******************************根据值取下标**********************************************
    //113、indexOf ：   >>>   val ix:Int = arr.indexOf(v:T[,start:Int])
/*
    val arrTest = Array(0, 1, 1, 3, 3)
    println(arrTest.indexOf(10))
    println(arrTest.indexOf(1))
    println(arrTest.indexOf(3,4))
    println(arrTest.indexOf(3,3))
*/

    //114、indexOfSlice ：   >>>   val ix:Int = arr.indexOfSlice(arr:GenSeq[,start:Int])
/*
    val arrTest = Array(0, 1, 1, 3, 3)
    val arrTest01 = Array(1,0)
    val arrTest02 = Array(1,1)
    val arrTest03 = Array(3)
    println(arrTest.indexOfSlice(arrTest01))
    println(arrTest.indexOfSlice(arrTest02))
    println(arrTest.indexOfSlice(arrTest03,3))
    println(arrTest.indexOfSlice(arrTest03,4))
*/

    //115、indexWhere ：   >>>   val ix:Int = arr.indexWhere(f:T=>Boolean[,start:Int])
/*
    println(arrStandBy.indexWhere(_%2==1))
    println(arrStandBy.indexWhere(_%2==0))
    println(arrStandBy.indexWhere(_%3==10))
    println(arrStandBy.indexWhere(_%2==0,5))
    println(arrStandBy.indexWhere(_%2==0,6))
*/

    //116、lastIndexOf ：   >>>   val ix:Int = arr.lastIndexOf(v:T[,end:Int])
/*
    val arrTest = Array(0, 1, 1, 3, 3)
    println(arrTest.lastIndexOf(10))
    println(arrTest.lastIndexOf(1))
    println(arrTest.lastIndexOf(3,3))
    println(arrTest.lastIndexOf(3,4))
*/

    //117、lastIndexOfSlice ：   >>>   val ix:Int = arr.lastIndexOfSlice(arr:GenSeq[,end: Int])
/*
    val arrTest = Array(0, 1, 1, 3, 3)
    val arrTest01 = Array(1,0)
    val arrTest02 = Array(1,3)
    val arrTest03 = Array(3)
    println(arrTest.lastIndexOfSlice(arrTest01))
    println(arrTest.lastIndexOfSlice(arrTest02))
    println(arrTest.lastIndexOfSlice(arrTest03,3))
    println(arrTest.lastIndexOfSlice(arrTest03,4))
*/

    //118、lastIndexWhere ：   >>>   val ix:Int = arr.lastIndexWhere(f:T=>Boolean[,end:Int])
/*
    println(arrStandBy.lastIndexWhere(_%2==1))
    println(arrStandBy.lastIndexWhere(_%2==0))
    println(arrStandBy.lastIndexWhere(_%3==10))
    println(arrStandBy.lastIndexWhere(_%2==0,5))
    println(arrStandBy.lastIndexWhere(_%2==0,6))
*/

    //119、indices ：   >>>   val ixs:Array[Int] = arr.indices
/*
    println(arr1.indices)
    arr1.indices.toArray.foreach(a=>print(s"${a}\t"))
    println()
    println(arrStandBy.indices)
    arrStandBy.indices.toArray.foreach(a=>print(s"${a}\t"))
*/


//******************************SCALA OOP**********************************************
    //120、andThen ：   >>>   val f3 = fl andThen f2
/*
    val f1 = (x:Int) => x+3
    val f2 = (x:Int) => x*3
    val f3 = (x:Int) => x-3

    val fat = f1 andThen f2 andThen f3      // 先执行f1后执行f2后执行f3
    val fcp = f1 compose  f2 compose f3     // 先执行f3后执行f2后执行f1
    println(fat(3))
    println(fcp(3))

    // andThen前面的方法是def时，需要加"_"
    def f4(x:Int) = x*3
    def f5(x:Int) = x-3

    val fdefat = f4 _ andThen f5
    val fdefcp = f4 _ compose f5
    println(fdefat(3))
    println(fdefcp(3))

    // andThen在数组中的应用:下标不存在报错，下标存在就把对应元素传入偏函数中，输出偏函数的结果
    val i: Int = arr1.andThen(x => {
      if (x % 2 == 0) x else x + 2
    })(2)
    println(i)

    val j: Int = arr1.andThen(x => {
      if (x % 2 == 0) x else x + 2
    })(3)
    println(j)
*/

    //121、compose ：   >>>   val f4 = fl compose f2
/*    val f1 = (x:Int) => x+3
    val f2 = (x:Int) => x*3
    val f3 = (x:Int) => x-3

    val fat = f1 andThen f2 andThen f3      // 先执行f1后执行f2后执行f3
    val fcp = f1 compose  f2 compose f3     // 先执行f3后执行f2后执行f1
    println(fat(3))
    println(fcp(3))

    // andThen前面的方法是def时，需要加"_"
    def f4(x:Int) = x*3
    def f5(x:Int) = x-3

    val fdefat = f4 _ andThen f5
    val fdefcp = f4 _ compose f5
    println(fdefat(3))
    println(fdefcp(3))
*/

    //122、== ：   >>>  val bool:Boolean = arr1 == arr2
/*    val arrTest = arr1.clone
    println(arr1 == arr1)
    println(arr1 == arr2)
    println(arr1 == arrTest)
*/

    //123、ensuring ：   >>>
/*
    val ints: Array[Int] = arr1.ensuring(true)
    println(ints)
*/

    //124、elemManifest  ：   >>>  val typeOf[T] = arr.elemManifest
/*    val arrTest = Array(1,2,3,"a","b","c")
    println(arr1.elemManifest)
    println(arr2.elemManifest)
    println(arrTest.elemManifest)
*/

    //125、elemTag ：   >>> val typeOf[T] = arr.elemTag
/*
    val arrTest = Array(1,2,3,"a","b","c")
    println(arr1.elemTag)
    println(arr2.elemTag)
    println(arrTest.elemTag)
*/


    //126、distinct ：   >>> val newArr[T] = arr.distinct
/*
    val arrTest = Array(1,1,2,2,3,3,4,5)
    arrTest.distinct.foreach(x=>print(s"${x}\t"))
*/

    //127、companion ：   >>> val ints:mutable.IndexedSeq[T] = arr.companion(T)
/*    val ints: mutable.IndexedSeq[Int] = arr1.companion(3, 4, 5)
    println(ints)
*/

    //128、combinations ：   >>> var iter:Iterator[Array[T]] = arr.combinations(size:Int)
/*    val arrTest= Array(1,2,3,4)
    val iter1: Iterator[Array[Int]] = arrTest.combinations(2)
    val iter2: Iterator[Array[Int]] = arrTest.combinations(3)
    iter1.foreach(x=>println(x.mkString(",")))
    println("***************************")
    iter2.foreach(x=>println(x.mkString(",")))*/

    //129、canEqual ：   >>>  val bool:Boolean = arr1.canEqual(arr2)
/*
    println(arr1.canEqual(arr2))
    println(arr1.canEqual(1))
    println("1".canEqual(1.0))
    println(arr1.canEqual("1"))
*/

    //130、eq ：   >>>  val bool:Boolean = arr1.eq(arr2)
/*
        val arrTest = arr1.clone
        println(arr1.eq(arr1))
        println(arr1.eq( arr2))
        println(arr1.eq( arrTest))
*/

    //131、equals ：   >>>  val bool:Boolean = arr1.equals(arr2)
/*        val arrTest = arr1.clone
        println(arr1.equals(arr1))
        println(arr1.equals(arr2))
        println(arr1.equals(arrTest))
*/

    //132、foreach ：   >>>  val T:Unit = arr1.foreach(f:(T) =>Unit)
/*
    arr1.foreach(x=>print(s"${x}\t"))
*/

    //133、formatted ：   >>>  val T:Double = T.formatted(T:Double)
/*
    val a = 520.345678
    println(a.formatted("%.2f"))
    println(a.formatted("%.3f"))
    println(a.formatted("%.4f"))
*/

    //134、genericBuilder ：   >>>  val builder: mutable.Builder[Nothing, mutable.IndexedSeq[Nothing]] = arr.genericBuilder
/*
    val builder: mutable.Builder[Nothing, mutable.IndexedSeq[Nothing]] = arr1.genericBuilder
    println(builder)
*/


    //135、getClass ：   >>>  val typeNameOfT = T.getClass
/*    println(arr1.getClass)
    println("arr1".getClass)
    println(1.getClass)
    println(1.0.getClass)
*/


    //136、hasDefiniteSize ：   >>>  val bool:Boolean = arr.hasDefiniteSize
/*    println(arr1.hasDefiniteSize)
    println(arr1.toStream.hasDefiniteSize)
*/

    //137、hashcode ：   >>>  val T:Int = T.hashcode
/*
    println(arr1.hashCode())
    println(arr2.hashCode())
*/

    //138、isDefinedAt ：   >>>  val bool:Boolean = arr.isDefinedAt(index:Int)
/*
    println(arr1.isDefinedAt(9))
    println(arr1.isDefinedAt(10))
*/

    //139、isTraversableAgain ：   >>>  val bool:Boolean = arr.isTraversableAgain
/*    println(arr1.isTraversableAgain)
      println(arr1.toIterator.isTraversableAgain)
*/

    //140、iterator ：   >>>  val T:Double = T.formatted(T:Double)
/*
      val iterator: Iterator[Int] = arr1.toIterator
      println(iterator.next())
      println(iterator.hasNext)
*/

    //141、ne ：   >>>  val bool:Boolean = arr.ne(arr2)
/*
    println(arr1.ne(arr1))
    println(arr1.ne(arr2))
*/

    //142、permutations ：   >>> var iter:Iterator[Array[T]] = arr.permutations
/*
    val arrTest = Array("a","b","c")
    val per: Iterator[Array[String]] = arrTest.permutations
    per.toList.foreach(a=>println(s"${a.mkString(",")}"))
*/

    //143、product ：   >>>  val T:Int = arr.product
/*  val arrTest = Array(1,2,3)
    println(arrTest.product)
    println(arr1.product)
*/

    //144、reduceOption ：   >>>  val\ value:B = arr.reduceOption(f:(T,T)=>B)
/*
    val arrTest1: Array[Int] = Array(1, 2, 3)
    val arrTest2: Array[Int]  = Array()
    println(arrTest1.reduceOption(_+_))
    println(arrTest2.reduceOption(_-_))
*/

    //145、runWith ：   >>>  val bool:Boolean = arr.runWith(f:PartialFunction)(index:Int)
/*
    // 偏函数
    var pf:PartialFunction[Int,Option[String]] = (x:Int) => x match {
      case i if i%3==0 => Some("three")
      case i if i%7==0 => Some("seven")
      case i => None
    }

    pf.runWith(println)(5) //=> 输出 None			返回false
    pf.runWith(println)(6) //=> 输出 Some(three)	返回true
    //以第二参数下标提取序列元素，作为第一参数函数的入口
    //下表存在，且元素符合函数规则返回true
    //下表存在，且元素不符合函数规则报异常
    //下标不存在返回false
    val boo1: Boolean = arr1.runWith(x => x match {
      case x if x % 2 == 0 => x
    })(17)
    println(boo1)

    val boo2: Boolean = arr1.runWith(x => x match {
      case x if x % 2 == 0 => x
    })(3)
    println(boo2)

*/


    //146、stringPrefix ：   >>>  val value:String = arr.stringPrefix
/*
    println(arr1.stringPrefix)
    println(arr1.toString)
*/

    //147、to ：   >>>  val bool:Boolean = arr.ne(arr2)
/*
    for(i <- 1 to 10){
      print(s"${i}\t")
    }
    println()
    for(i <- 1 until 10){
      print(s"${i}\t")
    }
    println(arr1.to)
*/


    //148、view ：   >>>  val value:mutable.IndexedSeqView[T, Array[T]] = arr.view(from: Int, until: Int)
/*
    val view: AnyRef with mutable.IndexedSeqView[Int, Array[Int]] = arr1.view
    println(view)
    view.foreach(a=>print(s"${a}\t"))
    println()
    val i: Int = arr1.view(1)
    println(i)
    val value: mutable.IndexedSeqView[Int, Array[Int]] = arr1.view(1, 8)
    println(value)
    value.foreach(a=>print(s"${a}\t"))
*/


    //149、withFilter ：   >>>  val arr:[Array[T]] = arr.filter(f:T=>Boolean)
/*    arr1.withFilter(_%2 == 0).foreach(a=>print(s"${a}\t"))
    println()
    arr1.withFilter(_%2 == 1).foreach(a=>print(s"${a}\t"))
*/

    //150、toVector ：   >>>  val vector: Vector[T] = arr.toVector
/*
    val vector: Vector[Int] = arr1.toVector
    println(vector)
*/
    //151、toTraversable  ：   >>>  val traversable: Traversable[T] = arr.toTraversable
/*
        val iterator = arr1.toIterator
        iterator.foreach(a=>print(s"${a}\t"))
        println
        iterator.foreach(a=>print(s"${a}\t"))
        println
        iterator.foreach(a=>print(s"${a}\t"))
        println
        val traversable: Traversable[Int] = iterator.toTraversable
        traversable.foreach(a=>print(s"${a}\t"))
        println()
        traversable.foreach(a=>print(s"${a}\t"))
        println()
        traversable.foreach(a=>print(s"${a}\t"))
    */

    //152、toIterable  ：   >>>  val iterable: Iterable[T] = arr1.toIterable
/*
    val iterable: Iterable[Int] = arr1.toIterable
    iterable.foreach(a=>print(s"${a}\t"))
    println()
    iterable.foreach(a=>print(s"${a}\t"))
    println()
    iterable.foreach(a=>print(s"${a}\t"))
*/

    //153、toIterator  ：   >>>  val iterator: Iterator[T] = arr.toIterator
/*
        val iterator: Iterator[Int] = arr1.toIterator
*/

    //154、toList  ：   >>>  val list: List[T] = arr.toList
/*
    val list: List[Int] = arr1.toList
*/

    //155、toSeq  ：   >>>   val seq: Seq[Int] = arr1.toSeq
/*
    val seq: Seq[Int] = arr1.toSeq
*/

    //156、toStream  ：   >>>   val stream: Stream[T] = arr.toStream
/*
    val stream1: Stream[Int] = arr1.toStream
    println(stream1)
*/

    //157、toString  ：   >>>   val string: String = arr.toString
/*
    val string: String = arr1.toString
    println(string)
*/

    //158、toIndexedSeq  ：   >>>   val seq: immutable.IndexedSeq[T] = arr1.toIndexedSeq
/*
    val seq: immutable.IndexedSeq[Int] = arr1.toIndexedSeq
    println(seq)
*/

    //158、++:  ：   >>>  val newArr = elem +: arr
/*
    // 1.都是immutable或都是mutbale时:++ 和 ++: 作用一样（并集）
    val arrTest1 = Array(10,11,12)
    val arrTest2 = Array("a","b","c")

    // 类型同样的并集
    val value1 = arr1 ++ arrTest1
    value1.foreach(a=>print(s"${a}\t"))
    println()
    // 类型不一样的并集
    val value2= arr1++arrTest2
    value2.foreach(a=>print(s"${a}\t"))
    println()

    //2.一个是immutable另一个是mutbale时
    //		++ 结果类型为immutable还是mutable由++前面决定
    //		++: 结果类型为immutable还是mutable由++:后面决定
    val arrTest3 = scala.collection.mutable.ListBuffer(10,11,12)
    val ints: Array[Int] = arr1 ++ arrTest3
    ints.foreach(a=>print(s"${a}\t"))
    println()
    val ints1: ListBuffer[Int] = arrTest3 ++ arr1
    ints1.foreach(a=>print(s"${a}\t"))
    println()
    val value3: scala.collection.mutable.ListBuffer[Int] = arr1 ++: arrTest3
    value3.foreach(a=>print(s"${a}\t"))
    println()
    val value4: Array[Int] = arrTest3 ++: arr1
    value4.foreach(a=>print(s"${a}\t"))
*/

    // ->   ：   >>>  val tuple: (Array[T], T)  = arr -> value:Any
/*
    val tuple: (Array[Int], String) = arr1 -> "arr1"
    println(tuple.toString())
*/
  }
}

算子作用分类图

（网上找的，自己是在不想写了）

scala算子分类

scala

本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 协议 ，转载请注明出处！