scala---array方法

array方法分类

1.元素操作	替换数组元素 +:前添加元素 :+尾添加元素 combinations排列组合；distinct去重；drop删除；dropRight从右删；dropWhile符合条件删除；max返回最大元素；min返回最小元素；maxBy返回符合条件的第一个；minBy返回不符合条件的第一个；padTo填充序列；patch批量替换；permutations排列；prefixLength返回元素数量；transform转换；update更新(改变原数组)；updated更新（不改变原数组）
2.元素取头尾	head返回第一个元素；headOption返回Option；last返回最后一个元素；lastOption返回Option；tail去除第一个元素；tailstail迭代操作；init去除尾元素；initsinit 迭代操作；take按个数返回当前序列；takeRight从右开始返回当前序列；takeWhile按条件返回当前序列
3.下标索引操作	apply按数组下标访问；applyOrElse按数组下标返回；charAt获取索引处字符；indexOf(elem)返回元素索引；indexOfSlice(that)返回序列索引；indexWhere返回元素索引；lastIndexOf(elem:T)返回元素最后一次出现的索引；lastIndexOfSlice(that)返回序列索引；lastIndexWhere返回元素索引；indices返回索引集合；slice返回指定序列（前包后不包）；subSequence返回字符序列（前包后不包）；view返回序列（前包后不包）
4. 数组中的计算	fold折叠计算 /:foldLeft左到右方式计算 :\foldRigh右到左方式计算；product乘积；reduce二元计算；reduceLeft从左向右计算；reduceRight从右向左计算；reduceOption二元计算返回option；reduceLeftOption从左向右计算返回option；reduceRightOption从右向左计算返回option；scan折叠计算返回新集合；scanLeft从左向右计算返回新集合；scanRight从右向左计算返回新集合；sum求和
5.数组拆分排序	groupBy按条件分组；grouped分组；par并行计算；partition分组；span拆分数组；splitAt按序列拆分成两个数组；sliding(size)滑动；sortBy按规则排序；sorted排序；sortWith自定义排序
6. 数组长度	length返回元素个数；size返回元素个数；lengthCompare长度比较；segmentLength查找返回
7.两数组操作	++合并数组操作 ++：合并数组操作； canEqual两数比较；corresponds元素比较；diff计算两数组差集；intersect计算两数组交集；union合并；sameElements值比较
8.数组克隆和复制	clone创建副本；copyToBuffer复制数组；seq序列
9.数组反转	reverse反转序列；reverseIterator反向迭代器；reverseMap反向操作
10.数组的行列操作	flatMap扁平化映射；flatten扁平化；transpose矩阵转置；unzip3三元数组；zip数组组合；zipAll数组组合；zipWithIndex元素和索引组成数组
11.字符串相关操作	addString逐个添加元素；mkString拼接成字符串；stringPrefix返回前缀
12.方法操作	aggregate聚合操作；andThen方法连续调用（与 compose 相反）；collect并行计算（偏函数）；collectFirst偏函数计算；compose方法连续调用（与 andThen 相反）；elemManifest返回集合元素的类型；elemTag返回集合元素的类型；foreach遍历；iterator迭代；map操作返回新序列；runWith执行偏函数
13.指定条件判断	contains包含；containsSlice包含序列；count统计；endsWith判断结尾；startsWith判断开头；exists判断符合条；filter过；filterNot过滤；withFilter条件过滤；find查找；forall全部满足；hasDefiniteSize检测有限长度；isDefinedAt判断指定索引；isEmpty判断为空；nonEmpty判断不为空；isTraversableAgain判断可以反复遍历
14.类型转换	toArray；toBuffer；toIndexedSeq；toIterable；toIterator；toList；toMap；toSeq；toSet；toStream；toVector

---

以下举例解释：

1,def ++ 两个集合合并相加

val a=Array(1,2)
val b=Array(3,4)
val c=a ++ b //c: Array[Int] = Array(1, 2, 3, 4)

2,def ++： 两个集合相加，返回的类型按照靠近 ： 的集合类型

