数组相关操作

Posted 2020-07-10 我是一个粉刷匠

知识点：

1.定长数组 Array

val nums = new Array[Int](10) //10个整数的数组，所有元素初始化为0
val a = new Array[String](10) //10个元素的字符串数组，所有元素初始化为null
val s= Array("Hello","World") //长度为2的Array(String) 类型是编译器推断出来的，已提供初始值就不需要new
s(0) = "Goodbye" //Array("Google","World") 使用()而不是[]来访问元素

Scala的Array以Java数组方式实现，例子中的s对应的是java.lang.String[]

2.变长数组：数组缓冲 ArrayBuffer

对于长度按需要变化的数组，Java-ArrayList || C++-vector || Scala-ArrayBuffer

  val b = ArrayBuffer[Int]() //或者 new ArrayBuffer[Int]
  b += 1 //ArrayBuffer(1) 用 += 在尾端添加元素
  b += (1,2,3,4,5) //ArrayBuffer(1,1,2,3,4,5) 在尾端添加多个元素，用括号包起来
  b ++= Array(6,7,8) //ArrayBuffer(1,1,2,3,4,5,6,7,8) 用  ++= 追加任何集合
  b.trimEnd(5) //ArrayBuffer(1,1,2,3)移除最后5个元素

在数组缓冲的尾部添加或移除元素是一个高效的操作。也可以在任意位置插入和删除元素，这样的操作不高效，引发位置后的元素都必须被平移。

  b.insert(2, 9) //ArrayBuffer(1,1,9,2,3)
  b.insert(2, 10,11) //ArrayBuffer(1,1,10,11,9,2,3)
  b.remove(2) //ArrayBuffer(1,1,11,9,2,3)
  b.remove(2,3) //ArrayBuffer(1,1,3)

有时候你需要构建一个Array，但不知道元素有多少个，可以先构建ArrayBuffer，再调用b.toArray();反过来，调用a.toBuffer可以将一个数组a转换为一个数组缓冲。

3.遍历数组和数组缓冲

for(i <- 0 until a.length) //变量i值从0取到a.length-1
    println(i + ": " + a(i))

for(i <- 区间) 会让i遍历区间所有值。

0 until (a.length, 2) 
  //Range(0,2,4,6,...) 每两个元素一跳
  
  (0 until a.length).reverse
  //Range(...,3,2,1,0) 逆序
  
  for(elem <- a)  //不使用数组下标时
    println(elem)

3.数组转换

val aa = Array(2,5,8,9)
  val result = for(elem <- aa) yield 2 * elem
  //result是Array(4,10,16,18)

for(…) yield 循环创建了一个类型与原始集合相同的新集合。结果包含yield之后的表达式，每次迭代对应一个。当你遍历一个集合时，你只想处理那些满足特定条件的元素，可以通过 守卫 ：for 中的 if 实现。

for(elem <- aa if elem % 2 == 0) yield 2 * elem
//另一种实现方法

a.filter(_ % 2 == 0).map(2 * _)
a.filter{ _ % 2 == 0} map { 2 * _}

4.常用方法

sum\max\sorted sum方法的数组元素类型必须是数值类型，sorted方法将数组或缓冲数组排序后返回经过排序的数组或缓冲数组，不修改原始版本。

显示数组或缓冲数组的内容，可以用mkString方法。

5.多维数组是通过数组的数组实现的

  val matrix = Array.ofDim[Double](3,4)
  matrix(row)(column) = 42
//创建不规则的数组  
  val triangle = new Array[Array[Int]](10)
  for(i <- 0 until triangle.length)
    triangle(i) = new Array[Int](i+1)

---

练习：（答案源链接）

1.编写一段代码，将a设置为一个n个随机整数的数组，要求随机数介于0（包含）和n(不包含)之间

class test{
  def main(args:Array[Int]){
    getArr(10).foreach(println)
  }
  
  def getArr(n:Int): Array[Int] = {
    val a = new Array[Int](n)
    val rand = new scala.util.Random()
    for(i <- a) yield rand.nextInt()
  }
  
}

2.编写一个循环，将整数数组中相邻的元素置换

class test{
  def main(args:Array[Int]){
    val arr = Array(1,2,3,4,5)
    revert(arr)
    arr.foreach(println)
  }
  
  def revert(a:Array[Int]) = {
    for(i <- 0 until (a.length - 1,2)){
      val t = a(i)
      a(i) = a(i+1)
      a(i+1) = t
    }
  }
}

3.重复前一个练习，不过这次生成一个新的值交换过的数组。用for/yield。

class test{
  def main(args:Array[Int]){
    val a = Array(1,2,3,4,5)
    val b = revertYield(a)
    b.foreach(println)
  }
  
  def revertYield(a:Array[Int]) = {
    for(i <- 0 until a.length) yield { 
      if( i < (a.length - 1) && i % 2 == 0){
        //偶数下标时，则交换下一个相邻的元素值
        val t = a(i)
        a(i) = a(i+1)
        a(i+1) = t
      }
      a(i) //因为生成新的数组，每一个元素都要返回
    }
  }
}

