Scala 3 — Book

向 Java 开发者介绍Scala

Language

    此页面通过共享每种语言的并排示例，对 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]：

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

    这个追溯到 Java 的 String[]:

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

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

    val nums = Array(1, 2, 3, 4, 5)
val doubledNums = 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 =
  new Pair<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, new Person("Eleven"));

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

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

    val a = ("eleven")
val b = ("eleven", 11)
val c = ("eleven", 11, 11.0)
val d = ("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 子句：

    public int makeInt(String s)
throws NumberFormatException {
  // code here to convert a String to an int
}

    Scala 不使用检查异常

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

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

    val a = f(x)
val b = g(a,z)
val c = h(b,y)

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

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

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

    def makeInt(s: String): Option[Int] =
  try
    Some(s.toInt)
  catch
    case e: NumberFormatException => None

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

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

    makeInt(aString) match
  case Some(i) => println(s"Int i = $i")
  case None => 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参数
    • 不透明类型别名
    • 多元相等性
    • 类型类
    • 中缀方法
    • 宏和元编程
    ← previous next →

    Contributors to this page:

    Contents
    Problem with this page?
         Please help us fix it!