Scala 3 — Book

向 Java 开发者介绍Scala

此页面通过共享每种语言的并排示例，对 Java 和 Scala 编程语言进行了比较。它适用于了解 Java 并希望了解 Scala 的程序员，特别是通过 Scala 特性与 Java 特性的对比来了解。

概述

在进入示例之前，第一部分提供了以下部分的相对简短的介绍和总结。它从高层次上介绍了 Java 和 Scala 之间的异同，然后介绍了您在每天编写代码时会遇到的差异。

高层次的相似性

在高层次上，Scala 与 Java 有以下相似之处：

Scala代码编译成_.class_文件，打包成JAR文件，运行在JVM上
这是一种面向对象编程 (OOP) 语言
它是静态类型的
两种语言都支持 lambdas 和高阶函数
它们都可以与 IntelliJ IDEA 和 Microsoft VS Code 等 IDE 一起使用
可以使用 Gradle、Ant 和 Maven 等构建工具构建项目
它具有用于构建服务器端、网络密集型应用程序的出色库和框架，包括 Web 服务器应用程序、微服务、机器学习等（参见 “Awesome Scala” 列表）
Java 和 Scala 都可以使用 Scala 库：
- 他们可以使用 Akka actor 库来构建基于 actor 的并发系统，并使用 Apache Spark 来构建数据密集型应用程序
- 他们可以使用 Play Framework 开发服务器端应用程序
您可以使用 GraalVM 将您的项目编译为本机可执行文件
Scala 可以无缝使用为 Java 开发的大量库

高层次的差异

同样在高层次上，Java 和 Scala 之间的区别是：

Scala 语法简洁易读；我们称之为_表现力_
虽然它是静态类型的，但 Scala 经常感觉像是一门动态语言
Scala 是一种纯 OOP 语言，因此每个对象都是类的一个实例，而像运算符一样的符号 + 和 += 是真正的方法；这意味着您可以创建自己的运算符
除了是纯OOP语言，Scala还是纯FP语言；实际上，它鼓励 OOP 和 FP 的融合，具有用于逻辑的函数和用于模块化的对象
Scala 拥有一整套不可变集合，包括 List、Vector 和不可变的 Map 和 Set 实现
Scala 中的一切都是一个_表达式_：像 if 语句、for 循环、match 表达式，甚至 try/catch 表达式都有返回值
Scala 习惯上倾向缺省使用不可变性：鼓励您使用不可变（final）变量和不可变集合
惯用的 Scala 代码不使用 null，因此不会遭受 NullPointerException
Scala 生态系统在 sbt、Mill 等中还有其他构建工具
除了在 JVM 上运行之外，Scala.js 项目允许您使用 Scala 作为 JavaScript 替代品
Scala Native 项目添加了低级结构，让您可以编写“系统”级代码，也可以编译为本机可执行文件

编程层次差异

最后，这些是您在编写代码时每天都会看到的一些差异：

Scala 的语法极其一致
变量和参数被定义为val（不可变，如Java中的final）或var（可变）
类型推导 让您的代码感觉是动态类型的，并有助于保持您的代码简洁
除了简单的 for 循环之外，Scala 还具有强大的 for comprehensions，可以根据您的算法产生结果
模式匹配和 match 表达式将改变你编写代码的方式
默认情况下编写不可变代码会导致编写_表达式_而不是_语句_；随着时间的推移，您会发现编写表达式可以简化您的代码（和您的测试）
顶层定义让您可以将方法、字段和其他定义放在任何地方，同时也带来简洁、富有表现力的代码
您可以通过将多个 traits “混合”到类和对象中来创建_混搭_（特征类似于 Java 8 和更新版本中的接口）
默认情况下类是封闭的，支持 Joshua Bloch 在 Effective Java 的习惯用法，“Design and document for inheritance or else forbid it”
Scala 的上下文抽象和 术语推导 提供了一系列特性：
- 扩展方法让您向封闭类添加新功能
- [给_实例]givens 让您定义编译器可以在 _using 点合成的术语，从而使您的代码不那么冗长，实质上让编译器为您编写代码
- 多元等式允许您在编译时将相等比较限制为仅那些有意义的比较
Scala 拥有最先进的第三方开源函数式编程库
Scala 样例类就像 Java 14 中的记录；它们可以帮助您在编写 FP 代码时对数据进行建模，并内置对模式匹配和克隆等概念的支持
由于名称参数、中缀符号、可选括号、扩展方法和高阶函数等功能，您可以创建自己的“控制结构”和 DSL
Scala 文件不必根据它们包含的类或 trait 来命名
许多其他好东西：伴生类和对象、宏、联合和交集、数字字面量、多参数列表、参数的默认值、命名参数等

