基本型と参照型

Java のデータ型は基本型と参照型に分類されます。基本型には null は代入できません。基本型には null 以外の初期値があり、boolean は false、int や long は 0 です。

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

        // 基本型
        boolean b = true;
        byte by = 127; // -128 ~ 127
        char c = 65535; // 0 ~ 65535 (2byte)
        short s = 32767; // -32768 ~ 32767 (2byte)
        int i = 1; // 4byte
        long l = 1L; // 8byte
        float f = 1.0F;
        double d = 1.0;

        // 参照型
        String str = "abc";
        Object obj = null;

        // ラッパークラス (参照型の一部, java.lang.*)
        Boolean bb = new Boolean(b);
        Byte bby = new Byte(by);
        Character cc = new Character(c);
        Short ss = new Short(s);
        Integer ii = new Integer(i);
        Long ll = new Long(l);
        Float ff = new Float(f);
        Double dd = new Double(d);
    }
}

参照型の比較は以下のようになります。

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

        // 参照先が同じであるかどうかの比較
        String str = "abc";
        String str2 = str;
        String str3 = "abc";
        System.out.println(str == str2); //=> true
        System.out.println(str == str3); //=> true になるとは限らない。偶然同じオブジェクトを参照していれば true。
        System.out.println(str == null); //=> false

        // 値の比較
        System.out.println("abc".equals(str)); //=> true
        System.out.println("ABC".equals(str)); //=> false
        System.out.println("abc".equals(null)); //=> false
        System.out.println(str.equals("abc")); // str が null だと例外が発生して危険。"abc".equals(str) が安全。
        System.out.println("AAA".equalsIgnoreCase("aaA")); //=> true (文字列のみ)

        System.out.println((new Integer(0)).compareTo(-1)); //=> 1 (0 > -1)
        System.out.println((new Integer(0)).compareTo(0)); //=> 0 (0 == 0)
        System.out.println((new Integer(0)).compareTo(1)); //=> -1 (0 < 1)
    }
}

ラッパークラスと基本型の相互変換

import java.util.ArrayList;

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

        // 基本型
        boolean b = true;
        byte by = 127;
        char c = 65535;
        int i = 1;
        double d = 1.0;

        // 基本型 → ラッパークラス
        Boolean bb = new Boolean(b);
        Byte bby = new Byte(by);
        Character cc = new Character(c);
        Integer ii = new Integer(i);
        Double dd = new Double(d);

        ArrayList<Integer> iList = new ArrayList<>(); // 暗黙的な変換 (オートボクシング)
        iList.add(i);

        // ラッパークラス → 基本型
        bb.booleanValue();
        bby.byteValue();
        cc.charValue();
        ii.intValue();
        dd.doubleValue();

        int i2 = ii; // 暗黙的な変換 (アンボクシング)
    }
}

アップキャストとダウンキャスト

C++ のアップキャストとダウンキャストは Java では以下のようになります。

class Main {
    public static void main(String args[]) {
        String str = "abc";
        Object obj = str; // アップキャスト
        System.out.println(obj instanceof String); //=> true
        String str2 = (String)obj; // ダウンキャスト
    }
}

Optional (Java 8)

Scala の Option 型のようなものです。Java 8 で導入されました。

import java.util.Optional;

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

        // Optional の生成
        Optional<Integer> iOpt = Optional.of(123); // null を渡すと例外が発生
        Optional<Integer> iOpt2 = Optional.empty();
        Optional<Integer> iOpt3 = Optional.ofNullable(null); // 例外が発生しない
        Optional<Integer> iOpt4 = Optional.ofNullable(123);

        System.out.println(iOpt); //=> Optional[123]
        System.out.println(iOpt2); //=> Optional.empty
        System.out.println(iOpt3); //=> Optional.empty
        System.out.println(iOpt4); //=> Optional[123]

        // 空かどうかの確認
        if(iOpt.isPresent()) {
            System.out.println(iOpt.get());
        }
        iOpt.ifPresent(i -> {
            System.out.println(i);
        });

        // Optional からの値の取得
        iOpt.get(); // 空ならば例外 java.util.NoSuchElementException
        iOpt.orElse(999); // 空ならば既定値
        iOpt.orElseGet(() -> { // 空ならば既定値 (ラムダ版)
            return 999;
        });
        try {
            iOpt.orElseThrow(() -> new Exception("例外")); // 空ならば例外
        }
        catch(Exception e) {
            e.printStackTrace();
        }

        // 操作
        Optional<Integer> iOpt5 = iOpt.filter(i -> i > 0);
        Optional<Integer> iOpt6 = iOpt.map(i -> i * -1);

        // 入れ子になる場合は flatMap が便利
        Optional<Optional<Integer>> iOpt7 = iOpt.map(i -> {
            return Optional.of(i);
        });
        Optional<Integer> iOpt8 = iOpt.flatMap(i -> {
            return Optional.of(i);
        });
    }
}

基本型のうち int, long, double については対応する Optional が用意されています。

import java.util.OptionalInt;
import java.util.OptionalLong;
import java.util.OptionalDouble;

class Main {
    public static void main(String args[]) {
        OptionalInt iOpt = OptionalInt.of(1);
        OptionalLong lOpt = OptionalLong.of(1L);
        OptionalDouble dOpt = OptionalDouble.of(1.0);
    }
}