删除类函数

scala.collection.GenTraversableOnce[B])(implicit

scala.collection.generic.CanBuildFrom[Repr,

That])

scala.collection.Traversable[B])(implicit

scala.collection.generic.CanBuildFrom[Repr,

That])

}描述这个方法同上一个方法类似两个加号后面多了一个冒号但是不同的是右边操纵数的类型决定着返回结果的类型

示例Array

bprintln(ints1.getClass.getName)

def

0println(b.toList)println(c.toList)

collect

scala.collection.generic.CanBuildFrom[Repr,

That])

PartialFunction[Int,String]{case

acase

o***r}println(a.collect(fun).toList

collectFirst

描述在序列中查找第一个符合偏函数定义的元素并执行偏函数计算返回一个

option

PartialFunction[Int,String]{case

acase

o***r}println(a.collectFirst(fun)

val

Array(1,2,3)println(a.collectFirst({case

Int

scala.collection.Iterator[Repr]

compiled

表示组合这个排列组合会选出所有包含元素不一样的组合但不考虑顺序对于

“123”、“321”视为相同组合参数

表示序列长度就是几个元素为一组返回的是一个迭代器迭代器里存放的是

val

a.combinations(2)combine.foreach(xprintln(x.toList))

permutations

scala.collection.Iterator[Repr]

compiled

表示排列这个排列组合会选出所有排列顺序不同的元素组合permutations

combinations

a.permutationspermutations.foreach(xprintln(x.toList))

copyToArray(xs)

Array[Int](5)a.copyToArray(b)println(b.toList)copyToArray(arr,

start)

Array[Int](5)a.copyToArray(b,1)println(b.toList)

copyToArray(arr,

Array[Int](5)a.copyToArray(b,1,2)println(b.toList)

copyToBuffer

scala.collection.mutable.Buffer[B])

scala.Unit

ArrayBuffer()a.copyToBuffer(buffer)println(buffer.toList)

3.删除类函数

a.dropRight(3)println(ints.toList)

dropWhile

}描述去除当前数组中符合条件的元素返回剩余的数组这个需要一个条件就是从当前数组的第一个元素起就要满足条件直到碰到第一个不满足条件的元素结束即使后面还有符合条件的元素否则返回整个数组

val

a.dropWhile(xx3)println(ints.toList)

4.查找类函数

a.lastIndexOf(2,5)println(index)

def

a.lastIndexOfSlice(slice)println(index)

end)

a.lastIndexOfSlice(slice,5)println(index)

lastIndexWhere

a.lastIndexWhere(xx3)println(index)

lastIndexWhere(p,

a.lastIndexWhere(xx3,5)println(index)

lastOption

Array(1,2,1,3,4,5,6,3,4,2,1)val

slide

a.indexOfSlice(slide)println(i)

indexOfSlice(that,

Array(1,2,1,3,4,5,6,3,4,2,1)val

slide

a.indexOfSlice(slide,4)println(i)

indexWhere

Array(1,2,1,3,4,5,6,3,4,2,1)val

Int

Array(1,2,1,3,4,5,6,3,4,2,1)val

Int

Array(1,2,1,3,4,5,6,3,4,2,1)println(a.segmentLength(xx3,0))println(a.segmentLength(xx3,4))

5.统计类函数

Array(1,2,3,4)println(a.count(xtrue))println(a.count(xx2))

max

Array(1,2,3,4)a.update(1,0)println(a.toList)updated

def

scala.collection.generic.CanBuildFrom[Repr,

That])

scala.collection.generic.CanBuildFrom[Repr,

That])

Array(1,2,3,4)println(a.contains(4))

containsSlice

Array(1,2,3,4)println(a.containsSlice(List(2,1)))println(a.containsSlice(List(1,2)))

endsWith

Array(1,2,3,4)println(a.endsWith(List(3,4)))

exists

Array(1,2,3,4)println(a.exists(xx5))println(a.exists(xx3))

isDefinedAt

Array(1,2,3,4)println(a.isDefinedAt(3))

isEmpty

Array[Any](0)println(a.isEmpty)println(b.isEmpty)

isTraversableAgain

a.iteratorprintln(a.isTraversableAgain)println(b.isTraversableAgain)

forall

Array(1,2,3,4)println(a.forall(xx2))println(a.forall(xx0))

nonEmpty

Array[Any](0)println(a.nonEmpty)println(b.nonEmpty)

sameElements

scala.collection.GenIterable[B])

scala.Boolean

scala.Boolean描述判断序列从指定偏移处是否以某个序列开始

val

Stream.emptyprintln(array数组是否存在有限的长度a.hasDefiniteSize)println(stream流是否存在有限的长度b.hasDefiniteSize)

canEqual

}描述判断两个序列的长度是否相等再判断对应位置元素是否符合某个条件。

如果两个序列具有相同的元素数量并且

f(x,

}描述获取指定索引处的元素,与a(0)的取值方法很像但是当数组中有不同类型的时候用

apply

b)println(a.apply(0))println(a(1))