用例子来进行特性对比

鉴于该介绍，以下部分提供了 Java 和 Scala 编程语言功能的并排比较。

OOP 风格的类和方法

本节提供了与 OOP 风格的类和方法相关的特性的比较。

注释：

// 
/* ... */ 
/** ... */

// 
/* ... */ 
/** ... */

OOP 风格类，主构造函数：

Scala不遵循JavaBeans标准，因此我们在这里展示的Java代码与它后面的Scala代码等效，而不是显示以JavaBeans风格编写的Java代码。

class Person { 
  public String firstName; 
  public String lastName; 
  public int age; 
  public Person( 
    String firstName, 
    String lastName, 
    int age 
  ) { 
    this.firstName = firstName; 
    this.lastName = lastName; 
    this.age = age; 
  } 
  public String toString() { 
    return String.format("%s %s is %d years old.", firstName, lastName, age); 
  } 
}

class Person ( 
  var firstName: String, 
  var lastName: String, 
  var age: Int 
):   
  override def toString = s"$firstName $lastName is $age years old."

辅助构造函数：

public class Person { 
  public String firstName; 
  public String lastName; 
  public int age; 

  // primary constructor 
  public Person( 
    String firstName, 
    String lastName, 
    int age 
  ) { 
    this.firstName = firstName; 
    this.lastName = lastName; 
    this.age = age; 
  } 

  // zero-arg constructor 
  public Person() { 
    this("", "", 0); 
  } 

  // one-arg constructor 
  public Person(String firstName) { 
    this(firstName, "", 0); 
  } 

  // two-arg constructor 
  public Person( 
    String firstName, 
    String lastName 
  ) { 
    this(firstName, lastName, 0); 
  } 

}

class Person ( 
  var firstName: String, 
  var lastName: String, 
  var age: Int 
): 
    // zero-arg auxiliary constructor 
    def this() = this("", "", 0) 

    // one-arg auxiliary constructor 
    def this(firstName: String) = 
      this(firstName, "", 0) 

    // two-arg auxiliary constructor 
    def this( 
      firstName: String, 
      lastName: String 
    ) = 
      this(firstName, lastName, 0) 

end Person

类默认是封闭的：

“Plan for inheritance or else forbid it.”

final class Person

class Person

为扩展开放的类：

class Person

open class Person

单行方法：

public int add(int a, int b) { 
  return a + b; 
}

def add(a: Int, b: Int): Int = a + b

多行方法：

public void walkThenRun() { 
  System.out.println("walk"); 
  System.out.println("run"); 
}

def walkThenRun() = 
  println("walk") 
  println("run")

不可变字段：

final int i = 1;

val i = 1

可变字段：

int i = 1; 
var i = 1;

var i = 1

接口、trait 和继承

本节将Java接口与Scala trait 进行比较，包括类如何扩展接口和 trait。

接口/trait：

public interface Marker;

trait Marker

简单接口：

public interface Adder { 
  public int add(int a, int b); 
}

trait Adder: 
  def add(a: Int, b: Int): Int

有实体方法的接口：

public interface Adder { 
  int add(int a, int b); 
  default int multiply( 
    int a, int b 
  ) { 
    return a * b; 
  } 
}

trait Adder: 
  def add(a: Int, b: Int): Int 
  def multiply(a: Int, b: Int): Int = 
    a * b

继承：

class Dog extends Animal implements HasLegs, HasTail

class Dog extends Animal, HasLegs, HasTail

扩展多个接口

这些接口和特征具有具体的、已实现的方法（默认方法）：

interface Adder { 
  default int add(int a, int b) { 
    return a + b; 
  } 
} 

interface Multiplier { 
  default int multiply ( 
    int a, 
    int b) 
  { 
    return a * b; 
  } 
} 

public class JavaMath 
implements Adder, Multiplier {} 

JavaMath jm = new JavaMath(); 
jm.add(1,1); 
jm.multiply(2,2);

trait Adder: 
  def add(a: Int, b: Int) = a + b 

trait Multiplier: 
  def multiply(a: Int, b: Int) = a * b 

