《快学Scala》习题详解 第3章 数组

1 编写一段代码，将a设置为n个随机整数的数组，要求随机数位于[0,n)之间

    //创建数组，[Int]显示指定数组的类型，new创建长为10的数组
    //如果不使用new，创建只有一个元素10，类型为Int的数组
    val arr = new Array[Int](10)
    for (i <- 0 until arr.length) arr(i) = util.Random.nextInt(10)
    //加强for只能用来遍历数组，不能用来修改元素
    for (elem <- arr) println(elem)

2 编写一个程序，将整数数组中相邻的元素置换；例如，Array(1,2,3,4,5)置换后变为Array(2,1,4,3,5)

    val arr = Array(1, 2, 3, 4, 5)
    //从索引1开始（防止数组越界），每隔2位迭代一次，
    for (i <- 1 until (arr.length, 2)) {
      var tmp = arr(i - 1)
      arr(i - 1) = arr(i)
      arr(i) = tmp
    }
    for (elem <- arr) println(elem)

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

    val arr = Array(1, 2, 3, 4, 5)
    //为索引为偶时，输出下一个元素，为奇，输出上一元素
    val arr2 = for (i <- 0 until arr.length) yield {
      if (i % 2 == 0) {
        // 防止数组越界，长度为奇数，最后一个元素仍取自身
        if (i < arr.length - 1) arr(i + 1)
        else if (i == arr.length - 1) arr(i)
      } else if (i % 2 != 0) arr(i - 1)
    }
    for (elem <- arr2) println(elem)

4 给定一个整数数组，产生一个新的数组，包含原数组中的所有正值，按原有顺序排序
零或者负值排在正数之后，按原有顺序排序

//创建变数组
    val arr = ArrayBuffer(1, 2, -3, 3, -4, 3, 0, -1, -3, 5, 5)
    //先取出>0的数
    val arr2 = for (elem <- arr if (elem > 0)) yield elem
    //其余数字，追加到新数组之后
    for (elem <- arr if (elem <= 0)) arr2 += elem

    for(elem <- arr2) println(elem)

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

  val arr = new Array[Double](10)
    for (i <- 0 to 9) arr(i) = util.Random.nextDouble()
    println("average:" + arr.sum / arr.length)

6 将Array[Int]中的元素进行反序排列？ArrayBuffer[Int]同样反序

    val arr = Array[Int](13, 5, 0, 1)
    val arr2 = ArrayBuffer[Int](13, 5, 0, 1)
    //获取相反数组
    val arr3 = arr.reverse
    val arr4 = arr2.reverse
    //将相反数组依次赋值给原数组
    for (i <- 0 until arr.length) arr(i) = arr3(i)
    for (i <- 0 until arr2.length) arr2(i) = arr4(i)

7 写一个程序，输出数组中的所有值，去掉重复项

    val arr = ArrayBuffer[Int](13, 5, 0, 11, 25, 1, 0, 0, 2, 5)

    val arr2 = arr.distinct

    for (elem <- arr2) println(elem)

8 重新编写3.4节结尾的标示便。收集负值元素的下标，反序，去掉最后一个下标，然后对每一个下标调用a.remove(i)，并比较效率

    //最原始方法，找到了逐个删除
    def f1() {
      val arr = ArrayBuffer[Int](0, 1, -2, -1, 11, 25, -20, 2, 5, -3)
      var flag = true
      var i = 0
      while (i < arr.length) { //方法改进：arr长度会动态变化
        if (arr(i) >= 0) i += 1
        else if (arr(i) < 0 && flag) { flag = false; i += 1 }
        else arr.remove(i) //删除元素后，后面的元素向前位移，继续判断
      }
    }
    //改进版，进行元素替换 ，整体删除尾部元素
    def f2() {
      val arr = ArrayBuffer[Int](0, 1, -2, -1, 11, 25, -20, 2, 5, -3)
      var flag = false
      val index = for (i <- 0 until arr.length if !flag || arr(i) >= 0) yield {
        if (arr(i) < 0) flag = true
        i
      }
      for (i <- 0 until index.length) arr(i) = arr(index(i))
      arr.trimEnd(arr.length - index.length)
    }
    // 题目要求的方法，倒序删除，位移相当要少，而且不用考虑位移带来的索引变化
    def f3() {
      val arr = ArrayBuffer[Int](0, 1, -2, -1, 11, 25, -20, 2, 5, -3)
      var flag = false
      val index = for (i <- 0 until arr.length if arr(i) < 0) yield i
      val index2 = index.reverse.dropRight(1)
      for (elem <- index2) arr.remove(elem)
    }
    //根据系统的时间差，判断执行的效率
    val v1 = System.currentTimeMillis()
    for (i <- 1 to 10000) f1()
    val v2 = System.currentTimeMillis()
    for (i <- 1 to 10000) f2()
    val v3 = System.currentTimeMillis()
    for (i <- 1 to 10000) f3()
    val v4 = System.currentTimeMillis()
    println(v2 - v1)
    println(v3 - v2)
    println(v4 - v3)

输出结果为：85,32,46
可知f1效率最低，f2整体删除的效率要高很多，f3倒序删除时，效率了提高了很多

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

  val arr = java.util.TimeZone.getAvailableIDs
    val arr2 = arr.filter { _.startsWith("America") } map (_.drop(8))
    //本身就是排好序的，为了好玩，改倒序了
    arr2.sorted.reverse.map { println }

10 引入java.awt.datatransfer._并构建一个类型为SystemFlavorMap的对象
然后以DataFlavor.imageFlavor为参数调用getNativesForFlavor的方法，以Scala缓冲保留返回值
为什么要用这样一个晦涩难懂的类？因为java标准类库中很难得到试用java.util.List的代码

package day
import collection.mutable.ArrayBuffer
import java.awt.datatransfer._
import collection.JavaConversions.asScalaBuffer
//导入后，进行隐式转换
import scala.collection.mutable.Buffer
object get {
  def main(args: Array[String]): Unit = {
    val f = SystemFlavorMap.getDefaultFlavorMap().asInstanceOf[SystemFlavorMap]
    val buffer: Buffer[String] = f.getNativesForFlavor(DataFlavor.imageFlavor)
    println(buffer.getClass) //class scala.collection.convert.Wrappers$JListWrapper
  }
}