Javaの型

Javaの型には、基本的な型（プリミティブ型：PrimitiveType）と参照型（ReferenceType）（および、特殊な空型（null type））が存在する。

プリミティブ型（基本的な型）

コンピューター（CPU）が自然に扱えるのがプリミティブ型。[2008-05-21]
booleanとかcharはそうとも言えないが、プログラム言語の基礎的な型として用意されているのだろう。

プリミティブ型の整数（整数型：IntegralType）は2の補数表現で値が保持される。[2008-07-03]
浮動小数点数型（FloatingPointType）はIEEE754規格の数値型。[2008-08-30]
→数値（リテラル）の書き方（表現方法）

Javaのプリミティブ型には、対応するラッパークラスがある。[2003-07-06]
プリミティブ型はオブジェクトではないので、（オブジェクトしか扱えない）コレクションに格納する時などにはラッパークラスを使用する。
また、プリミティブ型に属する情報（本来プリミティブ型が主管となるべき情報）（最大値・最小値とか特別な定数など）もラッパークラスに定義されている。
（ちなみにこれらのラッパークラスのほとんどは、共通のNumberクラスから派生している）

各プリミティブ型が何ビットなのかは、JDK1.5以降では該当ラッパークラスのSIZEという定数フィールドで表現されている。[2010-03-23]
JDK1.8ではBYTESという定数フィールドも定義され、何バイトなのかも表現されている。[2014-03-19]
（例えばIntger.SIZEは32ビット、Byte.SIZEは8ビット。したがってintのバイト数はInteger.BYTES＝Integer.SIZE/Byte.SIZE＝4）

C言語と異なり、unsigned（符号なし）は存在しない。
符号有りか無しかで結果が異なるのは右シフト演算だが、符号有り用と無し用の二種類の演算子が用意されている（演算子によって区別する）。
→JDK1.8で符号なし整数を扱うメソッドが追加された

byte→short→int→long、float→double（型の大きさが大きくなる方向）の代入は暗黙に変換される。（プリミティブ型のワイドニング変換：widening primitive conversion）
逆（型の大きさが小さくなる方向）の代入は、明示的に型を指定しないとコンパイルエラーとなる。（プリミティブ型のナローイング変換：narrowing primitive conversion）

	int i = 123;
	double d = i;	//キャスト不要

	double d = 1.2;
	int i = (int)d;	//明示的なキャストが必要

ただし、定数式に関してはコンパイル時に自動的に変換されてエラーにならないことがある。[2008-04-07]

	long l = 123L;
	short s1 = (int)l; 	//コンパイルエラー
	short s2 = (short)l;	//問題なし（通常のキャスト）（long→shortへキャスト）

	short s3 = (int)123L;	//問題なし（定数式が自動変換された）（long→intへキャスト→shortへ自動変換）

符号なし整数

Javaではプリミティブ型の整数は符号付きである。[2014-03-19]
が、JDK1.8で符号なし整数として扱うメソッドがラッパークラスに追加された。

Byte・Short・Integer・Longに同様のメソッドが用意されている。

除算以外（加算・減算・乗算）のメソッドが用意されていないのは、普通の演算子を使っても（その型のビット数に収まっている限りは）符号あり・符号なしで相違が無いからだろう。

参照型

プリミティブ型以外は、全て参照型。[/2008-05-21]
「参照型」と呼ばれる理由は、実態はＣ言語でいうところのポインター（すなわち“参照”）だから。
（つまり参照型の変数が保持する値は、オブジェクトの内容そのものではなく、メモリー上に格納されたオブジェクトの先頭アドレスに当たるもの（プリミティブ型の変数では、値そのものを保持している）。オブジェクトを使うときは、そのアドレスを元にオブジェクトへアクセスする。これを“参照する”と呼んでいる）

クラス（インスタンス・オブジェクト）や文字列（String）・配列も、全て参照型。
参照型のデフォルト値はnull。

Stringは、ユーザー定義型（クラス）。コンパイルされると、内部ではUnicodeで扱われる。
Stringも参照型なので、デフォルト値は空文字列などではなく、null。

全ての参照型はObjectクラスから派生している（Objectクラスを継承している）。

