Scala详解

1       快速入门... 4

1.1             分号... 4

1.2             常变量声明... 4

1.2.1         val常量... 4

1.2.2         var变量... 4

1.2.3         类型推导... 5

1.2.4         函数编程风格... 5

1.3             Range. 5

1.4             定义函数... 6

1.5             while、if6

1.6             foreach、for. 7

1.7             读取文件... 7

1.8             类、字段和方法... 7

1.9             Singleton单例对象... 9

1.10          Scala入口程序... 10

1.11          基本类型... 11

1.12          字面量... 12

1.12.1       整数字面量... 12

1.12.2       浮点数字面量... 12

1.12.3       字符字面量... 13

1.12.4       字符串字面量... 13

1.12.5       Symbol符号字面量... 14

1.12.6       布尔字面量... 15

1.13          操作符和方法... 15

1.14          数学运算... 16

1.15          关系和逻辑操作... 17

1.16          位操作符... 17

1.17          对象相等性... 18

1.18          操作符优先级... 19

1.19          基本类型富包装类型... 19  

 

1       快速入门

1.1               分号

分号表示语句的结束；

如果一行只有一条语句时，可以省略，多条时，需要分隔

一般一行结束时，表示表达式结束，除非推断该表达式未结束：

// 末尾的等号表明下一行还有未结束的代码.

def equalsign(s: String) =

  println("equalsign: " + s)

 

// 末尾的花括号表明下一行还有未结束的代码.

def equalsign2(s: String) = {

  println("equalsign2: " + s)

}

 

//末尾的逗号、句号和操作符都可以表明，下一行还有未结束的代码.

def commas(s1: String,

           s2: String) = Console.

  println("comma: " + s1 +

          ", " + s2)

 

多个表达式在同一行时，需要使用分号分隔

 

1.2              常变量声明

1.2.1      val常量

定义的引用不可变，不能再指向别的对象，相当于Java中的final

 

Scala中一切皆对象，所以，定义一切都是引用（包括定义的基本类型变量，实质上是对象）

val定义的引用不可变，指不能再指向其他变量，但指向的内容是可以变的：

val定义的常量必须要初始化

 

val的特性能并发或分布式编程很有好处

1.2.2      var变量

定义的引用可以再次改变（内容就更可以修改了），但定义时也需要初始化

 

在Java中有原生类型（基础类型），即char、byte、short、int、long、float、double和boolean，这些都有相应的Scala类型（没有基本类型，但好比Java中相应的包装类型），Scala编译成字节码时将这些类型尽可能地转为Java中的原生类型，使你可以得到原生类型的运行效率

 

用val和var声明变量时必须初始化，但这两个关键字均可以用在构造函数的参数中，这时变量是该类的一个属性，因此显然不必在声明时进行初始化。此时如果用val声明，该属性是不可变的；如果用var声明，则该属性是可变的：

class Person(val name: String, var age: Int)

即姓名不可变，但年龄是变化的

val p = new Person("Dean Wampler", 29)

 

 

var和val关键字只标识引用本身是否可以指向另一个不同的对象，它们并未表明其所引用的对象内容是否可变

1.2.3      类型推导

定义时可以省略类型，会根据值来推导出类型

scala> var str = "hello"

str: String = hello

scala> var int = 1

int: Int = 1

定义时也可明确指定类型：

scala> var str2:String = "2"

str2: String = 2

1.2.4      函数编程风格

以前传统Java都是指令式编程风格，如果代码根本就没有var，即仅含有val，那它或许是函数式编程风格，因此向函数式风格转变的方式之一，多使用val，尝试不用任何var编程

 

指令式编程风格：

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

    var i = 0

    while (i < args.length) {

      println(args(i))

      i += 1

    }

  }

函数式编程风格：

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

    for (arg <- args)

      println(arg)

  }

或者：

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

    //如果函数字面量只有一行语句并且只带一个参数，

    //则么甚至连指代参数都不需要

    args.foreach(println)

  }

 

1.3  Range

数据范围、序列

支持Range的类型包括Int、Long、Float、Double、Char、BigInt和BigDecimal

 

Range可以包含区间上限，也可以不包含区间上限；步长默认为1，也可以指定一个非1的步长：

 

1.4               定义函数

函数是一种具有返回值（包括空Unit类型）的方法

 

