Java 表达式

Java 符号运算符
Java 赋值运算符
Java 连接字符串
Java 自增和自减运算符
Java 算术运算符
Java 布尔运算符
Java 关系运算符
Java 按位运算符
Java 复合赋值运算符
Java instanceof运算符
Java lambda运算符
Java 双冒号运算符
Java 运算符优先级
Java 运算符优先级列表
Java 关联性规则
Java 三元运算符
计算素数

原文：http://zetcode.com/lang/java/expressions/

在 Java 教程的这一部分中，我们将讨论表达式。

表达式是根据操作数和运算符构造的。表达式的运算符指示将哪些运算应用于操作数。表达式中运算符的求值顺序由运算符的优先级和关联性确定。

运算符是特殊符号，表示已执行某个过程。编程语言的运算符来自数学。程序员处理数据。运算符用于处理数据。操作数是运算符的输入（参数）之一。

一个运算符通常有一个或两个操作数。那些仅使用一个操作数的运算符称为一元运算符。那些使用两个操作数的对象称为二进制运算符。还有一个三元运算符?:可与三个操作数一起使用。

某些运算符可以在不同的上下文中使用。例如+运算符。它可以在不同情况下使用。它添加数字，连接字符串或指示数字的符号。我们说运算符是重载。

Java 符号运算符

有两个符号运算符：+和-。它们用于指示或更改值的符号。

com/zetcode/SignOperators.java

package com.zetcode;
public class SignOperators {
    public static void main(String[] args) {
        System.out.println(2);
        System.out.println(+2);
        System.out.println(-2);
    }
}

+和-符号指示值的符号。加号可用于表示我们有一个正数。可以将其省略，并且通常可以这样做。

com/zetcode/MinusSign.java

package com.zetcode;
public class MinusSign {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(-a);
        System.out.println(-(-a));
    }
}

减号更改值的符号。

Java 赋值运算符

赋值运算符=将值赋给变量。变量是值的占位符。在数学中，=运算符具有不同的含义。在等式中，=运算符是一个相等运算符。等式的左侧等于右侧。

int x = 1;

在这里，我们为x变量分配一个数字。

x = x + 1;

这个表达式在数学上没有意义，但是在编程中是合法的。表达式将 1 加到x变量。右侧等于 2，并且 2 分配给x。

3 = x;

此代码行导致语法错误。我们无法为字面值分配值。

Java 连接字符串

在 Java 中，+运算符还用于连接字符串。

com/zetcode/ConcatenateStrings.java

package com.zetcode;
public class ConcatenateStrings {
    public static void main(String[] args) {
        System.out.println("Return " + "of " + "the king.");
        System.out.println("Return".concat(" of").concat(" the king."));
    }
}

我们将三个字符串连接在一起。

System.out.println("Return " + "of " + "the king.");

字符串用+运算符连接。

System.out.println("Return".concat(" of").concat(" the king."));

连接字符串的另一种方法是concat()方法。

$ java ConcatenateStrings.java
Return of the king.
Return of the king.

这是程序的输出。

Java 自增和自减运算符

将值递增或递减一个是编程中的常见任务。 Java 为此有两个方便的运算符：++和--。

x++;
x = x + 1;
...
y--;
y = y - 1;

上面两对表达式的作用相同。

com/zetcode/IncDec.java

package com.zetcode;
public class IncDec {
    public static void main(String[] args) {
        int x = 6;
        x++;
        x++;
        System.out.println(x);
        x--;
        System.out.println(x);
    }
}

在上面的示例中，我们演示了两个运算符的用法。

int x = 6;
x++;
x++;

将x变量初始化为 6。然后将x递增两次。现在变量等于 8。

x--;

我们使用减量运算符。现在变量等于 7。

$ java IncDec.java
8
7

这是示例的输出。

Java 算术运算符

下表是 Java 中的算术运算符表。

符号	名称
`+`	加法
`-`	减法
`*`	乘法
`/`	除法
`%`	余数

以下示例显示了算术运算。

com/zetcode/Arithmetic.java

package com.zetcode;
public class Arithmetic {
    public static void main(String[] args) {
        int a = 10;
        int b = 11;
        int c = 12;
        int add = a + b + c;
        int sb = c - a;
        int mult = a * b;
        int div = c / 3;
        int rem = c % a;
        System.out.println(add);
        System.out.println(sb);
        System.out.println(mult);
        System.out.println(div);
        System.out.println(rem);
    }
}

