scala1

右边操纵数b的类型决定着返回结果的类型: a ++：b println(c.getClass().getName()) c的类型
添加一个元素到最前面: 0 +: a
添加一个元素到最后面: a :+ 0
10加上数组里的每项的和/：val c=(10 /: a)(+) a(1,2,3)则c=16 /：折叠返回一条数据
将数组中的元素逐个添加到b中(直接拼在一起)([用,隔开])：val a=List(1,2,3,4) val b=new StringBuilder() val c=a.addString(b[,","]) //c内容为1234
val c = a.addString(b,"{",",","}") (首位各加一个字符串 并指定分隔符)
获取index索引处的字符(数组必须为char类型)：val chars=Array(‘a’,‘b’,‘c’) println(chars.charAt(0))
创建副本(克隆)：val chars=Array(‘a’,‘b’,‘c’) val newchars=chars.clone() 对list用不起来

判断当前数组是否包含符合条件的元素:println(a.exists({x:Int => x==3}))
检测当前序列中是否包含另一个序列，并返回第一个匹配出现的元素的索引：序列里查序列 println(a.indexOfSlice(b))
检测当前序列中是否包含另一个序列，并返回第一个匹配出现的元素的索引，指定从 from 索引处开始；序列里查序列 println(a.indexOfSlice(b,3))
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
检查a和b长度是否相等，并且a中元素是否小于b中对应位置的元素:
val a=Array(1,2,3) val b=Array(4,5,6) println(a.corresponds(b)(<))
统计符合条件的元素个数，下面统计大于 2 的元素个数:
val a=Array(1,2,3) println(a.count({x:Int => x > 2})) x > 2空格
将当前数组中没有在另一个数组中出现的元素返回：
val c=a.diff(b) println(c.mkString)
去除当前集合中重复的元素，只保留一个:
val b=a.distinct println(b.mkString(","))
将当前序列中前n个元素去除后，作为一个新序列返回:
val c=a.drop(2) println(c.mkString(","))
dropRight(必须大写):功能同 drop，去掉尾部的 n 个元素
dropWhile:
//下面去除大于2的，第一个元素 3 满足，它后面的元素 2 不满足，所以返回 2,3,4
val a = Array(3, 2, 3,4)
val c = a.dropWhile( {x:Int => x > 2} )
println(c.mkString(","))
//如果数组 a 是下面这样，第一个元素就不满足，所以返回整个数组 1, 2, 3,4
val a = Array(1, 2, 3,4)
判断是否以某个序列结尾: println(a.endsWith(b)) a是否以b结尾 boolean
取得当前数组中符合条件的元素，组成新的数组返回: val b=a.filter({x:Int => x>2})
取得当前数组中不符合条件的元素，组成新的数组返回: val b=a.filterNot({x:Int => x>2})
查找第一个符合条件的元素：val b=a.find({x:Int => x>2})
对当前序列的每个元素进行操作，结果放入新序列返回，参数要求是GenTraversableOnce及其子类:
val b=a.flatmap(x=>1 to x) println(b.mkString",") 从1开始，分别于集合a的每个元素生成一个递增序列1,1,2,1,2,3,1,2,3,4
检测序列中的元素是否都满足条件:val b=a.forall({x:Int => x>0}) boolean
遍历序列中的元素，进行 f 操作: a.foreach(x=> println(x10))
按条件分组，条件由 f 匹配，返回值是Map类型，每个key对应一个序列:
val b=a.groupBy(x=> x match{
case x if(x<3) => “small”
case _=> “big”
})
按指定数量分组，每组有 size 数量个元素，返回一个集合:
val b=a.grouped(3).toList 3个一分组
b.foreach((x)=> println"第"+(b.indexOf(x)+1)+“组”+x.mkString(",")))
检测序列是否存在有限的长度，对应Stream这样的流数据:println(a.hasDefiniteSize)
返回某某在序列中的索引，找到第一个就返回:println(a.indexOf(3)) 下标0开始
返回某某在序列中的索引，可以指定从某个索引处（from）开始查找，找到第一个就返回：println(a.indexOf(3,2)) 从下标为2的找3 输出3的下标还是从0开始
返回当前序列中第一个满足 p 条件的元素的索引:println(a.indexOfWhere({x:Int => x>3}))
返回当前序列中第一个满足 p 条件的元素的索引，可以指定从 from 索引处开始:println(a.indexOfWhere({x:Int => x>3},4))
返回当前序列索引集合: val b=a.indices println(b.mkString(",")) 返回目前索引
返回当前序列中不包含最后一个元素的序列：val b=a.init println(b.mkString(","))
取两个集合的交集：val c=a.intersect(b)
判断序列中是否存在指定索引:println(a.isDefinedAt(1))
判断当前序列是否为空:println(a.isEmpty)
取得序列中最后一个元素:println(a.last)
取得序列中最后一个等于4的元素的位置/下标：println(a.lastIndexOf(4))
取得序列中最后一个等于4的元素的位置，可以指定在 end 之前(包括)的元素中查找：println(a.lastIndexOf(4,3))
判断当前序列中是否包含序列并返回最后一次出现该序列的位置处的索引:println(a.lastIndexOfSlice(b))
判断当前序列中是否包含序列并返回最后一次出现该序列的位置处的索引，可以指定在 end 之前（包括）的元素中查找:println(a.lastIndexOfSlice(b,4))
返回当前序列中最后一个满足条件的元素的索引:println(a.lastIndexWhere({x:Int => x<2}))
返回当前序列中最后一个满足条件的元素的索引，可以指定在 end 之前（包括）的元素中查找:println(a.lastIndexWhere({x:Int => x<2},2))
返回当前序列中最后一个对象:println(a.lastOption)
返回当前序列中元素个数:println(a.length)=println(a.size)
返回序列中最大的元素：println(a.max)
将所有元素组合成一个字符串:println(a.mkString)
将所有元素组合成一个字符串，以,作为元素间的分隔符:println(a.mkString(","))
将所有元素组合成一个字符串，以 start 开头，以 sep 作为元素间的分隔符，以 end 结尾:println("{",",","}"))
判断序列是不是空：println(a.nonEmpty)
后补齐序列,如果当前序列长度小于 len，那么新产生的序列长度是 len，多出的几个位值填充 elem，如果当前序列大于等于 len ，则返回当前序列
需要一个长度为 7 的新序列，空出的填充 9:val b=a.padTo(7,9) println(b.mkString(","))
按条件将序列拆分成两个新的序列，满足条件的放到第一个序列中，其余的放到第二个序列，下面以序列元素是否是 2 的倍数来拆分:
val b:(Array[Int],Array[Int]) = a.partition( {x:Int => x % 2 == 0})
println(b._1.mkString(","))
println(b._2.mkString(","))
批量替换，从原序列的 from 处开始，后面的 replaced 数量个元素，将被替换成序列:
val c=a.patch(1,b,2) 从a数列第一个后面就是第二个开始，取2个元素替换成b,b可以是一个元素
反转序列 倒序输出:val b=a.reverse
反向生成迭代:val b=a.reverseMap({x:Int => x 10}) 乘以10倒序输出
判断两个序列是否顺序和对应位置上的元素都一样(都满足才true)：println(a.sameElements(b))
从序列的 from 处开始向后查找，所有满足条件的连续元素的长度：val b=a.segmentLength({x:Int =>x<3},3)
取出当前序列中，from 到 until 之间的片段:val b=a.slice(1,3) 左闭右开 下标为1和2的被取出
升序：val b =a.sortBy({x:Int => x}) val b=a.sorted
降序：val b=a.soetwith(.compareTo()>0)
分割序列为两个集合，从第一个元素开始，直到找到第一个不满足条件的元素止，之前的元素放到第一个集合，其它的放到第二个集合
val b =a.span({x:Int => x>2}) printlnb._1.mkString(",") printlnb._1.mkString(",")
从指定位置开始，把序列拆分成两个集合:val b=a.spiltAt(2) 前面两个取出来
是否以某个序列开始：println(a.startWith(b))
序列求和，元素需为Numeric[T]类型：val ba.sum
将序列中 i 索引处的元素更新为 x:a.update(1,9) 下标为1的数换位数值9
将序列中 i 索引处的元素更新为 x ,并返回替换后的数组：val b=a.updated(1,9)
返回除了当前序列第一个元素的其它元素组成的序列:val b=a.tail
返回当前序列中前 n 个元素组成的序列:val b=a.take(3)
返回当前序列中，从右边开始，选择 n 个元素组成的序列:val b=a.takeRight(3)
返回当前序列中，从第一个元素开始，满足条件的连续元素组成的序列:val b=a.takeWhile({x:Int => x<3})
联合两个序列，同操作符 ++:val c=a.union(b)
将含有两个元素的数组，第一个元素取出组成一个序列，第二个元素组成一个序列:val b=chars.unzip
将含有三个元素的三个数组，第一个元素取出组成一个序列，第二个元素组成一个序列，第三个元素组成一个序列:val b=chars.unzip(3)
返回 from 到 until 间的序列，不包括 until 处的元素:val b=a.view(1,3) 13只下标 左闭右开
将两个序列对应位置上的元素组成一个pair序列：变成二维数组
同 zip 但是允许两个序列长度不一样，不足的自动填充 val c=a.zipAll(b,9,8) a短b长：9填充 a长b短：8填充
序列中的每个元素和它的索引组成一个序列：val b=a.zipWithIndex (值，索引)