《快学Scala》第三章练习题答案+概述

第三章

1、内容概述

• 3.1 定长数组

  //定义
  val nums = new Array[Int](10)  //长度为10，值为0
  val strs = Array("one" , "two")    
  //获取
  nums(0)    
  

• 3.2 变长数组：数组缓冲区

  import scala.collection.mutable.ArrayBuffer
  //定义
  var x = ArrayBuffer[Int]() or new ArrayBuffer[Int]
  //添加数据 
  b += 1
  b += (1,5,9,6)     //最加多个元素
  b ++= Array(2,6,8) //追加集合
  b.trimEnd(2)       //移除后两个
  b.trimStart(2)	   //不解释
  b.insert(2,6)	   //下标为二的位置上插入6
  b.insert(2,6,8,9)  //下标为二的位置上插入6,8,9
  b.remove(2)		   //移除下标为二的元素
  b.remove(2,3)      //从下标2开始移除3个元素
  相互转换 缓冲区.toArray , 数组.toBuffer    
  

  注意：在尾端增删都是高效的，在其他位置插入或移除不高效（位置之后的元素必须平移）

• 3.3 遍历数组和数组缓冲区

  for(i <- 0 until a.length) println("下标" + i +"值："+ a(i))
  //until 返回所有小于（但不包括上限的数字）遍历数值的利器
  for(i <- (0 until a.length).reverse) println("下标" + i +"值："+ a(i))    
  

• 3.4 数组转换

  val x = Array(2,3,5,8,9)
  val res = for(y <- x) yield 2 * y //res结果是x中所有元素都翻倍    
  

• 3.5 常用算法

  var x = Array(2,3,5,8,9)
  x.sum //和
  x.min
  x = x.sorted
  x = x.sorted.reverse
  
  x.mkString(",") 2,3,5,8,9
  x.mkString("<"，"," ，">") <2,3,5,8,9>
  
  

• 3.6 解读Scaladoc

• 3.7 多维数组

  //定义
  val x = Array.ofDim[Double](3,4)
  //获取
   x(row)(column)   
  

• 3.8 java互相操作

  /**
      Scala数组运行时也是编译成calss文件运行在JVM中，当然Scala数组使用Java数组实现的，可以在Java和Scala中来回传递
     
  */
  // Scala到Java的转换
  import scala.collection.mutable.ArrayBuffer
  val com = Arrayuffer("one","two","three")
  val pb = new ProcessBuilder(command)    
  //java到Scala的转换
  import scala.collection.JavaConversions.asScalaBuffer
  import scala.collection.mutable.Buffer
  val cmd: Buffer[String] = pb.command()
      
  
  

2、习题

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

  def problem_1(n: Int): Array[Int] = {
      val random: Random = new Random()
      val randomArr: Array[Int] = new Array[Int](n)
      for (i <- 0 until n) randomArr(i) = random.nextInt(n)
      randomArr
  }
  

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

  def problem_2(arr: Array[Int]): Array[Int] = {
      for (i <- Range(0, arr.length / 2 + 1, 2)) {
        val temp = arr(i)
        arr(i) = arr(i + 1)
        arr(i + 1) = temp
      }
      arr
    }
  

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

  def problem_3(arr: Array[Int]): Array[Int] = {
      val newArr = for (i <- Range(0, arr.length)) yield {
        if (arr.length % 2 == 1 && i == arr.length - 1) arr(i) else if (i % 2 == 0) arr(i + 1) else arr(i - 1)
      }
      newArr.toArray
    }
  

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

  def problem_4(arr: Array[Int]): Array[Int] = {
      var newArr: Array[Int] = for (elem <- arr if elem > 0) yield elem
      val newArr1: Array[Int] = for (elem <- arr if elem <= 0) yield elem
      newArr ++= newArr1
      newArr
    }
  
  

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

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

• 3.6 如何组织Array[Int]使他们反序排列，如果是ArrayBuffer呢？

  def problem () = {
      //方案一
      val x = Array[Int](1, 2, 3)
      val y = new Array[Int](x.length)
      for (i <- 0 until x.length) {
        y(x.length - 1 - i) = x(i)
      }
  	//方案二
      val x = ArrayBuffer(1, 2, 3)
      val y = x.reverse
  }
  
  

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

  def problem_7(arr: Array[Int]): Array[Int] = {
      arr.distinct
  }
  

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

  def problem_8(): Unit ={
      //定义数值缓冲区
      val buff = ArrayBuffer[Int](-10, 2, 5, -2, 8, -3, 6)
      //收集负值的索引并反转（为什么要反转，因为：从前面每减去一个值，缓冲区的值的索引就会往前移动，导致索引越界）
      val fIndex = (for (x <- 0 until buff.length if (buff(x) < 0)) yield x).reverse
      //移除负值
      for (x <- 0 until fIndex.length - 1) buff.remove(fIndex(x))
      //查看结果
      for (x <- buff) print(x + "   ")
    }
  

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

  def problem_9(): Unit = {
      var timezoneArr: Array[String] = java.util.TimeZone.getAvailableIDs()
      var filterArr = for (elem <- timezoneArr if !elem.startsWith("America/")) yield elem
      var sortedArr = filterArr.sorted
      for (elem <- sortedArr) println(elem)
    }
  

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

  def problem_10(): Unit = {
      val flavors = SystemFlavorMap.getDefaultFlavorMap.asInstanceOf[SystemFlavorMap]
      val buffer: Buffer[String] = flavors.getNativesForFlavor(DataFlavor.imageFlavor)
  }