class ScalaMath extends Adder, Multiplier 

val sm = new ScalaMath 
sm.add(1,1) 
sm.multiply(2,2)

混搭：

N/A

class DavidBanner 

trait Angry: 
  def beAngry() = 
    println("You won’t like me ...") 

trait Big: 
  println("I’m big") 

trait Green: 
  println("I’m green") 

// mix in the traits as DavidBanner 
// is created 
val hulk = new DavidBanner with Big with Angry with Green

控制结构

本节比较在 Java 和 Scala 中的控制结构。

`if` 语句，单行：

if (x == 1) { System.out.println(1); }

if x == 1 then println(x)

`if` 语句，多行：

if (x == 1) { 
  System.out.println("x is 1, as you can see:") 
  System.out.println(x) 
}

if x == 1 then 
  println("x is 1, as you can see:") 
  println(x)

if, else if, else:

if (x < 0) { 
  System.out.println("negative") 
} else if (x == 0) { 
  System.out.println("zero") 
} else { 
  System.out.println("positive") 
}

if x < 0 then 
  println("negative") 
else if x == 0 
  println("zero") 
else 
  println("positive")

`if` 作为方法体：

public int min(int a, int b) { 
  return (a < b) ? a : b; 
}

def min(a: Int, b: Int): Int = 
  if a < b then a else b

从 `if` 返回值：

在 Java 中调用_三元运算符_：

int minVal = (a < b) ? a : b;

val minValue = if a < b then a else b

`while` 循环：

while (i < 3) { 
  System.out.println(i); 
  i++; 
}

while i < 3 do 
  println(i) 
  i += 1

`for` 循环，单行：

for (int i: ints) { 
  System.out.println(i); 
}

//preferred 
for i <- ints do println(i) 

// also available 
for (i <- ints) println(i)

`for` 循环，多行：

for (int i: ints) { 
  int x = i * 2; 
  System.out.println(x); 
}

for 
  i <- ints 
do 
  val x = i * 2 
  println(s"i = $i, x = $x")

`for` 循环，多生成器：

for (int i: ints1) { 
  for (int j: chars) { 
    for (int k: ints2) { 
      System.out.printf("i = %d, j = %d, k = %d\n", i,j,k); 
    } 
  } 
}

for 
  i <- 1 to 2 
  j <- 'a' to 'b' 
  k <- 1 to 10 by 5 
do 
  println(s"i = $i, j = $j, k = $k")

带守卫（`if`）表达式的生成器：

List ints = 
  ArrayList(1,2,3,4,5,6,7,8,9,10); 

for (int i: ints) { 
  if (i % 2 == 0 && i < 5) { 
    System.out.println(x); 
  } 
}

for 
  i <- 1 to 10 
  if i % 2 == 0 
  if i < 5 
do 
  println(i)

`for` comprehension:

N/A

val list = 
  for 
    i <- 1 to 3 
  yield 
    i * 10 
// list: Vector(10, 20, 30)

switch/match:

String monthAsString = ""; 
switch(day) { 
  case 1: monthAsString = "January"; 
          break; 
  case 2: monthAsString = "February"; 
          break; 
  default: monthAsString = "Other"; 
          break; 
}

val monthAsString = day match 
  case 1 => "January" 
  case 2 => "February" 
  _ => "Other"

switch/match, 每个情况下多个条件：

String numAsString = ""; 
switch (i) { 
  case 1: case 3: 
  case 5: case 7: case 9: 
    numAsString = "odd"; 
    break; 
  case 2: case 4: 
  case 6: case 8: case 10: 
    numAsString = "even"; 
    break; 
  default: 
    numAsString = "too big"; 
    break; 
}

val numAsString = i match 
  case 1 | 3 | 5 | 7 | 9 => "odd" 
  case 2 | 4 | 6 | 8 | 10 => "even" 
  case _ => "too big"

try/catch/finally:

try { 
  writeTextToFile(text); 
} catch (IOException ioe) { 
  println(ioe.getMessage()) 
} catch (NumberFormatException nfe) { 
  println(nfe.getMessage()) 
} finally { 
  println("Clean up resources here.") 
}

try 
  writeTextToFile(text) 
catch 
  case ioe: IOException => 
    println(ioe.getMessage) 
  case nfe: NumberFormatException => 
    println(nfe.getMessage) 
finally 
  println("Clean up resources here.")

集合类

