[備忘録 その５] Java Silver ～演算子～

# 演算子
演算子は、プログラミングにおいて変数や値に対して操作を行うため記号やキーワードです。javaでは、多くの種類の演算子が提供されている。


<body>

<h1>演算子の優先度と結合規則</h1>

<table>
    <thead>
        <tr>
            <th>優先度</th>
            <th>演算子</th>
            <th>結合規則</th>
            <th>説明</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>1</td>
            <td>[] () .</td>
            <td>左から右</td>
            <td>配列アクセス、メソッド呼び出し、フィールドアクセス</td>
        </tr>
        <tr>
            <td>2</td>
            <td>++ --</td>
            <td>右から左</td>
            <td>後置インクリメント、後置デクリメント</td>
        </tr>
        <tr>
            <td>3</td>
            <td>++ -- + - ~ !</td>
            <td>右から左</td>
            <td>前置インクリメント、前置デクリメント、単項プラス、単項マイナス、ビットNOT、論理NOT</td>
        </tr>
        <tr>
            <td>4</td>
            <td>* / %</td>
            <td>左から右</td>
            <td>乗算、除算、剰余</td>
        </tr>
        <tr>
            <td>5</td>
            <td>+ -</td>
            <td>左から右</td>
            <td>加算、減算</td>
        </tr>
        <tr>
            <td>6</td>
            <td>&lt;&lt; &gt;&gt; &gt;&gt;&gt;</td>
            <td>左から右</td>
            <td>左シフト、右シフト、ゼロ埋め右シフト</td>
        </tr>
        <tr>
            <td>7</td>
            <td>&lt; &lt;= &gt; &gt;=</td>
            <td>左から右</td>
            <td>小なり、小なりイコール、大なり、大なりイコール</td>
        </tr>
        <tr>
            <td>8</td>
            <td>== !=</td>
            <td>左から右</td>
            <td>等価、非等価</td>
        </tr>
        <tr>
            <td>9</td>
            <td>&</td>
            <td>左から右</td>
            <td>ビットAND</td>
        </tr>
        <tr>
            <td>10</td>
            <td>^</td>
            <td>左から右</td>
            <td>ビットXOR</td>
        </tr>
        <tr>
            <td>11</td>
            <td>|</td>
            <td>左から右</td>
            <td>ビットOR</td>
        </tr>
        <tr>
            <td>12</td>
            <td>&&</td>
            <td>左から右</td>
            <td>論理AND</td>
        </tr>
        <tr>
            <td>13</td>
            <td>||</td>
            <td>左から右</td>
            <td>論理OR</td>
        </tr>
        <tr>
            <td>14</td>
            <td>? :</td>
            <td>右から左</td>
            <td>条件（三項）演算子</td>
        </tr>
        <tr>
            <td>15</td>
            <td>= += -= *= /= %=</td>
            <td>右から左</td>
            <td>代入、複合代入</td>
        </tr>
    </tbody>
</table>

</body>


##### 高優先度の演算子が先に評価される例
```java
int result = 2 + 3 * 4; // 2 + (3 * 4) -> 2 + 12 -> 14
```


##### 結合規則が影響する例
```java
int a = 1, b = 2, c = 3;
int result = a + b * c; // a + (b * c) -> 1 + (2 * 3) -> 1 + 6 -> 7
```


##### 前置と後置のインクリメント・デクリメント
```java
int x = 5;
int y = ++x; // yは6, xは6
int z = x--; // zは6, xは5
```

## 算術演算子と単項演算子
算術演算子と単項演算子は、数値や変数に対して基本的な操作を行うための演算子です。

### 算術演算子
算術演算子は数値に対する基本的な操作を行います。

1 \. 加算(+)
2つの数値を加算する
```java
int a = 5;
int b = 3;
int sum = a + b; // sumは8
```
2 \. 減算(-)
2つの数値を減算する
```java
int a = 5;
int b = 3;
int difference = a - b; // differenceは2
```
3 \. 乗算(*)
2つの数値を乗算する
```java
int a = 5;
int b = 3;
int product = a * b; // productは15
```
4 \. 除算(/)
2つの数値を除算する。整数除算では小数点以下が切り捨てられます。
```java
int a = 10;
int b = 3;
int quotient = a / b; // quotientは3
```
5 \. 剰余(%)
除算の余りを求める。
```java
int a = 10;
int b = 3;
int remainder = a % b; // remainderは1
```

