このページではサンプルプログラムも使って、実際の動作を確認してみる。実際やってみるのが一番だが、これを確認してもらうだけでも使い方はわかるだろう。

Javaで文字列を結合する連結演算子の使い方

Javaの文字列連結演算子「+」は、ふたつの文字列の連結を行う。左のオペランド（文字列やら数字やら）の文字列の後に、右の文字列が連結される。

式のひとつのオペランドが文字列であるなら、他のオペランドが文字列でなくても、文字列連結が行われる。文字列でない値が数値でれば、連結した文字列を作り出すために数値は文字列に変換され、連結される。

• 文字列同士の連結 ：“ABC” + “DEF” →　“ABCDEF”
• 文字列と数値の連結 ：”ABC” + 1  →　“ABC1”

加算演算子と文字列連結演算子は、両方とも記号「+」が同じなので両方の記号がひとつの式の中に含まれていているときは注意しなければならない。

• 数値の加算と連結 ：1 + 2 + “ABC” →　“3ABC”

というわけで、書き方の基本は簡単だ。

演算結果 = オペランド1 + オペランド2;

でOKになる。

文字列の連結演算子のサンプルプログラム

このサンプルプログラムは、文字列連結演算子が文字列を結合すること、また文字列でない値を文字列に変換して文字列連結を行うことを示している。

public class StringConcatenationOperators {
    public static void main (String[] args) {
        int integerValue1 = 1;//[1]
        int integerValue2 = 2;//[2]
        String stringABC= "ABC";//[3]
        String stringDEF= "DEF";//[4]
        String result;//[5]
        result = stringABC + stringDEF;//[6]
        System.out.println("[7] ABC + DEF = " + result);
        result = stringABC + integerValue1;//[8]
        System.out.println("[9] ABC + 1 = " + result);
        result = integerValue1 + stringABC;//[10]
        System.out.println("[11] 1 + ABC = " + result);
        result = integerValue1 + integerValue2 +stringABC;//[12]
        System.out.println("[13] 1 + 2 + ABC = " + result);
    }
}

実行結果

[7] ABC + DEF = ABCDEF
[9] ABC + 1 = ABC1
[11] 1 + ABC = 1ABC
[13] 1 + 2 + ABC = 3ABC

それほど解説することはないが、やはり最後のものは注意が必要だろう。数字が並ぶと足されてしまうので、ここら辺は意識したいところだ。

まとめ

このページではJavaで文字列を結合する方法についてお伝えした。

連結演算子「+」を使うことによって結合ができる。数字と文字列の結合時には注意が必要なのも覚えておきたい。

エンジニアによって好みは分かれるが、数行のプログラムが１行で書け、便利な書き方になっている。if文を書かずとも、条件分岐をさせられる書き方で、使い方も簡単だ。

このページではJavaの三項演算子について使い方をお伝えする。参考にしてほしい。

三項演算子の使い方

Javaの三項演算子は、３つのオペランド（数字とか変数とか）を持つ演算子だ。最初のオペランドは、条件となる式である。あとの二つは、条件から選ばれる二つの式である。条件と選ばれる式の関係は次のようになる。

• オペランド1がtrueならば、オペランド2が生み出した値を演算結果に代入する。
• オペランド1がfalseならば、オペランド3が生み出した値を演算結果に代入する。

この三項演算子を用いると、条件とそれに対応した式をコンパクトに書くことができる。ただし、条件に応じて選ばれるふたつの式の型に注意が必要である。この点はJava言語仕様に詳しく書かれている。

書き方の基本は簡単だ。

演算結果 = オペランド1 ? オペランド2 : オペランド3;

例えば、xとyを比べて、xの方が大きい時はxを、yの方が大きい時はyをzに代入したいというときは次のようになる。

z = x > y ? x: y;

まだ知らない方も多いだろうが、if文で書くと、行数は跳ね上がる。それが一行でかけるので効率がいいわけだ。

三項演算子のサンプルプログラム

このサンプルプログラムは、三項演算子のオペランド1のBoolean値に応じてオペランド2とオペランド3が選択されることを示している。

さらに、オペランド3が選択されたときオペランド2の型と異なっていてもよいことも確認できるようになっている。

public class TernaryOperator {
    public static void main (String[] args) {
        byte byteValue2 = 2;//[1]
        short shortValue2 = 2;//[2]
        int integerValue2 = 2;//[3]
        long longValue2 = 2;//[4]
        int integerValue3 = 3;//[5]
        long result;//[6]
        result = integerValue3 > integerValue2 ? integerValue3 : integerValue2;//[7]
        System.out.println("[8] オペランド1 integer " + result);
        result = integerValue3 < integerValue2 ? integerValue3 : integerValue2;//[9]
        System.out.println("[10] オペランド2 integer " + result);
        result = integerValue3 < integerValue2 ? integerValue3 : longValue2;//[11]
        System.out.println("[12] オペランド2 long " + result);
        result = integerValue3 < integerValue2 ? integerValue3 : shortValue2;//[13]
        System.out.println("[14] オペランド2 short " + result);
        result = integerValue3 < integerValue2 ? integerValue3 : byteValue2;//[15]
        System.out.println("[16] オペランド2 byte " + result);
    }
}

実行結果

[8] オペランド2 integer 3
[10] オペランド3 integer 2
[12] オペランド3 long 2
[14] オペランド3 short 2
[16] オペランド3 byte 2 

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

• [7] integerValue3 > integerValue2 ? integerValue3 : integerValue2をresultに代入する。
• [8] resultを表示する。
• [9] integerValue3 < integerValue2 ? integerValue3 : integerValue2をresultに代入する。
• [10] resultを表示する。
• [11] integerValue3 < integerValue2 ? integerValue3 : longValue2をresultに代入する。
• [12] resultを表示する。
• [13] integerValue3 < integerValue2 ? integerValue3 : shortValue2をresultに代入する。
• [14] resultを表示する。
• [15] integerValue3 < integerValue2 ? integerValue3 : byteValue2をresultに代入する。
• [16] resultを表示する。

三項演算子は使わない方がいい？

「三項演算子はわかりにくいから使わないように」と教わることがある。理由は直感的でないからだ。

if文でも同じことができるので、そちらを使うという方針を取っている企業もある。

しかし、定義を考えると、三項演算子はあくまでも２つの数字から１つを効率良く選ぶ方法だ。分岐処理というより、２つの数字からどちらを選ぶというときには、効率がいい。

使い道を誤らず、使っていきたい演算子だ。

まとめ

このページではJavaの三項演算子についてお伝えした。使い方と読み方は必ず覚えておこう。