在前面的示例中，我们使用加法，减法，乘法，除法和余数运算。这些都是数学所熟悉的。

int rem = c % a;

%运算符称为余数或模运算符。它找到一个数除以另一个的余数。例如9 % 4，9 模 4 为 1，因为 4 两次进入 9 且余数为 1。

$ java Arithmetic.java
33
2
110
4
2

这是示例的输出。

接下来，我们将说明整数除法和浮点除法之间的区别。

com/zetcode/Division.java

package com.zetcode;
public class Division {
    public static void main(String[] args) {
        int c = 5 / 2;
        System.out.println(c);
        double d = 5 / 2.0;
        System.out.println(d);
    }
}

在前面的示例中，我们将两个数字相除。

int c = 5 / 2;

在这段代码中，我们完成了整数除法。除法运算的返回值为整数。当我们将两个整数相除时，结果是一个整数。

double d = 5 / 2.0;

如果值之一是double或float，则执行浮点除法。在我们的例子中，第二个操作数是双精度数，因此结果是双精度数。

$ java Division.java
2
2.5

我们看到了程序的结果。

Java 布尔运算符

在 Java 中，我们有三个逻辑运算符。 boolean关键字用于声明布尔值。

符号	名称
`&&`	逻辑与
`		`	逻辑或
`!`	否定

布尔运算符也称为逻辑运算符。

com/zetcode/BooleanOperators.java

package com.zetcode;
public class BooleanOperators {
    public static void main(String[] args) {
        int x = 3;
        int y = 8;
        System.out.println(x == y);
        System.out.println(y > x);
        if (y > x) {
            System.out.println("y is greater than x");
        }
    }
}

许多表达式导致布尔值。例如，在条件语句中使用布尔值。

System.out.println(x == y);
System.out.println(y > x);

关系运算符始终导致布尔值。这两行分别显示false和true。

if (y > x) {
    System.out.println("y is greater than x");
}

仅在满足括号内的条件时才执行if语句的主体。 y > x返回true，因此消息"y大于x"被打印到终端。

true和false关键字表示 Java 中的布尔字面值。

com/zetcode/AndOperator.java

package com.zetcode;
public class AndOperator {
    public static void main(String[] args) {
        boolean a = true && true;
        boolean b = true && false;
        boolean c = false && true;
        boolean d = false && false;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
    }
}

该代码示例显示了逻辑和（&&）运算符。仅当两个操作数均为true时，它的求值结果为true。

$ java AndOperator.java
true
false
false
false

true只产生一个表达式。

如果两个操作数中的任何一个为真，则逻辑或（||）运算符求值为true。

com/zetcode/OrOperator.java

package com.zetcode;
public class OrOperator {
    public static void main(String[] args) {
        boolean a = true || true;
        boolean b = true || false;
        boolean c = false || true;
        boolean d = false || false;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
    }
}

如果运算符的任一侧为真，则操作的结果为真。

$ java OrOperator.java
true
true
true
false

四个表达式中的三个导致true。

否定运算符!将true设为false，并将false设为false。

com/zetcode/Negation.java

package com.zetcode;
public class Negation {
    public static void main(String[] args) {
        System.out.println(! true);
        System.out.println(! false);
        System.out.println(! (4 < 3));
    }
}

该示例显示了否定运算符的作用。

$ java Negation.java
false
true
true

This is the output of the program.

||和&&运算符经过短路求值。短路求值意味着仅当第一个参数不足以确定表达式的值时才求值第二个参数：当逻辑的第一个参数为false时，总值必须为false; 当逻辑或的第一个参数为true时，总值必须为true。短路求值主要用于提高性能。

一个例子可以使这一点更加清楚。

com/zetcode/ShortCircuit.java

package com.zetcode;
public class ShortCircuit {
    public static boolean One() {
        System.out.println("Inside one");
        return false;
    }
    public static boolean Two() {
        System.out.println("Inside two");
        return true;
    }
    public static void main(String[] args) {
        System.out.println("Short circuit");
        if (One() && Two()) {
            System.out.println("Pass");
        }
        System.out.println("#############");
        if (Two() || One()) {
            System.out.println("Pass");
        }
    }
}