4.给定一个整数数组，产出一个新的数组，包含元数组中的所有正值，以原有顺序排列，之后的元素是所有零或负值，以原有顺序排列。

import scala.collection.mutable.ArrayBuffer

class test{
  def main(args:Array[Int]){
    val a = Array(1,-2,0,4,5,0,-3)
    val b = reCombine(a)
    b.foreach(println)
  }
  
  def reCombine(a:Array[Int]) = {
    val buf = new ArrayBuffer[Int]();
    buf ++= (for( i <- a if(i > 0)) yield i)
    buf ++= (for( i <- a if(i == 0 || i < 0)) yield i)
    buf.toArray
  }
}

5.如何计算Array[Double]的平均值？

class test{
  def main(args:Array[Int]){
    val a = Array(1.0,5.6,0.0,-3.0)
    val b = average(a)
    println(b)
  }
  
  def average(a:Array[Double]) = {
    var t = 0.0
    for(i <- a){
      t += i
    }
    t/a.length
  }
  
  def ave(a:Array[Double]) = {
     a.sum / a.length
  }
}

6.如何重新组织Array[Int]的元素将它们反序排列？对于ArrayBuffer[Int]你又会怎么做呢？

import scala.collection.mutable.ArrayBuffer

object Hello {       
  def main(args: Array[String]) {          
  val a = Array(1,2,3,4,5)
    reverseArray(a)
    println("array reverse:")
    a.foreach(println)
    val b = a.reverse //将a的值逆序回去了
     b.foreach(println)
    
    println("bufferArray reverse:")
    val c = ArrayBuffer(6,7,8,9,0);
    val d = c.reverse        
    d.foreach(println)
  }     
  def reverseArray(a:Array[Int]) = {
    for( i <- 0 until (a.length / 2)){
      val t = a(i)
      a(i) = a(a.length-1-i)
      a(a.length-1-i)=t
    }
  }
}

7.编写一段代码，产出数组中的所有值，去掉重复项

import scala.collection.mutable.ArrayBuffer

object Hello {       
  def main(args: Array[String]) {          
    val ab = new ArrayBuffer[Int]()
    val c = new ArrayBuffer[Int]()
    println("Input the array line,separated by a space,ended with an enter.")
    val input = readLine().toString().split(‘ ‘);
    for(i <- input){
      ab += i.toInt
    }
//    ab.foreach(println)
    c ++= ab.distinct
    c.foreach(println) 
  }     
}

8.重新编写3.4节结尾的示例。收集负值元素的下标，反序，去掉最后一个下标，然后对每一个下标调用a.remove(i)。比较这样做的效率和3.4节中另外两种方法的效率

import scala.collection.mutable.ArrayBuffer

object Hello {       
  def main(args: Array[String]) {          
    val a = ArrayBuffer(1,2,4,-2,0,-1,-4,8)
    deleteNeg(a)
    a.foreach(println) 
  }  
  def deleteNeg(a:ArrayBuffer[Int]) = {
    val indexes = for(i <- 0 until a.length if a(i) < 0 ) yield  i 
    //不能val b = indexex.reverse.trimEnd(1) reverse后，它是一个Seq序列。
    //value trimEnd is not a member of scala.collection.immutable.IndexedSeq[Int]
    val b = new ArrayBuffer[Int]()
    b ++= indexes.reverse
    b.trimEnd(1)
    //remove是ArrayBuffer的函数,如果传入的是Array，则需要调用toBuffer
    for(i <- b){
      a.remove(i)
    }
  }
}

9.创建一个由java.util.TimeZone.getAvailableIDs返回的时区集合，判断条件是它们在美洲，去掉”America/“前缀并排序。

import scala.collection.mutable.ArrayBuffer
import scala.collection.JavaConversions.asScalaBuffer

object Hello
{
  def main(args: Array[String])  = {
    var c = timeZoneName()
    c.foreach(println)
  }        
  
  def timeZoneName() = {
    val arr = java.util.TimeZone.getAvailableIDs();
    val tmp = (for (i <- arr if i.startsWith("America/")) yield {
      i.drop("America/".length)
    })
    scala.util.Sorting.quickSort(tmp)
    tmp
  }
}

10.引入java.awt.datatransfer._并构建一个类型为SystemFlavorMap类型的对象，然后以DataFlavor.imageFlavor为参数调用getNativesForFlavor方法，以Scala缓冲保存返回值。

import scala.collection.JavaConversions.asScalaBuffer
import scala.collection.mutable.Buffer
import java.awt.datatransfer._

object Hello
{
  def main(args: Array[String])  = {
     val flavors = SystemFlavorMap.getDefaultFlavorMap().asInstanceOf[SystemFlavorMap]
     val buf : Buffer[String] = flavors.getNativesForFlavor(DataFlavor.imageFlavor);
     buf.foreach(println);
  }
}