ここで使われるのが条件演算子「&&」と「||」だ。このページでは条件演算子についてまとめたので、参考にして欲しい。

Javaの条件演算子の使い方

Javaの条件演算子は、条件の演算を行う演算子だ。

条件の演算は、条件を表す式の値を演算子のオペランドに与えて論理積や論理和などの演算を行い、結果をboolean型の値として生み出す。この時、オペランド（右と左の値）に与えられる式はboolean型である。

論理演算子と条件演算子は、boolean型の値に対して演算を行うので似ている。しかし、違いがある。条件演算子は、右の式が左の式の値によって、評価されないときがあるということだ。

なかなかわかりにくいと思うので、詳細は次のセクションを見ていただければと思う。

また、条件演算子を使うと、式を組み合わせていろいろな条件を作り出すことができる。複雑な条件を書くためにはどうしたらよいかもサンプルプログラムにある。

まずは、演算子の種類から見ていこう。

「かつ」と「または」を表す演算子の種類

条件演算子には、ふたつの種類がある。次のセクションでこれらのひとつひとつの演算子の詳細を説明している。

• 条件演算子 &&
• 条件演算子 ||

「かつ」を表す条件演算子 &&

演算子「&&」はBoolean型の値の論理積を求める。&&演算子の左と右にあるオペランドに対して演算が行われる。

書き方の基本は簡単だ。

演算結果 = オペランド1 && オペランド2;

• オペランド1とオペランド2が両方ともtrueならば、演算結果はtrueとなる。
• それ以外はfalseとなる。
• オペランド1がfalseの場合、オペランド2は評価されない。

ここが違いになるが、はじめは深く考えなくていいだろう。とりあえず、少々違いはありつつも、ほとんど同じように動くと思っておけばいい。

下記のようにすると、20代以上の男性というのが表現出来る。

演算結果 = x > 20 && sex == "男性";

図で表すとこんな感じだ。

「または」を表す条件演算子 ||

演算子「||」は整数のビットの論理和を求める。||演算子の左と右にあるふたつのオペランドに対して演算が行われる。

書き方の基本は簡単だ。

演算結果 = オペランド1 || オペランド2;

オペランド1とオペランド2の論理和の演算結果は次のようになる。

• オペランド1とオペランド2のどちらかがtrueならば、演算結果はtrueとなる。
• それ以外はtrueとなる。
• オペランド1がtrueの場合、オペランド2は評価されない。

例えば、20歳以下または女性というのを表現すると次のようになる。

演算結果 = x <= 20 || sex == "女性";

条件演算子のサンプルプログラム

このサンプルプログラムは、ふたつのオペランドに基本的なboolean型の値の組み合わせを設定したとき、条件演算子からどんな演算結果が得られるかを表示している。実際のコードで、条件演算子の書き方と演算結果を確かめよう。

public class ConditionalOperators {
    public static void main (String[] args) {
        boolean valueTrue = true;//[1]
        boolean valueFalse = false;//[2]
        boolean result;//[3]
        result = valueTrue && valueTrue;//[4]
        System.out.println("[5] true && true = " + result);
        result = valueTrue && valueFalse;//[6]
        System.out.println("[7] true && false = " + result);
        result = valueFalse && valueTrue;//[8]
        System.out.println("[9] false && false = " + result);
        result = valueFalse && valueFalse;//[10]
        System.out.println("[11] false && false = " + result);
        result = valueTrue || valueTrue;//[12]
        System.out.println("[13] true || true = " + result);
        result = valueTrue || valueFalse;//[14]
        System.out.println("[15] true || false = " + result);
        result = valueFalse || valueTrue;//[16]
        System.out.println("[17] false || true = " + result);
        result = valueFalse || valueFalse;//[18]
        System.out.println("[19] false || false = " + result);
    }
}

実行結果

[5] true && true = true
[7] true && false = false
[9] false && false = false
[11] false && false = false
[13] true || true = true
[15] true || false = true
[17] false || true = true
[19] false || false = false

このような結果になる。

二つの式を持つ条件演算子のサンプルプログラム

このサンプルプログラムは、ふたつの式を組み合わせて新しい条件を作り出す方法を示している。実際のコードで、式の組み合わせ方を見てみよう。

public class ConditionalOperatorsOnTwoExpressions {
    public static void main (String[] args) {
        int value1 = 2;//[1]
        int value2 = 7;//[2]
        boolean result;//[3]
        result = (value1 == 2) && (value2 == 7);//[4]
        System.out.println("[5] value1は2 かつ value2は7 = " + result);
        result = (value1 == 2) && (value2 == 3);//[6]
        System.out.println("[7] value1は2 かつ value2は3 = " + result);
        result = (value1 == 2) || (value2 == 3);//[8]
        System.out.println("[9] value1は2 または value3は3 = " + result);
        result = (value1 == 1) || (value2 == 3);//[10]
        System.out.println("[11] value1は1 または value2は3 = " + result);
    }
}

実行結果

[5] value1は2 かつ value2は7 = true
[7] value1は2 かつ value2は3 = false
[9] value1は2 または value3は3 = true
[11] value1は1 または value2は3 = false

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

• [1] 変数value1を宣言し、2を代入する。
• [2] 変数value2を宣言し、7を代入する。
• [3] 変数resultを宣言する。
• [4] resultに (value1 == 2) && (value2 == 7)を代入する。
• [5] resultを表示する。
• [6] resultに(value1 == 2) && (value2 == 3)を代入する。
• [7] resultを表示する。
• [8] resultに(value1 == 2) || (value2 == 3)を代入する。
• [9] resultを表示する。
• [10] resultに(value1 == 1) || (value2 == 3)を代入する。
• [11] resultを表示する。

複雑な条件演算子のサンプルプログラム

このサンプルプログラムは、お母さんと子供の年齢が設定された条件に入っているかどうかを検査している。条件が条件演算子と括弧を使ってちょっと複雑に組み合わせられている。実際のコードで確認してみよう。

public class ConditionalOperatorsOnExpressions {
    public static void main (String[] args) {
        int ageOfMother = 25;//[1]
        int ageOfChild = 4;//[2]
        boolean result;//[3]
        result = (ageOfMother == 20) && (ageOfChild >= 7) && (ageOfChild <= 12);//[4]
        System.out.println("[5] お母さんは20才で子供が小学生 = " + result);
        result = (ageOfMother == 25) && ((ageOfChild == 4) || (ageOfChild == 5));//[6]
        System.out.println("[7] お母さんは25才で子供が4才か5才 = " + result);
    }
}