### 単項演算子
単項演算子は、1つのオペランドに対して操作を行います。

1 \. 単項プラス(+)
値にプラスの符号をつける（通常は数値に変化はない）
```java
int a = 5;
int positive = +a; // positiveは5
```

2 \. 単項マイナス(-)
値にマイナスの符号をつける。
```java
int a = 5;
int negative = -a; // negativeは-5
```

3 \. インクリメント(++)
値を1増加させる。後置(x++)と前置(++x)があります。
* 後置インクリメント：変数の値を使用した後に1増加
* 前置インクリメント：変数の値を1増加させた後に使用。
```java
int a = 5;
int b = a++; // bは5、aは6
int c = ++a; // cは7、aは7
```

4 \. デクリメント(--)
値を1減少させる。後置(x--)と前置(--x)があります。
* 後置デクリメント：変数の値を使用した後に1減少
* 前置デクリメント：変数の値を1減少させた後に使用
```java
int a = 5;
int b = a--; // bは5、aは4
int c = --a; // cは3、aは3
```
5 \. ビットNOT(~)
ビット単位での反転(すべてのビットを反転させる。)
```java
int a = 5; // 0000 0101 in binary
int notA = ~a; // 1111 1010 in binary, which is -6 in decimal
```

6 \. 剰余(%)
ブール値を反転させる(trueをfalseにfalseをtrueにする)
```java
boolean flag = true;
boolean notFlag = !flag; // notFlagはfalse
```

## 代入演算子
代入演算子は、変数に値を代入するために使用される演算子です。多くのプログラミング言語で使用されており、基本的には'='記号が代入演算子として使用されます。

### 基本的な代入
```java
int a = 5;  // 変数aに5を代入
String name = "Alice";  // 変数nameに文字列"Alice"を代入
```
#### 複合代入演算子
複合代入演算子は、変数の現在の値に対して操作を行い、その結果を同じ変数に代入します。
```java
int a = 10;
a += 5;  // a = a + 5; と同じ。結果は15。

int b = 20;
b -= 3;  // b = b - 3; と同じ。結果は17。

int c = 4;
c *= 2;  // c = c * 2; と同じ。結果は8。

int d = 8;
d /= 2;  // d = d / 2; と同じ。結果は4。

int e = 7;
e %= 3;  // e = e % 3; と同じ。結果は1。

```

#### 代入演算子の使い方の例
```java
public class Main {
    public static void main(String[] args) {
        int number = 10;  // 変数numberに10を代入
        System.out.println("Number: " + number);  // Number: 10

        number += 5;  // numberに5を加算して再代入
        System.out.println("Number after += 5: " + number);  // Number after += 5: 15

        number -= 2;  // numberから2を減算して再代入
        System.out.println("Number after -= 2: " + number);  // Number after -= 2: 13

        number *= 3;  // numberに3を乗算して再代入
        System.out.println("Number after *= 3: " + number);  // Number after *= 3: 39

        number /= 3;  // numberを3で除算して再代入
        System.out.println("Number after /= 3: " + number);  // Number after /= 3: 13

        number %= 5;  // numberを5で割った余りを再代入
        System.out.println("Number after %= 5: " + number);  // Number after %= 5: 3
    }
}
```

## 関係演算子
関係演算子(比較演算子とも呼ばれます)は二つの値を比較し、その関係を評価するために使用されます。
評価結果は真(true)または偽(false)になります。

### 関係演算子の一覧