函数体中最后一条语句即为返回值。如果函数会根据不同情况返回不同类型值时，函数的返回类型将是不同值的通用（父）类型，或者是可以相互转换的类型（如Char->Int）

 

如果函数体只一条语句，可以省略花括号：

def max2(x:Int,y:Int)=if(x>y)x else y

 

scala> max2(3,5)

res2: Int = 5

 

Unit：返回类型为空，即Java中的void类型。如果函数返回为空，则可以省略

scala> def greet()=println("Hello")

greet: ()Unit

 

1.5               while、if

打印入口程序的外部传入的参数：

 

object Test {
  def main(args: Array[String]): Unit = {
    var i = 0
    while (i < args.length) {
      if (i != 0) print(" ")
      print(args(i))
      i += 1
    }
  }
}

　　

注：Java有++i及i++，但Scala中没有。

 

与Java一样，while或if后面的布尔表达式必须放在括号里，不能写成诸如 if i < 10 的形式

1.6               foreach、for

object Test {
  def main(args: Array[String]): Unit = {
    var i = 0;
    args.foreach(arg => { if (i != 0) print(" "); print(arg); i += 1 })
  }
}

　　

foreach方法参数要求传的是函数字面量（匿名函数），arg为函数字面量的参数，并且值为遍历出来的集合中的每个元素，类型为String，已省略，如不省略，则应为：

    args.foreach((arg: String) => { if (i != 0) print(" "); print(arg); i += 1 })

 

如果函数字面量只有一行语句并且只带一个参数，则么甚至连指代参数都不需要：

    args.foreach(println)

 

也可以使用for循环来代替：

    for (arg <- args) println(arg)

1.7               读取文件

object Test {

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

    import scala.io.Source

    //将文件中所有行读取到List列表中

    val lines = Source.fromFile(args(0)).getLines().toList

    //找到最长的行：类似冒泡排序，每次拿两个元素进行比较

    val longestLine = lines.reduceLeft((a, b) => if (a.length() > b.length()) a else b)

    //最长行的长度本身的宽度

    val maxWidth = widthOfLength(longestLine)

    for (line <- lines) {

      val numSpaces = maxWidth - widthOfLength(line)

      //让输出的每行宽度右对齐

      val padding = " " * numSpaces

      println(padding + line.length() + " | " + line)

    }

  }

 

  def widthOfLength(s: String) = s.length().toString().length()

}

 

1.8               类、字段和方法

类的方法以 def 定义开始，要注意的 Scala 的方法的参数都是 val 类型，而不是 var 类型，因此在函数体内不可以修改参数的值，比如如果你修改 add 方法如下：

 

 

使用class定义类：

class ChecksumAccumulator {}

然后就可以使用 new 来实例化：

val cal = new ChecksumAccumulator

类里面可以放置字段和方法，这都称为成员（member）。

字段，不管是使用val还是var，都是指向对象的变量（即Java中的引用）

方法，使用def进行定义

 

class ChecksumAccumulator {

  var sum = 0

}

 

object Test {

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

    val acc = new ChecksumAccumulator

    val csa = new ChecksumAccumulator

  }

}

刚实例化时内存的状态如下：

 

注：在Scala中，由于数字类型（整型与小数）都是final类型的，即不可变，所以在内存中如果是同一数据，则是共享的

 

由于上面是使用var进行定义的字段，而不是val，所以可以重新赋值：

    acc.sum = 3

现在内存状态如下：

 

 

由于修改了acc中sum的内容，所以acc.sum指向了3所在的内存。

 

对象的稳定型就是要保证对象状态的稳定型，即对象中字段值在对象整个生命周期中持续有效。这需要将字段设为private以阻止外界直接对它进行访问与修改，因为私有字段只能被同一类里的方法访问，所以更新字段的代码将被锁定在类里：

class ChecksumAccumulator {

  private var sum = 0

  def add(b: Byte): Unit = {

    sum += b

  }

}

与Java 不同的，Scala 的缺省修饰符为 public，也就是如果不带有访问范围的修饰符 public,protected,private，Scala 缺省定义为 public

 

类的方法以 def 定义开始，要注意的 Scala 的方法的参数都是 val 类型，而不是 var 类型，因此在函数体内不可以修改参数的值，比如如果你修改 add 方法如下：

  def add(b: Byte): Unit = {

    b = 1 // 编译出错，因为b是val ：error: reassignment to val

    sum += b

  }

 