実行結果

[5] お母さんは20才で子供が小学生 = false
[7] お母さんは25才で子供が4才か5才 = true

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

• [1] 変数ageOfMotherを宣言し、25を代入する。
• [2] 変数ageOfChildを宣言し、4を代入する。
• [3] 変数resultを宣言する。
• [4] resultに(ageOfMother == 20) && (ageOfChild >= 7) && (ageOfChild <= 12)を代入する。
• [5] resultを表示する。
• [6] resultに(ageOfMother == 25) && ((ageOfChild == 4) || (ageOfChild == 5))を代入する。
• [7] resultを表示する。

まとめ

このページでは「かつ」と「または」を表す条件演算子「&&」と「||」についてまとめてお伝えした。

本当によく使うので、必ず覚えてしまおう。

このページではJavaの論理演算子についてまとめてご紹介する。初心者の方はぜひ習得しておこう。

Javaの論理演算子と近いもので条件演算子というものもある。「&&」と「||」だ。これも論理演算子と呼ぶことがあり、またこちらの方が有名だし、使われていたりする。

下記で解説しているので、こちらも確認して欲しい。

論理演算とは？

「この条件とこの条件どちらにもマッチしたとき」や「この条件とこの条件のどちらかにマッチしたとき」だけに○○したいというプログラムを書くことはとてもよくある。

例えば自動販売機のプログラムで、「見た目が男性」で「20代」だったら、ホットコーヒーをオススメする、などだ。こういったときに論理演算子を使う。

論理演算、本を読むと大体次のような図で表現がされている。Aという条件とBという条件があったときに、どこまでがYes（True）になって、どこまでがNo（False）になるかだ。

それぞれ確認をしていこう。

Javaの論理演算子の使い方

Javaの論理演算子は、論理演算を行う演算子だ。論理演算は、boolean型の値を演算子のオペランドに与えて論理積や論理和などの演算を行い、結果をboolean型の値として生み出す。

論理演算子にはビット演算子と共通の演算子（&, |, ^）がある。違いは、Boolean値に対して演算するか、それとも数値に対して演算するかである。

まずは、演算子の種類から見ていこう。

演算子の種類

論理演算子には、４つの種類がある。次のセクションでこれらのひとつひとつの演算子の詳細を説明している。

• Boolean論理演算子 &
• Boolean論理演算子 |
• Boolean論理演算子 ^
• 論理補数演算子 !

論理演算子の詳細を見てみよう。

 「かつ」を表すBoolean論理演算子 &

演算子「&」は「かつ」を表す。少々難しく言うと論理積だ。&演算子の左と右にあるオペランドのBoolean型の値に対して演算が行われる。

下記でいうと、青い部分のときだけTrueになる。

書き方の基本は簡単だ。

演算結果 = オペランド1 & オペランド2;

オペランド1とオペランド2の論理積の演算結果は次のようになる。

• オペランド1とオペランド2が両方ともtrueならば、演算結果はtrueとなる。
• それ以外はfalseとなる。

「または」を表すBoolean論理演算子 |

演算子「|」はBoolean型の値の論理和を求める。論理和とは「または」という意味だ。だから図で表すともっとも広い。条件に当てはまるものだいたい全部。

|演算子の左と右にあるふたつのオペランドのBoolean型の値に対して演算が行われる。

書き方の基本は簡単だ。

演算結果 = オペランド1 | オペランド2;

オペランド1とオペランド2の論理和の演算結果は次のようになる。

• オペランド1とオペランド2のどちらかがtrueならば、演算結果はtrueとなる。
• それ以外はfalseとなる。

「結果が異なれば」を表すBoolean論理演算子 ^

演算子「^」はBoolean型の値の排他論理和を求める。^演算子の左と右にあるふたつのオペランドのBoolean型の値に対して演算が行われる。

排他論理和というから言葉が難しい。簡単な日本語に直すと、「１の条件と２の条件の結果が違ければOK」という話だ。「または」から「かつ」の部分を除いた下記の部分がこれに当たる。

書き方の基本は簡単だ。

演算結果 = オペランド1 ^ オペランド2;

オペランド1とオペランド2の排他論理和の演算結果は次のようになる。

• オペランド1とオペランド2の値が異なれば、演算結果はtrueとなる。
• それ以外はfalseとなる。

論理補数演算子 !

演算子「!」は補数を求める。!演算子の右にあるオペランドのBoolean型の値に対して演算が行われる。要するに、「否定」とか「逆」を意味する。それ以外、という感じだ。

図で表すと次のようになる。

書き方の基本は簡単だ。

演算結果 = !オペランド;

オペランド1とオペランド2の補数の演算結果は次のようになる。

• オペランドがtrueならば、演算結果はfalseとなる。
• オペランドがfalseならば、演算結果はtrueとなる。

論理演算子のサンプルプログラム

このサンプルプログラムは、演算子の最初のオペランドがtrueで２番目のオペランドがfalseのとき、３種類の論理演算子はどのような演算結果を出すのかを示している。実際のコードで書き方と演算結果を確かめよう。

public class LogicalOperators {
    public static void main (String[] args) {
        boolean valueTrue = true;//[1]
        boolean valueFalse = false;//[2]
        boolean result;//[3]
        result = valueTrue & valueFalse;//[4]
        System.out.println("[5] true & false = " + result);
        result = valueTrue | valueFalse;//[6]
        System.out.println("[7] true | false = " + result);
        result = valueTrue ^ valueFalse;//[8]
        System.out.println("[9] true ^ false = " + result);
        result = ! valueTrue;//[10]
        System.out.println("[11]! valueTrue = " + result);
        result = ! valueFalse;//[12]
        System.out.println("[13]! valueFalse = " + result);
    }
}

実行結果

[5] true & false = false
[7] true | false = true
[9] true ^ false = true
[11]! valueTrue = false
[13]! valueFalse = true

なんとなくお分かりいただけただろうか？　

これだけだとわかりにくいかもしれないが、if文などで条件を分岐していくプログラムを書いたとき、よく理解できるようになるだろう。

また、上でも書いたが、実際には「&&」や「||」の条件演算子（論理演算子）の方がよく見る。下記も確認しておいて欲しい。

まとめ

このページでは論理演算子についてまとめてお伝えをしてきた。いずれもよく使うので、使い方含め覚えてしまおう。

非常によく使うというより、これがないとプログラミングでできることがほとんどなくなる。

このページでは関係演算子の使い方についてまとめている。

Javaの関係演算子の使い方