val a=List(1,2)
val b =scala.collection.mutable.LinkedList(3,4)
val c=a++:b //c: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2, 3, 4)
val c=b ++: a //c: List[Int] = List(3, 4, 1, 2)
val c=5 +: a //c: List[Int] = List(5, 3, 6, 1, 7)集合前加一个5
val c=a :+ 4 //c: List[Int] = List(3, 6, 1, 7, 4)集合后加一个4

3,def /: 对集合所有元素进行一个操作

val a=List(4,7,2,1)
val c=(10 /: a)(_+_) //4+7+2+1+10=24，c: Int = 24
val c=(10 /: a)(_*_) //4*7*2*1*10=560，c: Int = 560

4,def addString 用分隔符分开

val a=List(3,6,1,7)
a.addString(new StringBuilder()) //3617
a.addString(new StringBuilder(),"$") //StringBuilder = 3$6$1$7
a.addString(new StringBuilder(),"^") // StringBuilder = 3^6^1^7
a.addString(new StringBuilder(),"(","^",")") //StringBuilder = (3^6^1^7)

5,def aggregate 集合内容分别进行两种方法

val a=List(4,7,2,1)
a.aggregate(10)((x,y)=>{println("left",x,y);x+y},(x,y)=>{println("right",x,y);x+y})

//(left,10,4)
//(left,14,7)
//(left,21,2)
//(left,23,1)
//res2: Int = 24

6,def canEqual 判断俩对象是否可以进行比较

val a=List(1,2,3)
val b=Array(3,4,5)
a.canEqual(b) // Boolean = true

7,def charAt 只能char类型,获取下标位置的字符

val char=Array('a','b','c')
char.charAt(2) // Char = c 下标为2的字符是c

8,def collect 通过偏函数，变成一个新的数组

val char=Array('a','b','c')
char.collect({case 'a'=>'A'}) // Array[Char] = Array(A)
char.collect({case 'a'=>'A' case x=>x}) //Array[Char] = Array(A, b, c)
----
var info=Array("male","男","1","female","女","0")
info.collect(
| {
| case "男"=>"male"
| case "女"=>"female"
| case "1"=>"male"
| case "0"=>"female"
| case x=>x
| }
| )
//Array[String] = Array(male, male, male, female, female, female)

9,def collectFirst 找到第一个符合条件的执行偏函数

val arr=Array(1,'a',"b")
arr.collectFirst({case x:Int=>x*100}) // Option[Int] = Some(100)
----
val arr=Array(1,3,'a',"b")
arr.collectFirst({case x:Int=>x*100}) //Option[Int] = Some(100)
----
arr.collect({case x:Int=>x*100}) //Array[Int] = Array(100, 300)

10,def combinations 按照字符长度进行合并

val arr=Array(1,3,'a',"b")
arr.combinations(2)
//res15: Iterator[Array[Any]] = non-empty iterator 按照字符长度为2的分组
res15.foreach((x)=>println(x.mkString("(",",",")")))
//使用combinations的结果遍历， 注意：foreach只能遍历一次
//(1,3)
//(1,a)
//(1,b)
//(3,a)
//(3,b)
//(a,b)

11,def contains 集合中是否包含指定对象

val arr=Array(1,3,'a',"b")
scala> arr.contains(13) // Boolean = false
scala> arr.contains(1,3) //Boolean = false
scala> arr.contains(1) //Boolean = true

12,def containsSlice 判断当前序列是否包含另外一个序列

val arr=Array(1,3,'a',"b")
val arr1=Array(1,3)
val arr2=Array(2,3)
arr.containsSlice(arr1) //Boolean = true
arr.containsSlice(arr2) // Boolean = false

13,def copyToArray 复制集合元素

scala> a
res65: Array[Char] = Array(a, b, c)

scala> val b:Array[Char]=new Array(5)
b: Array[Char] = Array(?, ?, ?, ?, ?)

scala> a.copyToArray(b)

scala> b
res67: Array[Char] = Array(a, b, c, ?, ?)

scala> a.copyToArray(b,1,2) //以下标为1，步长为2的copy方式

