scala Array（一）

++、++:
+:、:+
/:、\:
addString(b:StringBuilder):StringBuilder
addString(b:StringBuilder,sep String):StringBuilder
apply(i:Int):T
charAt(index:Int):Char
clone():Array[T]
collect(pf: PartialFunction[A, B])：Array[B]
collectFirst(pf: PartialFunction[T, B])
combinations(n:Int):collection.Iterator[Array[T]]
contains(b):Boolean
containsSlice(that: GenSeq[B]):Boolean
copyToArray(a:Array[A],start:Int):Unit、copyToArray(a:Array[A],start:Int,len:Int)
copyToBuffer(B:ArrayBuffer):Unit
corresponds(that: GenSeq[B])(p: (T, B) ⇒ Boolean):Boolean
count(p: (T) ⇒ Boolean):Int
diff(that: collection.Seq[T]):Array[T]
distinct:Array[T]
drop(n:Int):Aray[T]
dropRight(n:Int):Array[T]
dropWhile(p: (T) ⇒ Boolean):Array[T]
endsWith(that: GenSeq[B]):Boolean
exist(p: (T) ⇒ Boolean):Boolean
filter(T) ⇒ Boolean):Array[T]
find(p: (T) ⇒ Boolean):Option[T]
flatten:Array[U]
forall(p: (T) ⇒ Boolean):Boolean
flagMap(f: (A) ⇒ B):Array[B]
foreach(f: (A) ⇒ Unit):Unit
groupBy(f: (T) ⇒ K): Map[K, Array[T]]
grouped(size: Int): collection.Iterator[Array[T]]
hasDefiniteSize:Boolean
head:T
headOption:Option
indexOf(elem: T):Int
indexOf(elem:T,from:Int):Int
indexOfSlice(that: GenSeq[B]):Int
indexOfSlice(that: GenSeq[B], from: Int):Int
indexWhere(p: (T) ⇒ Boolean):Int
indexWhere(p: (T) ⇒ Boolean, from: Int):Int
indices
init
inits
intersect(that: collection.Seq[T]):Array[T]
map(f: (A) ⇒ B):Array[B]
小试牛刀：用scala函数实现wordcount
map和foreach()的区别
productIterator
mkString: String
mkString(start: String, sep: String, end: String): String
nonEmpty: Boolean
padTo(len: Int, elem: A): Array[A]
par: ParArray[T]
partitioin(p: (T) ⇒ Boolean): (Array[T], Array[T])
patch(from: Int, that: GenSeq[A], replaced: Int): Array[A]
permutations: collection.Iterator[Array[T]]
permutations和combinations的区别：
prefixLength(p: (T) ⇒ Boolean): Int
produce: A
reduce(op: (A1, A1) ⇒ A1): A1
reduceLeft(op: (B, T) ⇒ B): B
reduceRight(op: (B, T) ⇒ B): B
reduceLeftOption(op: (B, T) ⇒ B): Option[B]
reduceRightOption(op: (T, B) ⇒ B): Option[B]
reverse: Array[T]
reverseIterator: collection.Iterator[T]
reverseMap(f: (A) ⇒ B): Array[B]
sameElements(that: GenIterable[A]): Boolean
scan(z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Array[T], B, That]): That
scanLeft(z: B)(op: (B, T) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That
scanRight(z: B)(op: (T, B) ⇒ B)(implicit bf: CanBuildFrom[Array[T], B, That]): That
segmentLength(p: (T) ⇒ Boolean, from: Int): Int
seq: collection.mutable.IndexedSeq[T]
size: Int
slice(from: Int, until: Int): Array[T]
sliding(size: Int): collection.Iterator[Array[T]]
sliding(size: Int,step: Int): Iterator[Array[Int]]
sortBy(f: (T) ⇒ B)(implicit ord: math.Ordering[B]): Array[T]
sorted(implicit ord: math.Ordering[B]): Array[T]]
sortWith()(lt: (Int, Int) => Boolean): Array[Int]
span(p: (T) ⇒ Boolean): (Array[T], Array[T])
splitAt(n: Int): (Array[T], Array[T])
startsWith(that: GenSeq[B]): Boolean
startsWith(that: GenSeq[B], offset: Int): Boolean
stringPrefix:String
subsequence(start: Int, end: Int): CharSequence
sum:A
tail:Array[T]
tails:collection.Iterator[Array[T]]
take(n: Int): Array[T]
takeRight(n: Int): Array[T]
takeWhile(p: (T) ⇒ Boolean): Array[T]
toArray:Array[A]
toBuffer:Buffer[A1]
toIndexSeq:collection.immutable.IndexedSeq[T]
toIterable:collection.Iterable[T]
toIterator: collection.Iterator[T]
toList:List[T]
toMap:Map[T, U]
toSeq: collection.Seq[T]
toSet: Set[B]
toVector:Vector[T]
transpose(implicit asArray: (T) ⇒ Array[U]): Array[Array[U]]
union(that: collection.Seq[T]): Array[T]
unzip(implicit asPair: (T) ⇒ (T1, T2), ct1: ClassTag[T1], ct2: ClassTag[T2]): (Array[T1], Array[T2])
unzip3(implicit asTriple: (T) ⇒ (T1, T2, T3), ct1: ClassTag[T1], ct2: ClassTag[T2], ct3: ClassTag[T3]): (Array[T1], Array[T2], Array[T3])
update(i: Int, x: T):Unit
updated(index: Int, elem: A): Array[A]
view(from: Int, until: Int): IndexedSeqView[T, Array[T]]
withFilter(p: (T) ⇒ Boolean): FilterMonadic[T, Array[T]]
withFilter与filter的区别
zip(that: GenIterable[B]): Array[(A, B)]
zipALL(that: collection.Iterable[B], thisElem: A, thatElem: B): Array[(A, B)]
zipWithIndex:Array[(A, Int)]
++、++:

++和++:都是球两个集合的并集，不同的是：
++看左边集合的类型是什么类型，那么返回的集合就是什么类型
++：看右边集合的类型是什么 类型，那么返回的集合就是什么类型

var a = List(100,200,300)
var b = Array(6,7,8,9,10)
a++b
//返回的是List类型的集合
List[Int] = List(100, 200, 300, 6, 7, 8, 9, 10)
a++:b
//返回的是Array类型的集合
Array[Int] = Array(100, 200, 300, 6, 7, 8, 9, 10)

+:、:+
+:和:+都是在一个集合中添加元素，不同的是
+: 是数字在+号前面，集合在:后面
:+ 是数字在+后面，集合在:前面
可以这么理解：+号跟的是数字，:号跟的是集合

1000+:a
//结果为
List[Int] = List(1000, 100, 200, 300)
a:+500
//结果为
List[Int] = List(100, 200, 300, 500)

/:、:
对数组中数据进行迭代操作
/: 对数组从左向右遍历， 进行相同的迭代操作 floadLeft
:\对数组从右向左遍历，进行相同的迭代操作 floadRight
是二叉树迭代操作，如下：
var c = Array(1,2,3,4,5)
(10/:c)(+)
//结果(((((10+1)+2)+3)+4)+5)
//从左向右进行两两相加
Int = 25
(c:\20)(+)
//结果(1+(2+(3+(4+(5+20)))))
//从右向左进行两两相加
Int = 35

addString(b:StringBuilder):StringBuilder
将数组中的元素逐个添加到StringBuilder中

var c = Array(1,2,3,4,5)
//定义一个StringBuilder
var g = new StringBuilder
//将数组c添加到g中
c.addString(g)
//结果
StringBuilder = 12345

addString(b:StringBuilder,sep String):StringBuilder
将数组添加到StringBuilder中，每个元素用sep分隔符分开
c.addString(g,"|")
StringBuilder = 1|2|3|4|5

apply(i:Int):T
获得指定索引处的元素
val e = List(1,2,3,4)
e.apply(2)
//结果，等同于e(2)
Int = 3
Array[Int] = Array(1, 2, 3, 4, 5)

charAt(index:Int):Char
获取index索引处的字符，这个方法会执行一个隐式的转换，将 Array[T] 转换为 ArrayCharSequence，只有当 T 为 Char 类型时，这个转换才会发生
var h = Array(‘a’,‘b’,‘c’,‘d’)
h.charAt(3)
//结果
Char = d

clone():Array[T]
创建一个副本，只是值相等，地址不相等
var c = Array(1,2,3,4,5)
var f = c //f指向c
f(3)=100
c
//发现f中索引为3的元素改变了，c中相同索引的元素也改变了，因为他们指向了相同地址
Array[Int] = Array(1, 2, 3, 100, 5)
var g = c.clone()
g(4)=4
//用clone()这个方法只是值相等