Javaの関係演算子は、ふたつの値を比較するための演算子だ。例えば、ふたつの値を比較してどちらが大きいか等しいかなどを知りたいとき、関係演算子を使う。

演算結果は、boolean型となる。関係演算子の条件が成立するならば、演算結果はtrueとなる。そうでなければ、falseになる。

書き方の基本は簡単だ。

比較結果 = オペランド1 演算子 オペランド2;

演算子の種類

代入演算子には、大きくふたつの種類がある。さらに、それぞれ演算の対象によって演算子が異なる。次のセクションでこれらのひとつひとつの演算子の詳細を説明している。

• 関係演算子　→　数値比較演算子、型比較演算子
• 等価演算子　→　数値等価演算子、Boolean等価演算子、参照等価演算子

では、その詳細を見てみよう。

関係演算子

関係演算子は、さらにふたつに分けられる。ひとつは、数値を比較するための数値比較演算子である。もうひとつは型を比較するための型比較演算子である。

数値比較演算子

数値を比較するための数値比較演算子の一覧を示す。演算子を使った例とその意味を説明している。

型比較演算子

型を比較するための型比較演算子の一覧を示す。演算子を使った例とその意味を説明している。

等価演算子

等価演算子はふたつのオペランドが等しいか等しくないかを調べる。演算子の一覧を示す。演算子を使った例とその意味を説明している。

これらふたつの等価演算子はオペランド（表のaとb）の種類よって、３つに分類される。

• 数値等価演算子 ：オペランドが数値型である。
• Boolean等価演算子：オペランドがBoolean型である。
• 参照等価演算子 ：オペランドが参照型である。

関係演算子を使ったサンプルプログラム

このサンプルプログラムは、前のセクションで例としてあげた関係演算子の例をそのままプログラムに書いたものだ。実際のコードで書き方と演算結果を確かめよう。

public class RelationalOperators {
    public static void main (String[] args) {
        int a;//[1]
        int b;//[2]
        boolean result;//[3]
        b = 3;  a = 10;//[4]
        result = a < b;//[5]
        System.out.println("[6] a < b = " + result);
        result = a <= b;//[7]
        System.out.println("[8] a <= b = " + result);
        result = a > b;//[9]
        System.out.println("[10] a > b = " + result);
        result = a >= b;//[11]
        System.out.println("[12] a >= b = " + result);
        String aOfString = new String("ABC");//[13]
        result = aOfString instanceof String;//[14]
        System.out.println("[15] a instanceof String = " + result);
    }
}

実行結果

[6] a < b = false
[8] a <= b = false
[10] a > b = true
[12] a >= b = true
[15] a instanceof String = true

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

• [4] bに3を、aに10を代入する。
• [5] resultにa < bを代入する。
• [7] resultにa <= bを代入する。
• [9] resultにa > bを代入する。
• [11] resultにa >= bを代入する。
• [13] String aOfStringにnew Stringを代入する。
• [14] resultにaOfString instanceof Stringを代入する。

等価演算子を使ったサンプルプログラム

このサンプルプログラムは、前のセクションで例としてあげた等価演算子の例をそのままプログラムに書いたものだ。実際のコードで書き方と演算結果を確かめよう。

public class EqualityOperators {
    public static void main (String[] args) {
        int a = 10;//[1]
        int b = 3;//[2]
        boolean result;//[3]
        result = a == b;//[4]
        System.out.println("[5] int a == b = " + result);
        result = a != b;//[6]
        System.out.println("[7] a != b = " + result);
        boolean aOfBoolean = true;//[8]
        boolean bOfBoolean = false;//[9]
        result = aOfBoolean == bOfBoolean;//[10]
        System.out.println("[11] boolean a == b  = " + result);
        result = aOfBoolean != bOfBoolean;//[12]
        System.out.println("[13] a != b  = " + result);
        String aOfString = new String("ABC");//[14]
        String bOfString = new String("EFG");//[15]
        result = aOfString == bOfString;//[16]
        System.out.println("[17] String a == b = " + result);
        result = aOfString != bOfString;//[18]
        System.out.println("[19] a != b = " + result);
    }
}

実行結果

[5] int a == b = false
[7] a != b = true
[11] boolean a == b = false
[13] a != b  = true
[17] String a == b = false
[19] a != b = true

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

• [4] resultにa == bを代入する。
• [6] resultにa != bを代入する。
• [8] 変数 aOfStringを宣言し、trueを代入する。
• [9] 変数 bOfStringを宣言し、falseを代入する。
• [10] resultに aOfString == bOfStringを代入する。
• [12] resultに aOfString!= bOfStringを代入する。
• [14] Stringを初期値”ABC”で生成し、aOfStringに代入する。
• [15] Stringを初期値”DEF”で生成し、bOfStringに代入する。
• [16] resultにaOfString == bOfStringを代入する。
• [18] resultにaOfString!= bOfStringを代入する。

まとめ

このページではJavaの比較演算子の使い方についてご紹介した。これだけだとなかなか何をしているかわかりにくいと思うが、今後必ず必要になってくる。（if文やfor文といったもので使う。）

大体のところは把握して、わからなくなったら、復習に来ていただければと思う。

代入演算子の演算子の組み合わせでできるのが、複合代入演算子だ。

このページではこれらの使い方について初心者の方向けにまとめた。参考にしていただければと思う。

代入演算子

代入演算子とは？

代入演算子は、右の値を代入演算子の左の変数へ代入する。代入するとは、割り当てること、もう少し簡単にいうと値をコピーすることだ。

代入演算子「=」は、シンプルな代入演算子である。それ以外の11の代入演算子は、代入と他の演算子を組み合わせた複合代入演算子である。

普通の変数への代入のことを難しく説明しているだけなので、よくわからなければスルーで構わない。

代入演算子の種類

Javaの代入演算子は、ふたつの種類がある。次のセクションでこれらのひとつひとつの演算子の詳細を説明している。

• シンプルな代入演算子 =
• 複合代入演算子

では、その詳細を見てみよう。

シンプルな代入演算子 =

シンプルな代入演算子「=」の書き方の基本は簡単だ。

オペランド1 = オペランド2;

代入演算子「=」は、シンプルにオペランド2の値をオペランド1へ代入する。オペランド1は置き換えられるので変数でなければならない。

複合代入演算子

ここからが新規のお話だ。

複合代入演算子は、代入演算子と組み合わされた演算子により、演算結果がオペランド1に代入される。どのような組み合わせがあるかは、下記の表を見てほしい。オペランド1は演算結果によって、置き換えられるので変数でなければならない。

