既然你已經學會了如何聲明和初始化變量，那么你可能想知道如何使用它們，學習Java編程語言的運算符是一個很好的起點，運算符是對一個、兩個或三個操作數執行特定運算的特殊符號，然后返回結果。

在我們探索Java編程語言的運算符時，提前知道哪些運算符具有最高優先級可能會對你有所幫助，下表中的運算符按優先順序列出，運算符出現在離表頂部越近，其優先級越高，優先級較高的運算符在優先級相對較低的運算符之前進行求值。同一行上的運算符具有相同的優先權，當具有相同優先級的運算符出現在同一表達式中時，規則必須控制首先計算的值，除了賦值運算符之外的所有二元運算符都是從左到右計算的，賦值運算符從右到左進行求值。

在通用編程中，某些運算符往往比其他運算符更頻繁地出現，例如，賦值運算符“=”比無符號右移運算符“>>>”更常見，考慮到這一點，以下討論首先關注你最有可能經常使用的運算符，并最終關注那些不太常見的運算符。每個討論都附帶可以編譯和運行的示例代碼，研究它的輸出將有助于加強你剛剛學到的東西。

你將遇到的最常見的運算符之一是簡單賦值運算符“=”，你在Bicycle類中看到了此運算符，它將右側的值賦給左側的操作數：

 int cadence = 0;
 int speed = 0;
 int gear = 1;

此運算符也可用于對象以分配對象引用，如創建對象中所述。

Java編程語言提供執行加法，減法，乘法和除法的運算符，很有可能你會被基礎數學方面的同行認出來，唯一可能看起來很新的符號是“％”，它將一個操作數除以另一個操作數，并將余數作為結果返回。

以下程序ArithmeticDemo測試算術運算符。

class ArithmeticDemo {

    public static void main (String[] args) {

        int result = 1 + 2;
        // result is now 3
        System.out.println("1 + 2 = " + result);
        int original_result = result;

        result = result - 1;
        // result is now 2
        System.out.println(original_result + " - 1 = " + result);
        original_result = result;

        result = result * 2;
        // result is now 4
        System.out.println(original_result + " * 2 = " + result);
        original_result = result;

        result = result / 2;
        // result is now 2
        System.out.println(original_result + " / 2 = " + result);
        original_result = result;

        result = result + 8;
        // result is now 10
        System.out.println(original_result + " + 8 = " + result);
        original_result = result;

        result = result % 7;
        // result is now 3
        System.out.println(original_result + " % 7 = " + result);
    }
}

該程序打印以下內容：

1 + 2 = 3
3 - 1 = 2
2 * 2 = 4
4 / 2 = 2
2 + 8 = 10
10 % 7 = 3

你還可以將算術運算符與簡單賦值運算符組合以創建復合賦值，例如，x+=1;和x=x+1;都將x的值遞增1。

+運算符也可用于將兩個字符串連接（連接）在一起，如下面的ConcatDemo程序所示：

class ConcatDemo {
    public static void main(String[] args){
        String firstString = "This is";
        String secondString = " a concatenated string.";
        String thirdString = firstString+secondString;
        System.out.println(thirdString);
    }
}

在該程序結束時，變量thirdString包含“This is a concatenated string.”，它被打印到標準輸出。

一元運算符只需要一個操作數，它們執行各種操作，例如將值遞增/遞減1，否定表達式或反轉布爾值。

以下程序UnaryDemo測試一元運算符：

class UnaryDemo {

    public static void main(String[] args) {

        int result = +1;
        // result is now 1
        System.out.println(result);

        result--;
        // result is now 0
        System.out.println(result);

        result++;
        // result is now 1
        System.out.println(result);

        result = -result;
        // result is now -1
        System.out.println(result);

        boolean success = false;
        // false
        System.out.println(success);
        // true
        System.out.println(!success);
    }
}

可以在操作數之前（前綴）或之后（后綴）應用遞增/遞減運算符，代碼result++;和++result;將兩個結果都加1。唯一的區別是前綴版本（++result）評估為增量值，而后綴版本（result++）評估為原始值。如果你只是執行簡單的增量/減量，那么選擇哪個版本并不重要，但是，如果你在較大的表達式中使用此運算符，則你選擇的運算符可能會產生顯著差異。

以下程序PrePostDemo演示了前綴/后綴一元增量運算符：

class PrePostDemo {
    public static void main(String[] args){
        int i = 3;
        i++;
        // prints 4
        System.out.println(i);
        ++i;               
        // prints 5
        System.out.println(i);
        // prints 6
        System.out.println(++i);
        // prints 6
        System.out.println(i++);
        // prints 7
        System.out.println(i);
    }
}