collect(pf: PartialFunction[A, B])：Array[B]
通过执行一个偏函数 ，得到一个新数组
//定义一个将a转成A的偏函数
var h = Array(‘a’,‘b’,‘c’,‘d’)
//第一个Char是传进来的参数类型，第二个Char是返回参数的类型
var test1:PartialFunction[Char,Char] = {
case ‘a’ => ‘A’
case x => x
}
h.collect(test1)
//结果为
Array[Char] = Array(A, b, c, d)

//定义一个将a转成A的偏函数
var h = Array(‘a’,‘b’,‘c’,‘d’)
//第一个Char是传进来的参数类型，第二个Char是返回参数的类型
var test1:PartialFunction[Char,Char] = {
case ‘a’ => ‘A’
case x => x
}
h.collect(test1)
//结果为
Array[Char] = Array(A, b, c, d)

collectFirst(pf: PartialFunction[T, B])
在序列中查找第一个符合偏函数定义的元素，，并执行偏函数计算
var pfTest01:PartialFunction[Any,Int] = {
case x:Int => x*100
}
var y = Array(‘t’,2,‘a’,“b”)
y.collectFirst(pfTest01)
//结果
Option[Int] = Some(200)//表示存在200，可以get来获取some中的值
y.collectFirst(pfTest01).get
//结果
Int = 200

combinations(n:Int):collection.Iterator[Array[T]]
combinations 表示组合，这个排列组合会选出所有包含字符不一样的组合，但不考虑顺序，对于 “abc”、“cba”，视为相同组合，参数 n 表示序列长度，就是几个字符为一组
var y = Array(‘t’,2,‘a’,“b”)
var t = y.combinations(3)
// 返回值是一个迭代器
Iterator[Array[Any]] = non-empty iterator
t.foreach(x=>println(x.mkString(",")))
//结果
t,2,a
t,2,b
t,a,b
2,a,b

contains(b):Boolean
判断数组中是否包含指定对象
var y = Array(‘t’,2,‘a’,“b”)
y.contains(“b”)
//结果为
Boolean = false

containsSlice(that: GenSeq[B]):Boolean
判断当前序列中是否包含另一个序列
var n =Array(“a”,“b”)
var y = Array(‘t’,2,“a”,“b”)
y.containsSlice(n)
//结果为
Boolean = true

copyToArray(a:Array[A],start:Int):Unit、copyToArray(a:Array[A],start:Int,len:Int)
将当前数组复制到另一个数组中，从start位置开始复制
val a = Array(1, 2, 3)
//定义一个长度为10的数组
var b:Array[Int]=new Array(10)
//把数组a复制给b,从索引为3开始
a.copyToArray(b,3)
//结果
Array[Int] = Array(0, 0, 0, 1, 2,3, 0, 0, 0, 0)

distinct:Array[T]
取出当前集合中重复的元素，只保留一个
var a = Array(1,2,3,4,5,1,5)
a.distinct
//结果
Array[Int] = Array(1, 2, 3, 4, 5)

drop(n:Int):Aray[T]
删除当前数组中的前n个元素，返回一个新数组
var a = Array(1,2,3,4,5)
a.dropRight(3)
//结果
Array[Int] = Array(1, 2, 3)

dropWhile(p: (T) ⇒ Boolean):Array[T]
从第一个元素开始，去除当前数组中符合条件的元素，直到遇到第一个不满足条件的元素（即使后面还有符合条件的元素），返回剩余的数组，如果整个数组都满足条件，那么就返回整个数组
var a = Array(1,2,3,4,3)
a.dropWhile(_❤️)
//结果，返回第一个不满足的元素及后面的所有元素
Array[Int] = Array(3, 4, 3)

endsWith(that: GenSeq[B]):Boolean
判断当前序列是否以某个序列结尾
是整个序列，而不是序列的末尾元素

var a = Array(“a”,“b”,“c”,“d”)
var b = Array(“c”,“d”)
a.endsWith(b)
//结果
Boolean = true

exist(p: (T) ⇒ Boolean):Boolean
判断当前数组是否包含符合条件的元素
参数返回的是boolean类型

var a = Array(“a”,“b”,“c”,“d”)
a.exists({_==“c”})
//结果
Boolean = true