複合代入演算子には、11の種類がある。書き方の基本は簡単だ。

オペランド1 演算子= オペランド2;

例）　x += 3;

下の一覧表は、11種類の複合代入演算子を演算子の種類ごとに示している。また、例の項目は、実際にどのように使われるのかを示している。また、説明の項目は、複合演算子を使わないで、同じ演算を基本的な演算子だけを使って記述している。

算術演算子と代入演算子の組み合わせ

シフト演算子と代入演算子の組み合わせ

ビット演算子と代入演算子の組み合わせ

複合代入演算子のサンプルプログラム

このサンプルプログラムは、11種類の複合代入演算子のうち算術演算子と組み合わせたものを取り上げ、例と説明をそのままプログラムに書いたものだ。

実際のコードで、書き方と演算結果を確かめよう。

public class AssignmentArithmeticOperators {
    public static void main (String[] args) {
        int a;//[1]
        int b;//[2]
        a = 10;  b = 3;//[3]
        a *= b;//[4]
        System.out.println("[5] a *= b; a = " + a);
        a = 10;  b = 3;//[6]
        a = a * b;//[7]
        System.out.println("[8] a = a * b; a = " + a);
        a = 10;  b = 3;//[9]
        a /= b;//[10]
        System.out.println("[11] a /= b; a = " + a);
        a = 10;  b = 3;//[12]
        a = a / b;//[13]
        System.out.println("[14] a = a / b; a = " + a);
        a = 10;  b = 3;//[15]
        a %= b;//[16]
        System.out.println("[17] a %= b; a = " + a);
        a = 10;  b = 3;//[18]
        a = a % b;//[19]
        System.out.println("[20] a = a % b; a = " + a);
        a = 10;  b = 3;//[21]
        a += b;//[22]
        System.out.println("[23] a += b; a = " + a);
        a = 10;  b = 3;//[24]
        a = a + b;//[25]
        System.out.println("[26] a = a + b; a = " + a);
        a = 10;  b = 3;//[27]
        a -= b;//[28]
        System.out.println("[29] a -= b; a = " + a);
        a = 10;  b = 3;//[30]
        a = a - b;//[31]
        System.out.println("[32] a = a - b; a = " + a);
    }
}

実行結果

[5] a *= b; a = 30
[8] a = a * b; a = 30
[11] a /= b; a = 3
[14] a = a / b; a = 3
[17] a %= b; a = 1
[20] a = a % b; a = 1
[23] a += b; a = 13
[26] a = a + b; a = 13
[29] a -= b; a = 7
[32] a = a - b; a = 7

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

• [3] aに10を代入し、bに3を代入する。
• [4] a *= bを実行する。
• [6] aに10を代入し、bに3を代入する。
• [7] a = a * bを実行する。
• [9] aに10を代入し、bに3を代入する。
• [10] a /= bを実行する。
• [12] aに10を代入し、bに3を代入する。
• [13] a = a / bを実行する。
• [15] aに10を代入し、bに3を代入する。
• [16] a %= bを実行する。
• [18] aに10を代入し、bに3を代入する。
• [19] a = a % bを実行する。
• [21] aに10を代入し、bに3を代入する。
• [22] a += bを実行する。
• [24] aに10を代入し、bに3を代入する。
• [25] a = a + bを実行する。
• [27] aに10を代入し、bに3を代入する。
• [28] a -= bを実行する。
• [30] aに10を代入し、bに3を代入する。
• [31] a = a - bを実行する。

シフト演算子と組み合わせのサンプルプログラム

このサンプルプログラムは、11種類の複合代入演算子のうちシフト演算子と組み合わせたものを取り上げ、例と説明をそのままプログラムに書いたものだ。

シフト演算子については下記で詳しい。

実際のコードで、書き方と演算結果を確かめよう。

public static void main (String[] args) {
        int a;//[1]
        int b;//[2]
        a = 10;  b = 3;//[3]
        a <<= b;//[4]
        System.out.println("[5] a <<= b; a = " + a);
        a = 10;  b = 3;//[6]
        a = a << b;//[7]
        System.out.println("[8] a = << b; a = " + a);
        a = 10;  b = 3;//[9]
        a >>= b;//[10]
        System.out.println("[11] a >>= b; a = " + a);
        a = 10;  b = 3;//[12]
        a = a >> b;//[13]
        System.out.println("[14] a = a >> b; a = " + a);
        a = 10;  b = 3;//[15]
        a >>>= b;//[16]
        System.out.println("[17] a >>>= b; a = " + a);
        a = 10;  b = 3;//[18]
        a = a >>> b;//[19]
        System.out.println("[20] a = a >>> b; a = " + a);
    }
}

実行結果

[5] a <<= b; a = 80
[8] a = << b; a = 80
[11] a >>= b; a = 1
[14] a = a >> b; a = 1
[17] a >>>= b; a = 1
[20] a = a >>> b; a = 1

サンプルプログラムの説明

• [3] aに10を代入し、bに3を代入する。
• [4] a <<= bを実行する。
• [6] aに10を代入し、bに3を代入する。
• [7] a = a << =bを実行する。
• [9] aに10を代入し、bに3を代入する。
• [10] a >>= bを実行する。
• [12] aに10を代入し、bに3を代入する。
• [13] a = a >>bを実行する。
• [15] aに10を代入し、bに3を代入する。
• [16] a >>>= bを実行する。
• [18] aに10を代入し、bに3を代入する。
• [19] a = a >>> bを実行する。

ビット演算子と組み合わせのサンプルプログラム

このサンプルプログラムは、11種類の複合代入演算子のうちビット演算子と組み合わせたものを取り上げ、例と説明をそのままプログラムに書いたものだ。実際のコードで、書き方と演算結果を確かめよう。

public class AssignmentBitwiseOperators {
    public static void main (String[] args) {
        int a;//[1]
        int b;//[2]
        a = 10;  b = 3;//[3]
        a *= b;//[4]
        System.out.println("[5] a &= b; a = " + a);
        a = 10;  b = 3;//[6]
        a = a & b;//[7]
        System.out.println("[8] a = a & b; a = " + a);
        a = 10;  b = 3;//[9]
        a ^= b;//[10]
        System.out.println("[11] a ^= b; a = " + a);
        a = 10;  b = 3;//[12]
        a = a ^ b;//[13]
        System.out.println("[14] a = a ^ b; a = " + a);
        a = 10;  b = 3;//[15]
        a |= b;//[16]
        System.out.println("[17] a |= b; a = " + a);
        a = 10;  b = 3;//[18]
        a = a | b;//[19]
        System.out.println("[20] a = a | b; a = " + a);
    }
}

