scala的一些特殊用法

1.创建多行字符串，只要把多行字符串放在3个双引号间（"""..."""）即可。这是Scala对于here document，或者叫heredoc的支持。这里我们创建一个三行长的字符串：

MultiLine.scala

val str = """Hello world!
How are you!
Good morning!"""
println(str)

输出如下：

Hello world!
How are you!
Good morning!
请按任意键继续. . .

2.运算符优先级

Scala没有定义运算符的优先级，但它定义了方法的优先级。

方法名的第一个字符决定了它的优先级。如果表达式里面有两个具有相同优先级的字符，那么左边的运算符优先级更高。下面从低到高列出了首字符的优先级：

所有字母
|
^
&
< >
= !
:
+ -
* / %
所有其他特殊字符

举例如下：

Complex.scala

class Complex(val real:Int, val imag:Int) {
def +(operand:Complex):Complex={
println("Calling +")
new Complex(real+operand.real , imag+operand.imag)
}

def *(operand:Complex):Complex={
println("Calling *")
new Complex(real*operand.real - imag*operand.imag , real*operand.imag + imag*operand.real )
}
override def toString():String = {
real + (if(imag<0) ""else "+")+ imag + "i"
}
}

object Complex extends App {
val c1 = new Complex(1,4)
val c2 = new Complex(2,-3)
val c3 = new Complex(2,2)
//  val sum = c1 + c2
//  println("(" + c1 + ") + (" + c2 + ")=" + sum )
println(c1+c2*c3)
}

运行结果如下：

Calling *
Calling +
11+2i

3. 类继承

在scala里，继承一个基类跟Java的做法很相似，只是多了两点限制：

（1）重写方法需要override关键字

（2）只有主构造函数才能往基类构造函数中传参数

下面是继承一个基类的例子：

Vehicle.scala

class Vehicle(val id:Int, val year:Int) {
override def toString(): String = "ID:" + id + " Year:" + year
}

class Cars(override val id:Int, override val year:Int,
var fuelLevel:Int)extends Vehicle(id,year){
override def toString(): String = super.toString()+ " Fuel Level:" + fuelLevel
}

object Cars extends App {
val car = new Cars(1, 2010, 100)
println(car)
}

程序运行结果如下：

ID:1 Year:2010 Fuel Level:100

4. Scala中的static

Scala中没有静态字段和静态方法。静态字段和静态方法会打破Scala所支持的完整的面向对象模型。不过，scala也是完全支持类一级的属性和操作的。这就是伴生对象的作用。

举例如下：

Marker.scala

class Marker private(val color:String) {
override def toString():String = "marker color "+color
}

object Marker extends App{
private val markers = Map(
"red" -> new Marker("red"),
"blue" -> new Marker("blue"),
"green" -> new Marker("green")
)

def primaryColors = "red, green, blue"

def apply(color:String) = if(markers.contains(color))
markers(color) else null

println("Primary colors are:" + Marker.primaryColors)
println(Marker("blue"))
println(Marker("red"))
}

程序运行结果如下：

Primary colors are:red, green, blue
marker color blue
marker color red

5. Option类型

Scala想让意图更清晰的表达出来，确实有时候我们就需要没有结果。Scala以一种类型安全的方式做到这一点：它使用Option[T]类型。举例如下：

OptionExample.scala

object OptionExample extends App{
def commentOnPractice(input:String) = {
//rather than returning null
if(input == "test") Some("good") else None
}
for(input <- Set("test","hack")){
val comment = commentOnPractice(input)
println("input "+input+"comment "+comment.getOrElse("Found no comments"))
}
}

程序运行结果如下：

input testcomment good
input hackcomment Found no comments

将类型显式声明为Option[String]，Scala会强制我们检查实例的不存在。如此一来，就不太可能因为没有检查null引用而抛出NullPointerException。调用返回Option[T]的getOrElse()方法，可以主动的应对结果不存在（None）的情形。

6.方法返回类型推演