#### 1 \. 等しいかどうか(==) 
```java
int a = 5;
int b = 5;
boolean result = (a == b);  // true
```
#### 2 \. 等しくないかどうか(!=)
```java
int a = 5;
int b = 10;
boolean result = (a != b);  // true
```
#### 3 \. より大きいかどうか(>)
```java
int a = 10;
int b = 5;
boolean result = (a > b);  // true
```
#### 4 \. より小さいかどうか(<)
```java
int a = 5;
int b = 10;
boolean result = (a < b);  // true
```
#### 5 \. 以上かどうか(=>)
```java
int a = 10;
int b = 10;
boolean result = (a >= b);  // true
```
#### 6 \. 以下かどうか(<=)
```java
int a = 5;
int b = 10;
boolean result = (a <= b);  // true
```

### 関係演算子の使い方の例
```java
public class Main {
    public static void main(String[] args) {
        int x = 10;
        int y = 20;

        // 等しいかどうかの比較
        if (x == y) {
            System.out.println("x is equal to y");
        } else {
            System.out.println("x is not equal to y");
        }

        // 等しくないかどうかの比較
        if (x != y) {
            System.out.println("x is not equal to y");
        } else {
            System.out.println("x is equal to y");
        }

        // より大きいかどうかの比較
        if (x > y) {
            System.out.println("x is greater than y");
        } else {
            System.out.println("x is not greater than y");
        }

        // より小さいかどうかの比較
        if (x < y) {
            System.out.println("x is less than y");
        } else {
            System.out.println("x is not less than y");
        }

        // 以上かどうかの比較
        if (x >= y) {
            System.out.println("x is greater than or equal to y");
        } else {
            System.out.println("x is not greater than or equal to y");
        }

        // 以下かどうかの比較
        if (x <= y) {
            System.out.println("x is less than or equal to y");
        } else {
            System.out.println("x is not less than or equal to y");
        }
    }
}
```

## 論理演算子
論理演算子は、ブール値(真/偽)を操作するために使用される演算子です。論理演算子は、複数の条件を組み合わせて複雑の論理式を作成する際に使用されます。

### 論理演算子の一覧
1 \. 論理積(AND)(&&)
両方の条件が真のときに真を返します。
```java
boolean a = true;
boolean b = false;
boolean result = (a && b);  // false
```
2\.  論理和(OR)(||)
少なくとも一方の条件が真のときに真を返します。

```java
boolean a = true;
boolean b = false;
boolean result = (a || b);  // true
```

3 \. 論理否定(NOT)(!)
条件が真の場合は偽を、偽の場合は真を返します。

```java
boolean a = true;
boolean result = !a;  // false
```

### 論理演算子の使い方の例
```java
public class Main {
    public static void main(String[] args) {
        boolean isAdult = true;
        boolean hasTicket = false;

        // AND 演算子
        if (isAdult && hasTicket) {
            System.out.println("You can enter the movie.");
        } else {
            System.out.println("You cannot enter the movie.");
        }

        // OR 演算子
        if (isAdult || hasTicket) {
            System.out.println("You might be able to enter the movie.");
        } else {
            System.out.println("You cannot enter the movie.");
        }

        // NOT 演算子
        if (!hasTicket) {
            System.out.println("You need a ticket to enter the movie.");
        }
    }
}
```

### 複雑の論理式
論理演算子を組み合わせて、複雑な論理式を作成することもできます。
```java
public class Main {
    public static void main(String[] args) {
        int age = 25;
        boolean hasID = true;
        boolean isMember = false;

        // 複雑な論理式
        if ((age >= 18 && hasID) || isMember) {
            System.out.println("You can enter the club.");
        } else {
            System.out.println("You cannot enter the club.");
        }
    }
}
```
最初のページ
[[備忘録 その１] Java Silver ～Javaプログラミング基礎～](https://qiita.com/MagicShowTime/items/9fcf3a2cb4a7162aafcf "[備忘録 その１] Java Silver ～Javaプログラミング基礎～")

前のページ
[[備忘録 その４] Java Silver ～変数と配列 その２～](https://qiita.com/MagicShowTime/items/a062e1385e9b963b519c "[備忘録 その４] Java Silver ～変数と配列 その２～")

次のページ
[[備忘録 その６] Java Silver ～文字列の取り扱いとデータの比較～](https://qiita.com/MagicShowTime/items/6f788fa9e2d525ccdbb0 "[備忘録 その６] Java Silver ～文字列の取り扱いとデータの比較～")