第一章 基础
val 定义的值实际上是一个常量
var 声明其值可变的变量
val xmax,ymax = 100
var greeting,message: String = null
1.3 常用类型
Scala的7种数值类型：Byte、Char、Short、Int、Long、Float和Double
1、toString()
2、to(10)
"Hello".intersect("World")
1.4 算术和操作符重载
val answer = 8 * 5 + 2
scala 提供 += 或者 -=
counter += 1
1.5调用函数和方法
sqrt(2)
pow(2,4)
min(3,Pi)
import scala.math._ //在scala中,_字符是“通配符”,类似Java中的*
BigInt.probablePrime(100,scala.util.Random)
1.6 apply方法
"Hello"(4)
def apply(n: Int): Char
"Hello".apply(4)
def count(p: (Char) => Boolean) : Int
第一章习题
1 简介
近期对Scala比较感兴趣，买了本《快学Scala》,感觉不错。比《Programming Scala:Tackle Multi-Core Complexity on the Java Virtual Machine》好很多。 是本不错的入门书。而且每个章节都设置了难度级别，每章有习题，可以巩固Scala语法。
本文的目的就是针对这些习题进行解答
2 基础
2.1 在Scala REPL中键入3,然后按Tab键。有哪些方法可以被应用?
这个。。。。直接操作一遍就有结果了.此题不知是翻译的问题，还是原题的问题，在Scala REPL中需要按3. 然后按Tab才会提示。 直接按3加Tab是没有提示的。下面是结果
Scala代码
1. != ## % & * +
2. - / < << <= ==
3. > >= >> >>> ^ asInstanceOf
4. equals getClass hashCode isInstanceOf toByte toChar
5. toDouble toFloat toInt toLong toShort toString
6. unary_+ unary_- unary_~ |
列出的方法并不全，需要查询全部方法还是需要到Scaladoc中的Int,Double,RichInt,RichDouble等类中去查看。
2.2 在Scala REPL中，计算3的平方根,然后再对该值求平方。现在，这个结果与3相差多少？(提示:res变量是你的朋友)
依次进行计算即可
Scala代码
1. scala> scala.math.sqrt(3)
2. warning: there were 1 deprecation warnings; re-run with -deprecation for details
3. res5: Double = 1.7320508075688772
4.
5. scala> res5*res5
6. res6: Double = 2.9999999999999996
7.
8. scala> 3 - res6
9. res7: Double = 4.440892098500626E-16
2.3 res变量是val还是var?
val是不可变的，而var是可变的，只需要给res变量重新赋值就可以检测res是val还是var了
Scala代码
1. scala> res9 = 3
2. <console>:8: error: reassignment to val
3. res9 = 3
4. ^
2.4 Scala允许你用数字去乘字符串—去REPL中试一下"crazy"*3。这个操作做什么？在Scaladoc中如何找到这个操作?
Scala代码
1. scala> "crazy"*3
2. res11: String = crazycrazycrazy
从代码可以推断,*是"crazy"这个字符串所具有的方法，但是Java中的String可没这个方法，很明显。此方法在StringOps中。
2.5 10 max 2的含义是什么？max方法定义在哪个类中？
直接在REPL中执行
Scala代码
1. scala> 10 max 2
2. res0: Int = 10
3.
4. scala> 7 max 8
5. res1: Int = 8
6.
7. scala> 0 max 0
8. res2: Int = 0
可以看出,此方法返回两个数字中较大的那个。此方法Java中不存在，所以在RichInt中。
2.6 用BigInt计算2的1024次方
简单的API调用
Scala代码
1. scala> BigInt(2).pow(1024)
2. res4: scala.math.BigInt = 1797693134862315907729305190789024733617976978942306572734300811577326758055009631327084773224
3. 075360211201138798713933576587897688144166224928474306394741243777678934248654852763022196012460941194530829520850057688
4. 38150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216
2.7 为了在使用probablePrime(100,Random)获取随机素数时不在probablePrime和Radom之前使用任何限定符，你需要引入什么？
so easy. import需要的包啊。Random在scala.util中，而probablePrime是BigInt中的方法，引入即可
Scala代码
1. import scala.math.BigInt._
2. import scala.util.Random
3.
4. probablePrime(3,Random)
2.8 创建随机文件的方式之一是生成一个随机的BigInt，然后将它转换成三十六进制，输出类似"qsnvbevtomcj38o06kul"这样的字符串。
查阅Scaladoc，找到在Scala中实现该逻辑的办法。 到BigInt中查找方法。
Scala代码
1. scala> scala.math.BigInt(scala.util.Random.nextInt).toString(36)
2. res21: String = utydx
2.9 在Scala中如何获取字符串的首字符和尾字符？
Scala代码
1. //获取首字符
2. "Hello"(0)
3. "Hello".take(1)
4. //获取尾字符
5. "Hello".reverse(0)
6. "Hello".takeRight(1)
2.10 take,drop,takeRight和dropRight这些字符串函数是做什么用的？和substring相比，他们的优点和缺点都是哪些？
查询API即可 take是从字符串首开始获取字符串,drop是从字符串首开始去除字符串。 takeRight和dropRight是从字符串尾开始操作。
这四个方法都是单方向的。 如果我想要字符串中间的子字符串，那么需要同时调用drop和dropRight，或者使用substring
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
第二章 控制结构和函数
2.1 条件表达式
if(x > 0) 1 else -1
val s = if(x > 0) 1 else -1
混合型表达式：
if(x>0) "positive" else -1
2.2 语句终止
val n = 12
if(n>0) { r = r * n; n -= 1}
s = s0 + (v - v0) * t + 0.5 * (a-a0) * t * t
if(n > 0){
r = r * n
n -= 1
}
2.3 块表达式和赋值
val distance = { val dx = x - x0; val dy = y - y0; sqrt(dx * dx + dy * dy)}
{ r = r * n; n -= 1}
2.4 输入和输出
print("Answer: ")
println(42)
println("Answer: " + 42)
println("Hello,%s! You are %d years old.\n","Fred",42)
val name = readLine("Your name: ")
print("Your age: ")
val age = readInt()
printf("Hello, %s! Next year,your will be %d.\n",name,age + 1)
2.5 循环
while(n > 0){
r = r * n
n -= 1
}
2.6 高级for循环和for推导式
for(i <- 1 to 3; j <- 1 to 3) print((10 * i + j) + " ")
for(i <- -1 to 3;j <- 1 to 3 if i != j) print((10 * i + j) + " ")
for(i <- 1 to 3; from = 4 - i;j <- from to 3) print((10 * i + j) + " ")
for(i <- 1 to 10 yield i % 3)
for(c <- "Hello"; i<- 0 to 1) yield (c + i).toChar
for(i <- 0 to 1;c <- "Hello") yield (c + i).toChar
for{ i<- 1 to 3
from = 4 -i
j <- from to 3
}
2.7 函数
def abs(x: Double) = if(x >= 0) x else -x
def fac(n: Int) = {
var r =1
for(i <- 1 to n) r = r * i
r
}
对于递归函数，我们必须指定返回类型。例如：
def fac(n: Int): Int = if (n <= 0) 1 else n * fac(n - 1)
2.8 默认参数和带名参数
def decorate(str: String,left: String = "[",right: String = "]") = left + str + right
decorate(left = "<<<",str = "Hello", right = ">>>")
decorate("Hello",right = "]<<<")
2.9 变长参数
def sum(args: Int*) = {
var result = 0
for(arg <- args) result += arg
result
}
val s = sum(1,4,9,16,25)
val s = sum(1 to 5)
val s = sum(1 to 5: _*)
def recursiveSum(args: Int*): Int = {
if(args.length == 0) 0
else args.head + recursiveSum(args.tail: _*)
}
val str = MessageFormat.format("The answer to {0} is {1}")
2.10 过程
Scala 对于不返回值的函数有特殊的表示法。如果函数体包含在花括号当中但没有前面的=号，那么返回类型就是Unit。
这样的函数被称做过程(procedure)。过程不返回值，我们调用它仅仅是为了它的副作用。举例来说，如下过程把一个字符串打印在一个框中，就像这样：
--------
|hello|
--------
由于过程不返回任何值，所以我们可以略去=号
def box(s: String){
var border = "-" * s.length + "--\n"
println(border + "|" + s + "|\n" + border)
}
显示声明Unit返回类型
def box(s: String): Unit={
var border = "-" * s.length + "--\n"
println(border + "|" + s + "|\n" + border)
}
2.11 懒值
当val被声明为lazy时，它的初始化将被推迟，直到我们首次对它取值。例如，
lazy val words = scala.io.Source.fromFile("/usr/share/dict/words").mkString
懒值对于开销较大的初始化语句而言十分有用。它们还可以应对其他初始化问题，比如循环依赖。
你可以把懒值当做是介于val和def的中间状态。对比如下定义：
//在worlds被定义时被取值
val words = scala.io.Source.fromFile("/usr/share/dict/words").mkString
//在words被首次使用时取值
lazy val words = scala.io.Source.fromFile("/usr/share/dict/words").mkString
//在每一次words被使用时取值
def words = scala.io.Source.fromFile("/usr/share/dict/words").mkString
2.12 异常
Scala异常工作机制和Java或C++一样
throws new IllegalArgumentException("x should not be negative")
if(x >= 0){
sqrt(x)
} else throw new IllegalArgumentException("x should not be negative")
捕获异常的语法采用的是模式匹配
try{
process(new URL("http://horstmann.com/fred-tiny.gif"))
} catch{
case _: MalformedURLException => println("Bad URL:" + url)
case ex: IOException => ex.printStackTrace()
}
var in = new URL("http://horstman.com/fred.gif").openStream()
try{
process(in)
} finally {
in.close()
}
try{...} catch{...} finally{...}
try{try{...} catch{...}} finally {...}
习题：
2 控制结构和函数
2.1 一个数字如果为正数，则它的signum为1;如果是负数,则signum为-1;如果为0,则signum为0.编写一个函数来计算这个值
简单的逻辑判断
def signum(num:Int){if(num>0)print(1)else if(num<0)print(-1)else print(0)}
Scala中已经有此方法了，刚才查找API的时候，应该能看到
BigInt(10).signum
2.2 一个空的快表达式{}的值是什么？类型是什么？
在REPL中就能看出来了
scala> val t = {}
t: Unit = ()
可以看出，它的值是()类型是Unit
2.2 指出在Scala中何种情况下赋值语句x=y=1是合法的。(提示：给x找个合适的类型定义)
题目已经给了明确的提示了。本章节中已经说过了，在scala中的赋值语句是Unit类型。所以只要x为Unit类型就可以了。
scala> var y=4;
y: Int = 4
scala> var x={}
x: Unit = ()
scala> x=y=7
x: Unit = ()
这也再次证明了{}是Unit类型
2.4 针对下列Java循环编写一个Scala版本:
for(int i=10;i>=0;i–)
System.out.println(i);
使用Scala版本改写就OK了
for(i <- 0 to 10 reverse)print(i)
2.5 编写一个过程countdown(n:Int)，打印从n到0的数字
这个就是将上面的循环包装到过程中而已。还是换个写法吧。
def countdown(n:Int){
0 to n reverse foreach print
}
2.6 编写一个for循环,计算字符串中所有字母的Unicode代码的乘积。举例来说，"Hello"中所有字符串的乘积为9415087488L
scala> var t:Long = 1
t: Long = 1
scala> for(i <- "Hello"){
| t = t * i.toLong
| }
scala> t
res57: Long = 9415087488
2.7 同样是解决前一个练习的问题，但这次不使用循环。（提示：在Scaladoc中查看StringOps）
scala> var t:Long = 1
t: Long = 1
scala> "Hello".foreach(t *= _.toLong)
scala> t
res59: Long = 9415087488
2.8 编写一个函数product(s:String)，计算前面练习中提到的乘积
def product(s:String):Long={
var t:Long = 1
for(i <- s){
t *= i.toLong
}
t
}
2.9 把前一个练习中的函数改成递归函数
配合前一章的take和drop来实现
def product(s:String):Long={
if(s.length == 1) return s.charAt(0).toLong
else s.take(1).charAt(0).toLong * product(s.drop(1))
}
2.10 编写函数计算xn,其中n是整数，使用如下的递归定义:
? xn=y2,如果n是正偶数的话，这里的y=x(n/2)
? xn = x*x(n-1),如果n是正奇数的话
? x0 = 1
? xn = 1/x(-n),如果n是负数的话
不得使用return语句
def mi(x:Double,n:Int):Double={
if(n == 0) 1
else if (n > 0 && n%2 == 0) mi(x,n/2) * mi(x,n/2)
else if(n>0 && n%2 == 1) x * mi(x,n-1)
else 1/mi(x,-n)
}
第3章 数组相关操作
本章重点包括：
若长度固定则使用Array，若长度可能有变化则使用ArrayBuffer
提供初始值时不要使用new。
用()来访问元素。
用for(elem <- arr)来遍历元素
用for(elem <- arr if ...)...yield...来将原数组转型为新数组
Scala数组和Java数组可以互操作；用ArrayBuffer，使用scala.collection.JavaConversions中的转换函数。
3.1 定长数组
val nums = new Array[Int](10)
val a = new Array[String](10)
val s = Array("Hello","World")
s(0) = "Goodbye"
在JVM中，Scala的Array以Java数组方式实现。
示例中的数组的JVM中的类型为java.lang.String[].Int、Double或其他与Java中基本类型对应的数组都是基本类型数组。举例来说，Array(2,3,5,7,11)
3.2 变长数组：数组缓存
import scala.collection.mutable.ArrayBuffer
val b = ArrayBuffer[Int]()
b += 1
b += (1,2,3,5)
//++=操作符追加任何集合
b ++= Array(8,13,21)
//移除最后5个元素
b.trimEnd(5)
//在下标2之前插入
b.insert(2,6)
//可以插入任意多的元素
b.insert(2,7,8,9)
b.remove(2)
b.remove(2,3)
//构建一个数组缓冲然后调用
b.toArray
//将数组a转换成一个数组缓冲
a.toBuffer
3.3 遍历数组和数组缓冲
for(i <- 0 until b.length)
println(i + ": " + b(i))
//util是RichInt类的方法，返回所有小于上限的数字。
0 until 10
0 until (b.length,2)
(0 until b.length).reverse
for(elem <- a)
println(elem)
3.4 数组转换
val a = Array(2,3,5,7,11)
val result = for(elem <- a) yield 2 * elem
for(elem <- a if elem % 2 == 0) yield 2 * elem
a.filter(_ % 2 == 0).map(2 * _)
a.filter{ _ % 2 == 0} map { 2 * _}
var first = true
var n = a.length
var i = 0
while(i < 0){
if(a(i) >= 0) i+=1
else
if(first){first = false; i += 1}
else {a.remove(i);n -= 1}
}
var first = true
val indexes = for(i <- 0 until a.length if first || a(i) >= 0) yield{
if (a(i) < 0) first = false;
i
}
for(j <- 0 until indexes.length) a(j) = a(indexes(j))
a.trimEnd(a.length - indexes.length)
3.5 常用算法
Array(1,7,2,9).sum
ArrayBuffer("Mary","had","a","little","lamb").max
val b = ArrayBuffer(1,7,2,9)
val bSorted = b.sorted(_ < _)
val bDescending = b.sorted(_ > _)
val a = Array(1,7,2,9)
scala.util.Sorting.quickSort(a)
a.mkString(" and ")
a.mkString("<",",",">")
a.toString
b.toString
3.6 解读Scaladoc
3.7 多维数组
val matrix = Array.ofDim[Double](3,4)
matrix(row)(column) = 42
val triangle = new Array[Array[Int]](10)
for(i <- until triangle.length)
triangle(i) = new Array[Int](i + 1)
3.8 与Java的互操作
import scala.collection.JavaConversions.bufferAsJavaList
import scala.collection.mutable.ArrayBuffer
val command = ArrayBuffer("ls","-a","/home/cay")
val pb = new ProcessBuilder(command)
import scala.collection.JavaConversions.asScalaBuffer
import scala.collection.mutable.Buffer
val cmd: Buffer[String] = pb.command()
1、编写一段代码，将a设置为一个n个随机整数的数组，要求随机数介于0(包含)和n(不包含)之间。
2、编写一个循环，将整数数组中相邻的元素置换。例如,Array(1,2,3,4,5)经过置换后变为Array(2,1,4,3,5)
3、重复前一个练习，不过这一次生成一个新的值交换过的数组。用for/yield
4、给定一个整数数组，产生一个新的数组，包含元数组中的所有正值，以原有顺序排列，之后的元素是所有零或负值，以原有顺序排序
5、如何计算Array[Double]的平均值？
6、如何重新组织Array[Int]的元素将它们以反序排序？对于ArrayBuffer[Int]你又会怎么做呢？
7、
第4章 映射和元组
4.1 构造映射
4.2 获取映射中的值
4.3 更新映射中的值
4.4 迭代映射
4.5 已排序映射
4.6 与Java的互操作
4.7 元组
映射是键/值对偶的集合。对偶是元组的最简单形式--元组是不同类型的值得聚集。
元组的值是通过将单个的值包含在圆括号中构成。例如：
(1,3,14,"Fred")
Tuple3[Int,Double,java.lang.String]
(Int,Double,java.lang.String)
val t = (1,3,14,"Fred")
val secnd = t._2
通常，使用模式匹配来获取元组的组元，例如：
val (first,second,third) = t //将first设为1，second设为3.14，third设为"Fred"
val (first,second, _) = t
"New York".partition(_.isUpper)
4.8 拉链操作
val symbols = Array("<","-",">")
val counts = Array(2,10,2)
val pairs = symbols.zip(counts)
本章的要点包括：
Scala有十分易用的语法来创建、查询和遍历映射。
你需要从可变的和不可变的映射中做出选择。
默认情况下，你得到的是一个哈希映射，不过你也可以指明要树形映射。
你可以很容易地在Scala映射和Java映射之间来回切换。
元组可以用来聚集值
4.1 构造映射
val scores = Map("Alice" -> 10,"Bob" -> 3,"Cindy" -> 8)
val scores = scala.collection.mutable.Map("Alice" -> 10,"Bob" -> 3,"Cindy" -> 8)
val scores = new scala.collection.mutable.HashMap[String,Int]
->操作符用来创建对偶
"Alice" -> 10
上述代码产出的值：
（）
1、设置一个映射，其中包含你想要的一些装备，以及它们的价格。然后构建另一个映射，采用用一组键，但在价格上9折
2、编写一段程序，从文件中读取单词。用一个可变映射来清点每一个单词出现的频率。读取这些单词的操作可以使用java.util.Scanner:
val in = new java.util.Scanner(new java.io.File("myfile.txt"))
while(in.hasNext()) 处理 in.next()
最后，打印出所有单词和它们出现的次数
3、重复前一个练习，这次用不可变的映射。
4、重复前一个练习，这次用已排序的映射，以便单词可以按顺序打印出来。
5、重复前一个练习，这次用java.util.TreeMap并使之适用于Scala API
6、定义一个链式哈希映射，将“Monday”映射到java.util.Calendar.MONDAY,依次类推加入其他日期。展示元素是以插入的顺序被访问的。
7、打印出所有Java系统属性的表格，类似这样：
java.runtime.name | Java(TM) SE Runtime Environment
sun.boot.library.path | /home/apps/jdk
1.6.0.21/jre/lib/i386
java.vm.version | 17.0-bl6
java.vm.vendor | Sun Microsystems Inc
java.vendor.url | http://java.sun.com/
path.separator | :
java.vm.name | Java HotSpot(TM) Server VM
8、编写一个函数
9、编写一个函数
10、当你将两个字符串拉链在一起，比如
11、
第5章
5.1 简单类和无参方法
class Counter{
private var value = 0 //
def increment(){ value += 1}
def current() = value
}
val myCounter = new Counter
myCounter.increment()
println(myCounter.current)
myCounter.current
myCounter.current()
5.2 带getter和setter的属性
5.3 只带getter的属性
5.4 对象私有字段
5.5 Bean属性
import scala.reflect.BeanProperty
class Person{
@BeanProperty var name: String = _
}
将会生成四个方法：
1、name: String
2、name_=(newValue:String):Unit
3、getName():String
4、setName(newValue:String):Unit
class Person(@BeanProperty var name: String)
5.6 辅助构造器
class Person{
private var name = ""
private var age = 0
def this(name: String){
this()
this.name = name
}
def this(name: String,age: Int){
this(name)
this.age = age
}
}
val p1 = new Person
val p2 = new Person("Fred")
val p3 = new Person("Fred",42)
5.7 主构造器
class Person(val name: String,val age: Int){
}
5.8 嵌套类
import scala.collection.mutable.ArrayBuffer
class Network{
class Member(val name: String){
val contacts = new ArrayBuffer[Member]
}
private val members = new ArrayBuffer[Member]
def join(name: String) = {
val m = new Member(name)
members += m
m
}
}
val chstter = new Network
val myFace = new Network
val fred = chatter.join("Fred")
val wilma = chatter.join("Wilma")
fred.contacts += wilma
val barney = myFace.join("Barney")
fred.contacts += barney
object Network{
class Member(val name: String){
val contacts = new ArrayBuffer[Member]
}
}
class Network{
private val members = new
}
第七章 包和引入
7.1 包
package com{
package horstman{
package impattern{
class Employee
}
}
}
package org{
package bigjava{
class Counter
}
}
7.2 作用域规则
package com{
package horstmann{
object Utils{
def percentOf(value: Double,rate: Double) = value * rate / 100
...
}
}
}
package impatient{
class Employee{
def giveRaise(rate: scala.Double){
salary += Utils.percentOf(salary,rate)
}
}
}
7.3 串联式包语句
7.4 文件顶部标记法
7.5 包对象
7.6 包可见性
7.7 引入
7.8 任何地方都可以声明引入
7.9 重命名和隐藏方法
import java.awt.{Color,Font}
import java.util.{HashMap => JavaHashMap}
import scala.collection.mutable._
import java.util.{HashMap => _,_}
import scala.collection.mutable._
7.10 隐式引入
import java.lang._
import scala._
import Predef._
collection.mutable.HashMap
scala.collection.mutable.HashMap
第8章 继承
8.1 扩展类
class Employee extends Person{
var salary = 0.0
}
8.2 重写方法
public class Person{
override def toString = getClass.getName + "[name=" + name + "]"
}
8.3 类型检查和转换
if(p.isInstanceOf[Employee]){
val s = p.asInstanceOf[Employee]
}
8.4 受保护字段和方法
8.5 超类的构造
8.6 重写字段
8.7 匿名子类
8.8 抽象类
8.9 抽象字段
8.10 构造顺序和提前定义
8.11 Scala继承层级
8.12 对象相等性