実行結果

[5] a &= b; a = 30
[8] a = a & b; a = 2
[11] a ^= b; a = 9
[14] a = a ^ b; a = 9
[17] a |= b; a = 11
[20] a = a | b; a = 11

サンプルプログラムの説明

• [3] aに10を代入し、bに3を代入する。
• [4] a &= b を実行する。
• [5] a を実行する。
• [6] aに10を代入し、bに3を代入する。
• [7] a = a & bを実行する。
• [9] aに10を代入し、bに3を代入する。
• [10] a ^= bを実行する。
• [12] aに10を代入し、bに3を代入する。
• [13] a = a ^ bを実行する。
• [15] aに10を代入し、bに3を代入する。
• [16] a |= bを実行する。
• [18] aに10を代入し、bに3を代入する。
• [19] a = a | bを表示する。

まとめ

このページでは、Javaの代入演算子についてまとめてきた。

基本的には便利な書き方だが、コードを見てからの理解に一瞬だが時間がかかるようになる部分もあるため、うまく使おう。

少なくとも読んですぐに理解できるようにしておこう。

このページではシフト演算子の使い方についてまとめた。参考にしていただきたい。

シフト演算子の使い方

Javaのシフト演算子は、ビットのシフト演算を行う演算子だ。ビットのシフト演算とは、データのビットの並びをまとめて右や左にシフトすることだ。シフトする方向だけでなくシフトするビットの数を指定することもできる。4ビット右にシフトする演算では、データの並びがすべて指定された右方向に4ビットずれる。

シフト演算子によって数値はどうなるか？　1ビット左にシフトするごと数値は2倍になる。1ビット右にシフトするごとに数値は半分になる。4ビット右シフトさせると、8分の1値になる。つまり、数値16を4ビット右シフトさせると、2になるということだ。

まずは、演算子の種類から見ていこう。

演算子の種類

シフト演算子には、３つの種類がある。次のセクションでこれらのひとつひとつの演算子の詳細を説明している。

• 左シフト演算子 <<
• 符号付右シフト演算子 >>
• 符号無し右シフト演算子 >>>

では、その詳細を見てみよう。

左シフト演算子 <<

シフト演算子「<<」は整数のビットを左にシフトする。演算子「<<」のオペランド1のビットをオペランド2の数だけシフトする。

書き方の基本は簡単だ。

演算結果 = オペランド1 << オペランド2;

ビットが左にシフトされると、右端のビットはどうなるかというと、0で埋められていく。左端のビットは、捨てられていく。

オペランド1がint型であれば、オペランド2の範囲は0から31になる。また、オペランド1がlong型であれば、オペランド2の範囲は0から63になる。

符号付右シフト演算子 >>

シフト演算子「>>」は、整数のビットを右に符号を付けてシフトする。>>演算子のオペランド1のビットをオペランド2の数だけシフトする。

書き方の基本は簡単だ。

演算結果 = オペランド1 >> オペランド2;

ビットが右にシフトされると、左端のビットはどうなるだろうか。符号付、つまり符号にしたがって埋められていく。左端のビットは符号によって、0（正の整数）または1（負の整数）になる。もし左端のビットが0ならば、0で埋められていく。もし左端のビットが1ならば、1で埋められていく。右端のビットは、捨てられていく。

オペランド2の範囲は、<<と同じだ。

符号無し右シフト演算子 >>>

シフト演算子「>>>」は整数のビットを符号無しで右にシフトする。>>>演算子のオペランド1のビットをオペランド2の数だけシフトする。

書き方の基本は簡単だ。

演算結果 = オペランド1 >>> オペランド2;

ビットが右にシフトされると、左端のビットはどうなるだろうか。符号無し、つまり符号に関係なく、左端のビットは0で埋められていく。右端のビットは、捨てられていく。

オペランド2の範囲は、<<と同じだ。

シフト演算子のサンプルプログラム

このサンプルプログラムは、前のセクションで例としてあげたビットの並びを4ビットシフトする演算をそのままプログラムに書いたものだ。実際のコードで書き方と演算結果を確かめよう。

public class ShiftOperators {
    public static void main (String[] args) {
        int startBit0 = 0b0011_1111_1111_1111_1111_1111_1111_1101;//[1]
        int startBit1 = 0b1011_1111_1111_1111_1111_1111_1111_1101;//[2]
        int result;//[3]
        result = startBit1 << 4;//[4]
        System.out.println("[4] 0b10111111111111111111111111111101 << 4 = " + Integer.toBinaryString(result));
        result = startBit1 >> 4;//[5]
        System.out.println("[6] 0b10111111111111111111111111111101 >> 4 = " + Integer.toBinaryString(result));
        result = startBit0 >> 4;//[7]
        System.out.println("[8]　0b00111111111111111111111111111101 >> 4 = 000000" + Integer.toBinaryString(result));
        result = startBit1 >>> 4;//[9]
        System.out.println("[10] 0b10111111111111111111111111111101 >>> 4 = 0000" + Integer.toBinaryString(result));
    }
}

実行結果

[4] 0b10111111111111111111111111111101 << 4 = 11111111111111111111111111010000
[6] 0b10111111111111111111111111111101 >> 4 = 11111011111111111111111111111111
[8] 0b00111111111111111111111111111101 >> 4 = 00000011111111111111111111111111
[10] 0b10111111111111111111111111111101 >>> 4 = 00001011111111111111111111111111

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

• [1] startBit0を宣言し、0b0011_1111_1111_1111_1111_1111_1111_1101を代入する。
• [2] startBit1を宣言し、0b1011_1111_1111_1111_1111_1111_1111_1101を代入する。
• [3] resultを宣言する。
• [4] resultにstartBit1 << 4を代入する。
• [5] resultを表示する。
• [6] resultにstartBit1 >> 4を代入する。
• [7] resultを表示する。
• [8] valueにstartBit0 >> 4を代入する。
• [9] resultを表示する。
• [10] valueにstartBit1 >>> 4を代入する。
• [11] resultを表示する。

まとめ

このページではJavaのシフト演算子についてまとめてきた。

すぐには使わないかもしれないが、ビット演算子と共になんとなくの全体像は把握しておくといいだろう。

このページではJavaでのビット演算子の使い方をまとめてみた。

Javaでのビット演算子の使い方

Javaのビット演算子は、そのままだが「ビットの演算を行う演算子」だ。

ビットの演算とは、数値をビット単位で演算することを指す。ビットの値を演算子のオペランドに与えて論理積や論理和などの演算を行い、結果を数値として生み出す。

