Scala学习三——数组相关操作

一.若长度固定则使用Array，若长度可能有变化则使用ArrayBuffer

　　固定长度数组：

　　　　如val nums=new Array[Int](10) //10个整型数组，所有元素初始化为0;

　　　　val a=new Array[String](10) //10个元素的字符串数组，所有元素为null

　　变长数组：

　　　　ArrayBuffer（相当于Java中的ArrayList）

import scala.collection.mutable.ArrayBuffer
val b=ArrayBuffer[Int]()
//或者new ArrayBuffer[Int]
//一个空的数组缓冲，准备存放整数
b+=1
//ArrayBuffer(1)
//用+在尾端添加元素
b+=(1,2,3,5)
//ArrayBuffer(1,1,2,3,5)
//在尾端添加多个元素，以括号包起来
b++=Array(8,13,21)
//ArrayBuffer(1,1,2,3,5,8,13,21)
//可以使用++=操作符追加任何集合
b.trimEnd(5)
//ArrayBuffer(1,1,2)
//移除最后5个元素

//可以在任意位置插入和移除元素，但是不高效
b.insert(2,6)
//ArrayBuffer(1,1,6,2)
//在下标2之前插入
b.insert(2,7,8,9)
//ArrayBuffer(11,7,8,9,6,2)
//可以插入任意多的元素
b.remove(2)
//ArrayBuffer(1,1,8,9,6,2)
b.remove(2,3)
//ArrayBuffer(1,1,2)
//第二个参数的含义是移除多少个元素
b.toArray()//数组缓冲转换为固定长度数组
a.toBuffer()//固定长度转换为数组缓冲

二.提供初始值时不要使用new

　　val s=Array("Hello","World")长度为2的Array(String),已经提供初始值就不需要new

三.用()来访问元素

　　注意使用()来访问元素，而不是[]

四.用for(elem<-arr)来遍历元素

　　for(i<- 0 until a.length)...:util是RichInt类的方法，返回所有小于（不包括）上限的数字（o until 10实际调用的是0.until(10)）。

　　每两个元素一跳（0 util (a.length,2)）;

　　从数组尾端开始：(0 until a.length).reverse;

　　如果在循环体中不需要用到数组下标，直接访问元素for(elem<-a)

五.用for(elem<-arr if...)...yiels...来将原数组转型为新数组

　　例子：

　　　　

val a=Array(2,3,5,7,11)
val result= for (elem-<a) yield 2*elem
//result为Array(4,6,10,14,22)

　　注：for(...)yield创建的是一个类型与原始集合相同的新集合;

　　　　常用算法，Array(1,2,3).sum/min/max,Array(22,4,5,1).sorted(_<_)[从小到大]，Array(22,4,5,1).sorted(_>_)[从大到小]　　　　

六.Scala数组和Java数组可以互操作;用ArrayBuffer，使用scala.collection.JavaConversions中的转换函数

　　多维数组创建：

　　　　val matrix=Array.ofDim[Double](3,5)//三行四列

　　使用scala.collection.JavaConversions转换案例：

　　

七.练习

 　　

　　

 　　1.

 import scala.util.Random
 def main (args: Array[String]) {
    createArr(10).foreach(println)
}
 def createArr(n:Int):Array[Int]={
        val arr=new Array[Int](n)
        val rand=new Random()
        for(ele <- arr)
        yield rand.nextInt(n)
    }

　　2.

  def main(args: Array[String]) = {
    val arr=Array(1,2,3,4,5)
    swap(arr)
    arr.foreach(print)

  }
  def swap(arr:Array[Int]):Unit={
    for(i<-0 until(arr.length-1,2)){
      val tmp=arr(i)
      arr(i)=arr(i+1)
      arr(i+1)=tmp
    }

　　3.

def main(args: Array[String]) = {
    val arr1 = Array(1, 2, 3, 4, 5)
    val arr2 = swapByYield(arr1)
    arr2.foreach(print)
  }

  def swapByYield(arrs: Array[Int]) = {
    for (i <- 0 until arrs.length) yield {
      if (i < arrs.length - 1 && i % 2 == 0) {
        val tmp = arrs(i)
        arrs(i) = arrs(i + 1)
        arrs(i + 1) = tmp
      }
    }
    arrs
  }

　　4.

def main(args: Array[String]) = {
    val a = Array(1, -2, 0, -3, 1, 2)
    val b = sigArr(a)
    b.foreach(println)
  }

  def sigArr(arr: Array[Int]) = {
    val buff = new ArrayBuffer[Int]()
    buff ++= (for (i <- arr if i > 0) yield i)
    buff ++= (for (i <- arr if i == 0) yield i)
    buff ++= (for (i <- arr if i < 0) yield i)
    buff.toArray
  }

　　5.

 def main(args: Array[String]) = {
    val a = Array[Double](1, 4, 2, 10, 3, -1, -3)
    val b = Avgarr(a)
    println(b)
  }

  def Avgarr(arr: Array[Double]) = {
    arr.sum / arr.length
  }

　　6.

  def main(args: Array[String]): Unit = {
    val arr1 = Array(5, 4, 3, 2, 1)
    reverseArray(arr1)
    arr1.foreach(print)
    print("
")
    val arr2 = ArrayBuffer(5, 4, 3, 2, 1)
    reverseArrayBuffer(arr2).foreach(print)
  }

  /**
   * Array反序排列（注：Array长度不可变）
   *
   * @param arr
   */
  def reverseArray(arr: Array[Int]) = {
    for (i <- 0 until arr.length / 2) {
      val tmp = arr(i)
      arr(i) = arr(arr.length - 1 - i)
      arr(arr.length - 1 - i) = tmp
    }
  }

  def reverseArrayBuffer(arr: ArrayBuffer[Int]) = {
    val reverseArr = ArrayBuffer[Int]()
    reverseArr++= arr.reverse
    reverseArr
  } 

　　7.

def main(args: Array[String]): Unit = {
    val arr1=ArrayBuffer(1,2,3,3,4,4,5,1,6,7)
    val arr2=ArrayBuffer[Int]()
    arr2++=arr1.distinct
    arr2.foreach(print)
  }

　　8.

def main(args: Array[String]): Unit = {
    val arr=Array(-1,2,3,-4,-5)
    val arr2=proResult(arr)
    arr2.foreach(print)
  }
  def proResult(arr:Array[Int])={
    val indexs=for(i <- 0 until arr.length if arr(i)<0) yield i
    val afterDropIndexs=indexs.reverse.dropRight(1)
    val tmp=arr.toBuffer
    for(i<-afterDropIndexs) tmp.remove(i)
    tmp
  }

　　9.

 def main(args: Array[String]): Unit = {
    val arr=timeTone
    arr.foreach(print)
  }
  def timeTone={
    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.

def main(args: Array[String]): Unit = {
    val flavors = SystemFlavorMap.getDefaultFlavorMap().asInstanceOf[SystemFlavorMap]
    println(flavors.getClass.getSimpleName)
  }