如果某个方法的方法体只有一条语句，则可以去掉花括号：

def add(b: Byte): Unit = sum += b

 

类的方法分两种，一种是有返回值的，一种是不含返回值

 

如果方法没有返回值（或为Unit），则定义方法时可以去掉结果类型和等号 =，并把方法体放在花括号里：

def add(b: Byte) { sum += b }

 

定义方法时，如果去掉方法体前面的等号 =，则方法的结果类型就一定是Unit，这不管方法体最后语句是啥，因为编译器可以把任何类型转换为Unit，如结果是String，但返回结果类型声明为Unit，那么String将被转换为Unit并丢弃原值。下面是明确定义返回类型为Unit：

scala> def f(): Unit = "this String gets lost"

f: ()Unit

去掉等号的方法返回值类型也一定是Unit：

scala> def g() { "this String gets lost too" }

g: ()Unit

 

加上等号时，如果没有确定定义返回类型，则会根据方法体最后语句来推导：

scala> def h() = { "this String gets returned!" }

h: ()java.lang.String

scala> h

res0: java.lang.String = this String gets returned!

 

Scala 代码无需使用“；”结尾，也不需要使用 return返回值，函数的最后一行的值就作为函数的返回值

1.9               Singleton单例对象

Scala中不能定义静态成员，而是以定义成单例对象（singleton object）来代替，即定义类时，使用的object关键字，而非class关键字，但看上去就像定义class一样：

class ChecksumAccumulator {

  private var sum = 0

  def add(b: Byte): Unit = {

    sum += b

  }

  def checksum(): Int = {

    return ~(sum & 0xFF) + 1

  }

}

 

import scala.collection.mutable.Map

object ChecksumAccumulator {

  private val cache = Map[String, Int]()

  def calculate(s: String): Int =

    if (cache.contains(s))

      cache(s)

    else {

      val acc = new ChecksumAccumulator

      for (c <- s)

        acc.add(c.toByte)

      val cs = acc.checksum()

      cache += (s -> cs)

      cs

    }

}

当单例对象（object）与某个类（class）的名称相同时（上面都为ChecksumAccumulator），它就被称为是这个类的伴生对象。类和它的伴生对象必须定义在一个源文件里。类被称为这个单例对象的伴生类。类和它的伴生对象可以互相访问其私有成员

 

可以将单例对象当作Java中的静态方法工具类来使用，可以直接通过单例对象的名称来调用：

ChecksumAccumulator.calculate("Every value is an object.")

其实，单例对象就是一个对象，不需要实例化就可以直接通过单例对象名来访问其成员，即单例对象名就相当于变量名，已指向了某个类的实例，只不过该类不是由你来实例化，而是在访问它时由Scala实例化出来的，且在JVM只有一个这个的实例。在编译伴生对象时，会生成一个相应名为ChecksumAccumulator$（在单例对象名后加上美元符号）的类：

 

类和单例对象的差别：单例对象定义时不带参数（Object关键字后面），而类可以（Class关键字后面可以带括号将类参数包围起来），因为单例对象不是使用new关键字实例化出来的（这也是 Singleton 名字的由来）

 

单例对象在第一次被访问的时候才会被始化

 

没有伴生类的单例对象被称为独立对象，一般作为相关功能方法的工具类，或者用作Scala应用的入口程序

 

1.10         Scala入口程序

在Java中，只要类中有如下签名的main方法，即可作为程序入口程序：

class T {

   public static void main(String[] args) {}

}

在Scala中，入口程序不是定义在类class中的，而是定义在单例对象中的，

object T {

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

}

与Java 类似，Scala 中任何 Singleton对象（使用Object关键字定义），如果包含 main 方法，都可以作为应用的入口

 

Scala的每个源文件都会自动引入包java.lang和scala包中的成员，和scala包中名为Predef的单例对象的成员，该单例对象中包含了许多有用的方法，例如，当在Scala源文件中写pringln的时候，实际调用了Predef.println，另外当你写assert，实质上是调用Predef.assert

 

Java的源文件扩展名为.java，而Scala的源文件扩展名为.scala

 

在Java中，如果源文件中有public的class，则该public类的类名必须与Java源文件名一致，但在Scala中没有这种限制，但一般会将源文件名与类名设为一致

 