スーパークラスの変数への代入は、特に問題なく行える。（参照型のワイドニング変換：widening reference conversion）[2008-08-30]
逆の代入（いわゆるダウンキャスト）は明示的なキャストが必要。（参照型のナローイング変換：narrowing reference conversion）

ナローイング変換が正しく行えることを事前チェックする目的でinstanceofが使われる。

class C1 {
}

class C2 extends C1 {
}

	C1 c = new C2();	//ワイドニング変換

	if (c instanceof C2) {
		C2 d = (C2)c; //ナローイング変換
	}

変数の初期化（デフォルト値）

Javaでは、ローカル変数を初期化しないで使おうとする（初期化されずに使われる可能性がある）と、コンパイルエラーになる（基本的なデータ型であっても）。[2008-05-21]
（C言語ではローカル変数を初期化しないと値が不定となる為、初期化しないのはご法度だった）
→ローカル変数無初期化の勧め(?)

しかし、クラスのフィールド（メンバー変数）で初期値を指定していない場合やnewで作った配列で 各要素を明示的に初期化していない場合はデフォルト値が入れられる。
デフォルト値は それぞれの型によって定められている。（booleanならfalse、その他のプリミティブ型は0、参照型はnull）

型変換

オブジェクト（参照型）からStringへ変換するには、toString()メソッドがよく使われる。[2008-05-21]
全てのクラスの親であるObjectクラスにはtoString()が定義されており、継承したサブクラスではそれをオーバーライドして文字列（String）への独自の変換処理を行う／行ってよい／行うのがよい。

String等から他クラス（自作クラス）への変換は、ラッパークラスや列挙型（enum）に倣ってvalueOf()を実装する…のがいいかなぁ。[/2009-12-31]
クラスによってはparse()とかdecode()というのもあるけど。

プリミティブ型に関する操作は、たいてい対応するラッパークラスに揃っている。[2007-06-30]
ちなみにこれらのラッパークラスのほとんどは 共通のNumberクラスを継承しているので、例えばintへ変換するintValue()はIntegerでもLongでもDoubleでもByteでも使える。

ラッパークラスにはコンストラクターがあるが、Java9から非推奨になった。[2021-03-21]
たいていはvalueOfメソッドでインスタンスを生成する。
Java16で、ラッパークラスのコンストラクターは削除対象（将来削除される）になった。

// Java18
jshell> Double.toString(2e23)
$1 ==> "1.9999999999999998E23"

// Java19
jshell> Double.toString(2e23)
$1 ==> "2.0E23"

jshell> String.format("%e", 2e23)
$1 ==> "2.000000e+23"

// Java20
jshell> String.format("%.16e", 2e23)
$2 ==> "1.9999999999999998e+23"

// Java21
jshell> String.format("%.16e", 2e23)
$2 ==> "2.0000000000000000e+23"

// Java20
jshell> String.format("%f", 2e23)
$1 ==> "199999999999999980000000.000000"

// Java21
jshell> String.format("%f", 2e23)
$1 ==> "200000000000000000000000.000000"

※Boolean.getBoolean()やInteger.getInteger()は、変換用ではなく、システムプロパティーの取得用。[2009-12-31]

十六進数文字⇔数値変換 [2007-01-12]

	char c = Character.forDigit(10, 16);  // 'a'が返る
	int  n = Character.digit('a', 16);    // 10が返る
	int  n = HexFormat.fromHexDigit('a'); // 10が返る（Java17以降）[2021-09-19]

数字判断 [2007-01-12]

	System.out.println(c + ":" + Character.isDigit(c) + "/" + Character.digit(c,16));

0:true/0
1:true/1
a:false/10
１:true/1		…全角数字も数字と判断されるし、数値変換も正しく行われる
一:false/-1	…さすがに漢数字等は無理(苦笑)
壱:false/-1
�T:false/-1
�@:false/-1
字:false/-1

→HexFormat.isHexDigit(c)（Java17以降）[2021-09-19]

→半角カタカナ⇔全角カタカナ⇔全角ひらがな変換

自動ボクシング