この演算子がよく使われるひとつの分野は、ハードウエアを制御する分野だ。32ビットの数値あり、そのひとつひとつのビットがスイッチの状態に対応しているとする。最下位のビットから数えて4番目のビットだけを抜き出して、スイッチの状態を調べたい。こんなとき、このビット演算子が使える。

Webアプリケーションなどではなかなか登場しないが、こういうものがあると知っておくのはJavaエンジニアとしていいことだろう。

まずは、演算子の種類から見ていこう。

演算子の種類

ビット演算子には、４つの種類がある。次のセクションでこれらのひとつひとつの演算子の詳細を説明している。

• 整数ビット演算子 &
• 整数ビット演算子 |
• 整数ビット演算子 ^
• ビット補数演算子 ~

これらの演算子は、整数のビットの並びの同じ位置にあるビット同士を演算する。この例は、&演算子の演算の様子を例として示している。

次は、ビット演算子の詳細だ。演算子それぞれに書き方ある。演算も違う。その詳細を見てみよう。

整数ビット演算子 &

演算子「&」は整数のビットの論理積を求める。&演算子の左と右にあるオペランドのビットごとに演算が行われる。

書き方の基本は簡単だ。

演算結果 = オペランド1 & オペランド2;

数値を構成するひとつのビットに注目すると、論理積の演算結果は次のようになる。

• オペランド1とオペランド2のビットが両方とも1ならば、演算結果は1となる。
• それ以外は0となる。

16ビットの数値をオペランドに持つ場合の演算結果は、次の表のようになる。この表は、演算がどのような結果になるかを示している。各ビットに注目すると上のひとつのビットに注目した表のとおりに演算しているのが分かる。

整数ビット演算子 |

演算子「|」は整数のビットの論理和を求める。|演算子の左と右にあるふたつのオペランドのビットごとに演算が行われる。

書き方の基本は簡単だ。

演算結果 = オペランド1 | オペランド2;

数値を構成するひとつのビットに注目すると論理和の演算結果は次のようになる。

• オペランド1とオペランド2のビットのどちらか1ならば、演算結果は1となる。
• それ以外は0となる。

16ビットの数値をオペランドに持つ場合の演算結果は次のようになる。

整数ビット演算子 ^

演算子「^」は整数のビットの排他論理和を求める。^演算子の左と右にあるふたつのオペランドのビットごとに演算が行われる。

書き方の基本は簡単だ。

演算結果 = オペランド1 ^ オペランド2;

数値を構成するひとつのビットに注目すると排他論理和の演算結果は次のようになる。

• オペランド1とオペランド2のビットの値が異なれば、演算結果は1となる。
• それ以外は0となる。

16ビットの数値をオペランドに持つ場合の演算結果は次のようになる。

ビット補数演算子 ~

演算子「~」は整数のビットの補数を求める。~演算子の左のあるオペランドのビットに対して演算が行われる。

書き方の基本は簡単だ。

演算結果 = ~オペランド;

数値を構成するひとつのビットに注目すると補数の演算結果は次のようになる。

• オペランドのビットが1ならば、演算結果は0となる。
• オペランドのビットが0ならば、演算結果は1となる。

16ビットの数値をオペランドに持つ場合の演算結果は次のようになる。

ビット演算子のサンプルプログラム

このサンプルプログラムは、前のセクションで例としてあげた16ビットのそれぞれの演算をそのままプログラムに書いたものだ。実際のコードで書き方と演算結果を確かめよう。

public class BitwiseOperator {
    public static void main (String[] args) {
        int value1 = 0xff00;//[1]
        int value2 = 0xf0f0;//[2]
        int result;//[3]
        result = value1 & value2;//[4]
        System.out.println("[5] 0xff00 & 0xf0f0 = 0x" + Integer.toHexString(result));
        result = value1 | value2;//[6]
        System.out.println("[7] 0xff00 | 0xf0f0 = 0x" + Integer.toHexString(result));
        result = value1 ^ value2;//[8]
        System.out.println("[9] 0xff00 ^ 0xf0f0 = 0x0" + Integer.toHexString(result));
        result = ~value1;//[10]
        System.out.println("[11] ~0xff00 = 0x0" + Integer.toHexString(result));
    }
}

実行結果

[5] 0xff00 & 0xf0f0 = 0xf000
[7] 0xff00 | 0xf0f0 = 0xfff0
[9] 0xff00 ^ 0xf0f0 = 0x0ff0
[11] ~0xff00 = 0x0ffff00ff

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

• [1] value1を宣言し、0xff00を代入する。
• [2] value2を宣言し、0xf0f0を代入する。
• [3] resultを宣言する。
• [4] resultにvalue1 & value2を代入する。
• [5] resultを表示する。
• [6] resultにvalue1 | value2を代入する。
• [7] resultを表示する。
• [8] valueにvalue1 ^ value2を代入する。
• [9] resultを表示する。
• [10] valueに~value1を代入する。
• [11] resultを表示する。

ビットの値を取り出すサンプルプログラム

このサンプルプログラムは、冒頭で書いたスイッチの状態を取り出す課題の回答となる。最下位ビットから４番目のビットにスイッチが繋がっていて、スイッチをONするとビットの値が1になり、OFFすると0になる。

このプログラムでは、この４番目のビットの値だけ取り出すために&演算子を使っている。Mask Bitで４番目のビットだけを1にしておけば、そのビットの変化だけを取り出せる。他のビットは、すべて0になる。

