[关闭]
@Arslan6and6 2016-08-29T02:36:39.000000Z 字数 4839 阅读 1290

scala学习 第三章 数组相关操作

scala学习

3.1 定长数组

  1. 字符串数组，元素初始化为null
  2. scala> val a = new Array[String](10)
  3. a: Array[String] = Array(null, null, null, null, null, null, null, null, null, null)
  5. 整数数组，元素初始化为0
  6. scala> val b = new Array[Int](10)
  7. b: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  9. 不需要 new
  10. scala> val s = Array("king", "mini")
  11. s: Array[String] = Array(king, mini)
  12. scala> s(0) = "aoao"

3.2变长数组

scala的变长数组数据结构为 ArrayBuffer

  1. scala> val b = ArrayBuffer[Int]()
  2. b: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()
  3. 或者是：
  4. scala> val c = new ArrayBuffer[Int]
  5. c: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()
  7. 用 += 在变长数组尾部加上元素
  8. scala> b += 1
  9. res4: b.type = ArrayBuffer(1)
  11. scala> b += (2, 4, 6)
  12. res6: b.type = ArrayBuffer(1, 2, 4, 6)
  14. 还可以用 -= 删除元素
  15. scala> b -= (2)
  16. res7: b.type = ArrayBuffer(1, 4, 6)
  18. 用 ++= 在尾部追加任何数组
  19. scala> b ++= Array(3,5,7)
  20. res9: b.type = ArrayBuffer(1, 4, 6, 3, 5, 7)
  22. 用 --=也可以删除数组
  23. scala> b --= Array(3,7)
  24. res10: b.type = ArrayBuffer(1, 4, 6, 5)
  26. 用 trimEnd(整数) 删除最后几个元素 高效操作！
  27. scala> b.trimEnd(2)
  28. scala> b += 0
  29. res12: b.type = ArrayBuffer(1, 4, 0)
  31. 插入元素，后面的元素被平移，效率不高！ insert(下标位置， 元素*)
  32. scala> b.insert(2,3)
  33. res16: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 4, 3, 0)
  35. 可以插入多个元素 
  36. scala> b.insert(2, 10, 17, 23)
  37. scala> b
  38. res19: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 4, 10, 17, 23, 3, 0)
  40. 用 remove(下标位置) 删除元素 或是 remove(下标位置, 删除元素个数)
  41. scala> b.remove(3)
  42. res20: Int = 17
  43. scala> b
  44. res21: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 4, 10, 23, 3, 0)
  45. scala> b.remove(3,2)
  46. scala> b
  47. res23: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 4, 10, 0)

需要构造一个定长数组Array，又不知道长度。可以先构造一个数组缓冲ArrayBuffer，然后用toArray将其转化为 Array b.toArray
相反 用 a.toBuffer可以将定长数组转化为一个缓冲数组