scala> b
res71: Array[Char] = Array(?, a, b, ?, ?)

14,def copyToBuffer 把数组中的内容拷贝到buffer中

scala> import scala.collection.mutable.ArrayBuffer //导包，用于Int类型
import scala.collection.mutable.ArrayBuffer
--
scala> val a=Array(1,2,3)
a: Array[Int] = Array(1, 2, 3)

scala> val b =new ArrayBuffer[Int]()
b: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

scala> a.copyToBuffer(b)

scala> b
res79: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)

15,def corresponds 判断两个集合中长度是否相等，并且是否都全部满足条件

scala> a
res80: Array[Int] = Array(1, 2, 3)

scala> val b=Array(3,4,5)
b: Array[Int] = Array(3, 4, 5)

scala> val c=Array(5,8,1,2,3)
c: Array[Int] = Array(5, 8, 1, 2, 3)

scala> a.corresponds(b)(_<_)
res82: Boolean = true

scala> a.corresponds(c)(_<_)
res83: Boolean = false

16,def count 统计符合条件的元素个数

var ints=Array(5,6,7,8,1)
ints.count(_>7) // Int = 1只有一个大于7的元素

17,def diff 查看当前数组与另一个数组的不同，返回当前数组中有异的值

scala> a
res80: Array[Int] = Array(1, 2, 3)

scala> val b=Array(3,4,5)
b: Array[Int] = Array(3, 4, 5)

scala> a.diff(b)
res84: Array[Int] = Array(1, 2)

scala> b.diff(a)
res85: Array[Int] = Array(4, 5)

18,def filter 过滤器

var ints=Array(5,6,7,8,1)
ints.filter(_>6) //Array[Int] = Array(7, 8)

19,def filterNot 过滤器取反

ints.filterNot(_>6) // Array[Int] = Array(5, 6, 1)

20,def endsWith 判断是否以另一个序列为结尾，注意必须是序列

scala> ints
res90: Array[Int] = Array(5, 6, 7, 8, 1)

scala> ints2
res91: Array[Int] = Array(8, 1)

scala> ints.endsWith(ints2)
res92: Boolean = true

21,def distinct 去重

var ints2=Array(1,2,5,9,1)
ints2.distinct
res30: Array[Int] = Array(1, 2, 5, 9)

22,def drop 删除前n个元素

var ints2=Array(1,2,5,9,1)
ints2.drop(2)
res31: Array[Int] = Array(5, 9, 1)

23,def dropRight 从尾部删除n个元素

var ints2=Array(1,2,5,9,1)
ints2.dropRight(2)
res32: Array[Int] = Array(1, 2, 5)

24,def dropWhile 返回第一个不符合条件的元素

var ints=Array(5,6,7,8,1)
ints.dropWhile(_>2) //Array[Int] = Array(1)

25,def exists 判断是否存在

var ints=Array(5,6,7,8,1)
ints.exists(_==8) // Boolean = true
scala> ints.exists(_==3) //Boolean = false

26,def find 找到第一个就成

ints.find(x=>x>6) //Option[Int] = Some(7)

27,def flatMap 每个元素进行指定操作

var ints=Array(5,6,7,8,1)
ints.flatMap(x=>1 to x)
//Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 8, 1)
//对每个元素进行1到x的操作

val arrays=Array(Array(0,2,3),Array(1,4,5),Array(5,8,9))
arrays.flatMap(x=>x)
// Array[Int] = Array(0, 2, 3, 1, 4, 5, 5, 8, 9)

28,def flatten将二维数组的所有元素联合在一起，形成一个一维数组

scala>arrays
res43: Array[Array[Int]] = Array(Array(0, 2, 3), Array(1, 4, 5), Array(5, 8, 9))

scala> arrays.flatten
res44: Array[Int] = Array(0, 2, 3, 1, 4, 5, 5, 8, 9)

29,def fold 对每个元素进行二元运算

scala> ints
res45: Array[Int] = Array(5, 6, 7, 8, 1)