除了推演变量的类型，Scala也会尝试推演方法返回值的类型。不过，这有个陷阱，推演会依赖于方法如何定义。如果用等号（=）定义方法，Scala就可以推演返回类型。否则，它就假设方法是一个void方法。

7. 隐式类型转换

举例如下：

import java.util._
class DateHelper(number:Int) {
def days(when:String):Date = {
var date = Calendar.getInstance()
when match {
case DateHelper.ago => date.add(Calendar.DAY_OF_MONTH, -number)
case DateHelper.from_now => date.add(Calendar.DAY_OF_MONTH, number)
case _ => date
}
date.getTime();
}
}

object DateHelper extends App{
val ago = "ago"
val from_now = "from_now"
implicit def convertInt2DateHelper(number:Int) = new DateHelper(number)
val past = 2 days ago
val appointment = 5 days from_now
println(past)
println(appointment)
}

程序运行结果如下：

Fri Mar 13 16:49:06 CST 2015
Fri Mar 20 16:49:06 CST 2015

7. 使用Set，合并Set集

如果需要将两个Set合并成一个新的Set，可以用++()：

scala> val feeds1 = Set("blog.toolshed.com","pragdave.pragprog.com","pragmactic-
osxer.blogspot.com","vita-contemplativa.blogspot.com")
feeds1: scala.collection.immutable.Set[String] = Set(blog.toolshed.com, pragdave
.pragprog.com, pragmactic-osxer.blogspot.com, vita-contemplativa.blogspot.com)

scala> val feeds2 = Set("blog.toolshed.com","martinfowler.com/bliki")
feeds2: scala.collection.immutable.Set[String] = Set(blog.toolshed.com, martinfo
wler.com/bliki)

scala> val mergedFeeds = feeds1 ++ feeds2
mergedFeeds: scala.collection.immutable.Set[String] = Set(pragdave.pragprog.com,
pragmactic-osxer.blogspot.com, vita-contemplativa.blogspot.com, blog.toolshed.c
om, martinfowler.com/bliki)

scala> println("# of merged feeds:" + mergedFeeds.size)
# of merged feeds:5

Set至多持有每个元素一次，从输出里可以看到这一点，在合并后的Set里，两个Set里公共的元素只存储一次：

如果想在每个元素前面加上“http://",可以用map()方法：

scala> val urls = feeds1 map("http://"+_)
urls: scala.collection.immutable.Set[String] = Set(http://blog.toolshed.com, http://pragdave.pragprog.com, http://pragmactic-osxer.blogspot.com, http://vita-con templativa.blogspot.com)

如果准备对Set集进行迭代，一次一个的进行刷新，可以用内建的迭代器foreach()，像这样：

scala> feeds1 foreach{ feed => println(" Refreshing " + feed)}
Refreshing blog.toolshed.com
Refreshing pragdave.pragprog.com
Refreshing pragmactic-osxer.blogspot.com
Refreshing vita-contemplativa.blogspot.com

8. 用Scala实现集合中相邻元素间的差值

如何计算同一集合中元素两两之间的差值，即求集合(a,b,c,d)中的(b-a,c-b,d-c)

实现方法如下：

scala> val l1 = 1 to 10 toList
warning: there were 1 feature warning(s); re-run with -feature for details
l1: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> val l2 = l1.tail
l2: List[Int] = List(2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> l1.zip(l2).map(p=>(p._2-p._1))
res1: List[Int] = List(1, 1, 1, 1, 1, 1, 1, 1, 1)

代码含义解释如下:

tail表示一个集合中除首元素外的剩余元素，也是一个集合。

zip将两个集合组成一个数值对集合，比如原来有两个集合分别是(a,b,c,d), (1,2,3,4)，使用zip之后，形成((a,1),(b,2),(c,3),(d,4))，如果两个集合长度不一致，多余元素将被舍去。

map操作中的p._1和p._2表示tuple（元组）中的第一个元素和第二个元素

head和tail head表示头元素，tail表示除head之外的剩余元素集合

init和last last表示尾元素, init表示除尾元素之外的剩余元素集合