在示例中，我们有两种方法。它们在布尔表达式中用作操作数。我们将看看它们是否被调用。

if (One() && Two()) {
    System.out.println("Pass");
}

One()方法返回false。短路&&不求值第二种方法。没有必要。一旦操作数为假，逻辑结论的结果始终为假。仅将"Inside one"打印到控制台。

if (Two() || One()) {
    System.out.println("Pass");
}

在第二种情况下，我们使用||运算符，并使用Two()方法作为第一个操作数。在这种情况下，"Inside two"和"Pass"字符串将打印到终端。同样，也不必求值第二个操作数，因为一旦第一个操作数计算为true，则逻辑或始终为true。

$ java ShortCircuit.java
Short circuit
Inside one
#############
Inside two
Pass

We see the result of the program.

Java 关系运算符

关系运算符用于比较值。这些运算符总是产生布尔值。

符号	含义
`<`	小于
`<=`	小于或等于
`>`	大于
`>=`	大于或等于
`==`	等于
`!=`	不等于

关系运算符也称为比较运算符。

com/zetcode/Relational.java

package com.zetcode;
public class Relational {
    public static void main(String[] args) {
        System.out.println(3 < 4);
        System.out.println(3 == 4);
        System.out.println(4 >= 3);
        System.out.println(4 != 3);
    }
}

在代码示例中，我们有四个表达式。这些表达式比较整数值。每个表达式的结果为true或false。在 Java 中，我们使用==比较数字。（某些语言（例如 Ada，Visual Basic 或 Pascal）使用=比较数字。）

Java 按位运算符

小数对人类是自然的。二进制数是计算机固有的。二进制，八进制，十进制或十六进制符号仅是数字符号。按位运算符使用二进制数的位。像 Java 这样的高级语言很少使用按位运算符。

符号	含义
`~`	按位取反
`^`	按位异或
`&`	按位与
`	`	按位或

按位取反运算符分别将 1 更改为 0，将 0 更改为 1。

System.out.println(~7); // prints -8
System.out.println(~ -8); // prints 7

运算符还原数字 7 的所有位。这些位之一还确定数字是否为负。如果我们再一次对所有位取反，我们将再次得到 7。

按位，运算符在两个数字之间进行逐位比较。仅当操作数中的两个对应位均为 1 时，位位置的结果才为 1。

      00110
   &  00011
   =  00010

第一个数字是二进制符号 6，第二个数字是 3，结果是 2。

System.out.println(6 & 3); // prints 2
System.out.println(3 & 6); // prints 2

按位或运算符在两个数字之间进行逐位比较。如果操作数中的任何对应位为 1，则位位置的结果为 1。

     00110
   | 00011
   = 00111

结果为00110或十进制 7。

System.out.println(6 | 3); // prints 7
System.out.println(3 | 6); // prints 7

按位互斥或运算符在两个数字之间进行逐位比较。如果操作数中对应位中的一个或另一个（但不是全部）为 1，则位位置的结果为 1。

      00110
   ^  00011
   =  00101

结果为00101或十进制 5。

System.out.println(6 ^ 3); // prints 5
System.out.println(3 ^ 6); // prints 5

Java 复合赋值运算符

复合赋值运算符是由两个运算符组成的简写运算符。

a = a + 3;
a += 3;

+=复合运算符是这些速记运算符之一。以上两个表达式相等。将值 3 添加到变量a中。

其他复合运算符是：

-=   *=   /=   %=   &=   |=   <<=   >>=

下面的示例使用两个复合运算符。

com/zetcode/CompoundOperators.java

package com.zetcode;
public class CompoundOperators {
    public static void main(String[] args) {
        int a = 1;
        a = a + 1;
        System.out.println(a);
        a += 5;
        System.out.println(a);
        a *= 3;
        System.out.println(a);
    }
}

我们使用+=和*=复合运算符。

int a = 1;
a = a + 1;

a变量被初始化为 1。使用非速记符号将值 1 添加到变量。

a += 5;

使用+=复合运算符，将 5 加到a变量中。该语句等于a = a + 5;。

a *= 3;

