Scala数组操作

Scala数组操作：

1.定长数组

长度不变的数组的声明：

[java]  view plain  copy

1. //长度为10的整数数组，所有元素初始化为0  
2.  val numArr = new Array[Int](10)  
3.   
4. //长度为10的字符串数组，所有元素初始化为null  
5. val numArr = new Array[String](10)  
6.   
7. //长度为2的数组，数据类型自动推断出来，已经提供初始值就不需要new关键字  
8. val s = Array("cai","yong")  
9.   
10. //通过ArrayName(index)访问数组元素和更改数组元素  
11. val s = Array("cai","yong")  
12.  println(s(0))  
13. s(0) = "haha"  
14. println(s(0))  

输出：
cai
haha

2.变长数组：数组缓冲

Scala也支持长度变化的数组，支持的数据结构是ArrayBuffer

[java]  view plain  copy

1. //一个空的数组缓冲，准备存放整数  
2.  val ab = ArrayBuffer[Int]()  
3.  val ab2 = new ArrayBuffer[Int]  
4.   
5. //用+=在尾部添加元素  
6. ab += 2  
7.   
8. //在尾部添加多个元素  
9. ab += (1,2,3,4,5)  
10.   
11. //通过++=往数组缓冲后面追加集合  
12.  ab ++= Array(6,7,8,9)  
13.   
14. //使用trimEnd(n)移除尾部n个元素  
15. ab.trimEnd(3)  
16.   
17. //在下标3之前插入元素  
18. ab.insert(3, 33)  
19.   
20. //插入多个元素，第一个值为index，后面所有的值为要插入的值  
21. ab.insert(3,3,4,5,6)  
22.   
23. //移除某个位置的元素  
24. ab.remove(3)  
25.   
26. //移除从下标为n开始（包括n）的count个元素  
27. ab.remove(n, count)  

        有时候需要构造一个Array，但是不知道具体要存放多少元素，可以先构造ArrayBuffer,再调用toArray方法转化成Array，同样，对Array调用toBuffer方法可以转成ArrayBuffer.

注：在数组缓冲的尾部进行元素添加移除操作的效率很高，但是在任意位置插入或移除元素的效率并不太高效，因为涉及到数组元素的移动。

3.遍历数组

[java]  view plain  copy

1. //for循环遍历  
2. for(i <- 0 until ab.length){  
3.  print(ab(i) + ", ")  
4.  }  
5.   
6. //根据特定步长遍历数组  
7. for(i <- 0 until (ab.length, 2)){  
8.  print(ab(i) + ", ")  
9.  }  
10.   
11. //从数组的尾部开始向前遍历数组  
12. for(i <- (0 until ab.length).reverse){  
13.  print(ab(i) + ", ")  
14. }  
15.   
16. //类似于Java中的foreach遍历数组  
17.  for(elem <- ab){  
18.  print(elem + ", ")  
19. }  

4.数组转换

[java]  view plain  copy

1. //进行数组转换会生成一个新的数组，而不会修改原始数组  
2.  val change = for(elem <- ab) yield elem * 2  
3. for(elem <- change){  
4. print(elem + ", ")  
5.  }  
6.   
7. //添加一个守卫的数组转换  
8. val change = for(elem <- ab if elem%2 == 0) yield elem * 2  

5.数组操作常用算法

[java]  view plain  copy

1. //sum求和(数组与阿奴必须是数值型数据)  
2. println(change.sum)  
3.   
4. //min max 输出数组中最小和最大元素  
5. println(change.min)  
6. println(change.max)  
7.   
8. //使用sorted方法对数组或数组缓冲进行升序排序，这个过程不会修改原始数组  
9.  val sortArr = ab.sorted   
10.  for(elem <- sortArr)  
11.  print(elem + ", ")  
12.   
13. //使用比较函数sortWith进行排序  
14. val sortArr = ab.sortWith(_>_)  
15.   
16. //数组显示  
17.  println(sortArr.mkString("|"))  
18.  println(sortArr.mkString("startFlag","|","endFlag"))  

6.多维数组

[java]  view plain  copy

1. //构造一个2行3列的数组  
2. val arr = Array.ofDim[Int](2,3)  
3. println(arr.length)  
4. println(arr(0).length)  
5. arr(0)(0) = 20  
6. println(arr(0)(0))  
7.   
8. //创建长度不规则的数组  
9. val arr = new Array[Array[Int]](3)  
10.         
11.  for(i <- 0 until arr.length){  
12. arr(i) = new Array[Int](i + 2)  
13. }  
14.         
15. for(i <- 0 until arr.length){  
16. println(arr(i).length)  
17. }  

*****************以上内容摘自：《快学Scala》  [美]Cay S. Horstmann著   电子工业出版社****************