Scala学习(七)练习

控制结构和函数

1. 编写示例程序，展示为什么

package com.horstmann.impatient

不同于

package com

package horstmann

package impatient

描述: 区别是后者的上层包也可见，而串写的只有当前包范围可见

程序代码: b.scala

package com{

package horstmann{

object A{

def hi=println("I am A")

}

package impatient{

object B extends App{

def hi=A.hi

hi

}

}

}

}

运行结果:


程序代码: c.scala


运行结果:


编译时找不到A,说明串联声明时不包含上级声明

程序代码: d.scala


2. 编写一段让你的Scala朋友们感到困惑的代码，使用一个不在顶部的com包

程序代码: a1.scala


程序代码: a2.scala


先编译a2.scala再编译a1.scala运行结果如下:


先编译a1.scala再编译a1.scala运行结果如下:


3. 编写一个包random，加入函数nextlnt(): Int、nextDouble(): Double和setSeed(seed : Int): Unit。生成随机数的算法采用线性同余生成器：

后值 =（前值×a+b）mod 2n

其中，a = 1664525，b =1013904223，n =32，前值的初始值为seed。

程序代码:

package random{

object Random {

private val a = 1664525

private val b = 1013904223

private val n = 32

private var seed=0

private var follow:BigInt=0

private var previous:BigInt=0

def nextInt():Int={

follow=(previous*a+b)%BigInt(math.pow(2, n).toLong)

previous=follow

(follow%Int.MaxValue).intValue()

}

def nextDouble():Double={

nextInt.toDouble

}

def setSeed(newSeed:Int){

seed=newSeed

previous=seed

}

}

}

object Test extends App{

var r =random.Random

r.setSeed(args(0).toInt)

for(i <- 1 to 10) println(r.nextInt())

for(i <- 1 to 10) println(r.nextDouble())

}

运行结果:


4. 在你看来，Scala的设计者为什么要提供package object法而不是简单地让你将函数和变量添加到包中呢

直接加函数和变量声明到包中，比如com.a.b.c。这样就跟c下面的的class或者object差 了一个层级。他们实际上是c下面的所有类的共同的上级定义。这样一来就没有了封装性。 而实现上来说估计也比较麻烦。

5. private[com] def giveRaise(rate: Double)的含义是什么，有用吗

该函数在com包下可见，可以扩大函数的可见范围

6. 编写一段程序，将Java哈希映射中的所有元素拷贝到Scala哈希映射。用引入语句重命名这两个类

程序代码:

import java.util.{HashMap=>JHashMap}

import scala.collection.mutable.HashMap

object JavaMap {

def transMapValues(javaMap:JHashMap[Any,Any]):HashMap[Any,Any]={

val result=new HashMap[Any,Any]

for(k <- javaMap.keySet().toArray()){

result+=k->javaMap.get(k)

}

result

}

def main(args: Array[String]): Unit = {

val jmap:JHashMap[Any,Any]=new JHashMap[Any,Any]

var smap=new HashMap[Any,Any]

for(i <- 1 to 9)

jmap.put(i,"JavaMap"+i)

smap=transMapValues(jmap)

smap.foreach(println)

}

}

运行结果:


7. 在前一个练习中，将所有引入语句移动到尽可能小的作用域里

描述：import可以放到任何区域，直接放到对象结构体当中，也没有问题

程序代码:

object JavaMap {

import java.util.{HashMap=>JHashMap}

import scala.collection.mutable.HashMap

def transMapValues(javaMap:JHashMap[Any,Any]):HashMap[Any,Any]={

val result=new HashMap[Any,Any]

for(k <- javaMap.keySet().toArray()){

result+=k->javaMap.get(k)

}

result

}

def main(args: Array[String]): Unit = {

val jmap:JHashMap[Any,Any]=new JHashMap[Any,Any]

var smap=new HashMap[Any,Any]

for(i <- 1 to 10)

jmap.put(i,"JavaMap"+i)

smap=transMapValues(jmap)

smap.foreach(println)

}

}

8. 以下代码的作用是什么，这是个好主意吗

import java._

import javax._

引入了java和javax的所有内容。因为Scala会自动覆盖java的同名类，不会有冲突。即使这样，引入过多的包，也会让人很迷惑。况且scala编译就已经够慢的了

9. 编写一段程序，引人java.lang.System类，从user.name系统属性读取用户名，从Console对象读取一个密码，如果密码不是" secret"，则在标准错误流中打印一个消息；如果密码是" secret"，则在标准输出流中打印一个问候消息。不要使用任其他引入，也不要使用任何限定词，即带句点的那种

程序代码:

object Sys{

import scala.io.StdIn

import java.lang.System._

def main(args: Array[String]): Unit = {

val pass=StdIn.readLine()

if(pass=="secret"){

val name=getProperty("user.name")

out.printf("Greetings,%s!",name)

}else{

err.println("error")

}

}

}

运行结果:


10. 除了StringBuilder，还有那些java.lang的成员是被scala包覆盖的

Console,Math, 还有基本类型包装对象，Long,Double,Char,Short等等都被Scala覆盖了。