序列间操作
++
描述： 合并两个序列(序列为空，必须指定泛型)，若序列类型不同以【左边】序列类型为主；若泛型类型不同以两个序列共同的最小父类为结果类型；结果元素是在A序列元素后面添加B序列的元素。
返回值： 左边序列类型，最小父类序列泛型类型
scala> val a = Array(1,2)
a: Array[Int] = Array(1, 2)
scala> val b = Array("a",1)
b: Array[Any] = Array(a, 1)
scala> a ++ b
res103: Array[Any] = Array(1, 2, a, 1)
// 若泛型类型不同以两个序列共同的最小父类为结果类型
scala> val c = Array(1.0,2.3)
c: Array[Double] = Array(1.0, 2.3)
scala> a ++ c
res104: Array[AnyVal] = Array(1, 2, 1.0, 2.3)
scala> val d = List(1,2)
d: List[Int] = List(1, 2)
// 若序列类型不同以【左边】序列类型为主
scala> a ++ d
res1: Array[Int] = Array(1, 2, 1, 2)
scala> d ++ a
res2: List[Int] = List(1, 2, 1, 2)
union
描述： 合并两个序列，同操作符 ++，相当于数据库中的union all(不会去重)
val a = Array(1, 2)
val b = Array(3, 4)
val c = a.union(b)
println(c.mkString(",")) // 1,2,3,4
scala> b
res92: Array[Int] = Array(3, 4, 1, 1, 3)
scala> val c = Array(1,1,1,2,3,4,5)
c: Array[Int] = Array(1, 1, 1, 2, 3, 4, 5)
scala> b ++c
res93: Array[Int] = Array(3, 4, 1, 1, 3, 1, 1, 1, 2, 3, 4, 5)
scala> res93.distinct //去重
res94: Array[Int] = Array(3, 4, 1, 2, 5)
++:
描述： 合并两个序列，若类型不同以【右边】类型为主。其他和 ++ 一样。
返回值： 右边序列类型
scala> val a = Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)
scala> val b = Array(4,5,6)
b: Array[Int] = Array(4, 5, 6)
scala> val c = List(7,8,9)
c: List[Int] = List(7, 8, 9)
scala> val d = a ++: b
d: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> val d = a ++: c
d: List[Int] = List(1, 2, 3, 7, 8, 9)
scala> val d = c ++: a
d: Array[Int] = Array(7, 8, 9, 1, 2, 3)
canEqual
描述： 判断两个对象是否可以进行比较(基本上都可以比较)
返回值： boolean
val a = List(1, 2, 3, 4)
val b = Array('a', 'b', 'c')
val c = ArrayBuffer()
println(a.canEqual(b)) // true
println(a.canEqual(Map())) //true
corresponds
描述： 判断两个序列的长度以及对应位置元素是否符合某个条件，满足返回true，不满足返回false
返回值：Boolean
// 下面代码检查 a 和 b、c长度是否相等，并且 a 中元素是否小于 b、c 中对应位置的元素
val a = Array(1, 2, 3, 4)
val b = Array(5, 6, 7, 8)
val c = Array(2, 1, 4, 5)
println(a.corresponds(b)(_ < _)) // true
println(a.corresponds(c)(_ < _)) // false
clone
描述： 创建一个数组的副本，复制数组的值,但不会引用地址；就是说是浅克隆，不是深克隆。
返回值： 数组
val a = Array(1,2,3,4)
val b = a.clone()
//a和b值相同，但地址不同
diff
描述： 计算当前数组与另一个数组的【差集】，即返回另外一个数组中没有的元素(不去重)
返回值： 数组
val a = Array(1, 2, 2, 3, 4,4)
val b = Array(3, 4, 5, 6,3)
val c = a.diff(b)
println(c.mkString(","))
// 1,2,2,4
intersect
描述：取两个集合的【交集】，可以和diff结合来记忆
val a = Array(1, 2, 3, 4)
val b = Array(3, 4, 5, 6)
val c = a.intersect(b)
println(c.mkString(","))
// 3,4
计算op
/: 和:/
描述： 对数组中所有的元素从左向右遍历，进行相同的迭代操作，foldLeft 的简写(冒号要离数组近)；相当于左二叉树。
返回值： 计算结果
scala> val a = List(1, 2, 3, 4)a: List[Int] = List(1, 2, 3, 4)scala> val b = (10 /: a) (_ + _) // (((10+1)+2)+3)+4b: Int = 20scala> val c = (10 /: a) (_ * _) // (((10*1)*2)*3)*4c: Int = 240scala> val d = ("a" /: a) (_ * _) // 1*2*3*4个ad: String = aaaaaaaaaaaaaaaaaaaaaaaa
fold/foldLeft
描述： 从左到右计算，对序列中的每个元素进行二元运算，和 aggregate 有类似的语义，但执行过程有所不同
val arr1 = Array(1,2,5,3,5,2)def cal2(a:Int,b:Int): Int ={ println(s"$a+$b=${a+b}") a+b}println(arr1.fold(1)(cal2)) //1是初始值//1+1=2//2+2=4//4+5=9//9+3=12//12+5=17//17+2=19//19
:和:\
描述： 对数组中所有的元素从右向左遍历，进行相同的迭代操作，foldLeft 的简写(冒号要离数组近)；相当于右二叉树。
返回值： 计算结果
scala> val a = List(1, 2, 3, 4)a: List[Int] = List(1, 2, 3, 4)scala> val b = (a :\ 10) (_ - _) // 1-(2-(3-(4-10)))b: Int = 8scala> val c = (a :\ 10) (_ * _) // 1*(2*(3*(4*10)))c: Int = 240scala> val d = (a \: "a") (_ + _) // 注意和 val d = ("a" /: a) (_ + _) 的区别<console>:12: error: value \: is not a member of String val d = (a \: "a") (_ + _) // (((10*1)*2)*3)*4
foldRight
val arr1 = Array(1,2,5,3,5,2)def cal2(a:Int,b:Int): Int ={ println(s"$a+$b=${a+b}") a+b}println(arr1.foldRight(1)(cal2)) //可以简写为：(arr1 :\ 1)(_+_)//2+1=3//5+3=8//3+8=11//5+11=16//2+16=18//1+18=19//19
reduce=reduceLeft,和reduceRight
描述： 同 fold，不需要初始值，直接从序列中先拿出两个值
var arr1 = Array(2,6,11,8,7)//元素的总和println(arr1.reduce(_+_)) //34val add = (x:Int,y:Int) => { println(s"${x}+${y}=${x+y}") x*y}println(arr1.reduce(add))//println(arr1.reduceLeft(add))//2+6=8//12+11=23//132+8=140//1056+7=1063//7392println(arr1.reduceRight(add))//8+7=15//11+56=67//6+616=622//2+3696=3698//7392
reduceLeftOption=reduceOption和reduceRightOption
描述： 同 reduceLeft…….，计算Option
返回值： Option
var arr1 = Array(2,6,11,8,7)val add = (x:Int,y:Int) => { println(s"${x}+${y}=${x+y}") x*y}println(arr1.reduceLeftOption(add))//println(arr1.reduceOption(add))//2+6=8//12+11=23//132+8=140//1056+7=1063//Some(7392)println(arr1.reduceRight(add))//8+7=15//11+56=67//6+616=622//2+3696=3698//Some(7392)
scan=scanLeft和scanRight
描述： 同 fold，scan 会把每一步的计算结果放到一个新的集合中返回，而 fold 返回的是最后的结果
scala> val a = Array(1, 2, 3, 4)
a: Array[Int] = Array(1, 2, 3, 4)
scala> val b = a.scan(5)(_ + _)
b: Array[Int] = Array(5, 6, 8, 11, 15)
scala> val b = a.scanRight(5)(_ + _)
b: Array[Int] = Array(15, 14, 12, 9, 5)
aggregate
描述：aggregate是柯里化方法（将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数）， aggregate 方法是一个聚合函数，接受多个输入，并按照一定的规则运算以后输出一个结果值
val arr1 = Array(1,2,5,3,5,2)
val map2 = (a:Int,b:Int) =>{
println(s"map2 : ${a}+${b}=${a+b}")
a+b
}
val reduce2 = (a:Int,b:Int) =>{
println(s"reduce : ${a}-${b}=${a-b}")
a-b
}
arr1.par.aggregate(0)(map2,reduce2) //par分区了
//map2 : 0+5=5
//map2 : 0+5=5
//map2 : 0+3=3
//map2 : 0+2=2
//map2 : 0+1=1
//map2 : 0+2=2
//reduce : 5-2=3
//reduce : 2-5=-3
//reduce : 3-3=0
//reduce : 1--3=4
//reduce : 4-0=4
arr1.aggregate(0)(map2,reduce2) //不分区 就相当于fold、reduce
//map2 : 0+1=1
//map2 : 1+2=3
//map2 : 3+5=8
//map2 : 8+3=11
//map2 : 11+5=16
//map2 : 16+2=18
andThen和compose
描述： 表示方法的连续调用，相当于嵌套函数 g(f(x)) （需满足第一个函数的返回值类型是第二个函数的输入值类型），与 compose 相反，compose是从后往前
val f1 = (x: Int) => x + 2
val f2 = (x: Int) => x * 2
val f3 = (x: Int) => x - 2
val f4 = f1 andThen f2 andThen f3
val f5 = f1 compose f2 compose f3
println(f4(1)) //1+2=3 3*2=6 6-2=4 输出4
println(f5(1)) //1-2=-1 -1*2=-2 -2+2=0 输出0
applyOrElse
描述：根据参数1下标提取集合元素，若下标不越界则返回下标元素，否则将越界下标作为参数传入参数的函数
val arr1 = Array(1, 2, 3,5)
println(arr1.applyOrElse(3,(ix:Int) => ix)) //5
println(arr1.applyOrElse(4,(ix:Int) => ix)) //越界了 则返回4
runWith
描述： 执行偏函数，当参数不在定义域内时，返回false，否则返回true，并执行action
val pf:PartialFunction[Int,Int] = (x:Int) => x match {
case x if(x%2==1) => x
}
pf.runWith(println)(3) //3
pf.runWith(println)(2) //无输出
类型转化
mkString
描述： 将序列中所有元素拼接成一个字符串，可以设置参数：mkString(start, sep, end) 将序列中所有元素拼接成一个字符串，以 start 开头，以 sep 作为元素间的分隔符，以 end 结尾)
val arr1 = Array(1,2,5,3,5,2)
println(arr1.mkString) //125352
println(arr1.mkString(",")) //1,2,5,3,5,2
println(arr1.mkString("{",",","}")) //{1,2,5,3,5,2}
addString
描述： 多集合拼接，将数组中的元素逐个添加到StringBuilder中
返回值： StringBuilder
val arr1 = Array(1,2,3,5)
val builder = new StringBuilder
val str: StringBuilder = arr1.addString(builder)
println(str)
builder.clear()
//1235
val str1: StringBuilder = arr1.addString(builder,",")
println(str1)
builder.clear()
//12351,2,3,5
val str2 = arr1.addString(builder,"{",",","}")
println(str2)
builder.clear()
//{1,2,3,5}
copyToArray
描述：将数组中的内容拷贝到Array中
val a = Array('a', 'b', 'c')
val b : Array[Char] = new Array(5)
a.copyToArray(b) //b中元素 ['a','b','c',0,0]
a.copyToArray(b,1) //b中元素 [0,'a',0,0,0]
a.copyToArray(b,1,2) //b中元素 [0,'a','b',0,0]
copyToBuffer
描述：将数组中的内容拷贝到Buffer中
val a = Array('a', 'b', 'c')
val b:ArrayBuffer[Char] = ArrayBuffer()
a.copyToBuffer(b)
println(b.mkString(",")) //a,b,c
iterator和iterable
描述：iterator获取集合的迭代器对象，只能迭代一次，iterable可重复迭代
val arr1 = Array(1, 2, 3,5)
val iter: Iterator[Int] = arr1.toIterator
iter.foreach(println)
println("=============================")
iter.foreach(println)
-->
1
2
3
5
=============================
val iterable: Iterable[Int] = arr1.toIterable
iterable.foreach(println)
//可重复迭代
println("=============================")
iterable.foreach(println)
-->
1
2
3
5
=============================
1
2
3
5
repr
描述： repr() 函数将对象转化为供解释器读取的形式
val a = Map(1 -> "a",2 -> "b")
println(a.repr) //等于 println(a) Map(1 -> a, 2 -> b)
val b = Array("java","scala")
println(b.repr) // 等于 println(b) 打印地址[Ljava.lang.String;@17550481
seq
描述： 产生一个引用当前序列的 sequential 视图
val a = Array(1, 2, 3, 4)
val b = a.seq
println(b) //WrappedArray(1, 2, 3, 4)
toArray/toBuffertoIndexedSeq/toIterator/toIterable/toList/toMap/toSeq/toStream/toTraversable/toVector
序列操作
combinaions
描述： 排列组合l列出所有包含字符不一样的组合，不考虑顺序，参数n表示每个组合的序列长度。(如对于 “ab”、“ba”，视为相同组合)
val arr1 = Array(1, 2, 5,3,5,2)
arr1.combinations(3).foreach(x=>println(x.mkString(",")))
1,2,2
1,2,5
1,2,3
1,5,5
1,5,3
2,2,5
2,2,3
2,5,5
2,5,3
5,5,3
permutations
描述： 排列组合会选出所有排列顺序不同的字符组合，与 combinations 不同的是，对于相同的字符组合，比如 “abc”、“cba”，视为不同的组合
val a = Array("a", "b", "c")
a.permutations.toList.foreach( x => println(x.mkString(",")))
a,b,c
a,c,b
b,a,c
b,c,a
c,a,b
c,b,a
flatMap
描述： 既可以降维，又可以运算
var arr2 = Array(Array(1,3,11,19),Array(7,9,33,45))
arr2.flatMap(_.map(_+2)).foreach(println)
-->
3
5
13
21
9
11
35
47
padTo
描述： 填充序列，如果当前序列长度小于 len，那么新产生的序列长度是 len，多出的几个位值填充 elem，如果当前序列长度大于等于 len ，则返回当前序列
val a = Array(1, 2, 3, 4)
println(a.padTo(7, 8).mkString(",")) //填充一个长度为 7 的序列，不足位补 8
// 1,2,3,4,8,8,8
println(a.padTo(3,5).mkString(",")) //1,2,3,4
par
描述： 开启分区，并行执行任务
segmentLength
描述： 从序列的 from 开始向后查找，返回满足条件 p 的连续元素的长度，只返回第一个
val a = Array(1,2,3,1,1,1,1,1,4,5)
val b = a.segmentLength( {x:Int => x < 3},3)
println(b) //5
product
描述： 返回所有元素乘积的值
val a = Array(1,2,3,4,5)
val b = a.product
println(b) //120
reverse
描述： 反转序列
val a = Array(1,2,3,4,5)
val b = a.reverse
println(b.mkString(",")) //5,4,3,2,1
reverseIterator
描述： 生成反向迭代器
返回值： Iterator
val a = Array(1, 2, 3, 4)
val b = a.reverseIterator
b.foreach(x => print(x + " ")) // 4 3 2 1
reverseMap
描述： 同 map，方向相反
val a = Array(1,2,3,4,5)
val b = a.reverseMap( {x:Int => x*10} )
println(b.mkString(",")) //50,40,30,20,10
stringPrefix
描述： 返回 toString 结果的前缀
val a = Array(0,1,2,3,4,5)
println(a.toString()) //[I@3daa57fb
val b = a.stringPrefix
println(b) //[I
transpose
描述： 矩阵转置，二维数组行列转换，二维数组的长度可以不一致，结果为缺省，但必须是二维数组
val chars = Array(Array("a","b"),Array("c","d"),Array("e","f"))
val b = chars.transpose
b.foreach(x=>println((x.mkString(","))))
//a,c,e
//b,d,f
unzip和unzip3
描述：将含有两个元素的数组，第一个元素取出组成一个序列，第二个元素组成一个序列
val chars = Array(("a","b"),("c","d"))
val b = chars.unzip
println(b._1.mkString(",")) //a,c
println(b._2.mkString(",")) //b,d
val chars = Array(("a","b","x"),("c","d","y"),("e","f","z"))
val b = chars.unzip3
println(b._1.mkString(",")) //a,c,e
println(b._2.mkString(",")) //b,d,f
println(b._3.mkString(",")) //x,y,z
zip
描述： 将两个序列对应位置上的元素组成一个元组数组，要求两个序列长度最好保证相同，不同的话取最小长度的序列长度，进行组成一个元组数组，其他的值过滤掉。
val a = Array(1,2,3,4,5)
val b = Array(5,4,3,2,1)
val c = a.zip(b)
println(c.mkString(","))
//(1,5),(2,4),(3,3),(4,2),(5,1)
zipAll
描述： 同 zip ，但是允许两个序列长度不同，不足的自动填充，如果当前序列短，不足的元素填充为 thisElem，如果 that 序列短，填充为 thatElem
val a = Array(1,2,3,4,5,6,7)
val b = Array(5,4,3,2,1)
val c = a.zipAll(b,8)
//(1,5),(2,4),(3,3),(4,2),(5,1),(6,8),(7,8)
zipWithIndex
描述： 序列中的每个元素和它的索引组成一个元组数组
val a = Array(10,20,30,40)
val b = a.zipWithIndex
println(b.mkString(","))
//(10,0),(20,1),(30,2),(40,3)
分组操作
groupBy
描述： 按条件分组，条件由 f 匹配，返回值是 Map 类型，每个 key 对应一个数组
返回值：Map
var arr3 = Array(("henry","male",22),("ariel","female",32),("pola","female",21),("jack","male",11),("rose","female",34))
arr3.map(x=>(x._2,1)).groupBy(_._1).map(x=>(x._1,x._2.size)).foreach(println)
//(male,2)
//(female,3)
grouped
描述： 按指定数量分组，每组有 size 个元素，当指定数量超出数组元素的长度时，分为一组
返回值： Iterator
var arr3 = Array(("henry","male",22),("ariel","female",32),("pola","female",21),("jack","male",11),("rose","female",34))
arr3.grouped(3).foreach(arr=>{
arr.foreach(println)
println("===========")
})
-->
//3个为一组归类
(henry,male,22)
(ariel,female,32)
(pola,female,21)
===========
(jack,male,11)
(rose,female,34)
===========
init
描述： 返回当前序列中不包含最后一个元素的序列
val arr1 = Array(1, 2, 5,3,5,2)
val init: Array[Int] = arr1.init
arr1.inits.foreach(line=>println(line.mkString(",")))
1
2
5
3
5
inits
描述： 对集合中的元素进行 init 迭代操作，该操作的返回值中， 第一个值是当前序列的副本，最后一个值为空，每一步都进行 init 操作，上一步的结果作为下一步的操作对象
val arr1 = Array(1,2,5,3,5,2)
val init: Array[Int] = arr1.init
arr1.inits.foreach(line=>println(line.mkString(",")))
1,2,5,3,5,2
1,2,5,3,5
1,2,5,3
1,2,5
1,2
1
tail
描述： 返回当前序列中不包含第一个元素的序列
val arr1 = Array(1, 2, 5,3,5,2)
println(arr1.tail.mkString(",")) //2,5,3,5,2
tails
描述： 同 inits，每一步都进行 tail 操作
arr1.tails.foreach(x=>println(x.mkString(",")))
1,2,5,3,5,2
2,5,3,5,2
5,3,5,2
3,5,2
5,2
2
partition
描述： 按条件将序列拆分成两个数组，满足条件的放到第一个数组，其余的放到第二个数组，返回的是包含这两个数组的元组
val a = Array(1, 2, 3, 4)
val b: (Array[Int], Array[Int]) = a.partition(x => x % 2 == 0)
println("偶数: " + b._1.mkString(",")) // 偶数: 2,4
println("奇数: " + b._2.mkString(",")) // 奇数: 1,3
sliding
描述： 滑动，从第一个元素开始，每个元素和它后面的 size - 1 个元素组成一个数组，最终组成一个新的集合返回，当剩余元素个数不够 size 时，则结束 。默认步长为1， (sliding(size, step) 可以设置步长 step，每一组元素组合完后，下一组从上一组起始元素位置 + step 后的位置处开始)
返回值： 迭代器
var arr1 = Array(2,6,11,8,7)
arr1.sliding(2).foreach(arr=>{
arr.foreach(x=>print(s"${x}\t"))
println()
})
//每两个元素为一数组
2 6
6 11
11 8
8 7
arr1.sliding(2,2).foreach(arr=>{
arr.foreach(x=>print(s"${x}\t"))
println()
})
//每两个元素为一数组,步数为2，从2开始，然后11开始，最后7
2 6
11 8
7
sortBy
描述： 按指定的排序规则对序列排序
val a = Array(3,2,1,4,5)
val b = a.sortBy( {x:Int => x})
println(b.mkString(",")) //1,2,3,4,5
sortWith
描述：自定义排序方法
val a = Array(3,2,1,4,5)
val b = a.sortWith(_.compareTo(_) > 0) // 大数在前
println(b.mkString(",")) //5,4,3,2,1
sorted
描述： 默认升序排列，无参数
val a = Array(3, 2, 1, 4)
val b = a.sorted
println(b.mkString(",")) // 1,2,3,4
span
描述： 将序列按条件拆分成两个数组，从第一个元素开始，直到第一个不满足条件的元素为止，满足条件的元素放到第一个数组，其余元素放到第二个数组
返回值： 包含这两个数组的元组
val a = Array(3,2,1,4,5)
val b = a.span( {x:Int => x > 2})
println(b._1.mkString(",")) //符合大于2的元素放在一个集合里 //3
println(b._2.mkString(",")) //不满足条件的元素在一个集合里 //2,1,4,5
splitAt
描述： 从指定位置开始，把序列拆分成两个数组，指定索引位置元素放入第二个数组中
val a = Array(3,2,1,4,5)
val b = a.splitAt(2)
println(b._1.mkString(",") //3,2
println(b._2.mkString(",")) //1,4,5
sum
描述： 序列求和
val a = Array(1, 2, 3, 4, 1)
println(a.sum) // 11
take和takeRight
描述： 返回当前序列中，前 n 个元素组成的序列
描述： 返回当前序列中，从右边开始，后 n 个元素组成的序列
val a = Array(1, 2, 3, 4)
val b = a.take(3)
println(b.mkString(",")) // 1,2,3
val a = Array(1, 2, 3, 4)
val b = a.takeRight(3)
println(b.mkString(",")) // 2,3,4
takeWhile
描述： 返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列，和span相似
val a = Array(1, 2, 3, 4, 1, 2)
val b = a.takeWhile(x => x < 3)
print(b.mkString(",")) // 1,2
元素判断
isEmpty
描述： 判断序列是否为空
nonEmpty
描述： 判断序列是否不为空
isTraversableAgain
描述： 判断序列是否可以反复遍历，该方法是 GenTraversableOnce 中的方法，对于 Traversables 一般返回 true，对于 Iterators 返回 false，除非被复写
val a = Array(1, 2, 3, 4)
val b = a.iterator
println(a.isTraversableAgain) // true
println(b.isTraversableAgain) // false
exists
描述： 判断当前数组是否包含符合条件的元素（至少一个）
val a = Array(1, 2, 3, 4)
println(a.exists(x => x == 3)) // true
println(a.exists(x => x == 5)) // false
contains
描述： 判断序列中是否包含指定对象
返回值：Boolean
val arr1 = Array(1, 2, 5,3,5,2)
println(arr1.contains(5)) // true
containsSlice
描述： 判断当前序列中是否包含另一个序列（数量和顺序相等）
返回值：Boolean
val arr1 = Array(1, 2, 5,3,5,2)
//集合中是否包含参数子序列
println(arr1.containsSlice(Array(5, 3, 5))) // true
endsWith和startsWith
描述： 判断当前序列是否以某个序列结尾
返回值：Boolean
val a = Array(1,2,3,4)
val b = Array(3,4)
println(a.endsWith(b)) // true
val c = Array(1,2)
println(a.startsWith(b)) // true
forAll
描述： 检测序列中的元素是否都满足条件 p，满足则返回true
返回值： boolean
val a = Array(1, 2, 3, 4)
println(a.forall(x => x > 0)) // true
println(a.forall(x => x > 2)) // false
sameElements
描述： 判断两个序列是否顺序和对应位置上的元素都一样
val arr1 = Array(1, 2, 5,3,5,2)
//两个集合中知否包含相同元素，且顺序相同
println(arr1.sameElements(Array(5, 3, 5))) // false
索引判断
hasDefiniteSize
描述： 检测序列是否存在有限的长度，对应 Stream 类型的流数据则返回 false
返回值： boolean
//流没有明确大小
//其他集合都有明确大小
println(arr1.hasDefiniteSize) // true
println(arr1.toBuffer.hasDefiniteSize) // true
println(arr1.toStream.hasDefiniteSize) // false
isDefinedAt
描述： 判断序列中是否存在指定索引
返回值： boolean
println(arr1.isDefinedAt(1)) // true
indexOf
描述： 返回元素 elem 在序列中第一次出现的索引，也可以指定索引 （包括）from从左向右开始查找，找不到返回-1；并且指定索引可以超出元素索引的范围
返回值： 索引值
val arr1 = Array(1,2,5,3,5,2)
println(arr1.indexOf(5)) //2
println(arr1.indexOf(3, 0)) //从下标0开始找3，输出为下标 //3
indexOfSlice
描述： 检测当前序列中是否包含序列 that，并返回第一次出现该序列的索引(可以指定从索引 from 开始查找，并返回第一次出现该序列的索引)，找不到就输出-1
返回值： 索引值
val arr1 = Array(1,2,5,3,5,2)
val arr2 = Array(1,2)
println(arr1.indexOfSlice(arr2)) //0
println(arr1.indexOfSlice(arr2,3)) //找不到 -1
indexWhere
描述： 返回当前序列中第一个满足条件 p 的元素的索引,可以指定从索引 from 开始查找
返回值： 索引值
val arr1 = Array(1,2,5,3,5,2)
println(arr1.indexWhere(_ < 5)) //0
lastIndexOf
描述： 返回元素 elem 在序列中最后一次出现的索引 (返回元素 elem 在序列中最后一次出现的索引，然后往左向右到指定索引遍历查找
返回值： 索引值
val a = Array(1, 3, 2, 3, 4)
println(a.lastIndexOf(3)) // 3
println(a.lastIndexOf(3, 2)) // 1
lastIndexOfSlice
描述： 检测当前序列中是否包含序列 that，并返回最后一次出现该序列的索引 (可以指定索引，往左向右到指定索遍历查找)，注意序列的查找以序列第一个元素为准
返回值： 索引值
val a = Array(1, 2, 3, 2, 3, 4)
val b = Array(2, 3)
println(a.lastIndexOfSlice(b)) //3
lastIndexWhere
描述： 返回当前序列中最后一个满足条件 p 的元素的索引 (可以指定索引，往前查找)
返回值： 索引值
val a = Array(1, 2, 3, 4)
println(a.lastIndexWhere(x => x > 2)) // 3
println(a.lastIndexWhere(x => x > 2, 2)) // 2
indices
描述： 返回当前序列索引集合
返回值： Range
arr1.indices.foreach(println)
添加元素
+:
描述： 在数组前面添加一个元素(添加的元素在前，就在数组 头部 添加，冒号要离数组近)，结果泛型类型取元素类型和数组类型的共同最小父类。
返回值： 数组
val a = Array(1,2,3)
val b = 1 +: a
b.foreach(x=>println(x))
1
1
2
3
val b = "a" +: a
b.foreach(x=>println(x))
a
1
2
3
:+
描述： 在数组后面添加一个元素(添加的元素在后，就在数组 尾部 添加，冒号要离数组近)；和 [+:](https://editor.csdn.net/md?articleId=108437748# 😃 相反
返回值： 数组
val a = Array(1,2,3)
val b = a :+ 1
b.foreach(x=>println(x))
1
2
3
1
查询元素
foreach
描述： 遍历序列中的元素
map
描述： 对序列中的元素进行 f 操作，返回生成的新序列
val a = Array(1, 2, 3, 4)
val b = a.map(x => x * 10)
println(b.mkString(",")) // 10,20,30,40
slice
描述： 类似subSequence和view，返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素(左闭右开)
val a = Array(1, 2, 3, 4)
val b = a.slice(1, 3)
println(b.mkString(",")) // 2,3
apply
描述： 按下标取数组数据
返回值： 数组中的元素类型
val a = Array(1,2,3,4)
a.apply(2)
println(a) //3
view
描述： 同subSequence，返回当前序列中从 from 到 until 之间的序列，不包括 until 处的元素(左闭右开)
val a = Array(1, 2, 3, 4)
val b = a.view(1, 3)
println(b.mkString(",")) // 2,3
subSequence
描述：同view，返回 start 和 end 间的字符序列，不包含 end 处的元素(左闭右开)
val a = Array('a', 'b', 'c', 'd')
val b = a.subSequence(1, 3)
println(b.toString) // bc
count
描述： 统计符合条件的元素个数
//统计符合条件的元素个数
var arr1 = Array(2,6,11,8,7)
println(arr1.count(_%2==0)) //3
length=size
描述： 返回序列元素个数
val a = Array(1, 2, 3, 4, 5)
println(a.length) //5
println(a.size) //5
lengthCompare
描述： 比较序列的长度和参数 len，返回序列的长度 - len
val a = Array(1, 2, 3, 4)
println(a.lengthCompare(3)) // 1
println(a.lengthCompare(4)) // 0
println(a.lengthCompare(5)) // -1
prefixLength
描述： 给定一个条件 p，返回一个前置数列（数列开头的）满足条件的元素个数
val a = Array(1,2,3,4,1,2,3,4)
val b = a.prefixLength( {x:Int => x<3})
println(b) //总共有两个小于2的元素 //2
filter/filterNot(与filter相反)
描述： 筛选数组中符合条件的元素
返回值： 数组
val a = Array(3, 2, 3,4)
val b = a.filter( {x:Int => x> 2} )
println(b.mkString(",")) //3,3,4
withFilter
描述： 根据条件 p 过滤元素
val a = Array(1,2,3,4,5)
val b = a.withFilter( {x:Int => x>3}).map(x=>x)
println(b.mkString(",")) //4,5
find
描述： 查找第一个符合条件的元素
返回值： Option
val arr1 = Array(1,2,5,3,5,2)
arr1.find(_>3).foreach(println) //5
head
描述： 返回序列的第一个元素，如果序列为空会报错
println(Array(1, 2, 3).head) //1
headOption
描述： 返回序列的第一个元素的 Option 类型对象，就是scala.Some 或者 None，如果序列为空，则返回 None
返回值： Option
val a = Array(1,2,3)
println(a.headOption) //Some(1)
last
描述： 返回序列的最后一个元素，如果序列为空，将引发错误
println(Array(1, 2, 3).last) //3
lastOption
描述： 返回序列的最后一个元素的 Option 类型对象，如果序列为空，则返回 None
返回值： Option
val a = Array(1, 2, 3, 4, 5)
println(a.lastOption) //Some(5)
/minBy,max/min
描述： 返回序列中符合条件的第一个元素(找不到满足条件的元素返回一个元素)
描述： 返回序列中不符合条件的第一个元素(找不到满足条件的元素返回一个元素)
var arr3 = Array(("henry","male",22),("ariel","female",32),("pola","female",21),("jack","male",11),("rose","female",34))
println(arr3.maxBy(_._3))
//找到年龄最大的数据
//(rose,female,34)
修改元素
transform
描述： 将序列中的元素转换成指定的元素（同类型）
val a = Array(1,2,3,4)
arr.transform(_*2).foreach(println) //2,4,6,8
arr.transform(x=>2).foreach(println) //2,2,2,2 把所有元素都转换成2
patch
描述： 批量替换，从原序列的 from 处开始，后面的 replaced 个元素，将被替换成序列 that
val a = Array(1, 2, 3, 4, 5)
val b = Array(3, 4, 6)
val c = a.patch(1,b,2)
println(c.mkString(","))
//从 a 的第二个元素开始，取两个元素，即2和3 ，这两个元素被替换为 b的内容
//1,3,4,6,4,5
update和updated
描述： 将序列中 i 索引处的元素更新为 x (直接在本数组上修改)
描述： 将序列中 i 索引处的元素更新为 x，并返回替换后的数组（修改副本
把第一个元素改成30
var arr1 = Array(2,6,11,8,7)
arr1.update(1,30)
println(arr1(1)) //30
//将集合的下标处的元素更改为 x ,并返回替换后的数组
val a = Array(1,2,3,4,5)
val b = a.updated(1,9)
println(b.mkString(",")) //1,9,3,4,5
collect
描述： 输入参数类型为偏函数，对序列中的元素进行转换（通过执行一个并行计算（偏函数），得到一个新的数组对象）
val arr1 = Array(1,2,5,3,5,2)
val pf:PartialFunction[Int,Int] = (x:Int) => x match {
case x if(x%2==1) => x
}
arr1.collect(pf).foreach(println) //奇数
1
3
5
collectFirst
描述： 查找序列中第一个符合偏函数的元素执行相应操作
返回值： Option类型
//提取集合中符合条件的元素：返回第一个元素，类似于filter
val arr1 = Array(1, 2, 3,5)
//arr1.collectFirst({case x if(x%2==1) => x}).foreach(println)
println(arr1.collectFirst({case x if(x >= 10 ) => x}))
-->
NONE
删除元素
drop
描述： 删除数组中前 n 个元素
返回值： 数组
val a = Array(1, 2, 3, 4)
val b = a.drop(2) //删除前两个元素
println(b.mkString(",")) // 3,4
dropRight
描述： 删除数组中尾部的 n 个元素
返回值： 数组
val a = Array(1, 2, 3, 4)
val b = a.dropRight(2)
println(b.mkString(",")) // 1,2
dropWhile
描述： 删除数组中符合条件的元素，从第一个元素起，直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），若第一个条件就不满足就返回整个数组
返回值： 数组
val a = Array(1,2,3,4,3,2,1)
val b = a.dropWhile(x => x < 3) //删除小于3的元素
println(b.mkString(",")) // 3,4,3,2,1 遇到4截止
val b = a.dropWhile(x => x > 2)
println(b.mkString(",")) // 1,2,3,4,3,2,1 第一个条件就不满足，返回整个数组
扫一扫
1712
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