charAt

Array(a,b,c)println(a.charAt(2))

foreach

Array(a,b,c)println(a.headOption)

init

Array(a,b,c)println(a.init.toList)

inits

scala.collection.Iterator[Repr]

compiled

a.initsinits.foreach(xprintln(x.toList))

tail

scala.collection.Iterator[Repr]

compiled

a.tailsinits.foreach(xprintln(x.toList))

take

a.takeRight(2)println(b.toList)

takeWhile

}描述返回当前序列中从第一个元素开始满足条件的连续元素组成的序列

val

a.takeWhile(xxc)println(b.toList)println(a.takeWhile(xxb).toList)

view

scala.collection.mutable.IndexedSeqView[A,

Repr]

scala.collection.generic.FilterMonadic[A,

Repr]

过滤元素如果后续的操作需要使用到map/flatMap/withFilter推荐使用这样可以减少filter产生的中间collection使得执行更加高效

val

a.reverseprintln(reverse.toList)

reverseIterator

a.reverseIteratorprintln(iterator.toList)par

override

scala.collection.parallel.mutable.ParArray[T]

compiled

}描述按条件将序列拆分成两个数组满足条件的放到第一个数组其余的放到第二个数组返回的是包含这两个数组的元组

val

scala.collection.immutable.Map[K,

Repr]

none})stringToInts.foreach(xprintln(x._1

x._2.toList))

scala.collection.Iterator[Repr]

compiled

a.grouped(2)b.foreach(xprintln(x.toList))

sortBy

x)println(升序排列ints.toList)println(倒序排列a.sortBy(x

x).toList)

scala.collection.Iterator[Repr]

compiled

a.sliding(3)iterator.foreach(xprintln(x.toList))

sliding(size,

scala.collection.Iterator[Repr]

compiled

a.sliding(3,2)iterator.foreach(xprintln(x.toList))

span

}描述将序列拆分成两个数组从第一个元素开始直到第一个不满足条件的元素为止其中的元素放到第一个数组其余的放到第二个数组返回的是包含这两个数组的元组

val

3)println(tuple._1.toList)println(tuple._2.toList)

splitAt

a.splitAt(4)println(第一组tuple._1.toList)println(第二组tuple._2.toList)

subSequence

scala.collection.GenTraversableOnce[B]])(implicit

scala.collection.generic.CanBuildFrom[Repr,

That])

}描述对当前序列的每个元素进行操作,可以理解成降维最低到一维也可以对一维数组操作但每一个元素应该都返回一个序列结果放入新序列返回参数要求是

GenTraversableOnce

Array(Array(1,2,3),Array(2,3,4))val

ints:

a.flatMap(xx)println(ints.toList)

flatten

scala.collection.Traversable[U]],

scala.Array[U]

}描述扁平化将二维数组的所有元素组合在一起形成一个一维数组返回

val

Array(Array(1,2,3),Array(2,3,4))println(a.flatten.toList)

iterator

a.iteratorprintln(iterator.getClass.getName

iterator.toList)

scala.collection.generic.CanBuildFrom[Repr,

That])

scala.collection.generic.CanBuildFrom[Repr,

That])

scala.collection.mutable.Buffer[B]

compiled

scala.collection.immutable.IndexedSeq[A]

compiled

scala.collection.immutable.Map[T,

compiled

Array((1,a),(2,b),(3,c),(4,d))val

map:

Array((1,a),(2,b),(3,c),(4,d))val

seq:

scala.collection.immutable.Set[B]

compiled

Array((1,a),(2,b),(3,c),(4,d))val

set:

scala.collection.immutable.Stream[A]

compiled

Array((1,a),(2,b),(3,c),(4,d))val

stream:

Array((1,a),(2,b),(3,c),(4,d))val

vector:

Array(Array(11,12,13),Array(21,22,23))val

transpose:

a.transposetranspose.foreach(xprintln(x.mkString(,)))

seq

scala.collection.mutable.IndexedSeq[T]

compiled

}描述将含有两个二元组的数组每个元组的第一个元素组成一个数组第二个元素组成一个数组返回包含这两个数组的元组