与Java一样，也有对应的编译与运行命令，它们分别是scalac（编译）与scala（运行），ava中的为javac、java，不管是Java还是Scala程序，都会编译成.class的字节码文件

 

Scala 为 Singleton 对象的 main 定义了一个 App trait 类型

Scala的入口程序还可以继承scala.App特质（Trait，Scala中的Trait像Java中的Interface，但不同的是可以有方法的实现），这样就不用写main方法（因为scala.App特质里实现了main方法），而直接将代码写在花括号里，花括号里的代码会被收集进单例对象的主构造器中，并在类被初始化时执行：

object T extends scala.App {

  println("T")

}

缺点：命令参数行args不能再被访问；某些JVM线程会要求main方法不能通过继承得到，必须自己行编写；

 

1.11         基本类型

Java 支持的基本数据类型，Scala 都有对应的支持，不过 Scala 的数据类型都是对象，而且这些基本类型都可以通过隐式自动转换的形式支持比 Java 基本数据类型更多的方法：比如调用 （-1）.abs() ，Scala 发现基本类型 Int 没有提供 abs（）方法，但可以发现系统提供了从 Int 类型转换为 RichInt 的隐式自动转换，而 RichInt 具有 abs 方法，那么 Scala 就自动将 1 转换为 RichInt 类型，然后调用 RichInt 的 abs 方法。

 

Scala 的基本数据类型有: Byte,Short，Int，Long 和 Char （这些成为整数类型）。整数类型加上 Float 和 Double 成为数值类型。此外还有 String 类型，除 String 类型在 java.lang 包中定义，其它的类型都定义在包 scala 中。比如 Int 的全名为 scala.Int。实际上 Scala 运行环境自动会载入包 scala 和 java.lang 中定义的数据类型，你可以使用直接使用 Int，Short，String 而无需再引入包或是使用全称（如scala.xx与java.lang.xx）。

 

Scala的基本类型与Java对应类型范围完全一样，这样可以让Scala编译器直接把这些类型编译成Java中的原始类型

 

scala> var hex=0xa  //十六进制，整数默认就是Int类型

hex: Int = 10

scala> var hex:Short=0x00ff //若要Short类型，则要明确指定变量类型

hex: Short = 255

scala> var hex=0xaL //赋值时明确指定数据为Long型，否则默认为Int类型

hex: Long = 10

scala> val prog=2147483648L //若超过了Int范围，则后面一定要加上 L ，置换为Long类型

prog: Long = 2147483648

scala> val bt:Byte= 38 //若要Byte类型，则要在定义时明确指定变量的类型为Byte类型

bt: Byte = 38

 

scala> val big=1.23232 //小数默认就是Double类型

big: Double = 1.23232

 

scala> val big=1.23232f //如果要定义成Float，则可直接在小数后面加上F

big: Float = 1.23232

scala> val big=1.23232D //虽然默认就是Double，但也可在小数后面加上D

big: Double = 1.23232

 

scala> val a='A' //类型推导成Char类型

a: Char = A

scala> val f ='\u0041' //也可以使用Unicode编码表示，以 \u 开头，u一定要小写，且\u后面接4位十六进制

f: Char = A

 

scala> val hello="hello" //类型推导成String类型

hello: String = hello

scala> val longString=""" Welcome to Ultamix 3000. Type "Help" for help.""" //以使用三个引号（"""）开头和结尾，这样之间的字符都将看作是最原始的字符，不会被转义

longString: String = " Welcome to Ultamix 3000. Type "Help" for help." //注：开头与结尾的双引号不属于上面字符串的一部分，而是表示控制台上输出的是String

 

scala> val bool=true

bool: Boolean = true

1.12         字面量

字面量就是直接写在代码里的常量值

1.12.1              整数字面量

十六进制以 0x或0X开头：

scala> val hex = 0x5

hex: Int = 5

scala> val hex2 = 0x00FF

hex2: Int = 255

scala> val magic = 0xcafebabe

magic: Int = -889275714

注：不区分大小写

 

八进制以0开头

scala> val oct = 035 // （八进制35是十进制29）

oct: Int = 29

scala> val nov = 0777

nov: Int = 511

scala> val dec = 0321

dec: Int = 209

 

如果是非0开头，即十进制：

scala> val dec2 = 255

dec2: Int = 255

 

注：不管字面量是几进制，输出时都会转换为十进制

 

如果整数以L或l结尾，就是Long类型，否则默认就是Int类型：

