免费开源企业网站,做网站网站内容怎么找,网站推广模板,中国室内设计联盟官方网站入口目录
1. 添加类函数
2.生成类函数
3.删除类函数
4.查找类函数
5.统计类函数
6.修改类函数
7.判断类函数
8.获取集合元素
9.集合操作类函数
10.转换类函数
11.工具类函数
12.集合内与集合间计算函数 在 scala 中Array数组是一种可变的、可索引的数据集合
创建数组…目录
1. 添加类函数
2.生成类函数
3.删除类函数
4.查找类函数
5.统计类函数
6.修改类函数
7.判断类函数
8.获取集合元素
9.集合操作类函数
10.转换类函数
11.工具类函数
12.集合内与集合间计算函数 在 scala 中Array数组是一种可变的、可索引的数据集合
创建数组语法为 val arr : Array[Int] Array(1,2,3) [ ]内为数组内的数据类型Any 表示任何类型如果你研究过 scala 就会明白 scala 有面向对象的特点这里 Any 就是对象的父类类比 java 中的 object
Array 数组的 基础操作
val arr Array(1, 2, 3, 4) // 声明一个数组对象
val first arr(0) // 读取第一个元素
arr(3) 100 // 替换第四个元素为 100
val newarr arr.map(_ * 2) // 所有元素乘 2
println(newarr.mkString(,)) // 打印数组结果为2,4,6,200Array 数组的函数 1. 添加类函数 定义 def [B : A, That](that : scala.collection.GenTraversableOnce[B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That { /* compiled code */ }描述合并集合并返回一个新的数组新数组包含左右两个集合的内容 演示 val a Array(1,2,3)val b Array(3,4,5)val ints1: Array[Int] a bprintln(ints1.toList) : 定义 def :[B : A, That](that : scala.collection.Traversable[B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That { /* compiled code */ }描述这个方法同上一个方法类似两个加号后面多了一个冒号但是不同的是右边操纵数的类型决定着返回结果的类型 示例Array 和 List 结合返回结果是 List 类型 val a Array(1,2,3)val b List(3,4,5)val ints1 a : bprintln(ints1.getClass.getName) : 定义 def :[B : T](elem : B)(implicit evidence$3 : scala.reflect.ClassTag[B]) : scala.Array[B] { /* compiled code */ }描述在数组前面添加一个元素并返回新的数组对象 示例 val a Array(1,2,3,4)val ints: Array[Int] 0 : aprintln(ints.toList) : 定义 def :[B : T](elem : B)(implicit evidence$2 : scala.reflect.ClassTag[B]) : scala.Array[B] { /* compiled code */ }描述在数组后面添加一个元素并返回新的数组对象 示例 val a Array(1,2,3,4)val ints: Array[Int] a : 0println(ints.toList) 2.生成类函数 clone 定义 override def clone() : scala.Array[T] { /* compiled code */ } 描述克隆创建一个副本 示例clone 和 的区别通过下面的结果很容易就能对比出来 var a Array(1,2,3)var b avar c a.clonea(0) 0println(b.toList)println(c.toList) collect 定义 def collect[B, That](pf : scala.PartialFunction[A, B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That { /* compiled code */ }描述通过执行一个并行计算偏函数得到一个新的数组对象 示例通过下面的偏函数参数只能是偏函数把数组中的1转换为“a” val a Array(1,2,3)def fun : PartialFunction[Int,String]{case 1 acase _ other}println(a.collect(fun).toList ) collectFirst 定义 def collectFirst[B](pf : scala.PartialFunction[A, B]) : scala.Option[B] { /* compiled code */ } 描述在序列中查找第一个符合偏函数定义的元素并执行偏函数计算返回一个 option 示例 val a Array(1,2,3)def fun : PartialFunction[Int,String]{case 1 acase _ other}println(a.collectFirst(fun) ) 偏函数也可以用匿名函数表示 val a Array(1,2,3)println(a.collectFirst({case x : Int if (x 2) x1}) ) combinations 定义 def combinations(n : scala.Int) : scala.collection.Iterator[Repr] { /* compiled code */ } 描述combinations 表示组合这个排列组合会选出所有包含元素不一样的组合但不考虑顺序对于 “123”、“321”视为相同组合参数 n 表示序列长度就是几个元素为一组返回的是一个迭代器迭代器里存放的是 每一种组合的Array 数组 val a Array(1,2,3)val combine: Iterator[Array[Int]] a.combinations(2)combine.foreach(xprintln(x.toList)) permutations 定义 def permutations : scala.collection.Iterator[Repr] { /* compiled code */ }描述permutations 表示排列这个排列组合会选出所有排列顺序不同的元素组合permutations 与 combinations 不同的是相同的组合考虑排列对于 “abc”、“cba”视为不同的组合 示例 val a Array(1,2,3)val permutations: Iterator[Array[Int]] a.permutationspermutations.foreach(xprintln(x.toList)) copyToArray(xs) 定义 def copyToArray[B : A](xs : scala.Array[B]) : scala.Unit { /* compiled code */ }描述将当前数组元素复制到另一个数组中 示例 val a Array(1,2,3)val b new Array[Int](5)a.copyToArray(b)println(b.toList)copyToArray(arr, start) 定义 def copyToArray[B : A](xs : scala.Array[B], start : scala.Int) : scala.Unit { /* compiled code */ }描述将当前数组元素复制到另一个数组中从 start 位置开始复制 示例 val a Array(1,2,3)val b new Array[Int](5)a.copyToArray(b,1)println(b.toList) copyToArray(arr, start, len) 定义 override def copyToArray[U : T](xs : scala.Array[U], start : scala.Int, len : scala.Int) : scala.Unit { /* compiled code */ }描述将当前数组元素复制到另一个数组中从 start 位置开始复制长度为 len 示例 val a Array(1,2,3)val b new Array[Int](5)a.copyToArray(b,1,2)println(b.toList) copyToBuffer 定义 def copyToBuffer[B : A](dest : scala.collection.mutable.Buffer[B]) : scala.Unit { /* compiled code */ } 描述将数组中的元素复制到 Buffer 中 示例 val a Array(1,2,3)val buffer: ArrayBuffer[Int] ArrayBuffer()a.copyToBuffer(buffer)println(buffer.toList) 3.删除类函数 drop 定义 override def drop(n : scala.Int) : Repr { /* compiled code */ } 描述将当前数组中前 n 个元素去除返回一个新数组 示例 val a Array(1,2,3,4,5,6,7)val ints: Array[Int] a.drop(3)println(ints.toList) dropRight 定义 override def dropRight(n : scala.Int) : Repr { /* compiled code */ } 描述功能同 drop去掉尾部的 n 个元素 示例 val a Array(1,2,3,4,5,6,7)val ints: Array[Int] a.dropRight(3)println(ints.toList) dropWhile 定义 override def dropWhile(p : scala.Function1[A, scala.Boolean]) : Repr { /* compiled code */ }描述去除当前数组中符合条件的元素返回剩余的数组这个需要一个条件就是从当前数组的第一个元素起就要满足条件直到碰到第一个不满足条件的元素结束即使后面还有符合条件的元素否则返回整个数组 示例 val a Array(1,2,3,4,5,6,7,1)val ints: Array[Int] a.dropWhile(xx3)println(ints.toList) 4.查找类函数 find 定义 override def find(p : scala.Function1[A, scala.Boolean]) : scala.Option[A] { /* compiled code */ }描述查找第一个符合条件的元素返回 Option 示例 val a Array(1,2,3,4,5,6,2,1)val maybeInt: Option[Int] a.find(x x2)println(maybeInt) last 定义 override def last : A { /* compiled code */ } 描述返回序列的最后一个元素如果序列为空将引发错误 示例 val a Array(1,2,3,4,5,6)val last: Int a.lastprintln(last) lastIndexOf(elem) 定义 def lastIndexOf[B : A](elem : B) : scala.Int { /* compiled code */ }描述返回元素 elem 在序列中最后一次出现的索引 示例 val a Array(1,2,3,4,5,6)val index: Int a.lastIndexOf(5)println(index) lastIndexOf(elem, end) 定义 def lastIndexOf[B : A](elem : B, end : scala.Int) : scala.Int { /* compiled code */ }描述返回元素 elem 在序列中最后一次出现的索引指定在索引 end 之前包括的元素中查找 示例 val a Array(1,2,3,4,5,6,2,1)val index: Int a.lastIndexOf(2,5)println(index) lastIndexOfSlice(that) 定义 def lastIndexOfSlice[B : A](that : scala.collection.GenSeq[B]) : scala.Int { /* compiled code */ }描述检测当前序列中是否包含序列 that并返回最后一次出现该序列的索引 示例 val a Array(1,2,3,4,5,6,3,4,2,1)val slice Array(3,4)val index: Int a.lastIndexOfSlice(slice)println(index) lastIndexOfSlice(that, end) 定义 def lastIndexOfSlice[B : A](that : scala.collection.GenSeq[B], end : scala.Int) : scala.Int { /* compiled code */ }描述检测当前序列中是否包含序列 that并返回最后一次出现该序列的索引指定在索引 end 之前包括的元素中查找 示例 val a Array(1,2,3,4,5,6,3,4,2,1)val slice Array(3,4)val index: Int a.lastIndexOfSlice(slice,5)println(index) lastIndexWhere 定义 def lastIndexWhere(p : scala.Function1[A, scala.Boolean]) : scala.Int { /* compiled code */ }描述返回当前序列中最后一个满足条件 p 的元素的索引 示例 val a Array(1,2,3,4,5,6,3,4,2,1)val index: Int a.lastIndexWhere(xx3)println(index) lastIndexWhere(p, end) 定义 def lastIndexWhere(p : scala.Function1[A, scala.Boolean], end : scala.Int) : scala.Int描述返回当前序列中最后一个满足条件 p 的元素的索引指定在索引 end 之前包括的元素中查找 示例 val a Array(1,2,3,4,5,6,3,4,2,1)val index: Int a.lastIndexWhere(xx3,5)println(index) lastOption 定义 def lastOption : scala.Option[A] { /* compiled code */ } 描述返回序列的最后一个元素的 Option 类型对象如果序列为空则返回 None 示例 val a Array(1,2,3,4,5,6,3,4,2,1)val option: Option[Int] a.lastOptionprintln(option) indexOf(elem) 定义 def indexOf[B : A](elem : B) : scala.Int { /* compiled code */ }描述返回元素 elem 在序列中第一次出现的索引 示例 val a Array(1,2,3,4,5,6,3,4,2,1)val i: Int a.indexOf(2)println(i) indexOf(elem, from) 定义 def indexOf[B : A](elem : B, from : scala.Int) : scala.Int { /* compiled code */ }描述返回元素 elem 在序列中第一次出现的索引指定从索引 from 开始查找 示例 val a Array(1,2,3,4,5,6,3,4,2,1)val i: Int a.indexOf(2,3)println(i) indexOfSlice(that) 定义 def indexOfSlice[B : A](that : scala.collection.GenSeq[B]) : scala.Int { /* compiled code */ }描述检测当前序列中是否包含序列 that并返回第一次出现该序列的索引 示例 val a Array(1,2,1,3,4,5,6,3,4,2,1)val slide Array(2,1)val i: Int a.indexOfSlice(slide)println(i) indexOfSlice(that, from) 定义 def indexOfSlice[B : A](that : scala.collection.GenSeq[B], from : scala.Int) : scala.Int { /* compiled code */ }描述检测当前序列中是否包含另一个序列 that指定从索引 from 开始查找并返回第一次出现该序列的索引 示例 val a Array(1,2,1,3,4,5,6,3,4,2,1)val slide Array(2,1)val i: Int a.indexOfSlice(slide,4)println(i) indexWhere 定义 def indexWhere(p : scala.Function1[A, scala.Boolean]) : scala.Int { /* compiled code */ }描述返回当前序列中第一个满足条件 p 的元素的索引 示例 val a Array(1,2,1,3,4,5,6,3,4,2,1)val i: Int a.indexWhere(xx3)println(i) indexWhere(p, from) 定义 def indexWhere(p : scala.Function1[A, scala.Boolean], from : scala.Int) : scala.Int描述返回当前序列中第一个满足条件 p 的元素的索引指定从索引 from 开始查找 示例 val a Array(1,2,1,3,4,5,6,3,4,2,1)val i: Int a.indexWhere(xx3,6)println(i) segmentLength 定义 override def segmentLength(p : scala.Function1[A, scala.Boolean], from : scala.Int) : scala.Int { /* compiled code */ }描述从序列的 from 开始向后查找返回满足条件 p 的连续元素的长度只返回第一个 示例 val a Array(1,2,1,3,4,5,6,3,4,2,1)println(a.segmentLength(xx3,0))println(a.segmentLength(xx3,4)) 5.统计类函数 count 定义 def count(p : scala.Function1[A, scala.Boolean]) : scala.Int { /* compiled code */ }描述统计符合条件的元素个数 示例下面代码统计数组中所以元素个数和大于 2 的元素个数 val a Array(1,2,3,4)println(a.count(xtrue))println(a.count(xx2)) max 定义 def max[B : A](implicit cmp : scala.Ordering[B]) : A { /* compiled code */ } 描述返回序列中最大的元素 示例
val a Array(1, 2, 3, 4)
println(a.max) // 4maxBy 定义 def maxBy[B](f : scala.Function1[A, B])(implicit cmp : scala.Ordering[B]) : A { /* compiled code */ }描述返回序列中符合条件的第一个元素 示例
val a Array(1, 2, 3, 4)
println(a.maxBy(x x 2)) // 3 min 定义 def min[B : A](implicit cmp : scala.Ordering[B]) : A { /* compiled code */ }描述返回序列中最小的元素 示例
val a Array(1, 2, 3, 4)
println(a.min) // 1 minBy 定义 def minBy[B](f : scala.Function1[A, B])(implicit cmp : scala.Ordering[B]) : A { /* compiled code */ }描述返回序列中不符合条件的第一个元素 示例
val a Array(1, 2, 3, 4)
println(a.minBy(x x 2)) // 2 product 定义 def product[B : A](implicit num : scala.Numeric[B]) : B { /* compiled code */ }描述返回所有元素乘积的值 示例
val a Array(1, 2, 3, 4)
println(a.product) // 1*2*3*424 sum 定义 def sum[B : A](implicit num : scala.Numeric[B]) : B { /* compiled code */ }描述序列求和元素需为 Numeric[T] 类型 示例
val a Array(1, 2, 3, 4)
println(a.sum) // 10 6.修改类函数 update 定义 def update(i : scala.Int, x : T) : scala.Unit { /* compiled code */ }描述将序列中 i 索引处的元素更新为 x 示例 val a Array(1,2,3,4)a.update(1,0)println(a.toList)updated 定义 def updated[B : A, That](index : scala.Int, elem : B)(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That { /* compiled code */ }描述将序列中 i 索引处的元素更新为 x并返回替换后的数组 示例 val a Array(1,2,3,4)val ints: Array[Int] a.updated(1, 0)println(ints.toList) patch 定义 def patch[B : A, That](from : scala.Int, patch : scala.collection.GenSeq[B], replaced : scala.Int)(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That { /* compiled code */ }描述批量替换从原序列的 from 处开始后面的 replaced 个元素将被替换成序列 that,返回替换后的数组 示例从 a 的第二个元素开始取两个元素即 2 和 3 将这两个元素替换为序列 b val a Array(1,2,3,4)val b Array(9,8,7)val ints: Array[Int] a.patch(1, b, 2)println(ints.toList) 7.判断类函数 contains 定义 def contains[A1 : A](elem : A1) : scala.Boolean { /* compiled code */ }描述判断序列中是否包含指定对象 示例 val a Array(1,2,3,4)println(a.contains(4)) containsSlice 定义 def containsSlice[B](that : scala.collection.GenSeq[B]) : scala.Boolean { /* compiled code */ }描述判断当前序列中是否包含另一个序列 示例 val a Array(1,2,3,4)println(a.containsSlice(List(2,1)))println(a.containsSlice(List(1,2))) endsWith 定义 override def endsWith[B](that : scala.collection.GenSeq[B]) : scala.Boolean { /* compiled code */ }描述判断当前序列是否以某个序列结尾 示例 val a Array(1,2,3,4)println(a.endsWith(List(3,4))) exists 定义 override def exists(p : scala.Function1[A, scala.Boolean]) : scala.Boolean { /* compiled code */ }描述判断当前数组是否包含符合条件的元素 示例 val a Array(1,2,3,4)println(a.exists(xx5))println(a.exists(xx3)) isDefinedAt 定义 def isDefinedAt(idx : scala.Int) : scala.Boolean { /* compiled code */ }描述判断序列中是否存在指定索引 示例 val a Array(1,2,3,4)println(a.isDefinedAt(3)) isEmpty 定义 override def isEmpty : scala.Boolean { /* compiled code */ }描述判断序列是否为空 示例 val a Array(1,2,3,4)val b new Array[Any](0)println(a.isEmpty)println(b.isEmpty) isTraversableAgain 定义 final def isTraversableAgain : scala.Boolean { /* compiled code */ }描述判断序列是否可以反复遍历该方法是 GenTraversableOnce 中的方法对于 Traversables 一般返回 true对于 Iterators 返回 false除非被复写 示例 val a Array(1,2,3,4)val b a.iteratorprintln(a.isTraversableAgain)println(b.isTraversableAgain) forall 定义 override def forall(p : scala.Function1[A, scala.Boolean]) : scala.Boolean { /* compiled code */ }描述检测序列中的元素是否都满足条件 p如果序列为空则返回 true 示例 val a Array(1,2,3,4)println(a.forall(xx2))println(a.forall(xx0)) nonEmpty 定义 def nonEmpty : scala.Boolean { /* compiled code */ }描述判断序列是否不为空 示例 val a Array(1,2,3,4)val b new Array[Any](0)println(a.nonEmpty)println(b.nonEmpty) sameElements 定义 override def sameElements[B : A](that : scala.collection.GenIterable[B]) : scala.Boolean { /* compiled code */ }描述判断两个序列是否顺序和对应位置上的元素都一样 示例 val a Array(1,2,3,4)val b Array(1,2,3,4)val c Array(1,4,3,2)println(a 和 ba.sameElements(b))println(a 和 ca.sameElements(c)) startsWith(that) 定义 def startsWith[B](that : scala.collection.GenSeq[B]) : scala.Boolean { /* compiled code */ }描述判断序列是否以某个序列开始 示例 val a Array(1,2,3,4)println(a开头是否有 12a.startsWith(Array(1,2))) startsWith(that, offset) 定义 def startsWith[B](that : scala.collection.GenSeq[B], offset : scala.Int) : scala.Boolean描述判断序列从指定偏移处是否以某个序列开始 示例 val a Array(1,2,3,4)println(a在 1 位置是否有 23a.startsWith(Array(2,3),1)) hasDefiniteSize 定义 override def hasDefiniteSize : scala.Boolean { /* compiled code */ }描述检测序列是否存在有限的长度对应 Stream 这样的流数据则返回 false 示例 val a Array(1,2,3,4)val b 1 #:: 2 #:: 3 #:: Stream.emptyprintln(array数组是否存在有限的长度a.hasDefiniteSize)println(stream流是否存在有限的长度b.hasDefiniteSize) canEqual 定义 override def canEqual(that : scala.Any) : scala.Boolean { /* compiled code */ }描述判断两个对象是否可以进行比较 示例基本上所有对象都可以进行比较我不知道这个方法的意义何在
val a List(1, 2, 3, 4)
val b Array(a, b, c)
println(a.canEqual(b)) // true
val chars Array(a, b, c)
println(chars.charAt(0)) // a corresponds 定义 def corresponds[B](that : scala.collection.GenSeq[B])(p : scala.Function2[A, B, scala.Boolean]) : scala.Boolean { /* compiled code */ }描述判断两个序列的长度是否相等再判断对应位置元素是否符合某个条件。如果两个序列具有相同的元素数量并且 f(x, y)true则返回 true 示例下面代码检查 a 和 b 长度是否相等并且 a 中元素是否小于 b 中对应位置的元素 val a Array(1, 2, 3, 4)val b Array(5, 6, 7, 8)println(a.corresponds(b)(_ _)) 8.获取集合元素 apply 定义 def apply(i : scala.Int) : T { /* compiled code */ }描述获取指定索引处的元素,与a(0)的取值方法很像但是当数组中有不同类型的时候用 apply 取值则会报错 示例 //val a: Array[Any] Array(1,2, a, b)val a: Array[Any] Array( a, b)println(a.apply(0))println(a(1)) charAt 定义 def charAt(index : scala.Int) : scala.Char { /* compiled code */ }描述获取 index 索引处的字符这个方法会执行一个隐式的转换将 Array[T] 转换为 ArrayCharSequence只有当 T 为 Char 类型时这个转换才会发生 示例 val a Array(a,b,c)println(a.charAt(2)) foreach 定义 override def foreach[U](f : scala.Function1[A, U]) : scala.Unit { /* compiled code */ }描述遍历序列中的元素进行 f 操作 示例 val a Array(a,b,c)a.foreach(println) head 定义 override def head : A { /* compiled code */ }描述返回序列的第一个元素如果序列为空将引发错误 示例 val a Array(a,b,c)println(a.head) headOption 定义 def headOption : scala.Option[A] { /* compiled code */ }描述返回序列的第一个元素的 Option 类型对象如果序列为空则返回 None 示例 val a Array(a,b,c)println(a.headOption) init 定义 override def init : Repr { /* compiled code */ }描述返回当前序列中不包含最后一个元素的序列 示例 val a Array(a,b,c)println(a.init.toList) inits 定义 def inits : scala.collection.Iterator[Repr] { /* compiled code */ }描述对集合中的元素进行 init 迭代操作该操作的返回值中 第一个值是当前序列的副本最后一个值为空每一步都进行 init 操作上一步的结果作为下一步的操作对象 示例 val a Array(a,b,c,d)val inits: Iterator[Array[Char]] a.initsinits.foreach(xprintln(x.toList)) tail 定义 override def tail : Repr { /* compiled code */ }描述同 init返回当前序列中不包含第一个元素的序列 示例
val a Array(1, 2, 3, 4)
val b a.tail
println(b.mkString(,)) // 2,3,4 tails 定义 def tails : scala.collection.Iterator[Repr] { /* compiled code */ }描述同 inits每一步都进行 tail 操作 示例 val a Array(a,b,c,d)val inits: Iterator[Array[Char]] a.tailsinits.foreach(xprintln(x.toList)) take 定义 override def take(n : scala.Int) : Repr { /* compiled code */ }描述返回当前序列中前 n 个元素组成的序列 示例 val a Array(a,b,c,d)val b: Array[Char] a.take(2)println(b.toList) takeRight 定义 override def takeRight(n : scala.Int) : Repr { /* compiled code */ }描述返回当前序列中从右边开始后 n 个元素组成的序列 示例 val a Array(a,b,c,d)val b: Array[Char] a.takeRight(2)println(b.toList) takeWhile 定义 override def takeWhile(p : scala.Function1[A, scala.Boolean]) : Repr { /* compiled code */ }描述返回当前序列中从第一个元素开始满足条件的连续元素组成的序列 示例 val a Array(a,b,c,d)val b: Array[Char] a.takeWhile(xxc)println(b.toList)println(a.takeWhile(xxb).toList) view 定义 override def view(from : scala.Int, until : scala.Int) : scala.collection.mutable.IndexedSeqView[A, Repr] { /* compiled code */ }描述返回当前序列中从 from 到 until 之间的序列不包括 until 处的元素 示例 val a Array(a,b,c,d)val value: mutable.IndexedSeqView[Char, Array[Char]] a.view(1, 3)println(value.toList) 9.集合操作类函数 filter 定义 def filter(p : scala.Function1[A, scala.Boolean]) : Repr { /* compiled code */ }描述取得当前数组中符合条件的元素组成新的数组返回 示例 val a Array(1,2,3,4)val ints: Array[Int] a.filter(_ 2)println(ints.toList) filterNot 定义 def filterNot(p : scala.Function1[A, scala.Boolean]) : Repr { /* compiled code */ }描述取得当前数组中不符合条件的元素组成新的数组返回 示例 val a Array(1,2,3,4)val ints: Array[Int] a.filterNot(_ 2)println(ints.toList) withFilter 定义 def withFilter(p : scala.Function1[A, scala.Boolean]) : scala.collection.generic.FilterMonadic[A, Repr] { /* compiled code */ }描述根据条件 p 过滤元素如果后续的操作需要使用到map/flatMap/withFilter推荐使用这样可以减少filter产生的中间collection使得执行更加高效 示例 val a Array(1,2,3,4)val ints: Array[Int] a.withFilter(_ 2).map(x x1)println(ints.toList) reverse 定义 override def reverse : Repr { /* compiled code */ }描述反转序列返回一个 Array 数组 示例 val a Array(1,2,3,4)val reverse: Array[Int] a.reverseprintln(reverse.toList) reverseIterator 定义 override def reverseIterator : scala.collection.Iterator[A] { /* compiled code */ }描述生成反向迭代器 示例 val a Array(1,2,3,4)val iterator: Iterator[Int] a.reverseIteratorprintln(iterator.toList)par 定义 override def par : scala.collection.parallel.mutable.ParArray[T] { /* compiled code */ }描述返回一个并行实现产生的并行序列不能被修改 示例 val a Array(1,2,3,4,21)val par: ParArray[Int] a.parprintln(par) partition 定义 def partition(p : scala.Function1[A, scala.Boolean]) : scala.Tuple2[Repr, Repr] { /* compiled code */ }描述按条件将序列拆分成两个数组满足条件的放到第一个数组其余的放到第二个数组返回的是包含这两个数组的元组 示例下面以序列元素是否是偶数来拆分 val a Array(1, 2, 3, 4)val b: (Array[Int], Array[Int]) a.partition(x x % 2 0)println(偶数: b._1.mkString(,)) println(奇数: b._2.mkString(,)) groupBy 定义 def groupBy[K](f : scala.Function1[A, K]) : scala.collection.immutable.Map[K, Repr] { /* compiled code */ }描述按条件分组条件由 f 匹配返回值是 Map 类型每个 key 对应一个数组 示例把数组中元素分为小于 2、大于 2 和其他返回 Map[String, Array[Int]] val a Array(1,2,3,4)val stringToInts: Map[String, Array[Int]] a.groupBy(x x match {case x if (x 2) bigcase x if (x 2) smallcase _ none})stringToInts.foreach(xprintln(x._1 : x._2.toList)) grouped 定义 def grouped(size : scala.Int) : scala.collection.Iterator[Repr] { /* compiled code */ }描述按指定数量分组每组有 size 个元素返回一个迭代器 示例 val a Array(1,2,3,4)val b: Iterator[Array[Int]] a.grouped(2)b.foreach(xprintln(x.toList)) sortBy 定义 def sortBy[B](f : scala.Function1[A, B])(implicit ord : scala.math.Ordering[B]) : Repr { /* compiled code */ }描述按指定的排序规则对序列排序 示例 val a Array(1,3,2,4)val ints: Array[Int] a.sortBy(x x)println(升序排列ints.toList)println(倒序排列a.sortBy(x 0 - x).toList) sorted 定义 def sorted[B : A](implicit ord : scala.math.Ordering[B]) : Repr { /* compiled code */ }描述使用默认的排序规则对序列排序 示例 val a Array(1,2,4,3)val sorted: Array[Int] a.sortedprintln(sorted.toList) slice 定义 override def slice(from : scala.Int, until : scala.Int) : scala.Array[T] { /* compiled code */ }描述返回当前序列中索引从 from 到 until 之间的序列不包括 until 处的元素 示例 val a Array(1,2,3,4,5)val ints: Array[Int] a.slice(2, 4)println(ints.toList) sliding(size) 定义 def sliding(size : scala.Int) : scala.collection.Iterator[Repr] { /* compiled code */ }描述滑动从第一个元素开始每个元素和它后面的 size - 1 个元素组成一个数组最终组成一个新的集合返回当剩余元素个数不够 size 时则结束 示例 val a Array(1,2,3,4,5)val iterator: Iterator[Array[Int]] a.sliding(3)iterator.foreach(xprintln(x.toList)) sliding(size, step) 定义 def sliding(size : scala.Int, step : scala.Int) : scala.collection.Iterator[Repr] { /* compiled code */ }描述从第一个元素开始每个元素和它后面的 size - 1 个元素组成一个数组最终组成一个新的集合返回当剩余元素个数不够 size 时则结束。该方法可以设置步长 step每一组元素组合完后下一组从上一组起始元素位置 step 后的位置处开始 示例 val a Array(1,2,3,4,5)val iterator: Iterator[Array[Int]] a.sliding(3,2)iterator.foreach(xprintln(x.toList)) span 定义 override def span(p : scala.Function1[A, scala.Boolean]) : scala.Tuple2[Repr, Repr] { /* compiled code */ }描述将序列拆分成两个数组从第一个元素开始直到第一个不满足条件的元素为止其中的元素放到第一个数组其余的放到第二个数组返回的是包含这两个数组的元组 示例 val a Array(1,2,3,4,5,4,3,2,1)val tuple: (Array[Int], Array[Int]) a.span(x x 3)println(tuple._1.toList)println(tuple._2.toList) splitAt 定义 override def splitAt(n : scala.Int) : scala.Tuple2[Repr, Repr] { /* compiled code */ }描述从指定位置开始把序列拆分成两个数组 示例 val a Array(1,2,3,4,5,4,3,2,1)val tuple: (Array[Int], Array[Int]) a.splitAt(4)println(第一组tuple._1.toList)println(第二组tuple._2.toList) subSequence 定义 def subSequence(start : scala.Int, end : scala.Int) : java.lang.CharSequence { /* compiled code */ }描述类比 sliceslice 是对于数组的subSequence是对于字符数组返回 start 和 end 间的字符序列不包含 end 处的元素 示例 val a Array(a,b,c,d)val sequence: CharSequence a.subSequence(1, 2)println(sequence) 10.转换类函数 flatMap 定义 def flatMap[B, That](f : scala.Function1[A, scala.collection.GenTraversableOnce[B]])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That { /* compiled code */ }描述对当前序列的每个元素进行操作,可以理解成降维最低到一维也可以对一维数组操作但每一个元素应该都返回一个序列结果放入新序列返回参数要求是 GenTraversableOnce 及其子类即返回可迭代的集合 示例 val a Array(Array(1,2,3),Array(2,3,4))val ints: Array[Int] a.flatMap(xx)println(ints.toList) flatten 定义 def flatten[U](implicit asTrav : scala.Function1[T, scala.collection.Traversable[U]], m : scala.reflect.ClassTag[U]) : scala.Array[U] { /* compiled code */ }描述扁平化将二维数组的所有元素组合在一起形成一个一维数组返回 示例 val a Array(Array(1,2,3),Array(2,3,4))println(a.flatten.toList) iterator 定义 override def iterator : scala.collection.Iterator[A] { /* compiled code */ }描述生成当前序列的迭代器 示例 val a Array(1,2,3)val iterator: Iterator[Int] a.iteratorprintln(iterator.getClass.getName ; iterator.toList) map 定义 def map[B, That](f : scala.Function1[A, B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That { /* compiled code */ }描述对序列中的元素进行 f 操作返回生成的新序列并且能够对结构进行调整 示例 val a Array(1,2,3,4)val ints: Array[Int] a.map(x x 2)println(ints.toList) reverseMap 定义 def reverseMap[B, That](f : scala.Function1[A, B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That { /* compiled code */ }描述同 map方向相反 示例 val a Array(1,2,3,4)val ints: Array[Int] a.reverseMap(x x 2)println(ints.toList) toArray 定义 def toArray[B : A](implicit evidence$1 : scala.reflect.ClassTag[B]) : scala.Array[B] { /* compiled code */ }描述将序列转换成 Array 类型 示例 val a List(1,2,3,4)val array: Array[Int] a.toArray toBuffer 定义 def toBuffer[B : A] : scala.collection.mutable.Buffer[B] { /* compiled code */ }描述将序列转换成 Buffer 类型 示例 val a List(1,2,3,4)val buffer: mutable.Buffer[Int] a.toBuffer toIndexedSeq 定义 def toIndexedSeq : scala.collection.immutable.IndexedSeq[A] { /* compiled code */ }描述将序列转换成 IndexedSeq 类型 示例 val a List(1,2,3,4)val seq: immutable.IndexedSeq[Int] a.toIndexedSeq toIterable 定义 override def toIterable : scala.collection.Iterable[A] { /* compiled code */ }描述将序列转换成【可重复迭代】的类型 示例 val a List(1,2,3,4)val iterable: Iterable[Int] a.toIterable toIterator 定义 override def toIterator : scala.collection.Iterator[A] { /* compiled code */ }描述将序列转换成迭代器同 iterator 方法 示例 val a List(1,2,3,4)val iterator: Iterator[Int] a.toIterator toList 定义 override def toList : scala.List[A] { /* compiled code */ }描述将序列转换成 List 类型 示例 val a Array(1,2,3,4)val list: List[Int] a.toList toMap 定义 def toMap[T, U](implicit ev : _root_.scala.Predef.:[A, scala.Tuple2[T, U]]) : scala.collection.immutable.Map[T, U] { /* compiled code */ }描述将序列转转换成 Map 类型需要被转化序列中包含的元素是 Tuple2 类型 示例 val a Array((1,a),(2,b),(3,c),(4,d))val map: Map[Int, String] a.toMap toSeq 定义 override def toSeq : scala.collection.Seq[A] { /* compiled code */ }描述将序列转换成 Seq 类型 示例 val a Array((1,a),(2,b),(3,c),(4,d))val seq: Seq[(Int, String)] a.toSeq toSet 定义 def toSet[B : A] : scala.collection.immutable.Set[B] { /* compiled code */ }描述将序列转换成 Set 类型 示例 val a Array((1,a),(2,b),(3,c),(4,d))val set: Set[(Int, String)] a.toSet toStream 定义 override def toStream : scala.collection.immutable.Stream[A] { /* compiled code */ }描述将序列转换成 Stream 类型 val a Array((1,a),(2,b),(3,c),(4,d))val stream: Stream[(Int, String)] a.toStream toVector 定义 def toVector : scala.Vector[A] { /* compiled code */ }描述将序列转换成 Vector 类型 示例 val a Array((1,a),(2,b),(3,c),(4,d))val vector: Vector[(Int, String)] a.toVector transpose 定义 def transpose[U](implicit asArray : scala.Function1[T, scala.Array[U]]) : scala.Array[scala.Array[U]] { /* compiled code */ }描述矩阵转置二维数组行列转换 示例 val a Array(Array(11,12,13),Array(21,22,23))val transpose: Array[Array[Int]] a.transposetranspose.foreach(xprintln(x.mkString(,))) seq 定义 def seq : scala.collection.mutable.IndexedSeq[T] { /* compiled code */ }描述产生一个引用当前序列的 sequential 视图 示例 val a Array(1,2,3,4)val seq: mutable.IndexedSeq[Int] a.seqprintln(seq) unzip 定义 def unzip[T1, T2](implicit asPair : scala.Function1[T, scala.Tuple2[T1, T2]], ct1 : scala.reflect.ClassTag[T1], ct2 : scala.reflect.ClassTag[T2]) : scala.Tuple2[scala.Array[T1], scala.Array[T2]] { /* compiled code */ }描述将含有两个二元组的数组每个元组的第一个元素组成一个数组第二个元素组成一个数组返回包含这两个数组的元组 示例 val a Array((1,2),(3,4),(5,6))val unzip: (Array[Int], Array[Int]) a.unzipprintln(元组的_1 : unzip._1.toList)println(元组的_2 : unzip._2.toList) unzip3 定义 def unzip3[T1, T2, T3](implicit asTriple : scala.Function1[T, scala.Tuple3[T1, T2, T3]], ct1 : scala.reflect.ClassTag[T1], ct2 : scala.reflect.ClassTag[T2], ct3 : scala.reflect.ClassTag[T3]) : scala.Tuple3[scala.Array[T1], scala.Array[T2], scala.Array[T3]] { /* compiled code */ }描述将含有三个三元组的数组每个元组的第一个元素组成一个数组第二个元素组成一个数组第三个元素组成一个数组返回包含这三个数组的元组 示例 val a Array((1,2,3),(4,5,6),(7,8,9))val unzip: (Array[Int], Array[Int], Array[Int]) a.unzip3println(元组的_1 : unzip._1.toList)println(元组的_2 : unzip._2.toList)println(元组的_3 : unzip._3.toList) zipWithIndex 定义 override def zipWithIndex[A1 : A, That](implicit bf : scala.collection.generic.CanBuildFrom[Repr, scala.Tuple2[A1, scala.Int], That]) : That { /* compiled code */ }描述序列中的每个元素和它的索引组成一个元组数组 示例 val a Array(a,b,c)val index: Array[(Char, Int)] a.zipWithIndexprintln(index.mkString(,)) 11.工具类函数 addString(b) 定义 def addString(b : scala.StringBuilder) : scala.StringBuilder { /* compiled code */ }描述将数组中的元素逐个添加到 StringBuilder 中 示例 val a Array(1,2,3)val b new StringBuildera.addString(b)println(b) addString(b, sep) 定义 def addString(b : scala.StringBuilder, sep : _root_.scala.Predef.String) : scala.StringBuilder { /* compiled code */ }描述将数组中的元素逐个添加到 StringBuilder 中每个元素用 sep 分隔符分开 示例 val a Array(1,2,3)val b new StringBuildera.addString(b,,)println(b) distinct 定义 def distinct : Repr { /* compiled code */ }描述去除当前集合中重复的元素只保留一个,返回去重后的集合 示例 val a Array(1,2,3,2,1)val distinct: Array[Int] a.distinctprintln(distinct.toList) indices 定义 def indices : scala.collection.immutable.Range { /* compiled code */ }描述返回当前序列索引集合 示例 val a Array(1,2,3,2,1)val indices: Range a.indicesprintln(indices) padTo 定义 def padTo[B : A, That](len : scala.Int, elem : B)(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That { /* compiled code */ }描述填充序列如果当前序列长度小于 len那么新产生的序列长度是 len多出的几个位值填充 elem如果当前序列大于等于 len 则返回当前序列并不会截取当前序列 示例填充一个长度为 7 的序列不足位补 0填充长度为 2 返回原序列 val a Array(1,2,3)val ints: Array[Int] a.padTo(7, 0)val ints1: Array[Int] a.padTo(2, 0)println(ints.toList)println(ints1.toList) prefixLength 定义 def prefixLength(p : scala.Function1[A, scala.Boolean]) : scala.Int { /* compiled code */ }描述给定一个条件 p返回一个前置数列的长度这个数列中的元素都满足 p 示例 val a Array(1,2,3,2,1)val i: Int a.prefixLength(x x 3)println(i) mkString 定义 def mkString : _root_.scala.Predef.String { /* compiled code */ }描述将序列中所有元素拼接成一个字符串 示例 val a Array(1,2,3,2,1)println(a.mkString) mkString(sep) 定义 def mkString(sep : _root_.scala.Predef.String) : _root_.scala.Predef.String { /* compiled code */ }描述将序列中所有元素拼接成一个字符串以 sep 作为元素间的分隔符 示例 val a Array(1,2,3,2,1)println(a.mkString(,)) mkString(start, sep, end) 定义 def mkString(start : _root_.scala.Predef.String, sep : _root_.scala.Predef.String, end : _root_.scala.Predef.String) : _root_.scala.Predef.String { /* compiled code */ }描述将序列中所有元素拼接成一个字符串以 start 开头以 sep 作为元素间的分隔符以 end 结尾 示例 val a Array(1,2,3,2,1)println(a.mkString((,,,))) length 定义 def length : scala.Int { /* compiled code */ }描述返回序列元素个数 示例 val a Array(1,2,3,2,1)val length: Int a.lengthprintln(length) lengthCompare 定义 override def lengthCompare(len : scala.Int) : scala.Int { /* compiled code */ }描述比较序列的长度和参数 len返回序列的长度 length- 参数len
示例
val a Array(1, 2, 3, 4)
println(a.lengthCompare(3)) // 1
println(a.lengthCompare(4)) // 0
println(a.lengthCompare(5)) // -1 size 定义 override def size : scala.Int { /* compiled code */ }描述返回序列元素个数同 length 示例 val a Array(1, 2, 3, 4)val size: Int a.sizeprintln(size) stringPrefix 定义 def stringPrefix : _root_.scala.Predef.String { /* compiled code */ }描述返回 toString 结果的前缀 示例 val a List(1,2,3)println(a.toString())println(a.stringPrefix) 12.集合内与集合间计算函数 aggregate 定义 def aggregate[B](z : B)(seqop : scala.Function2[B, A, B], combop : scala.Function2[B, B, B]) : B { /* compiled code */ }描述聚合计算aggregate 是柯里化方法参数是两个方法 示例为了方便理解把 aggregate 的两个参数分别封装成两个方法并把分区和不分区的计算过程分别打印出来 def seq(m:Int,n:Int):Int{println(seq:mn)mn}def combine(m:Int,n:Int):Int{println(combine:mn)mn}val a Array(1,2,3,4)println(不分区情形)val i: Int a.aggregate(5)(seq, combine) //不分区println(不分区的 i i)println()println(分区情形)val i1: Int a.par.aggregate(5)(seq, combine) //分区println(分区的 i1 i1) 通过上面的运算不难发现不分区时seqno 是把初始值顺序和每个元素相加把得到的结果与下一个元素进行运算。 分区时seqno 是把初始值与每个元素相加但结果不参与下一步运算而是放到另一个序列中由第二个方法 combine 进行处理。 上面过程可以简写为
val b a.aggregate(5)(__,__) // 不分区
val c a.par.aggregate(5)(__,__) // 分区 fold 定义 def fold[U : T](z : U)(op : scala.Function2[U, U, U]) : U { /* compiled code */ }描述对序列中的每个元素进行二元运算和 aggregate 有类似的语义但执行过程有所不同fold类的函数分区内的计算逻辑就是分区间的计算逻辑而aggregate却可以指定分区内的计算逻辑与分区间的计算逻辑此外fold方法要求聚合的两者类型相同【map聚合时会被当做元组】而foldLeft和foldRight则不必 示例 def seq(m:Int,n:Int):Int{println(seq:mn)mn}val a Array(1,2,3,4)println(不分区情形)val i: Int a.fold(5)(seq) //不分区println(不分区的 i i)println()println(分区情形)val i1: Int a.par.fold(5)(seq) //分区println(分区的 i1 i1) foldLeft 可简写为 /: 定义 def foldLeft[S](z : S)(op : scala.Function2[S, T, S]) : S { /* compiled code */ }描述从左到右计算简写方式 示例 def seq(m:Int,n:Int):Int{println(seq:mn)mn}val a Array(1,2,3,4)val i: Int a.foldLeft(5)(seq) // 也可简写(5 /: a)(_ _)println(i i) foldRight 可简写为 :/ 定义 override def foldRight[B](z : B)(op : scala.Function2[A, B, B]) : B { /* compiled code */ }描述从右到左计算简写方式 示例 def seq(m:Int,n:Int):Int{println(seq:mn)mn}val a Array(1,2,3,4)val i: Int a.foldRight(5)(seq) // 也可简写(a :/ 5)(_ _)println(i i) reduce 定义 描述不需要初始值在集合内部进行聚合运算 示例 val a Array(1,2,3,4)val i: Int a.reduce((x,y){println(seq:xy)xy})println(i i) reduceLeft val a Array(1,2,3,4)val i: Int a.reduceLeft((x,y){println(seq:xy)xy})println(i i) 定义 override def reduceLeft[B : A](op : scala.Function2[B, A, B]) : B { /* compiled code */ }描述同 foldLeft从左向右计算不需要初始值 示例 reduceRight 定义 override def reduceRight[B : A](op : scala.Function2[A, B, B]) : B { /* compiled code */ }描述同 foldRight从右向左计算不需要初始值 示例 val a Array(1,2,3,4)val i: Int a.reduceRight((x,y){println(seq:xy)xy})println(i i) reduceLeftOption 定义 def reduceLeftOption[B : A](op : scala.Function2[B, A, B]) : scala.Option[B] { /* compiled code */ }描述同 reduceLeft返回 Option 示例 val a Array(1,2,3,4)val i: Option[Int] a.reduceLeftOption((x, y) {println(seq: x y)x y})println(i i) reduceRightOption 定义 def reduceRightOption[B : A](op : scala.Function2[A, B, B]) : scala.Option[B] { /* compiled code */ }描述同 reduceRight返回 Option 示例 val a Array(1,2,3,4)val i: Option[Int] a.reduceRightOption((x, y) {println(seq: x y)x y})println(i i) scan 定义 def scan[B : A, That](z : B)(op : scala.Function2[B, B, B])(implicit cbf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That { /* compiled code */ }描述同 foldscan 会把每一步的计算结果放到一个新的集合中返回而 fold 返回的是最后的结果 示例 val a Array(1,2,3,4)val i: Array[Int] a.scan(5)((x, y) {println(seq: x y)x y})println(i i.mkString((,,,))) scanLeft 定义 def scanLeft[B, That](z : B)(op : scala.Function2[B, A, B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That { /* compiled code */ }描述同 foldLeft从左向右计算每一步的计算结果放到一个新的集合中返回 示例 val a Array(1,2,3,4)val i: Array[Int] a.scanLeft(5)((x, y) {println(seq: x y)x y})println(i i.mkString((,,,))) scanRight 定义 def scanRight[B, That](z : B)(op : scala.Function2[A, B, B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That { /* compiled code */ }描述同 foldRight从右向左计算每一步的计算结果放到从右向左放一个新的集合中返回 示例 val a Array(1,2,3,4)val i: Array[Int] a.scanRight(5)((x, y) {println(seq: x y)x y})println(i i.mkString((,,,))) diff 定义 def diff[B : A](that : scala.collection.GenSeq[B]) : Repr { /* compiled code */ }描述计算当前数组与另一个数组的差集即将当前数组中没有在另一个数组中出现的元素返回 示例 val a Array(1,2,3)val b Array(2,3,4)val a_diff_b: Array[Int] a.diff(b)println(a_diff_b.toList) intersect 定义 def intersect[B : A](that : scala.collection.GenSeq[B]) : Repr { /* compiled code */ }描述取两个集合的交集 示例 val a Array(1,2,3)val b Array(2,3,4)val a_intersect_b: Array[Int] a.intersect(b)println(a_intersect_b.toList) union 定义 override def union[B : A, That](that : scala.collection.GenSeq[B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That { /* compiled code */ }描述合并两个序列同操作符 示例 val a Array(1,2,3)val b Array(2,3,4)val a_union_b: Array[Int] a.union(b)println(a_union_b.toList) zip 定义 override def zip[A1 : A, B, That](that : scala.collection.GenIterable[B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, scala.Tuple2[A1, B], That]) : That { /* compiled code */ }描述将两个序列对应位置上的元素组成一个元组数组要求两个序列长度相同 示例 val a Array(1,2,3)val b Array(2,3,4)val a_zip_b: Array[(Int, Int)] a.zip(b)println(a_zip_b.toList) zipAll 定义 def zipAll[B, A1 : A, That](that : scala.collection.GenIterable[B], thisElem : A1, thatElem : B)(implicit bf : scala.collection.generic.CanBuildFrom[Repr, scala.Tuple2[A1, B], That]) : That { /* compiled code */ }描述同 zip 但是允许两个序列长度不同不足的自动填充如果当前序列短不足的元素填充为 thisElem如果 that 序列短填充为 thatElem 示例 val a Array(1,2,3,4,5)val b Array(2,3,4)val a_zipAll_b: Array[(Int, Int)] a.zipAll(b,1,0)println(a_zipAll_b.toList)val b_zipAll_a: Array[(Int, Int)] b.zipAll(a,1,0)println(b_zipAll_a.toList)
