Scala 3 — Book

向 Java 开发者介绍Scala

Language
Info: JavaScript is currently disabled, code tabs will still work, but preferences will not be remembered.

此页面通过共享每种语言的并排示例,对 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参数
  • 不透明类型别名
  • 多元相等性
  • 类型类
  • 中缀方法
  • 宏和元编程

Contributors to this page:

Contents

AltStyle によって変換されたページ (->オリジナル) /