本节比较 Java 和 Scala 里的集合类。

不可变集合类

如何创建不可变集合实例的例子。

Sequences:

List strings = List.of("a", "b", "c");

val strings = List("a", "b", "c") 
val strings = Vector("a", "b", "c")

Sets:

Set set = Set.of("a", "b", "c");

val set = Set("a", "b", "c")

Maps:

Map map = Map.of( 
  "a", 1, 
  "b", 2, 
  "c", 3 
);

val map = Map( 
  "a" -> 1, 
  "b" -> 2, 
  "c" -> 3 
)

可变集合类

Scala 在其 scala.collection.mutable 包中有可变集合类，例如 ArrayBuffer、Map 和 Set。在导入它们到当前作用域之后，创建它们就像刚刚显示的不可变 List、Vector、Map 和 Set 示例一样。

Scala 还有一个 Array 类，您可以将其视为 Java array 原始类型的包装器。一个 Scala Array[A] 映射到一个 Java A[]，所以你可以认为这个是 Scala Array[String]：

vala=Array("a","b")

这个追溯到 Java 的 String[]:

String[]a={"a","b"};

但是，Scala Array 还具有您期望在 Scala 集合中使用的所有函数方法，包括 map 和 filter：

valnums=Array(1,2,3,4,5)valdoubledNums=nums.map(_*2)val过滤Nums=nums.filter(_>2)

因为 Scala Array 的表示方式与 Java array 相同，所以您可以轻松地在 Scala 代码中使用返回数组的 Java 方法。

尽管讨论了 Array，但请记住，在 Scala 中通常有可能更适合的 Array 替代品。数组对于与其他语言（Java、JavaScript）的互操作很有用，并且在编写需要从底层平台获得最大性能的低级代码时也很有用。但总的来说，当你需要使用序列时，Scala 的习惯用法是更喜欢像 Vector 和 List 这样的不可变序列，然后在你真的需要可变序列时使用 ArrayBuffer。

您还可以使用 Scala CollectionConverters 对象在 Java 和 Scala 集合类之间进行转换。在不同的包中有两个对象，一个用于从 Java 转换为 Scala，另一个用于从 Scala 转换为 Java。下表显示了可能的转换：

Java	Scala
java.util.Collection	scala.collection.Iterable
java.util.List	scala.collection.mutable.Buffer
java.util.Set	scala.collection.mutable.Set
java.util.Map	scala.collection.mutable.Map
java.util.concurrent.ConcurrentMap	scala.collection.mutable.ConcurrentMap
java.util.Dictionary	scala.collection.mutable.Map

集合类的方法

由于能够将 Java 集合视为流，Java 和 Scala 现在可以使用许多相同的通用函数方法：

map
filter
forEach/foreach
findFirst/find
reduce

如果您习惯在 Java 中将这些方法与 lambda 表达式一起使用，您会发现在 Scala 的集合类上使用相同的方法很容易。

Scala 也有_数十个_其他集合方法，包括 head、tail、drop、take、distinct、flatten 等等。起初你可能想知道为什么会有这么多方法，但是在使用 Scala 之后你会意识到_因为_有这些方法，你很少需要再编写自定义的 for 循环了。

（这也意味着你也很少需要_读_自定义的 for 循环。因为开发人员倾向于在_读_代码上花费的时间是_编写_代码的十倍，这很重要。）

元组

Java 元组是这样创建的：

Pair<String,Integer>pair=newPair<String,Integer>("Eleven",11);Triplet<String,Integer,Double>triplet=Triplet.with("Eleven",11,11.0);Quartet<String,Integer,Double,Person>triplet=Quartet.with("Eleven",11,11.0,newPerson("Eleven"));

其他 Java 元组名称是 Quintet、Sextet、Septet、Octet、Ennead、Decade。

Scala 中任何大小的元组都是通过将值放在括号内来创建的，如下所示：

vala=("eleven")valb=("eleven",11)valc=("eleven",11,11.0)vald=("eleven",11,11.0,Person("Eleven"))

枚举

本节比较 Java 和 Scala 中的枚举。

基本枚举：

enum Color { 
  RED, GREEN, BLUE 
}

enum Color: 
  case Red, Green, Blue

参数化的枚举：

enum Color { 
  Red(0xFF0000), 
  Green(0x00FF00), 
  Blue(0x0000FF); 

  private int rgb; 