プリミティブ型とラッパークラスは別物なのでお互いに直接代入することは出来ないが、JDK1.5からは出来るようになった。[2007-05-02]
これを自動ボクシング（オートボクシング：AutoBoxing）と呼ぶ。
→Sunのオートボクシング

	Integer i = 123;	//オートボクシング（ボクシング変換：boxing conversion）
	int j = i;	//オートアンボクシング（アンボクシング変換：unboxing conversion）

（コンパイルする際にはソースのレベルを1.5以上にする必要がある）

コンパイルしたものを逆コンパイルして見ると、ただ単に変換メソッドに置き換えられているだけ…。

	Integer i = Integer.valueOf(123);
	int j = i.intValue();

なので、コーディング上は便利だけど、実行効率的には気をつけた方が良さげ。

プログラミング上も、オーバーロードされているメソッドで引数の違いがintとObjectだった場合とかは、どちらのメソッドが呼ばれるか気をつけなきゃいけないだろうな。

	Integer i = 123;
	System.out.println(i);	//引数がObject型のprintln()が呼ばれる

Objectクラスとの自動ボクシング

ちなみに、プリミティブ型からObjectクラスへのボクシングも勝手にやってくれるが、Objectからプリミティブ型への変換は やってくれない。[2007-05-10]

	Object obj = 123;	//OK（実体はIntegerのインスタンス）
	int i = obj;	//コンパイルエラー

intへ変換するintValue()とかlongへ変換するlongValue()とかは、実は“IntegerやLongの親クラスであるNumberクラス”のメソッドなので、「int i = ((Number)o).intValue();」とかに変換してコンパイルすることは出来るはず。
だが、実体がNumberの派生クラスでない場合は実行時エラーになる（実行してみるまで分からない）ので、コンパイルエラーにしておくのが無難なのかな。
（nullだと実行時にNullPointerExceptionが起きるらしいが）

Integerであることが分かっているなら、キャストしておけばコンパイルエラーは消せる。[2008-07-21]

	Object obj = 123;
	int i = (Integer)obj;	//OK
//×	int i = (Number)obj;	//Numberからintへ変換できないというコンパイルエラー
//×	long l = (Long)obj;	//コンパイルエラーにはならないが、実行時にClassCastException(Integer→Longは×)

使用上の注意

プリミティブ同士なら==演算子で比較するが、オートボクシングで変換されればラッパークラスというオブジェクト（参照型）になるので、==で比較するなんて、もっての他。[2008-05-21]

	public static void main(String[] args) {
		{
			System.out.print(127);
			Integer i1 = 127;
			Integer i2 = 127;
			if (i1 == i2) {
				System.out.println("は等しい");
			} else {
				System.out.println("は異なる");
			}
		}
		{
			System.out.print(128);
			Integer i1 = 128;
			Integer i2 = 128;
			if (i1 == i2) {
				System.out.println("は等しい");
			} else {
				System.out.println("は異なる");
			}
		}
	}

実行結果：

127は等しい
128は異なる

何で結果が違うかというと、intからIntegerへは「new Integer()」でなく「Integer.valueOf()」が使われるから。
これは（現状では）-128〜127の範囲ではキャッシュされたIntegerを返すようになっているので、その範囲なら同一のインスタンスとなる。だから==で比較しても等しくなる。
しかしその範囲外だとnewで作るので、==では一致しない。

そういうわけで現状は-128〜127の範囲なら大丈夫かもしれないが、将来バージョンで変わっても不思議は無いので、==を使うべきではない。
というかクラス（Integer）が明示的に現れているんだから、そもそも==で比較しようとすんなやって話。

※Java言語仕様第3版5.1.7章の中で「-128〜127」と書かれているので、その範囲が狭くなることは無いと思うが。[2008-08-30]

逆のオートアンボクシングでは、ラッパークラス側がnullにならないように注意。[2008-05-21]
nullだと実行時にNullPointerExceptionが発生してしてしまう。

	Integer n = null;
	int i = n;	//NullPointerException

	Map<String, Integer> map = new HashMap<String, Integer>();
	int i = map.get("zzz");	//NullPointerException

	Integer n = null;
	n++;	//NullPointerException

Integer nに対するn++は、実際には「int temp = n.intValue(); temp++; n = Integer.valueOf(temp);」という感じに変換されている。
ループのカウンターとかに使ったら、えらくムダだな…。