val

}描述将含有三个三元组的数组每个元组的第一个元素组成一个数组第二个元素组成一个数组第三个元素组成一个数组返回包含这三个数组的元组

val

Array((1,2,3),(4,5,6),(7,8,9))val

unzip:

scala.collection.generic.CanBuildFrom[Repr,

scala.Tuple2[A1,

a.zipWithIndexprintln(index.mkString(,))

11.工具类函数

StringBuildera.addString(b)println(b)

addString(b,

StringBuildera.addString(b,,)println(b)

distinct

a.distinctprintln(distinct.toList)

indices

scala.collection.immutable.Range

compiled

scala.collection.generic.CanBuildFrom[Repr,

That])

0)println(ints.toList)println(ints1.toList)

prefixLength

Array(1,2,3,2,1)println(a.mkString)

mkString(sep)

Array(1,2,3,2,1)println(a.mkString(,))

mkString(start,

Array(1,2,3,2,1)println(a.mkString((,,,)))

length

List(1,2,3)println(a.toString())println(a.stringPrefix)

12.集合内与集合间计算函数

的两个参数分别封装成两个方法并把分区和不分区的计算过程分别打印出来

def

seq(m:Int,n:Int):Int{println(seq:mn)mn}def

combine(m:Int,n:Int):Int{println(combine:mn)mn}val

Array(1,2,3,4)println(不分区情形)val

Int

是把初始值顺序和每个元素相加把得到的结果与下一个元素进行运算。

分区时seqno

是把初始值与每个元素相加但结果不参与下一步运算而是放到另一个序列中由第二个方法

combine

有类似的语义但执行过程有所不同fold类的函数分区内的计算逻辑就是分区间的计算逻辑而aggregate却可以指定分区内的计算逻辑与分区间的计算逻辑此外fold方法要求聚合的两者类型相同【map聚合时会被当做元组】而foldLeft和foldRight则不必

def

seq(m:Int,n:Int):Int{println(seq:mn)mn}val

Array(1,2,3,4)println(不分区情形)val

Int

seq(m:Int,n:Int):Int{println(seq:mn)mn}val

Array(1,2,3,4)val

seq(m:Int,n:Int):Int{println(seq:mn)mn}val

Array(1,2,3,4)val

a.reduce((x,y){println(seq:xy)xy})println(i

reduceLeft

a.reduceLeft((x,y){println(seq:xy)xy})println(i

override

a.reduceRight((x,y){println(seq:xy)xy})println(i

reduceLeftOption

scala.collection.generic.CanBuildFrom[Repr,

That])

scala.collection.generic.CanBuildFrom[Repr,

That])

foldLeft从左向右计算每一步的计算结果放到一个新的集合中返回

val

scala.collection.generic.CanBuildFrom[Repr,

That])

foldRight从右向左计算每一步的计算结果放到从右向左放一个新的集合中返回

val

}描述计算当前数组与另一个数组的差集即将当前数组中没有在另一个数组中出现的元素返回

val

a.diff(b)println(a_diff_b.toList)

intersect

a.intersect(b)println(a_intersect_b.toList)

union

scala.collection.GenSeq[B])(implicit

scala.collection.generic.CanBuildFrom[Repr,

That])

a.union(b)println(a_union_b.toList)

zip

scala.collection.GenIterable[B])(implicit

scala.collection.generic.CanBuildFrom[Repr,

scala.Tuple2[A1,

}描述将两个序列对应位置上的元素组成一个元组数组要求两个序列长度相同

val

a.zip(b)println(a_zip_b.toList)

zipAll

scala.collection.GenIterable[B],

thisElem

scala.collection.generic.CanBuildFrom[Repr,

scala.Tuple2[A1,

但是允许两个序列长度不同不足的自动填充如果当前序列短不足的元素填充为

thisElem如果

a.zipAll(b,1,0)println(a_zipAll_b.toList)val

b_zipAll_a:

b.zipAll(a,1,0)println(b_zipAll_a.toList)