scala> val prog = 0XCAFEBABEL

prog: Long = 3405691582

scala> val tower = 35L

tower: Long = 35

scala> val of = 31l

of: Long = 31

 

从上面可以看出，定义Int型时可以省去类型即可，如果是Long类型，定义时也可省略Long类型，此时在数字后面加上L或l即可，但也可以直接定义成Long也可：

scala> var lg:Long = 2

lg: Long = 2

如果要得到Byte或Short类型的变量时，需在定义时指定变量的相应类型：

scala> val little: Short = 367

little: Short = 367

scala> val littler: Byte = 38

littler: Byte = 38

1.12.2              浮点数字面量

scala> val big = 1.2345

big: Double = 1.2345

scala> val bigger = 1.2345e1

bigger: Double = 12.345

scala> val biggerStill = 123E45

biggerStill: Double = 1.23E47

 

小数默认就是Double类型，如果要是Float，则要以F结尾：

scala> val little = 1.2345F

little: Float = 1.2345

scala> val littleBigger = 3e5f

littleBigger: Float = 300000.0

 

当然Double类型也可以D结尾，不过是可选的

scala> val anotherDouble = 3e5

anotherDouble: Double = 300000.0

scala> val yetAnother = 3e5D

yetAnother: Double = 300000.0

 

当然，也要以在定义变量时明确指定类型也可：

scala> var f2 = 1.0

f2: Double = 1.0

scala> var f2:Float = 1

f2: Float = 1.0

1.12.3              字符字面量

使用单引号引起的单个字符

scala> val a = 'A'

a: Char = A

 

单引号之间除了直接是字符外，也可以是对应编码，编码是八进制或十六进制来表示

 

如果以八进制表示，则以 \ 开头，且为 '\0 到 '\377' （0377=255）：

scala> val c = '\101'

c: Char = A

注：如果以八进制表示，则只能表示一个字节大小的字符，即0~255之间的ASCII码单字节字符，如果要表示大于255的Unicode字符，则只能使用十六进制来表示：

scala> val d = '\u0041'

d: Char = A scala>

val f = '\u0044'

f: Char = D

scala> val c = '\u6c5f'

c: Char = 江

注：以十六进制表示时，需以 \u（小写）开头，即后面跟4位十六进制的编码（两个字节）

 

实际上，十六进制可以出现在Scala程序的任何地方，如可以用在变量名里：

scala> val B\u0041\u0044 = 1

BAD: Int = 1

 

转义字符：

scala> val backslash = '\\'

backslash: Char = \

 

1.12.4              字符串字面量

使用双引号引起来的0个或多个字符

scala> val hello = "hello"

hello: java.lang.String = hello

 

特殊字符也需转义：

scala> val escapes = "\\\"\'"

escapes: java.lang.String = \"'

 

