Scala学习(七)练习


控制结构和函数

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

package com.horstmann.impatient

不同于

package com

package horstmann

package impatient

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

程序代码: b.scala

  1. package com{
  2.   package horstmann{
  3.     object A{
  4.       def hi=println("I am A")
  5.     }
  6.     package impatient{
  7.       object B extends App{
  8.         def hi=A.hi
  9.         hi
  10.       }
  11.     }
  12.   }
  13. }

运行结果:

E:\Test>scalac b.scala

E:\Test>scala com.horstmann.impatient.B

I am A

E:\Test>

程序代码: c.scala

package com.horstmann.impatient{

object C extends App{

B.hi

A.hi

}

}

运行结果:

E:\Test>scalac c.scala

c.scala:4: error: not found: value A

A.hi

^

one error found

E:\Test>

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

程序代码: d.scala

E:\Test>scalac d.scala

E:\Test>scala com.horstmann.impatient.C

I am A

I am A

E:\Test>

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

程序代码: a1.scala

package com {

package horstmann {

package com {

package horstmann {

object A {

def hi = println("I am the Ghost A")

}

}

}

}

}

程序代码: a2.scala

package com {

package horstmann {

object A {

def hi =println("I am A")

}

package impatient {

object B extends App {

def hi = com.horstmann.A.hi

hi

}

}

}

}

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

E:\Test>scalac a2.scala

E:\Test>scalac a1.scala

E:\Test>scala com.horstmann.impatient.B

I am A

E:\Test>

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

E:\Test>scalac a1.scala

E:\Test>scalac a2.scala

E:\Test>scala com.horstmann.impatient.B

I am the Ghost A

E:\Test>

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

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

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

程序代码:

  1. package random{
  2.   object Random {
  3.     private val a = 1664525
  4.     private val b = 1013904223
  5.     private val n = 32
  6.  
  7.     private var seed=0
  8.     private var follow:BigInt=0
  9.     private var previous:BigInt=0
  10.  
  11.     def nextInt():Int={
  12.       follow=(previous*a+b)%BigInt(math.pow(2, n).toLong)
  13.       previous=follow
  14.       (follow%Int.MaxValue).intValue()
  15.     }
  16.     def nextDouble():Double={
  17.       nextInt.toDouble
  18.     }
  19.     def setSeed(newSeed:Int){
  20.       seed=newSeed
  21.       previous=seed
  22.     }
  23.   }
  24. }
  25. object Test extends App{
  26.   var r =random.Random
  27.   r.setSeed(args(0).toInt)
  28.   for(i <- 1 to 10) println(r.nextInt())
  29.   for(i <- 1 to 10) println(r.nextDouble())
  30. }

运行结果:

E:\Test>scalac Random.scala

E:\Test>scala Test 0

1013904223

1196435762

1372387050

720982837

1649599747

523159175

1476291629

601448361

33406696

351317787

1.27442629E9

1.020336477E9

4.8889166E8

1.654060783E9

2.8987765E7

6.3353937E7

8.92205936E8

1.338634754E9

1.649346937E9

6.21388933E8

E:\Test>

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

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

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

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

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

程序代码:

  1. import java.util.{HashMap=>JHashMap}
  2. import scala.collection.mutable.HashMap
  3. object JavaMap {
  4.   def transMapValues(javaMap:JHashMap[Any,Any]):HashMap[Any,Any]={
  5.     val result=new HashMap[Any,Any]
  6.     for(k <- javaMap.keySet().toArray()){
  7.       result+=k->javaMap.get(k)
  8.     }
  9.     result
  10.   }
  11.   def main(args: Array[String]): Unit = {
  12.     val jmap:JHashMap[Any,Any]=new JHashMap[Any,Any]
  13.     var smap=new HashMap[Any,Any]
  14.     for(i <- 1 to 9)
  15.       jmap.put(i,"JavaMap"+i)
  16.     smap=transMapValues(jmap)
  17.     smap.foreach(println)
  18.   }
  19. }

运行结果:

(8,JavaMap8)

(2,JavaMap2)

(5,JavaMap5)

(4,JavaMap4)

(7,JavaMap7)

(1,JavaMap1)

(9,JavaMap9)

(3,JavaMap3)

(6,JavaMap6)

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

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

程序代码:

  1. object JavaMap {
  2.   import java.util.{HashMap=>JHashMap}
  3.   import scala.collection.mutable.HashMap
  4.   def transMapValues(javaMap:JHashMap[Any,Any]):HashMap[Any,Any]={
  5.     val result=new HashMap[Any,Any]
  6.     for(k <- javaMap.keySet().toArray()){
  7.       result+=k->javaMap.get(k)
  8.     }
  9.     result
  10.   }
  11.   def main(args: Array[String]): Unit = {
  12.     val jmap:JHashMap[Any,Any]=new JHashMap[Any,Any]
  13.     var smap=new HashMap[Any,Any]
  14.     for(i <- 1 to 10)
  15.       jmap.put(i,"JavaMap"+i)
  16.     smap=transMapValues(jmap)
  17.     smap.foreach(println)
  18.   }
  19. }

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

import java._

