プリミティブ型（基本データ型）

■
プリミティブ型（基本データ型）
◆
プリミティブ型（基本データ型）
浮動小数点の数値範囲が正負対称でないのは，べき乗表示にバイアスがかかっている
のと 0 以外すべて最上位 bit が 1 と決まっているので最上位を省略しているためであ
分類
型
る。
ビット数 数値の範囲
【ポイント】外部データを扱うときは，long 型と double 型を推奨する。int 型や float
型は桁数が少なすぎて世の中にある普通のデータには不適切である。内部の繰り返し
符号付き整数 byte
8
-27～+27-1（-128～+127）
符号付き整数 short
16
-215～+215-1（-32768～+32767）
型にする必要はない。
符号付き整数 int
32
-231～+231-1（-2147483648～+2147483647，10 桁）
いまどき，コンピュータのリソースや計算速度を気づかう必要はまったくない。
63
63
符号付き整数 long
64
-2 ～2 -1（19 桁）
浮動小数点
float
32
仮数部 223，指数部 28（±3.40E+38～±1.40E-45）
浮動小数点
double 64
符号なし整数 char
16
論理値/真偽値 boolean 1
回数や配列数などは，ディフォルトの int 型で十分であり，わざわざ byte 型や short
仮数部 252，指数部 211（±4.94E-324～±1.79E+308）
◆
ユニコード\u0000～\uFFFF（0～65535）
◆
true / false
１文字を扱う。
例
◆
論理値／真偽値／ブールリテラル
boolean 型は，真偽を表す。すなわち，「true」「false」のみ。
整数リテラル
10 進法：
そのまま表記
8 進法：
数値の先頭に 0 を付ける
16 進法：
数値の先頭に 0X または，0x を付ける
文字リテラル
‘c’
//整数 99 と等しい
‘\c3042’
//‘あ’と等しい
正の 16 ビット内の数値は全て char 型に代入できる。
【注意】文字列をあつかう String クラスはラッパークラスではない。つまり，文字
列はプリミティブ型（基本データ型）ではない。ちなみに，文字列リテラルはダブル
整数は，デフォルトで int 型。long 型には数値の後に，L または l を付ける。
16 進法では負数に「-」は付けない。-1 がフルビットになり，0xff（8bit），0xffff
（16bit），0xffffffff（32bit），0xffffffffffffffff（64bit）となる。
16 進法の負数の表記法は，10 進法の負数に，bit 数に対応して，28，216，232，264 を
加えてから 16 進法に変換する。16 進法では，負数は最上位 bit が 1 であり，正数は
コート「”」で囲む。
◆
識別子の名前の付け方
Java で指定されているキーワードは識別子に使えない。
リテラル値(true，false，null)も使用できない。
先頭は文字もしくは，「_」か「$」は使用できる。数字は先頭には使えない。
最上位 bit が 0 である。
例
-1
◆
16bit の場合
→
65536 - 1 = 65535 →
-32768 →
32767 →
0xffff
65536 - 32768 = 32768 →
プリミティブ型（基本データ型）のサンプルプログラム
明示的な型変換（キャスト）と暗黙の型変換の例
0x1000
暗黙の型変換は小さな入れ物から大きな入れ物へ変換するときに可。
0x7fff
【注意】ドラッグして eclipse のソースに貼り付ければコンパイル可。Java のソース
◆
浮動小数点リテラル
浮動小数点は，デフォルトで double 型。float 型には数値の後に，F または f を付け
る。
のファイル名は，main メソッドのあるクラスの「クラス名.java」とする。Java を起
動すると，次のメソッドからはしる。
public static void main(String[] args){}
サンプルプログラムには，メソッドは main だけしかない。
01
class TestPrimitiveType{
public static void main(String[] args){
02
03
//整数
04
byte b = 127;
05
byte bb = -128;
06
short s = 32767;
07
short ss = -32768;
08
int i = 2147483647;
09
int ii = -2147483648;
10
long l = 127L;
11
byte ll = (byte)127L;
//この数字を超えるとエラー
//この数字を超えるとエラー
System.out.println('\uff1d');//＝
39
System.out.println((char)0xff1d);//＝，明示的な型変換
40
//char 型の負数
41
char c3 = (char) -53182 ;//明示的な型変換（キャスト）
//この数字を超えるとエラー
43
//
44
//変数の識別子」
49
51
double d = 123.456;
//ディフォルトは double 型
52
15
System.out.println(d);
//123.456
53
16
double d2 = 123.456e+12;
17
System.out.println(d2); //1.23456E14
18
float f = 123;
19
float f2 = 123.456F ;
20
//
22
23
24
//エラー，65535 よりも大きいため
int bc = 4;
//
int %c = 8;
//
int 6d = 4;
//エラー，記号は $ _ だけ可
int d6 = 6;
//エラー，先頭に数字は不可
int e$_3333 = 9 ;
50
//浮動小数点
= 12354 = \u3042
int $a = 3;
48
//明示的な型変換（キャスト）
14
21
char c4 = 65536 ;
46
47
65536-53182
System.out.println(c3); //あ
42
45
12
13
38
//
int true = 9;
//エラー，true false null は不可
int False = 9;
//大文字は区別される
}
54
}
// float 型←int 型暗黙の型変換
■
ラッパークラスとは
//左辺右辺とも float 型
Java では，メソッドの操作の対象はオブジェクト（インスタンス）である。プリミテ
//暗黙の型変換は小さな入れ物から大きな入れ物へ
ィブ型（基本データ型）に対応するオブジェクトを生成するのがラッパークラスであ
float f3 = 123.456;
り，このインスタンス化することをラップするといい，インスタンス化されたものを
//float 型←double 型暗黙の型変換不可
float f3 = (float)123.456;//明示的な型変換（キャスト）
ラッパーオブジェクトという。これによって，プリミティブ型（基本データ型）の値
System.out.println(f3); //123.456
をオブジェクトと同様に操作できるようになる。
//ブール
boolean b11 = true;
25
ラッパークラスは String クラスと合わせて，プリミティブ型（基本データ型）をい
boolean b12 = false ;
26
ろいろ操作する仕組みを提供している。print メソッドなどはプリミティブ型（基本
27
//
boolean b3 = 1;
//エラー，int 型不可
データ型）を扱っているように見えるが，実は，自動的に toString がプリミティブ
28
//
boolean b4 = "true" ;
//エラー，文字列不可
型（基本データ型）を文字列（String オブジェクト）に変換しているのである。
29
//文字
30
char c
31
System.out.println(c);
= 'c';
32
System.out.println('\u0063');//c
以下，見やすくするために，プリミティブ型（基本データ型）の値を（boolean，cahr
33
char c1 = '\u3042';
も含めて）「数値」といい，String オブジェクトの値を「文字列」という。
34
System.out.println(c1); //あ
35
char c2 = 0xff1d;
36
System.out.println(c2); //＝
37
System.out.println((char)65309);//＝，明示的な型変換
ラッパーオブジェクトは不変性（final）であり，設定した値は変更できない。
//c
//char 型は単に符号なし 16bit 整数
◆
ラッパークラスの種類とコンストラクタ
Short f2 = new Short(100);
//short←int 暗黙の型変換不可
Byte
byte / String（例外スロー）
short
Short
short / String（例外スロー）
int
Integer
int / String（例外スロー）
27
//
Integer h2 = new Integer(100L); //int←long 暗黙の型変換不可
long
Long
long / String
28
//
Integer h3 = new Integer(1.23); //int←double 暗黙の型変換不可
24
Integer g = new Integer(100);
25
Integer h = new Integer("123"); //文字列可
26
System.out.println(h);
29
Long i = new Long(123) ;
30
Long j = new Long(123L);
//123
//long←int 暗黙の型変換可
float
Float
float / double / String
double
Double
double / String（例外スロー）
31
Long k = new Long('c') ;
char
Character
Char / （String 不可）
32
System.out.println(k);
//99
boolean / String
33
Long k2 = new Long('\uFF43');
//long←char 暗黙の型変換可
Boolean
ラッパークラスのコンストラクタのサンプルプログラム
class TestWrapperConstructor{
public static void main(String[] args){
boolean a = true;
03
04
Boolean b = new Boolean(a);
05
if(b){
//boolean←Boolean unboxing 自動変換
System.out.println(b);
06
//true
//unboxing によりラッパーオブジェクトを print できる
07
08
}
09
Character c = new Character('c');//Character←char autoboxing
10
System.out.println(c);
11
Character c2 = new Character(c);//文字リテラルと認識する
//c
12
System.out.println(c2);
13
//Character のみコンストラクタ(char)，他は引数に String 可
//
//c
Character c3 = new Character("c");//Character のみ文字列不可
15
byte d = 125;
16
Byte e = new Byte(d);
//byte←int 暗黙の型変換可
Byte e2 = new Byte("125");
//文字列可
Byte e22 = new Byte(125);
//byte←int 暗黙の型変換不可
//
Byte e4 = new Byte("128");
Byte e3 = new Byte((byte)125); //明示的な型変換
19
//文字列可，例外スロー
//long←char 暗黙の型変換可
34
System.out.println(k2);
//65347
35
Float l = new Float(1);
//float←int 暗黙の型変換
36
Float m = new Float(1L);
//float←long 暗黙の型変換
37
//Float のみコンストラクタ(float, double, String)
38
Float n = new Float(1.23D);
39
System.out.println(n);
40
Float n2 = new Float(123.456e+12);
41
System.out.println(n2);
42
Float n3 = new Float(123.456789012e+12);
43
System.out.println(n3);
44
Float n4 = new Float(123.456e+78);
//1.23
//1.23456E14
//1.23456788E14
45
System.out.println(n4);
46
Double o = new Double(1.23f); //double←float 暗黙の型変換可
47
Double p = new Double('c');
48
Double q = new
49
//
//Infinity
//double←char 暗黙の型変換可
Double("111.1111");
Double r = new Double("tanaka");//例外スロー
50
//ラッパーオブジェクトに変換可能な文字列でなくてはならない
51
//実行時，java.lang.NumberFormatException
52
Double s = new
53
System.out.println(s);
}
54
//
17
20
//
byte
02
18
23
コンストラクタ引数
ドラッグして eclipse のソースに貼り付ければコンパイル可。
14
Short f = new Short((short)100);//明示的な型変換
ラッパークラス
例外：NumberFormatException:数値でない，整数でない，範囲を超えた
01
//実行時；java.lang.NumberFormatException
22
プリミティブ型
boolean
◆
21
55
}
Double(123.456e+78);
//1.23456E80
◆
ラッパーメソッドのサンプルプログラム
ドラッグして eclipse のソースに貼り付ければコンパイル可。
01
class TestWrapperMethod{
public static void main(String[] args){
02
03
//数値（プリミティブ型）と文字列（String オブジェクト）のプリント
04
//引数が数値のときは自動的に toSring()を呼ぶ
05
System.out.println(123);
//123
06
System.out.println("123");
//123
07
System.out.println(123.456);
//123.456
08
System.out.println("123.456");
//123.456
09
System.out.println(1.23e+12);
//1.23E12
10
System.out.println("1.23e+12"); //1.23e+12
11
System.out.println(true);
//true
12
System.out.println("true");
//true
13
System.out.println('c');
//c
14
System.out.println("c");
//c
15
System.out.println("--------");
16
//数値←ラッパーオブジェクト←文字列
Integer obj11 = Integer.valueOf("123");//引数は数値も可
17
18
//
Integer obj11 = new Integer("123"); //これも可，引数は数値も可
19
int num11 = obj11.intValue();
20
System.out.println(obj11);
//123
21
System.out.println(num11);
//123
22
int num22 = Integer.valueOf("456").intValue();//１行にまとめる
23
System.out.println(num22);
24
System.out.println(Integer.valueOf("456"));//もっとまとめる？
25
26
27
28
//456
//数値←文字列
int num33 = Integer.parseInt("789");//引数は数値不可
System.out.println(num33);
//789
//文字列←数値
29
String str44 = String.valueOf(123);//引数は文字列も可
30
System.out.println(str44);
31
String str55 = Integer.toString(456);
32
System.out.println(str55);
33
34
//123
//456
System.out.println("========");
//valueOf()
（ラッパーオブジェクト←文字列，数値）
35
//ラッパークラス.valueOf(文字列／数値)
36
Integer i = Integer.valueOf("11111"); //引数は文字列可
37
System.out.println(i);//11111
38
Integer ia = Integer.valueOf(11111); //引数は数値も可
76
39
System.out.println(ia);//11111
77
40
Long l = Long.valueOf("010101" ,2); //第１引数は数値不可
78
//ラッパークラス.toxxxxString(数値)
41
System.out.println(l);
79
System.out.println(Integer.toBinaryString(256));
42
Float f = new Float("1.11f"); //引数は数値も可
80
System.out.println(Integer.toOctalString(256)) ;
43
System.out.println(f);
81
System.out.println(Long.toHexString(80));
44
Boolean b = Boolean.valueOf("true"); //引数は true も可
82
45
System.out.println(b);//true
83
46
Character c = Character.valueOf('c'); //引数は数値のみ
84
//ラッパーオブジェクト.toString()
47
System.out.println(c);//c
85
//ラッパークラス.toString(数値)
//1.11
System.out.println("\\\\\\\\");
//toString
Character c1 = Character.valueOf("c"); //エラー，文字列不可
86
Boolean bbb = new Boolean(true);
49
Double humei = new Double(123.456e+78);
87
System.out.println(bbb.toString());//true
50
System.out.println(String.valueOf(humei)); //1.23456E80
88
System.out.println(bbb);
51
System.out.println(humei);
89
//オーバーロードされた toString()メソッド
52
System.out.println("********");
90
//基本型を String 型で返す
91
System.out.println(Boolean.toString(true));//true
48
53
//
//21
System.out.println("++++++++");
//toHexString，toxxxString
//1.23456E80
//intValue，xxxxValue
//true
54
//ラッパーオブジェクト.intValue()
92
System.out.println(true);
55
Double d = new Double("123.4"); //小数点のディフォルトは double
93
//引数を 2 つ持つ toString()メソッド
56
byte b1 = d.byteValue(); //ラッパーオブジェクトと xx は不一致可
94
//Integer と Long にしかない。
57
System.out.println(b1) ;
95
//第二引数の基数で値を返す
//123
58
Integer i1 = new Integer(123);
96
59
byte b2 = i1.byteValue(); //ラッパーオブジェクトと xx は不一致可
97
60
System.out.println(b2) ;
98
Integer i2
61
62
//
= Integer.valueOf("111");
byte b3 = i2.intValue(); //byte←int の暗黙の型変換は不可
System.out.println("////////");
63
64
//123
//parseInt，parsexxxx
65
//ラッパークラス.parsexxxx(文字列)
66
byte aa = Byte.parseByte("123");
67
System.out.println(aa +
68
//
3);
//126
byte bb = Integer.parseInt("23"); //byte←int 暗黙の型変換不可
69
short cc = Short.parseShort("0011111" , 2);
70
System.out.println(cc);
71
double dd = Float.parseFloat("1.23F"); //double←float 可
72
System.out.println(dd);
73
boolean ddd = Boolean.parseBoolean("true");
74
System.out.println(ddd);//true
75
//
//31
//1.2300000190734863
char ccc = Character.parseCharacter("c"); //存在しない
//true
System.out.println(Integer.toString(256 , 2)); //100000000
}
}