如果字符串中需要转义的字符很多时，可以使用三个引号（"""）开头和结尾，这样之间的字符都将看作是最原始的字符，不会被转义（当然三个连续的引号除外）：

 

发现第二行前面的空格也会原样输出来，所以第二行前面看起来缩进了，如果要去掉每行前面的空白字符（ASCII编码小于等于32的都会去掉），则把管道符号（|）放在每行前面，然后对字符串调用stripMargin：

 

1.12.5              Symbol符号字面量

以单引号打头，后面跟一个或多个数字、字母或下划线，但第一个字符不能是数字，这种字面量会转换成预定义类scala.Symbol的实例，如 'cymbal编译器将会调用工厂方法Symbol("cymbal")转化成Symbol实例。

scala> val s = 'aSymbol

s: Symbol = 'aSymbol

scala> s.name

res20: String = aSymbol

 

符号字面量 'x 是表达式 scala.Symbol("x") 的简写

 

Java中String的intern()方法：String类内部维护一个字符串池(strings pool)，当调用String的intern()方法时，如果字符串池中已经存在该字符串，则直接返回池中字符串引用，如果不存在，则将该字符串添加到池中，并返回该字符串对象的引用。执行过intern()方法的字符串，我们就说这个字符串被拘禁了(interned)，即放入了池子。默认情况下，代码中的字符串字面量和字符串常量值都是被拘禁的，例如：

      String s1 = "abc";

      String s2 = new String("abc");

      System.out.println(s1 == s2);//false

      System.out.println(s1 == s2.intern());//true

同值字符串的intern()方法返回的引用都相同，例如：

      String s2 = new String("abc");

      String s3 = new String("abc");

      System.out.println(s2 == s3);// false

      System.out.println(s2.intern() == s3.intern());// true

 

      String str1 = "abc";

      String str2 = "abc";

      System.out.println(str1 == str2);//true

      String str3 = new String("abc");

      System.out.println(str1 == str3);//false

 

Sysmbol实质上也是一种字符串，其好好处：

1. 节省内存

在Scala中，Symbol类型的对象是被拘禁的(interned，即会被放入池中)，任意的同名symbols都指向同一个Symbol对象，避免了因冗余而造成的内存开销：

    val s1 = "aSymbol"

    val s2 = "aSymbol"

    println(s1.eq(s2)) //true ：表明s1与s2指向同一对象

    val s3 = new String("aSymbol") //由于在编译时就确定，所以还是会放入常量池

    println(s1.eq(s3)) //false : 表明s1与s3不是同一对象

    println(s1 == s3) //true：虽然不是同一对象，但是它们的内容相同

 

    val s = 'aSymbol

    println(s.eq('aSymbol)) //true

println(s.eq(Symbol("aSymbol"))) //true：只要是同名的Symbol，则都是指向同一对象

    //即使s与s3的内容相同，但eq比较的是对象地址，所以不等

    println(s.name.eq(s3)) //false

    println(s.name == s3) //true：但内容相同

println(s.name.eq(s1)) //true : s与s1的的内容都会放入池中，所以指向的是同一对象

注：在Scala中，如果要基于引用地址进行比较，则要使用eq方法，而不是==，这与Java是不一样的

2. 快速比较

由于Symbol类型的对象会自动拘禁的(interned)，任意的同名symbols（准确的说是值）都指向同一个Symbol对象，而相同值的字符串并不一定是同一个instance，所以symbols对象之间的比较操作符==速度会很快：因为它只基于地址进行比较，如果发现不是同一Symbols对象，则就认为不相同，不会在对内容进行比较（因为不同名的Symbols的值肯定也不相同）

Symbol类型的应用

Symbol类型一般用于快速比较，例如用于Map类型：Map<Symbol, Data>,根据一个Symbol对象，可以快速查询相应的Data, 而Map<String, Data>的查询效率则低很多。

虽说利用String的intern方法也可以实现Map<String, Data>的键值快速比较，但是由于需要显式地调用intern()方法，在编码时会造成很多的麻烦，而且如果忘了调用intern()方法，还会造成难以寻找的bug。从这个角度看，Scala的Symbol类型会自动进行intern操作（加入到池中），所以简化了编码的复杂度；而Java中除了字符串常量，是不会自动进行intern的，需要对相应对象手动调用interned方法

1.12.6              布尔字面量

scala> val bool = true

bool: Boolean = true

scala> val fool = false

fool: Boolean = false

1.13         操作符和方法

操作符如+加号，实质上是类型中有名为 + 的方法：

scala> val sum = 1 + 2 // Scala调用了(1).+(2)

sum: Int = 3

scala> val sumMore = (1).+(2)

sumMore: Int = 3

实际上Int类型包含了名为 + 的各种不同参数的重载方法，如Int+Long：

scala> val longSum = 1 + 2L // Scala调用了(1).+(2L)

longSum: Long = 3

 

既然+是名为加号的方法，可以以 1+2 这种操作模式来调用，那么其他方法也是可以如下方式来调用：

scala> val s = "Hello, world!"

s: java.lang.String = Hello, world!

scala> s indexOf 'o' // 调用了s.indexOf(’o’)

res0: Int = 4

如果有多个参数，则要使用括号：

scala> s indexOf ('o', 5) // Scala调用了s.indexOf(’o’, 5)

res1: Int = 8

 

在 Scala 中任何方法都可以是操作符：Scala里的操作符不是特殊的语法，任何方法都可以是操作符，到底是方法还是操作符取决于你如何使用它。如果写成s.indexOf('o')，indexOf就不是操作符。不过如果写成，s indexOf 'o'，那么indexOf就是操作符了

 

上面看到的是中缀操作符，还是前缀操作符，如 -7里的“-”，后缀操作符如 7 toLong里的“toLong”（ 实为 7.toLong ）。

前缀操作符与后缀操作都只有一个操作数，是一元（unary）操作符，如-2.0、!found、~0xFF，这些操作符对应的方法是在操作符前加上前缀“unary_”：

scala> -2.0 // Scala调用了(2.0).unary_-

res2: Double = -2.0

scala> (2.0).unary_-

res3: Double = -2.0

 

可以当作前缀操作符用的标识符只有+、-、!和~。因此，如果你定义了名为unary_!的方法，就可以对值或变量用 !P 这样的前缀操作符方式调用方法。但是如果你定义了名为unary_*的方法，就没办法将其用成前缀操作符了，因为*不是四种可以当作前缀操作符用的标识符之一。

 

后缀操作符是不用点与括号调用的不带任何参数的方法：

scala> val s = "Hello, world!"

s: java.lang.String = Hello, world!

scala> s.toLowerCase()

res4: java.lang.String = hello, world!

由于不带参数，则可能省略括号

scala> s.toLowerCase

res5: java.lang.String = hello, world!

还可以省去点：

scala> import scala.language.postfixOps//需要导一下这个来激活后缀操作符使用方式，否则会警告

import scala.language.postfixOps

scala> s toLowerCase

res6: java.lang.String = hello, world!

1.14         数学运算

scala> 1.2 + 2.3

res6: Double = 3.5

scala> 3 - 1

res7: Int = 2

scala> 'b' - 'a'

res8: Int = 1

scala> 2L * 3L

res9: Long = 6

scala> 11 / 4

res10: Int = 2

scala> 11 % 4

res11: Int = 3

scala> 11.0f / 4.0f

res12: Float = 2.75

scala> 11.0 % 4.0

res13: Double = 3.0

 

数字类型还提供了一元的前缀 + 和 - 操作符（方法 unary_+ 和 unary_-）

scala> val neg = 1 + -3

neg: Int = -2

scala> val y = +3

y: Int = 3

scala> -neg

res15: Int = 2

1.15         关系和逻辑操作

scala> 1 > 2

res16: Boolean = false

scala> 1 < 2

res17: Boolean = true

scala> 1.0 <= 1.0

res18: Boolean = true

scala> 3.5f >= 3.6f

res19: Boolean = false

scala> 'a' >= 'A'

res20: Boolean = true

 

可以使用一元操作符!（unary_!方法）改变Boolean值：

scala> val thisIsBoring = !true

thisIsBoring: Boolean = false

scala> !thisIsBoring

res21: Boolean = true

 

逻辑与（&&）和逻辑或（||）：

scala> val toBe = true

toBe: Boolean = true

scala> val question = toBe || !toBe

question: Boolean = true

scala> val paradox = toBe && !toBe

paradox: Boolean = false

 

与Java里一样，逻辑与和逻辑或有短路：

scala> def salt() = { println("salt"); false }

salt: ()Boolean

scala> def pepper() = { println("pepper"); true }

pepper: ()Boolean

scala> pepper()&& salt()

pepper

salt

res22: Boolean = false

scala> salt()&& pepper()

salt

res23: Boolean = false

 

scala> pepper() || salt()

pepper

res24: Boolean = true

scala> salt() || pepper()

salt

pepper

res25: Boolean = true

1.16         位操作符

按位与运算（&）：都为1时才为1，否则为0

按位或运算（|）：只要有一个为1 就为1，否则为0

按位异或运算（^）：相同位产生0，不同产生1，因此0011 ^ 0101产生0110。

scala> 1 & 2  // 0001 & 0010 = 0000 = 0

res24: Int = 0

scala> 1 | 2 // 0001 | 0010 = 0011 = 3

res25: Int = 3

scala> 1 ˆ 3 // 0001 ^ 0011 = 0010 = 2

res26: Int = 2

scala> ~1  // ~0001 = 1110(负数原码：从最末一位向前除符号位各位取反即可) = 1010 = -2

res27: Int = -2

负数补码：反码+1

 

左移（<<），右移（>>）和无符号右移（>>>）。左移和无符号右移在移动的时候填入零。右移则在移动时填入左侧整数的最高位（符号位）。

scala> -1 >> 31 //1111 1111 1111 1111 1111 1111 1111 1111 向右移动后，还是 1111 1111 1111 1111 1111 1111 1111 1111，左侧用符号位1填充

res38: Int = -1

scala> -1 >>> 31 //1111 1111 1111 1111 1111 1111 1111 1111 向右无符号移动后，为0000 0000 0000 0000 0000 0000 0000 0001，左侧用0填充

es39: Int = 1

scala> 1 << 2 //0000 0000 0000 0000 0000 0000 0000 0001 向左位移后，为0000 0000 0000 0000 0000 0000 0000 0100，右侧用0填充

res40: Int = 4

1.17         对象相等性

基本类型比较：

scala> 1 == 2
res31: Boolean = false
scala> 1 != 2
res32: Boolean = true
scala> 2 == 2
res33: Boolean = true

 

这些操作对所有对象都起作用，而不仅仅是基本类型，如列表的比较：

scala> List(1, 2, 3) == List(1, 2, 3)
res34: Boolean = true
scala> List(1, 2, 3) == List(1, 3, 2)
res35: Boolean = false

 

还可以对不同类型进行比较，如：

scala> 1 == 1.0
res36: Boolean = true
scala> List(1, 2, 3) == "hello"
res37: Boolean = false

 

甚至可以与null进行比较：

scala> List(1, 2, 3) == null
res38: Boolean = false

 

== 操作符在比较之前，会先判断左侧的操作符是否为null，不为null时再调用左操作数的equals方法进行比较，比较的结果主要是看这个左操作数的equals方法是怎么实现的。只要比较的两者内容相同且并且equals方法是基于内容编写的，不同对象之间比较也可能为true。x == that判断表达式判断的过程实质如下：

    if (x.eq(null))

      that eq null

    else

      x.equals(that)

equals方法是检查值是否相等，而eq方法检查的是引用是否相等。所以如果使用 == 操作符比较两个对象时，如果左操作数是null，那么调用eq判断右操作数也是否为null；如果左操作数不是null的情况则调用equals基于对象内容进行比较

 

!= 就是 == 计算结果取反

Java中的==即可以比较原始类型，也可以比较引用类型。对于原始类型，Java的==比较值的相等性，与Scala一致，而对于引用类型，Java的==是比较这两个引用是否都指向了同一个对象，不过Scala比较对象地址不是 == 而是使用eq方法，所以Scala中的 == 操作符作用于对象时，会转换调用equals方法来比较对象的内容（在左操作数非null情况下）

 

AnyRef的equals方法默认调用eq方法实现，也就是说，默认情况下，判断两个变量相等，要求必须指向同一个对象实例

 

注：在Scala中，如果要基于引用地址进行比较，则要使用eq方法，而不是==，这与Java是不一样的

1.18         操作符优先级

Scala中没有操作符，操作符只是方法的一种表达方式，其优先级是根据作用符的第一个字符来判断的（也有例外，请看后面以等号 = 字符结束的一些操作符），如规定第一个字符*就比+的优先级高。以操作符的第一个字符为依据，优先级如下：

(所有其他的特殊字符)
* / %
+ -
:
= !
< >
&

^

|
(所有字母)

(所有赋值操作)

上面同一行的字符具有同样的优先级

 

scala> 2 << 2 + 2 // 2<< (2 + 2)
res41: Int = 32

<<操作符第一个字符为<，根据上表 << 要比 + 优先级低

 

如果操作符以等号字符（ =）结束 ， 且操作符并非比较操作符<=，> =， ==，或=，那么这个操作符的优先级与赋值符（ =）相同。也就是说，它比任何其他操作符的优先级都低。例如：

x *= y + 1

与下面的相同：

x *= (y + 1)

操作符 *= 以 = 结束，被当作赋值操作符，它的优先级低于+，尽管操作符的第一个字符是*看起来高于+。

 

任何以“：”字符结尾的方法由它的右操作数调用，并传入左操作数；其他结尾的方法与之相反，它们被左操作数调用，并传入右操作：a * b 变成 a.*(b)， a:::b 变成 b.:::(a)。

 

多个同优先级操作符出现时，如果方法以：结尾，它们就被从右往左进行分组；反之，就从左往右进行分组，如：a ::: b ::: c 会被当作 a :::

(b ::: c)，而 a * b * c 被当作(a * b) * c

1.19         基本类型富包装类型

基本类型除了一些常见的算术操作外，还有一些更为丰富的操作，这些操作可以直接使用，更多需要参考API中对应的富包装类：

上述相应的富操作都是由下面相应的富包装类提供的，使用前会先自动进行隐式转换：