使用*=运算符，将a乘以 3。该语句等于a = a * 3;。

$ java CompoundOperators.java
2
7
21

这是示例输出。

Java `instanceof`运算符

instanceof运算符将对象与指定类型进行比较。

com/zetcode/InstanceofOperator.java

package com.zetcode;
class Base {}
class Derived extends Base {}
public class InstanceofOperator {
    public static void main(String[] args) {
        Base b = new Base();
        Derived d = new Derived();
        System.out.println(d instanceof Base);
        System.out.println(b instanceof Derived);
        System.out.println(d instanceof Object);
    }
}

在示例中，我们有两个类：一个基类和一个从基类派生的类。

System.out.println(d instanceof Base);

此行检查变量d是否指向作为Base类实例的类。由于Derived类继承自Base类，因此它也是Base类的实例。该行打印正确。

System.out.println(b instanceof Derived);

b对象不是Derived类的实例。该行显示false。

System.out.println(d instanceof Object);

每个类都有Object作为超类。因此，d对象也是Object类的实例。

$ java InstanceofOperator.java
true
false
true

This is the output of the program.

Java `lambda`运算符

Java8 引入了 lambda 运算符（->）。

(parameters) -> expression
(parameters) -> { statements; }

这是 Java 中 lambda 表达式的基本语法。 Lambda 表达式允许使用 Java 创建更简洁的代码。

参数类型的声明是可选的；编译器可以从参数的值推断类型。对于单个参数，括号是可选的；对于多个参数，它们是必需的。如果表达式主体中只有一个语句，则花括号是可选的。最后，如果主体具有用于返回值的单个表达式，则return关键字是可选的；需要大括号以指示表达式返回一个值。

com/zetcode/LambdaExpression.java

package com.zetcode;
import java.util.Arrays;
public class LambdaExpression {
    public static void main(String[] args) {
        String[] words = { "kind", "massive", "atom", "car", "blue" };
        Arrays.sort(words, (String s1, String s2) -> (s1.compareTo(s2)));
        System.out.println(Arrays.toString(words));
    }
}

在示例中，我们定义了一个字符串数组。使用Arrays.sort()方法和 lambda 表达式对数组进行排序。

$ java LambdaExpression.java
[atom, blue, car, kind, massive]

这是输出。

Lambda 表达式主要用于定义函数式接口的内联实现，即仅具有单个方法的接口。接口是用于强制执行合同的抽象类型。

com/zetcode/LambdaExpression2.java

package com.zetcode;
interface GreetingService {
    void greet(String message);
}
public class LambdaExpression2 {
    public static void main(String[] args) {
        GreetingService gs = (String msg) -> {
            System.out.println(msg);
        };
        gs.greet("Good night");
        gs.greet("Hello there");
    }
}

在示例中，我们借助 lambda 表达式创建了问候服务。

interface GreetingService {
    void greet(String message);
}

接口GreetingService已创建。实现此接口的所有对象都必须实现greet()方法。

GreetingService gs = (String msg) -> {
    System.out.println(msg);
};

我们创建一个使用 lambda 表达式实现GreetingService的对象。该对象具有将消息打印到控制台的方法。

gs.greet("Good night");

我们调用对象的greet()方法，该方法将一条给定消息打印到控制台。

$ java LambdaExpression2.java
Good night
Hello there

这是程序输出。

有一些常见的函数式接口，例如Function，Consumer或Supplier。

com/zetcode/LambdaExpression3.java

package com.zetcode;
import java.util.function.Function;
public class LambdaExpression3 {
    public static void main(String[] args) {
        Function<Integer, Integer> square = (Integer x) -> x * x;
        System.out.println(square.apply(5));
    }
}

该示例使用 lambda 表达式计算整数平方。

Function<Integer, Integer> square = (Integer x) -> x * x;
System.out.println(square.apply(5));

Function是一个接受一个参数并产生结果的函数。 lambda 表达式的运算产生给定整数的平方。

Java 双冒号运算符

Java8 中引入的双冒号运算符（::）用于创建对方法的引用。

com/zetcode/DoubleColonOperator.java

package com.zetcode;
import java.util.function.Consumer;
public class DoubleColonOperator {
    private static void greet(String msg) {
        System.out.println(msg);
    }
    public static void main(String[] args) {
        Consumer<String> f = DoubleColonOperator::greet;
        f.accept("Hello there");
    }
}