scala> ints.fold(100)((x,y)=>{println(x,y);x*y})
(100,5)
(500,6)
(3000,7)
(21000,8)
(168000,1)
res46: Int = 168000
--
scala> ints.foldLeft(100)((x,y)=>{println(x,y);x*y})
(100,5)
(500,6)
(3000,7)
(21000,8)
(168000,1)
res47: Int = 168000

scala> ints.foldRight(100)((x,y)=>{println(x,y);x*y})
(1,100)
(8,100)
(7,800)
(6,5600)
(5,33600)
res48: Int = 168000

30,def forall 判断是否全部是满足条件

scala> ints
res45: Array[Int] = Array(5, 6, 7, 8, 1)

scala> ints.forall(_>2)
res49: Boolean = false

scala> ints.forall((x)=>{x>0})
res51: Boolean = true

31,def foreach 遍历数组

scala> ints
res45: Array[Int] = Array(5, 6, 7, 8, 1)

scala> ints.foreach(println(_))
5
6
7
8
1

32,def groupBy 按照条件分组

scala> ints
res45: Array[Int] = Array(5, 6, 7, 8, 1)

scala> ints.groupBy((x)=>{if(x%2==0) 0 else 1})
res54: scala.collection.immutable.Map[Int,Array[Int]] = Map(1 -> Array(5, 7, 1), 0 -> Array(6, 8))

33,def grouped 按照指定数量分组

scala> a
res99: Array[Int] = Array(1, 2, 3)

scala> a.grouped(2)
res100: Iterator[Array[Int]] = non-empty iterator

scala> res100.foreach((x)=>(println(x.mkString(","))))
1,2
3

34,def hasDefiniteSize 检查是否存在有限长度

scala> a
res104: Array[Int] = Array(1, 2, 3)

scala> a.hasDefiniteSize
res105: Boolean = true

35,def head 返回序列的第一个元素

scala> a.head
res106: Int = 1

36,def indexOf 返回元素在序列中的索引，找到第一个就返回

scala> a.indexOf(2)
res107: Int = 1
--
scala> a.indexOf(2,2)
res108: Int = -1

37,def indexOfSlice 检测当前序列是否包含另一个序列，并返回第一个满足条件的元素的索引

scala> a
res110: Array[Int] = Array(1, 2, 3)

scala> val c=Array(1,2)
c: Array[Int] = Array(1, 2)

scala> a.indexOfSlice(c)
res113: Int = 0

38,def indexWhere 返回第一个满足条件的元素的索引

scala> a
res110: Array[Int] = Array(1, 2, 3)

scala> a.indexWhere(_>1)
res114: Int = 1

scala> a.indexWhere(_>1,2)
res116: Int = 2 //从第2个位置开始检索

39,def indices 返回当前序列索引集合

scala> a
res110: Array[Int] = Array(1, 2, 3)

scala> a.indices
res119: scala.collection.immutable.Range = Range(0, 1, 2)

40,def init 返回当前序列中不包含最后一个元素的序列

scala> a
res120: Array[Int] = Array(1, 2, 3)

scala> a.init
res121: Array[Int] = Array(1, 2)

41,def inits 返回当前序列所有元素多次进行init操作

scala> a
res120: Array[Int] = Array(1, 2, 3)

scala> a.inits
res122: Iterator[Array[Int]] = non-empty iterator

scala> res122.foreach((x)=>(println(x.mkString(","))))
1,2,3
1,2
1

42,def intersect 取两个集合的交集

scala> a
res124: Array[Int] = Array(1, 2, 3)

scala> b
res125: Array[Int] = Array(3, 4, 5)

scala> a.intersect(b)
res126: Array[Int] = Array(3)

43,def isDefinedAt 判断序列中是否存在指定索引

scala> a.isDefinedAt(1)
res127: Boolean = true

scala> a.isDefinedAt(4)
res128: Boolean = false

44,def isEmpty 判断当前序列是否为空

scala> a.isEmpty
res129: Boolean = false

45,def iterator 对序列中的每个元素产生一个iterator

scala> a.iterator
res130: Iterator[Int] = non-empty iterator

---

就写到这里吧。。。。