import javax._

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

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

程序代码:

  1. object Sys{
  2.   import scala.io.StdIn
  3.   import java.lang.System._
  4.   def main(args: Array[String]): Unit = {
  5.     val pass=StdIn.readLine()
  6.     if(pass=="secret"){
  7.       val name=getProperty("user.name")
  8.       out.printf("Greetings,%s!",name)
  9.    }else{
  10.      err.println("error")
  11.    }
  12.   }
  13. }

运行结果:

secret

Greetings,hadoop!

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

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

如果，您认为阅读这篇博客让您有些收获，不妨点击一下右下角的【推荐】。
如果，您希望更容易地发现我的新博客，不妨点击一下左下角的【关注我】。
如果，您对我的博客所讲述的内容有兴趣，请继续关注我的后续博客，我是【Sunddenly】。

本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。

时间： 2024-10-29 11:42:09

Scala学习(七)练习的相关文章

Scala学习(七)---包和引入

包和引入 摘要: 在本篇中,你将会了解到Scala中的包和引入语句是如何工作的.相比Java不论是包还是引入都更加符合常规,也更灵活一些.本篇的要点包括: 1. 包也可以像内部类那样嵌套 2. 包路径不是绝对路径 3. 包声明链x.y.z并不自动将中间包x和x.y变成可见 4. 位于文件顶部不带花括号的包声明在整个文件范围内有效 5. 包对象可以持有函数和变量 6. 引入语句可以引入包.类和对象 7. 引入语句可以出现在任何位置 8. 引入语句可以重命名和隐藏特定成员 9. java.lang.

Spark学习七：spark streaming与flume集成

Spark学习七:spark streaming与flume集成 标签(空格分隔): Spark 一,启动flume flume-conf.properties文件 agent002.sources = sources002 agent002.channels = channels002 agent002.sinks = sinks002 ## define sources agent002.sources.sources002.type = exec agent002.sources.sour

Scala学习笔记及与Java不同之处总结-从Java开发者角度

Scala与Java具有很多相似之处,但又有很多不同.这里主要从一个Java开发者的角度,总结在使用Scala的过程中所面临的一些思维转变. 这里仅仅是总结了部分两种语言在开发过程中的不同,以后会陆续更新一些切换后在开发过程中值得注意的地方.以下列举了部分,但令人印象深刻的Scala语言的不同之处,具体的代码演示样例及具体阐述见下文. ? Scala中可直接调用Java代码,与Java无缝连接. 语句能够不用";"结束.且推荐不适用";". 变量声明时以var或va

Scala学习笔记-环境搭建以及简单语法

关于环境的搭建,去官网下载JDK8和Scala的IDE就可以了,Scala的IDE是基于Eclipse的. 下面直接上代码: 这是项目目录: A是scala写的: package first import scala.collection.mutable.ListBuffer object A { def main(args: Array[String]) { print("Hello,Scala");//学习程序设计的第一句 println("---");//pr

Spark之Scala学习

1. Scala集合学习: http://blog.csdn.net/lyrebing/article/details/20362227 2. scala实现kmeans算法 http://www.thinksaas.cn/group/topic/93852/ 3. Spark之Scala学习网站 http://spark.apache.org/docs/latest/mllib-decision-tree.html 4. Spark wordcount开发并提交到集群运行: http://ww

scala学习（一）

开始学习scala,有一种学习java的感觉. 首先,从网站下载scala的包,下载后要安装,安装后把安装目录的bin放到环境变量psth里 cmd里,输入scala,如果出现下图,那么恭喜咯,安装成功咯~~ 1:变量 首先我们看下定义变量方法 var 可以定义变量,可以改变值 val 定义的变量不可以改变值,类似于java的final变量: 2:函数 如图定义了一个函数 def max(x:Int,y:Int):Int ={ if(x>y)x else y } def:表面定义函数 max :

springMVC3学习(七)--Interceptor拦截器

Spring为我们提供了:org.springframework.web.servlet.HandlerInterceptor接口, org.springframework.web.servlet.handler.HandlerInterceptorAdapter适配器, 实现这个接口或继承此类,能够很方便的实现自己的拦截器. 有下面三个方法: Action之前运行 public boolean preHandle(HttpServletRequest request, HttpServletR

scala学习（二）

接着上次的学习,今天学习scala的下面内容咯~~ 1·使用集(set)和映射(map) 学习过java的童鞋们,看见这两个肯定很开心咯,因为很眼熟哦. scala的集合,分为可变类型和不可变类型.array--可变:list保持不变 那么set和map呢,他们通过类继承的差别控制可变和不可变~~ 先看个set的列子吧: var jetSet = Set("zhangsan","lisi") jetSet += "wangwu" println(

scala学习三---文件里读取文本行

学习了scala的基本知识后,发现了scala是集函数式和指令式结合为一体的一种语言,代码更加简洁,但是对于用习惯了java的人来说,还真的不是一件易事~~ 今天学习scala脚本读取文本文件 列子如下: import scala.io.Source if(args.length>0){ for(line <- Source.fromFile(args(0)).getLines) print(line.length+" "+line) }else{ Console.err.