在代码示例中，我们使用双冒号运算符创建对静态方法的引用。

private static void greet(String msg) {
    System.out.println(msg);
}

我们有一个静态方法向控制台打印问候语。

Consumer<String> f = DoubleColonOperator::greet;

Consumer是一个函数式接口，表示接受单个输入参数且不返回结果的操作。使用双冒号运算符，我们创建对greet()方法的引用。

f.accept("Hello there");

我们使用accept()方法执行函数式操作。

Java 运算符优先级

运算符优先级告诉我们首先求值哪个运算符。优先级对于避免表达式中的歧义是必要的。

以下表达式 28 或 40 的结果是什么？

3 + 5 * 5

像数学中一样，乘法运算符的优先级高于加法运算符。结果是 28。

(3 + 5) * 5

要更改求值的顺序，可以使用括号。括号内的表达式始终首先被求值。上面的表达式的结果是 40。

Java 运算符优先级列表

下表显示了按优先级排序的常见 Java 运算符（最高优先级优先）：

运算符	含义	关联性
`[] () .`	数组访问，方法调用，对象成员访问	从左到右
`++ -- + -`	递增，递减，一元加减	从右到左
`! ~ (type) new`	否定，按位非，类型转换，对象创建	从右到左
`* / %`	乘法，除法，模	从左到右
`+ -`	加，减	从左到右
`+`	字符串连接	从左到右
`<< >> >>>`	移位	从左到右
`< <= > >=`	关系	从左到右
`instanceof`	类型比较	从左到右
`== !=`	相等	从左到右
`&`	按位与	从左到右
`^`	按位异或	从左到右
`	`	按位或	从左到右
`&&`	逻辑与	从左到右
`		`	逻辑或	从左到右
`? :`	三元	从右到左
`=`	简单赋值	从右到左
`+= -= *= /= %= &=`	复合赋值	从右到左
`^= \|= <<= >>= >>>=`	复合赋值	从右到左

Table: Operator precedence and associativity

表的同一行上的运算符具有相同的优先级。如果我们使用具有相同优先级的运算符，则将应用关联规则。

com/zetcode/Precedence.java

package com.zetcode;
public class Precedence {
    public static void main(String[] args) {
        System.out.println(3 + 5 * 5);
        System.out.println((3 + 5) * 5);
        System.out.println(! true | true);
        System.out.println(! (true | true));
    }
}

在此代码示例中，我们显示一些表达式。每个表达式的结果取决于优先级。

System.out.println(3 + 5 * 5);

该行打印 28。乘法运算符的优先级高于加法。首先，计算5*5的乘积，然后加 3。

System.out.println(! true | true);

在这种情况下，求反运算符的优先级高于按位或。首先，将初始true值取反为false，然后|运算符将false和true组合在一起，最后给出true。

$ java Precedence.java
28
40
true
false

This is the example output.

Java 关联性规则

有时，优先级不能令人满意地确定表达式的结果。还有另一个规则称为关联性。运算符的关联性决定了具有相同优先级的运算符的求值顺序。

9 / 3 * 3

此表达式的结果是 9 还是 1？乘法，删除和模运算符从左到右关联。因此，该表达式的计算方式为：(9 / 3) * 3，结果为 9。

算术，布尔，关系和按位运算符都是从左到右关联的。赋值运算符，三元运算符，递增，递减，一元正负，取反，按位 NOT，类型强制转换，对象创建运算符从右到左关联。

com/zetcode/Associativity.java

package com.zetcode;
public class Associativity {
    public static void main(String[] args) {
        int a, b, c, d;
        a = b = c = d = 0;
        String str = String.format("%d %d %d %d", a, b, c, d);
        System.out.println(str);
        int j = 0;
        j *= 3 + 1;
        System.out.println(j);
    }
}

在该示例中，有两种情况，其中关联性规则确定表达式。

int a, b, c, d;
a = b = c = d = 0;

赋值运算符从右到左关联。如果关联性从左到右，则以前的表达式将不可能。

int j = 0;
j *= 3 + 1;

复合赋值运算符从右到左关联。我们可能期望结果为 1。但是实际结果为 0。由于有关联性。首先求值右边的表达式，然后应用复合赋值运算符。