  Color(int rgb) { 
    this.rgb = rgb; 
  } 
}

enum Color(val rgb: Int): 
  case Red   extends Color(0xFF0000) 
  case Green extends Color(0x00FF00) 
  case Blue  extends Color(0x0000FF)

用户定义的枚举成员：

enum Planet { 
  MERCURY (3.303e+23, 2.4397e6), 
  VENUS   (4.869e+24, 6.0518e6), 
  EARTH   (5.976e+24, 6.37814e6); 
  // more planets ... 

  private final double mass; 
  private final double radius; 

  Planet(double mass, double radius) { 
    this.mass = mass; 
    this.radius = radius; 
  } 

  public static final double G = 
    6.67300E-11; 

  private double mass() { 
    return mass; 
  } 

  private double radius() { 
    return radius; 
  } 

  double surfaceGravity() { 
    return G * mass / 
      (radius * radius); 
  } 

  double surfaceWeight( 
    double otherMass 
  ) { 
    return otherMass * 
      surfaceGravity(); 
  } 

}

enum Planet( 
  mass: Double, 
  radius: Double 
): 
  case Mercury extends 
    Planet(3.303e+23, 2.4397e6) 
  case Venus extends 
    Planet(4.869e+24, 6.0518e6) 
  case Earth extends 
    Planet(5.976e+24, 6.37814e6) 
    // more planets ... 

  private final val G = 6.67300E-11 

  def surfaceGravity = 
    G * mass / (radius * radius) 

  def surfaceWeight(otherMass: Double) 
    = otherMass * surfaceGravity

异常和错误处理

本节介绍 Java 和 Scala 中的异常处理之间的差异。

Java 使用检查异常

Java 使用检查的异常，因此在 Java 代码中，您历来编写过 try/catch/finally 块，以及方法上的 throws 子句：

publicintmakeInt(Strings)throwsNumberFormatException{// code here to convert a String to an int}

Scala 不使用检查异常

Scala 的习惯用法是_不_使用这样的检查异常。在处理可能抛出异常的代码时，您可以使用 try/catch/finally 块从抛出异常的代码中捕获异常，但是如何从那里开始的方式是不同的。

解释这一点的最好方法是说 Scala 代码是由具有返回值的_表达式_组成的。其结果是，最终你写代就像写一系列代数表达式：

vala=f(x)valb=g(a,z)valc=h(b,y)

这很好，它只是代数。您创建方程来解决小问题，然后组合方程来解决更大的问题。

非常重要的是——正如你在代数课程中所记得的那样——代数表达式不会短路——它们不会抛出会破坏一系列方程的异常。

因此，在 Scala 中，我们的方法不会抛出异常。相反，它们返回像 Option 这样的类型。例如，这个 makeInt 方法捕获一个可能的异常并返回一个 Option 值：

defmakeInt(s:String):Option[Int]=trySome(s.toInt)catchcasee:NumberFormatException=>None

Scala Option 类似于 Java Optional 类。如图所示，如果 string 到 int 的转换成功，则在 Some 值中返回 Int，如果失败，则返回 None 值。 Some 和 None 是 Option 的子类型，因此该方法被声明为返回 Option[Int] 类型。

当您有一个 Option 值时，例如 makeInt 返回的值，有很多方法可以使用它，具体取决于您的需要。此代码显示了一种可能的方法：

makeInt(aString)matchcaseSome(i)=>println(s"Int i = $i")caseNone=>println(s"Could not convert $aString to an Int.")

Option 在 Scala 中很常用，它内置在标准库的许多类中。其他类似的类的集合，例如 Try/Success/Failure 和 Either/Left/Right，提供了更大的灵活性。

有关在 Scala 中处理错误和异常的更多信息，请参阅函数式错误处理部分。

Scala 独有的概念

以上就是 Java 和 Scala 语言的比较。

Scala 中还有其他一些概念目前在 Java 11 中是没有的。这包括：

与 Scala 的上下文抽象相关的一切
几个 Scala 方法特性：
- 多参数列表
- 默认参数值
- 调用方法时使用命名参数
样例类（如 Java 14 中的“记录”）、样例对象以及伴生类和对象（参见领域建模）一章
创建自己的控制结构和 DSL 的能力
顶级定义
模式匹配
match 表达式的高级特性
类型 lambdas
trait参数
不透明类型别名
多元相等性
类型类
中缀方法
宏和元编程

← previousnext →