public class SwitchStatuesByUsingBitwiseOperator {
    public class SwitchStatuesByUsingBitwiseOperator {
    public static void main (String[] args) {
        int switchStatusOff      = 0b0000_0000_0000_0000_0000;//[1]
        int switchStatusOn       = 0b0000_0000_0000_0000_1000;//[2]
        int switchNumber4MaskBit = 0b0000_0000_0000_0000_1000;//[3]
        int switchStatus;//[4]
        switchStatus = switchStatusOn & switchNumber4MaskBit;//[5]
        System.out.println("[6] Switch ON = " + Integer.toHexString(switchStatus));
        switchStatus = switchStatusOff & switchNumber4MaskBit;//[7]
        System.out.println("[8] Switch OFF = " + Integer.toHexString(switchStatus));
    }
}

実行結果

[6] Switch ON = 8
[8] Switch OFF = 0

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

• [1] switchStatusOffを宣言し、0b0000_0000_0000_0000_0000を代入する。
• [2] switchStatusOnを宣言し、0b0000_0000_0000_0000_1000を代入する。
• [3] switchNumber4MaskBitを宣言し、0b0000_0000_0000_0000_1000を代入する。
• [4] switchStatusを宣言する。
• [5] switchStatusにswitchStatusOn & switchNumber4MaskBitを代入する。
• [6] switchStatusを表示する。
• [7] switchStatusにswitchStatusOff & switchNumber4MaskBitを代入する。
• [8] switchStatusを表示する。

まとめ

このページではbit演算子についてまとめてきた。Javaは組みこみ系プログラミングでも動くため、こういったbit演算子も豊富に用意されている。

はじめはとっつきにくいかもしれないが、それほど難しくはないので、マスターしてしまおう。

これらは一見同じように「１を加える」というだけなのだが、意味合いが変わってくる。このページでは前置と後置の違いについてお伝えしよう。

インクリメント・デクリメントの前置と後置の使い方

インクリメント・デクリメントとは？については、下記で詳しい。

Javaのインクリメント演算子とデクリメント演算子は、オペランド（演算の対象となる変数）の左か右に置かれる。

インクリメント演算子「++」は、オペランドの左にあっても右にあってもオペランドの値に1増やす。デクリメント演算子「--」は、オペランドの左にあっても右にあってもオペランドの値から1減らす。

これらの演算子が前にあるか後ろにあるかの違いは、ただひとつだ。

オペランドの前にあれば、式の中でオペランドの値は増やされたり減らされたりした後の値が用いられる。

一方、オペランドの右にあれば、式の中でオペランドの値は増やされたり減らされたりする前の値が用いられる。

これだけだとわかりにくいので、前置と後置の詳細を見ていこう。

前置

オペランドの左に演算子を置く書き方を「前置」と呼ぶ。式の中で、オペランドの値は演算子による演算後の値が用いられる。

書き方の基本はこうだ。

++オペランド;

--オペランド;

後置

オペランドの右に演算子を置く書き方を「後置」と呼ぶ。式の中で、オペランドの値は演算子による演算前の値が用いられる。

書き方の基本はこうだ。

オペランド++;

オペランド--;

サンプルプログラムで確認する

このサンプルプログラムは、演算が終わった後の値（value）と、演算結果（result）つまり式の中の値を比較している。前置と後置ではそれぞれ値が違う。その違いを理解しよう。

public class IncrementDecrement {
    public static void main (String[] args) {
        int result;//[1]
        int value;//[2]
        value = 3;//[3]
        result = ++value;//[4]
        System.out.println("[5] ++value -> value = " + value + ", result = " + result);
        value = 3;//[6]
        result = value++;//[7]
        System.out.println("[8] value++ -> value = " + value + ", result = " + result);
        value = 3;//[9]
        result = --value;//[10]
        System.out.println("[11] --value -> value = " + value + ", result = " + result);
        value = 3;//[12]
        result = value--;//[13]
        System.out.println("[14] value-- -> value = " + value + ", result = " + result);
    }
}

実行結果

下記のような結果になる。なんとなく違いがわかるようになっただろうか？

[5] ++value -> value = 4, result = 4
[8] value++ -> value = 4, result = 3
[11] --value -> value = 2, result = 2
[14] value-- -> value = 2, result = 3

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

• [4] resultに++valueを代入する。
• [5] resultを表示する。
• [6] valueに3を代入する。
• [7] resultにvalue++を代入する。
• [8] resultを表示する。
• [9] valueに3を代入する。
• [10] resultに--valueを代入する。
• [11] resultを表示する。
• [12] valueに3を代入する。
• [13] resultにvalue--を代入する。
• [14] resultを表示する。

まとめ

このページではインクリメントとデクリメントの前置と後置の違いについてお伝えした。挙動に違和感を感じたら、この点、再度確認してみよう。

しかし、中には見慣れない演算子に出会うこともある。その中でも、よく出会うのがインクリメント「++」とデクリメント「--」だ。

このページではインクリメント演算子とデクリメント演算子についてご紹介しよう。

インクリメント・デクリメント演算子

Javaのインクリメント・デクリメント演算子は、数値型の変数の値を1だけ増やしたり、1だけ減らしたりする演算子だ。このような演算をどんな場面で使うかというと、数を数えるような場面でカウンターとして使用する場合がある。また、連続するデータの位置を管理するためにインデックスとして使う場合もある。

では、それぞれの演算子の基本的な働きを見ていこう。

インクリメント演算子 ++

インクリメント演算子「++」はオペランドの値を取り出してその値に1増やした後、その値をオペランドに書き込む。オペランドは、数値型の変数でなければならない。ただし、式の中でvalueがどんな値をとるかは注意が必要なので、次のセクションの「前置と後置」に関する記事を参考にしてほしい。

書き方の基本は簡単だ。

オペランド ++:

この演算子は加算に置き換えられるので、以下のふたつの式は同じ結果になる。

• value ++;
• value = value + 1;

デクリメント演算子 --

デクリメント演算子「--」はオペランドの値を取り出してその値から1減らした後、その値をオペランドに書き込む。オペランドは、数値型の変数でなければならない。ただし、式の中でvalueがどんな値をとるかは注意が必要なので、次のセクションの「前置と後置」に関する記事を参考にしてほしい。

書き方の基本は簡単だ。

オペランド --;

この演算子は減算に置き換えられるので、以下のふたつの式は同じ結果になる。

• value --;
• value = value - 1;

サンプルプログラム

このサンプルプログラムは、インクリメント演算子とデクリメント演算子の演算結果を表示する。

public class IncrementAndDecrement {
    public static void main (String[] args) {
        int value;//[1]
        value = 3;//[2]
        value ++;//[3]
        System.out.println("[4] value ++ = " + value);
        value = 3;//[5]
        value --;//[6]
        System.out.println("[7] value -- = " + value);
    }
}

実行結果

[4] value ++ = 4
[7] value -- = 2

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

• [1] valueを宣言する。
• [2] valueに3を代入する。
• [3] value ++を実行する。
• [4] valueを表示する。
• [2] valueに3を代入する。
• [3] value --を実行する。
• [4] valueを表示する。

前置と後置の違い

実は、インクリメントとデクリメントには前置きと後置きのパターンがある。「a++」と「++a」では意味が違う。この辺りは下記で詳しく説明している。

【Java入門】インクリメント演算子の前置と後置の違いとは？

まとめ

+1や-1を簡単に書くために存在するのがインクリメントとデクリメントになる。共にプログラムではよく使うため通常の演算子とは別に用意されているわけだ。

カウンターや後々お伝えするfor文で必ず使うものなので、把握しておこう。