$ java Associativity.java
0 0 0 0
0

This is the output of the program.

Java 三元运算符

三元运算符?:是条件运算符。对于要根据条件表达式选择两个值之一的情况，它是一个方便的运算符。

cond-exp ? exp1 : exp2

如果cond-exp为true，则求值exp1并返回结果。如果cond-exp为false，则求值exp2并返回其结果。

com/zetcode/TernaryOperator.java

package com.zetcode;
public class TernaryOperator {
    public static void main(String[] args) {
        int age = 31;
        boolean adult = age >= 18 ? true : false;
        System.out.println(String.format("Adult: %s", adult));
    }
}

在大多数国家，成年是基于年龄的。如果您的年龄超过特定年龄，则您已经成年。对于三元运算符，这是一种情况。

boolean adult = age >= 18 ? true : false;

首先，对赋值运算符右侧的表达式进行求值。三元运算符的第一阶段是条件表达式求值。因此，如果年龄大于或等于 18，则返回?字符后的值。如果不是，则返回:字符后的值。然后将返回值分配给成人变量。

$ java TernaryOperator.java
Adult: true

31 岁的成年人是成年人。

计算素数

在下面的示例中，我们将计算素数。

com/zetcode/PrimeNumbers.java

package com.zetcode;
public class PrimeNumbers {
    public static void main(String[] args) {
        int[] nums = { 0, 1, 2, 3, 4, 5, 6, 7, 8,
            9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
            19, 20, 21, 22, 23, 24, 25, 26, 27, 28 };
        System.out.print("Prime numbers: ");
        for (int num : nums) {
            if (num == 0 || num == 1) {
                continue;
            }
            if (num == 2 || num == 3) {
                System.out.print(num + " ");
                continue;
            }
            int i = (int) Math.sqrt(num);
            boolean isPrime = true;
            while (i > 1) {
                if (num % i == 0) {
                    isPrime = false;
                }
                i--;
            }
            if (isPrime) {
                System.out.print(num + " ");
            }
        }
        System.out.print('\n');
    }
}

在上面的示例中，我们处理了几个运算符。质数（或质数）是一个自然数，它具有两个截然不同的自然数除数：1 和它本身。我们选择一个数字并将其除以 1 到所选数字的数字。实际上，我们不必尝试所有较小的数字。我们可以将数字除以所选数字的平方根。该公式将起作用。我们使用余数除法运算符。

int[] nums = { 0, 1, 2, 3, 4, 5, 6, 7, 8,
    9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
    19, 20, 21, 22, 23, 24, 25, 26, 27, 28 };

我们将从这些数字计算素数。

if (num == 0 || num == 1) {
    continue;
}

值 0 和 1 不被视为素数。

if (num == 2 || num == 3) {
    System.out.print(num + " ");
    continue;
}

我们跳过 2 和 3 的计算。它们是质数。请注意等式和条件或运算符的用法。 ==的优先级高于||运算符。因此，我们不需要使用括号。

int i = (int) Math.sqrt(num);

如果我们仅尝试小于所讨论数字的平方根的数字，那么我们可以。

while (i > 1) {
    ...
    i--;
}

这是一个while循环。 i是计算出的数字的平方根。我们使用减量运算符将每个循环周期的i减 1。当i小于 1 时，我们终止循环。例如，我们有 9。9 的平方根是 3。我们将 9 的数字除以 3 和 2。这对于我们的计算就足够了。

if (num % i == 0) {
    isPrime = false;
}

如果余数除法运算符针对任何i值返回 0，则说明该数字不是质数。

在 Java 教程的这一部分中，我们介绍了 Java 表达式。我们提到了各种类型的运算符，并在表达式中描述了优先级和关联性规则。

Java 符号运算符

Java 赋值运算符

Java 连接字符串

Java 自增和自减运算符

Java 算术运算符

Java 布尔运算符

Java 关系运算符

Java 按位运算符

Java 复合赋值运算符

Java instanceof运算符

Java lambda运算符

Java 双冒号运算符

Java 运算符优先级

Java 运算符优先级列表

Java 关联性规则

Java 三元运算符

计算素数

Java `instanceof`运算符

Java `lambda`运算符