函数名
函数具体用法
++
def ++[B](that: GenTraversableOnce[B]): Array[B]
合并集合，并返回一个新的数组，新数组包含左右两个集合对象的内容。若类型不同合并之后一般为Array[Any]
val a = Array(1,2)
val b = Array(3,4)
val c = a ++ b
//c中的内容是(1,2,3,4)
++:
def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Array[T], B, That]): That
将两个集合中的元素合并到一个新的集合中，新集合的类型由“:”后面的集合类型决定
val a = List(1,2)
val b = scala.collection.mutable.LinkedList(3,4)
val c = a ++: b
println(c.getClass().getName())// c的类型是：scala.collection.mutable.LinkedList
+:
def +:(elem: A): Array[A]
在数组前面添加一个元素，并返回新的对象，下面添加一个元素 0
val a = List(1,2)
val c = 0 +: a // c中的内容是 （0,1,2）
:+
同上面的方法想法，在数组末尾添加一个元素，并返回新对象
val a = List(1, 2)
val b = a :+ 3
println(b.mkString(",")) // 1,2,3
/:
def /:[B](z: B)(op: (B, T) ⇒ B): B
对数组中所有的元素从左向右遍历，进行相同的迭代操作，foldLeft 的简写
val a = List(1, 2, 3, 4)
val b = (10 /: a) (_ + _) // (((10+1)+2)+3)+4
val c = (10 /: a) (_ * _) // (((10*1)*2)*3)*4
println("b: " + b) // b: 20
println("c: " + c) // c: 240
:\
def :[B](z: B)(op: (T, B) ⇒ B): B
对数组中所有的元素从右向左遍历，进行相同的迭代操作，foldRight 的简写,返回计算结果
val a = List(1, 2, 3, 4)
val b = (a :\ 10) (_ - _) // 1-(2-(3-(4-10)))
val c = (a :\ 10) (_ * _) // 1*(2*(3*(4*10)))
addString
def addString(b : scala.StringBuilder, start : scala.Predef.String, sep : scala.Predef.String, end : scala.Predef.String) : scala.StringBuilder = { /* compiled code */ }
def addString(b : scala.StringBuilder, sep : scala.Predef.String) : scala.StringBuilder = { /* compiled code */ }
def addString(b : scala.StringBuilder) : scala.StringBuilder = { /* compiled code */ }
将数组中的元素逐个添加到StringBuilder中
val a = List(1, 2, 3, 4)
val b = new StringBuilder()
a.addString(b)
println(b) // 1234
val a = List(1, 2, 3, 4)
val b = new StringBuilder()
a.addString(b, ",")
println(b) // 1,2,3,4
val a = List(1, 2, 3, 4)
val b = new StringBuilder()
a.addString(b, "[",",","]")
println(b) // [1,2,3,4]
aggregate
def aggregate[B](z: ⇒ B)(seqop: (B, T) ⇒ B, combop: (B, B) ⇒ B): B
聚合计算，aggregate 是柯里化方法，参数是两个方法
def seqno(m: Int, n: Int): Int = {
val s = "seq_exp = %d + %d"
println(s.format(m, n))
m + n
}
def combine(m: Int, n: Int): Int = {
val s = "com_exp = %d + %d"
println(s.format(m, n))
m + n
}
def main(args: Array[String]) {
val a = List(1, 2, 3, 4)
val b = a.aggregate(5)(seqno, combine) // 不分区
println("b = " + b)
/**
* seq_exp = 5 + 1
* seq_exp = 6 + 2
* seq_exp = 8 + 3
* seq_exp = 11 + 4
* b = 15
*/
val c = a.par.aggregate(5)(seqno, combine) // 分区
println("c = " + c)
/**
* seq_exp = 5 + 3
* seq_exp = 5 + 2
* seq_exp = 5 + 4
* seq_exp = 5 + 1
* com_exp = 6 + 7
* com_exp = 8 + 9
* com_exp = 13 +17
* c = 30
*/
}
andThen
override def andThen[C](k : scala.Function1[B, C]) : scala.PartialFunction[A, C] = { /* compiled code */ }
表示方法的连续调用，相当于嵌套函数 g(f(x)) （需满足第一个函数的返回值类型是第二个函数的输入值类型），与 compose 相反
def f(a:Int) = {
println("2*"+a)
2*a
}
def g(b:Int) = {
println("3*"+b)
3*b
}
def result1 = f _ andThen g _
println(result1(1))
/*
2*1
2*3
6
*/
def result2 = f _ compose g _
println(result2(1))
/*
3*1
3*2
6
*/
apply
def apply(i : scala.Int) : T = { /* compiled code */ }
按下标取数组数据
val a = Array(1,2,3,4)
a.apply(2) //等同于直接写a(2)
a(2)
applyOrElse
def applyOrElse[A1 <: A, B1 >: B](x : A1, default : scala.Function1[A1, B1]) : B1 = { /* compiled code */ }
接收2个参数，第一个是调用的参数，第二个是个回调函数。如果第一个调用的参数匹配，返回匹配的值，否则调用回调函数。（回调函数的输入类型需与调用参数类型一致）
val pf1:PartialFunction[Int,String] = { //定义一个偏函数，输入 1 返回 "one"
case i if i == 1 => "One"
}
pf1.applyOrElse(1,{num:Int=>"two"}) //输入1匹配到"one"
pf1.applyOrElse(2,{num:Int=>"two"}) //输入2匹配失败则触发回调函数，返回 "Two" 字符串
pf1.applyOrElse(3,{num:Int=>"two"}) //输入3匹配失败则触发回调函数，返回 "Two" 字符串
array
同其他语言数组的定义没什么区别
Array是scala中数组是用来存储同类型的元素结构，数组中本身size不可变，但是数组中元素可变，可重新赋值
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,200
canEqual
def canEqual(that: Any): Boolean
判断两个对象是否可以进行比较
val a = List(1, 2, 3, 4)
val b = Array('a', 'b', 'c')
println(a.canEqual(b)) // true
charAt
def charAt(index: Int): Char
获取index索引处的字符，这个方法会执行一个隐式的转换，将Array[T]转换为 ArrayCharSequence，只有当T为char类型时，这个转换才会发生。
val chars = Array('a','b','c')
println("c:"+chars.charAt(0)) //结果 a
clone
def clone(): Array[T]
创建一个集合的副本
val a = Array(1,2,3,4)
val b = a.clone()
collect
def collect[B, That](pf : scala.PartialFunction[A, B])(implicit bf : scala.collection.generic.CanBuildFrom[Repr, B, That]) : That = { /* compiled code */ }
输入参数类型为偏函数，对序列中的元素进行转换
（scala里的偏函数定义：对给的集合中的部分值进行特定的操作的函数，就时偏函数）
val fun: PartialFunction[Char, Char] = {
case 'a' => 'A'
case x => x
}
val a = Array('a', 'b', 'c')
val b = a.collect(fun)
println(b.mkString(",")) // A,b,c
collectFirst
def collectFirst[B](pf: PartialFunction[T, B]): Option[B]
在序列中查找第一个符合偏函数定义的元素，并执行偏函数计算
val fun: PartialFunction[Any, Int] = {
case x: Int => x + 1
}
val a = Array('a',1,3, "A")
val b = a.collectFirst(fun)
println(b) // Some(2)
combinations
def combinations(n : scala.Int) : scala.collection.Iterator[Repr] = { /* compiled code */ }
combinations 表示组合，这个排列组合会选出所有包含字符不一样的组合，但不考虑顺序，对于 “abc”、“cba”，视为相同组合，参数 n 表示序列长度，就是几个字符为一组
val a = Array("a", "b", "c")
val b = a.combinations(2)
b.foreach(x => println(x.mkString(",")))
/*
* a,b
* a,c
* b,c
*/
companion
override def companion : scala.collection.generic.GenericCompanion[scala.collection.mutable.IndexedSeq] = { /* compiled code */ }
compose
def compose[A](g : scala.Function1[A, T1]) : scala.Function1[A, R] = { /* compiled code */ }
表示方法的连续调用，与 andThen 相反，不同的是需满足第二个函数的返回值类型是第一个函数的输入值类型
def f(a:Int) = {
println("2*"+a)
2*a
}
def g(b:Int) = {
println("3*"+b)
3*b
}
def result1 = f _ andThen g _
println(result1(1))
/*
2*1
2*3
6
*/
def result2 = f _ compose g _
println(result2(1))
/*
3*1
3*2
6
*/
contains
override def contains[A1 >: A](elem : A1) : scala.Boolean = { /* compiled code */ }
判断序列中是否包含指定对象
val a = List(1, 2, 3, 4)
println(a.contains(1)) // true
containsSlice
def containsSlice[B](that : scala.collection.GenSeq[B]) : scala.Boolean = { /* compiled code */ }
判断当前序列中是否包含另一个序列
val a = List(1,2,3,4)
val b = List(2,3)
val c = List(2,3,5)
println(a.containsSlice(b)) // true
println(a.containsSlice(c)) //false
copyToArray
def copyToArray[B >: A](xs : scala.Array[B], start : scala.Int) : scala.Unit = { /* compiled code */ }
def copyToArray[B >: A](xs : scala.Array[B]) : scala.Unit = { /* compiled code */ }
将当前数组元素复制到另一个数组中(可以指定起始下标引入，选择引入几个元素)
val a = Array(1, 2, 3)
val b: Array[Int] = new Array(10)
a.copyToArray(b)
println(b.mkString(",")) // 1,2,3,0,0,0,0,0,0,0
a.copyToArray(b, 4, 2) //从5位引入2个数字
println(b.mkString(",")) // 1,2,3,0,1,2,0,0,0,0
copyToBuffer
def copyToBuffer[B >: A](dest : scala.collection.mutable.Buffer[B]) : scala.Unit = { /* compiled code */ }
将数组中的元素复制到 Buffer 中
（这里的Buffer就相当于java中ArrayList）
//需先引入ArrayBuffer jar包
import scala.collection.mutable.ArrayBuffer
val a = Array(1, 2, 3, 4)
val b: ArrayBuffer[Int] = ArrayBuffer()
a.copyToBuffer(b)
println(b.mkString(",")) // 1,2,3,4
corresponds
def corresponds[B](that : scala.collection.GenSeq[B])(p : scala.Function2[A, B, scala.Boolean]) : scala.Boolean = { /* compiled code */ }
判断两个序列的长度以及对应位置元素是否符合某个条件,满足返回true，不满足返回false
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
count
def count(p : scala.Function1[A, scala.Boolean]) : scala.Int = { /* compiled code */ }
与java的count不同的是，这里的count是对满足条件的元素计数
val a = Array(1, 2, 3, 4)
println(a.count(x => x > 2)) // 2
deep
def deep : scala.collection.IndexedSeq[scala.Any] = { /* compiled code */ }
diff
def diff[B >: A](that : scala.collection.GenSeq[B]) : Repr = { /* compiled code */ }
计算当前数组与另一个数组的差集，即返回另外一个数组中没有的元素（即减去与另一个集合的交集）
val a = Array(1, 2, 3, 4)
val b = Array(3, 4, 5, 6)
val c = a.diff(b)
println(c.mkString(",")) // 1,2
distinct
def distinct : Repr = { /* compiled code */ }
去掉集合中重复的元素，保留一个
val a = Array(1, 2, 2, 3, 3,4, 4)
val b = a.distinct
println(b.mkString(",")) // 1,2,3,4
drop
override def drop(n : scala.Int) : Repr = { /* compiled code */ }
删除集合中前n个元素
val a = Array(1, 2, 3, 4)
val b = a.drop(2) //删除前两个元素
println(b.mkString(",")) // 3,4
dropRight
override def dropRight(n : scala.Int) : Repr = { /* compiled code */ }
删除集合中尾部的 n 个元素
val a = Array(1, 2, 3, 4)
val b = a.dropRight(2)
println(b.mkString(",")) // 1,2
dropWhile
override def dropWhile(p : scala.Function1[A, scala.Boolean]) : Repr = { /* compiled code */ }
删除数组中符合条件的元素，从第一个元素起，直到碰到第一个不满足条件的元素结束（即使后面还有符合条件的元素），若第一个条件就不满足就返回整个数组
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 第一个条件就不满足，返回整个数组
elemManifest
暂时不知道使用方法
elemTag
暂时不知道使用方法
endsWith
override def endsWith[B](that : scala.collection.GenSeq[B]) : scala.Boolean = { /* compiled code */ }
判断当前序列是否以某个序列结尾
val a = Array(1, 2, 3, 4)
val b = Array(3, 4)
println(a.endsWith(b)) // true
exists
override def exists(p : scala.Function1[A, scala.Boolean]) : scala.Boolean = { /* compiled code */ }
判断当前数组是否包含符合条件的元素
val a = Array(1, 2, 3, 4)
println(a.exists(x => x == 3)) // true
println(a.exists(x => x == 5)) // false
filter
def filter(p : scala.Function1[A, scala.Boolean]) : Repr = { /* compiled code */ }
筛选数组中符合条件的元素
val a = Array(1, 2, 3, 4)
val b = a.filter(x => x > 2)
println(b.mkString(",")) // 3,4
filterNot
def filterNot(p : scala.Function1[A, scala.Boolean]) : Repr = { /* compiled code */ }
与filter相反，将不满足条件的元素筛选出来
val a = Array(1, 2, 3, 4,0)
val b = a.filterNot(x => x > 2)
println(b.mkString(",")) // 1,2,0
find
override def find(p : scala.Function1[A, scala.Boolean]) : scala.Option[A] = { /* compiled code */ }
查找第一个符合条件的元素
val a = Array(1, 2, 3, 4)
val b = a.find(x => x > 2)
println(b) // Some(3)
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 */ }
flatMap = map + flatten 即先对集合中的每个元素进行map，再对map后的每个元素（map后的每个元素必须还是集合）中的每个元素进行flatten
val a = Array(1, 2, 3, 4)
val b = a.flatMap(x => 1 to x)
println(b.mkString(",")) //展开返回一个数组 1,1,2,1,2,3,1,2,3,4
/*
1
1,2
1,2,3
1,2,3,4
*/
//与map的区别
val c = a.map(x => 1 to x)
println(c.mkString(",")) //分别返回4个数组 Range(1),Range(1, 2),Range(1, 2, 3),Range(1, 2, 3, 4)
//展开一个Array[Array]类型的数组
val arr = Array(Array(1, 2, 3), Array(4, 5, 6), Array(7, 8, 9))
val ints = arr.flatMap(x => x)
println(ints.mkString(",")) //展开arr中每一个数组元素 1,2,3,4,5,6,7,8,9
flatten
def flatten[U](implicit asTrav: (T) ⇒ collection.Traversable[U], m: ClassTag[U]): Array[U]
扁平化，将二维数组的所有元素组合在一起，形成一个一维数组返回
val a = Array(Array(1, 2, 3), Array(4, 5, 6))
val b = a.flatten
println(b.mkString(",")) // 1,2,3,4,5,6
fold
def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1ClassTag[U]): Array[U]
对序列中的每个元素进行二元运算，和 aggregate 有类似的语义，但执行过程有所不同
def seqno(m: Int, n: Int): Int = {
val s = "seq_exp = %d + %d"
println(s.format(m, n))
m + n
}
def main(args: Array[String]) {
val a = Array(1, 2, 3, 4)
val b = a.fold(5)(seqno) // 不分区
println("b = " + b)
/*
* seq_exp = 5 + 1
* seq_exp = 6 + 2
* seq_exp = 8 + 3
* seq_exp = 11 + 4
* b = 15
*/
val c = a.par.fold(5)(seqno) // 分区
println("c = " + c)
/*
* seq_exp = 5 + 3
* seq_exp = 5 + 2
* seq_exp = 5 + 4
* seq_exp = 5 + 1
* com_exp = 6 + 7
* com_exp = 8 + 9
* com_exp = 13 + 17
* c = 30
*/
}
foldLeft
def foldLeft[B](z: B)(op: (B, T) ⇒ B): BClassTag[U]): Array[U]
从左到右计算，简写方式：def /:[B](z: B)(op: (B, T) ⇒ B): B
def seqno(m: Int, n: Int): Int = {
val s = "seq_exp = %d + %d"
println(s.format(m, n))
m + n
}
def main(args: Array[String]): Unit = {
val a = Array(1, 2, 3, 4)
val b = a.foldLeft(5)(seqno) // 简写: (5 /: a)(_ + _)
println("b = " + b)
/**
* seq_exp = 5 + 1
* seq_exp = 6 + 2
* seq_exp = 8 + 3
* seq_exp = 11 + 4
* b = 15
*/
}
foldRight
foldRight[B](z: B)(op: (B, T) ⇒ B): B
从右到左计算，简写方式：def :[B](z: B)(op: (T, B) ⇒ B): B
def seqno(m: Int, n: Int): Int = {
val s = "seq_exp = %d + %d"
println(s.format(m, n))
m + n
}
def main(args: Array[String]): Unit = {
val a = Array(1, 2, 3, 4)
val b = a.foldRight(5)(seqno) // 简写: (a :\ 5)(_ + _)
println("b = " + b)
/**
* seq_exp = 4 + 5
* seq_exp = 3 + 9
* seq_exp = 2 + 12
* seq_exp = 1 + 14
* b = 15
*/
}
forall
def forall(p: (T) ⇒ Boolean): Boolean
检测序列中的元素是否都满足条件 p，如果序列为空，则返回 true
val a = Array(1, 2, 3, 4)
println(a.forall(x => x > 0)) // true
println(a.forall(x => x > 2)) // false
foreach
def foreach(f: (A) ⇒ Unit): Unit
遍历序列中的元素，进行 f 操作
val a = Array(1, 2, 3, 4)
a.foreach(x => println(x * 10))
/**
* 10
* 20
* 30
* 40
*/
genericBuilder
def genericBuilder[B] : scala.collection.mutable.Builder[B, CC[B]] = { /* compiled code */ }
groupBy
def groupBy[K](f : scala.Function1[A, K]) : scala.collection.immutable.Map[K, Repr] = { /* compiled code */ }
按条件分组，条件由 f 匹配，返回值是 Map 类型，每个 key 对应一个数组
var a = Array(1,2,3,4)
a.groupBy(x => x>2)
Map[Boolean,Array[Int]] = Map(false -> Array(1, 2), true -> Array(3, 4, 5))
//生成一个新的map集合
grouped
def grouped(size : scala.Int) : scala.collection.Iterator[Repr] = { /* compiled code */ }
按指定数量分组，每组有 size 个元素
val a = Array(1,2,3,4,5)
a.grouped(3)
Iterator[Array[Int]] = non-empty iterator
//生成的结果是一个迭代器
a.grouped(3).foreach(x => println(x.toList))
//将迭代器转成List输出
List(1, 2, 3)
List(4, 5)
hasDefiniteSize
def hasDefiniteSize : scala.Boolean = { /* compiled code */ }
检测序列是否存在有限的长度，对应 Stream 类型的流数据则返回 false
val a = Array(1,2,3,4,5)
a.hasDefiniteSize
Boolean = true
a.grouped(3).hasDefiniteSize//例如迭代器
Boolean = false
head
override def head : A = { /* compiled code */ }
返回序列的第一个元素，如果序列为空会报错
val a = Array(1, 2, 3, 4)
a.head
Int = 1
headOption
def headOption : scala.Option[A] = { /* compiled code */ }
返回序列的第一个元素的 Option 类型对象，如果序列为空，则返回 None
val a = Array(1, 2, 3, 4)
a.headOption
//为了防止head一个空序列时报错影响程序，一般采用headOption比较好
Some(1)
//
val b:Array[Int] =Array()
b.head
//java.util.NoSuchElementException: next on empty iterator
b.headOption
Option[Int] = None
indexOf
def indexOf[B >: A](elem : B) : scala.Int = { /* compiled code */ }
返回元素 elem 在序列中第一次出现的索引，也可以指定从索引 from 开始查找
val a = Array(1,2,3,4,2,3)
a.indexOf(3)
Int = 2
a.indexOf(3,4)
Int = 5
467
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