等于和關系運算符確定一個操作數是否大于，小于，等于或不等于另一個操作數，這些運算符中的大多數也可能看起來很熟悉，請記住，在測試兩個原始值是否相等時，必須使用“==”而不是“=”。

以下程序ComparisonDemo測試比較運算符：

class ComparisonDemo {

    public static void main(String[] args){
        int value1 = 1;
        int value2 = 2;
        if(value1 == value2)
            System.out.println("value1 == value2");
        if(value1 != value2)
            System.out.println("value1 != value2");
        if(value1 > value2)
            System.out.println("value1 > value2");
        if(value1 < value2)
            System.out.println("value1 < value2");
        if(value1 <= value2)
            System.out.println("value1 <= value2");
    }
}

輸出：

value1 != value2
value1 <  value2
value1 <= value2

&&和||運算符對兩個布爾表達式執行條件與和條件或運算，這些運算符表現出“最少運算”行為，這意味著僅在需要時才評估第二個操作數。

以下程序ConditionalDemo1測試這些運算符：

class ConditionalDemo1 {

    public static void main(String[] args){
        int value1 = 1;
        int value2 = 2;
        if((value1 == 1) && (value2 == 2))
            System.out.println("value1 is 1 AND value2 is 2");
        if((value1 == 1) || (value2 == 1))
            System.out.println("value1 is 1 OR value2 is 1");
    }
}

另一個條件運算符是?:，這可以被認為是if-then-else語句的簡寫（在本課程的控制流語句部分中討論），此運算符也稱為三元運算符，因為它使用三個操作數，在以下示例中，應將此運算符讀作：“如果someCondition為true，則將value1的值賦給result，否則，將value2的值賦給result。”

以下程序ConditionalDemo2測試?:運算符：

class ConditionalDemo2 {

    public static void main(String[] args){
        int value1 = 1;
        int value2 = 2;
        int result;
        boolean someCondition = true;
        result = someCondition ? value1 : value2;

        System.out.println(result);
    }
}

因為someCondition為true，所以此程序在屏幕上打印“1”，如果它使代碼更具可讀性，請使用?:運算符而不是if-then-else語句，例如，當表達式緊湊且沒有副作用（例如賦值）時。

instanceof運算符將對象與指定的類型進行比較，你可以使用它來測試對象是否是類的實例，子類的實例或實現特定接口的類的實例。

以下程序InstanceofDemo定義了一個父類（名為Parent），一個簡單的接口（名為MyInterface）和一個繼承自父類并實現接口的子類（名為Child）。

class InstanceofDemo {
    public static void main(String[] args) {

        Parent obj1 = new Parent();
        Parent obj2 = new Child();

        System.out.println("obj1 instanceof Parent: "
            + (obj1 instanceof Parent));
        System.out.println("obj1 instanceof Child: "
            + (obj1 instanceof Child));
        System.out.println("obj1 instanceof MyInterface: "
            + (obj1 instanceof MyInterface));
        System.out.println("obj2 instanceof Parent: "
            + (obj2 instanceof Parent));
        System.out.println("obj2 instanceof Child: "
            + (obj2 instanceof Child));
        System.out.println("obj2 instanceof MyInterface: "
            + (obj2 instanceof MyInterface));
    }
}

class Parent {}
class Child extends Parent implements MyInterface {}
interface MyInterface {}

輸出：

obj1 instanceof Parent: true
obj1 instanceof Child: false
obj1 instanceof MyInterface: false
obj2 instanceof Parent: true
obj2 instanceof Child: true
obj2 instanceof MyInterface: true

使用instanceof運算符時，請記住null不是任何實例。

Java編程語言還提供對整數類型執行按位和位移操作的運算符，本節中討論的運算符不太常用，因此，他們的報道很簡短，目的是讓你意識到這些運算符的存在。

一元按位補碼運算符“?”反轉位模式，它可以應用于任何整數類型，使每個“0”為“1”，每個“1”為“0”，例如，一個字節包含8位，將此運算符應用于位模式為“00000000”的值會將其模式更改為“11111111”。

帶符號的左移運算符“<<”將位模式向左移位，帶符號的右移運算符“>>”將位模式向右移位，位模式由左側操作數給出，以及由右側操作數移位的位置數。無符號右移運算符“>>>”將零移動到最左側位置，而“>>”之后的最左側位置取決于符號擴展。

按位＆運算符執行按位與運算。
按位^運算符執行按位異或運算。
按位|運算符執行按位或運算。

以下程序BitDemo使用按位與運算符將數字“2”打印到標準輸出。

class BitDemo {
    public static void main(String[] args) {
        int bitmask = 0x000F;
        int val = 0x2222;
        // prints "2"
        System.out.println(val & bitmask);
    }
}

以下快速參考總結了Java編程語言支持的運算符。