3.3遍历数组和数组缓冲

  1. scala> val a = Array(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
  2. a: Array[Int] = Array(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
  4. scala> for(i <- 0 until a.length){
  5.      | print(i + ":" + a(i) + "\t")
  6.      | }
  7. 0:10    1:20    2:30    3:40    4:50    5:60    6:70    7:80    8:90    9:100   
  9. 可以n个一跳
  10. scala> for(i <- 0 until (a.length, 2))
  11.      | print(i + ":" + a(i) + "\t")
  12. 0:10    2:30    4:50    6:70    8:90    
  13. scala> for(i <- 0 until (a.length, 3))
  14.      | print(i + ":" + a(i) + "\t")
  15. 0:10    3:40    6:70    9:100
  17. 从尾端遍历，即翻转
  18. scala> for(i <- 0 until a.length reverse){
  19.      | print(i + ":" + a(i) + "\t")}
  20. warning: there were 1 feature warning(s); re-run with -feature for details
  21. 9:100   8:90    7:80    6:70    5:60    4:50    3:40    2:30    1:20    0:10    
  23. 还可以不用下标，直接遍历元素
  24. scala> for(elem <- a) print(elem + "\t")
  25. 10  20  30  40  50  60  70  80  90  100

3.4数组转换

  1. for推导式 ： yield 后得到一个新的定长数组或是新的数组缓冲 ，返回 yield 后表达式的值
  2. scala> for(elem <- a) yield 2*elem
  3. res38: Array[Int] = Array(20, 40, 60, 80, 100, 120, 140, 160, 180, 200)
  5. scala> val b = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
  6. b: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
  9. scala> for(elem <- b ) yield 2*elem
  10. res42: Array[Int] = Array(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
  11. 可以用守卫 if 条件判断过滤复合if条件的元素再生成新的数组进行操作
  12. scala> for(elem <- b if elem %2==0) yield 2*elem
  13. res41: Array[Int] = Array(4, 8, 12, 16, 20)
  15. 另一种操作途径
  16. scala> b.filter( _ % 2==0).map(2 * _ )
  17. res44: Array[Int] = Array(4, 8, 12, 16, 20)
  18. 甚至
  19. scala> b.filter( _ % 2==0)map(2 * _ )
  20. res45: Array[Int] = Array(4, 8, 12, 16, 20)

3.5常用算法

  1. sum
  2. scala> Array(1, 3, 5).sum
  3. res47: Int = 9
  5. max
  6. scala> ArrayBuffer("Mary", "had", "a", "little", "lamb").max
  7. res53: String = little
  8. max
  9. scala> ArrayBuffer("Mary", "had", "a", "Little", "lamb").max
  10. res54: String = lamb
  11. max
  12. scala> ArrayBuffer("mary", "had", "a", "Little", "lamb").max
  13. res55: String = mary
  15. sort排序 Array 和ArrayBuffer 都可以用
  16. scala> val a = Array (1, 9, 21, 30, 5)
  17. a: Array[Int] = Array(1, 9, 21, 30, 5)
  18.      sorted 按升序排序 
  19.         scala> val s = a.sorted
  20.         s: Array[Int] = Array(1, 5, 9, 21, 30)
  21.     sortWith 指定顺序排序
  22.         scala> val sw = a.sortWith( _ > _)
  23.         sw: Array[Int] = Array(30, 21, 9, 5, 1)
  24.         scala> val sw = a.sortWith( _ < _)
  25.         sw: Array[Int] = Array(1, 5, 9, 21, 30)
  26.     注意：排序后原定长数组或数组缓冲不变，会生成排序后的新数组或定长数或数组缓冲    
  27.         scala> a
  28.         res56: Array[Int] = Array(1, 9, 21, 30, 5)
  29.         scala> b
  30.         res57: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 9, 21, 30, 5)
  32.     可以对数组本身排序，而不能对数组缓冲排序
  33.         scala> scala.util.Sorting.quickSort(a)
  34.         scala> a
  35.         res60: Array[Int] = Array(1, 5, 9, 21, 30)
  37.         scala> scala.util.Sorting.quickSort(b)
  38.         <console>:10: error: overloaded method value quickSort with alternatives:
  39.           (a: Array[Float])Unit <and>
  40.           (a: Array[Int])Unit <and>
  41.           [K](a: Array[K])(implicit evidence$1: scala.math.Ordering[K])Unit <and>
  42.           (a: Array[Double])Unit
  43.          cannot be applied to (scala.collection.mutable.ArrayBuffer[Int])
  44.                       scala.util.Sorting.quickSort(b)
  45.     显示数组或数组缓冲的内容 用 mkString
  46.         不分割显示内容
  47.         scala> a.mkString
  48.         res72: String = 1592130
  49.         指定分隔符显示内容
  50.         scala> a.mkString("|")
  51.         res71: String = 1|5|9|21|30
  52.                 scala> a.mkString(" | ")
  53.         res70: String = 1 | 5 | 9 | 21 | 30
  54.         指定分割符及后缀显示内容
  55.         scala> a.mkString("<", "|" , ">")
  56.         res69: String = <1|5|9|21|30>
  58.         和 toString 相比
  59.         scala> a.toString
  60.         res74: String = [I@c800f96
  61.         scala> b.toString
  62.         res75: String = ArrayBuffer(1, 9, 21, 30, 5)

3.6解读Scaladoc

image_1aqgimm8e1dfss2788114qi1gif9.png-229.4kB
image_1aqgirhvp1l1p85d14lp1ajr2pnm.png-53.6kB

  1.     count
  2.         scala> val c = Array(-1, 2, 3, -4, 5)
  3.         c: Array[Int] = Array(-1, 2, 3, -4, 5)
  4.         scala> c.count(_>0)
  5.         res79: Int = 3
  6.         scala> c.count(_<0)
  7.         res80: Int = 2
  8.         scala> c.count(_>2)
  9.         res81: Int = 2
  10.     +=
  11.         scala> b+=51
  12.         res83: b.type = ArrayBuffer(1, 9, 21, 30, 5, 51)
  13.         scala> b+=51-=9
  14.         res84: b.type = ArrayBuffer(1, 21, 30, 5, 51, 51)

3.7 多维数组

和Java一样，多维数组是通过数组的数组来实现的。举例来说，Double的二维数组类型为Array[Array[Double]]。要构造这样一个数组，可以用ofDim方法：

  1. scala> val matrix = Array.ofDim[Double](3, 4)
  2. matrix: Array[Array[Double]] = Array(Array(0.0, 0.0, 0.0, 0.0), Array(0.0, 0.0, 0.0, 0.0), Array(0.0, 0.0, 0.0, 0.0))
  4. 要访问其中的元素，使用两对圆括号：matrix(从0开始行标)(从0开始列标)
  5. scala> matrix(2)(3) = 42 
  6. scala> matrix
  7. res87: Array[Array[Double]] = Array(Array(0.0, 0.0, 0.0, 0.0), Array(0.0, 0.0, 0.0, 0.0), Array(0.0, 0.0, 0.0, 42.0))
  8. 可以创建不规则的数组，每一行的长度各不相同
  9. val triangle = new Array[Array[Int]](10)
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注