摘要：字符串和基本數據類型也能通過進行拼接操作，比如字符串的內容為。即基本類型和字符串類型相加時，基本類型會自動轉換為其字符串表示，在這個例子中相當于回顧包裝類這一小節的代碼類型的最大值就是將字符串和數據類型的拼接。

數據類型定義了變量可以采用的值，例如，定義變量為 int 類型，則只能取整數值。

在 Java 中有兩類數據類型：

1）原始數據類型

2）非原始數據類型 - 數組和字符串是非原始數據類型，將在以后的教程中討論它們。

這次我們將討論Java中的原始數據類型和字符。

Java 變量必須先指定它的數據類型（變量聲明），然后才能使用。

int num;

像這種變量數據類型在編譯時已知，則這種語言稱為靜態類型的。

在Java中，我們有八種基本數據類型：

1）boolean：布爾類型

2）char：字符類型

3）byte：字節類型

4）short：短類型

5）int：整數類型

6）long：長類型

7）float：浮點類型

8）double：雙精度類型

byte、 short 、int、 long 類型用于存儲整數類型數據。

float 和 double 用于存儲分數或者小數類型數據，也可用于存儲整數值。

char用于存儲字符(字母)類型數據。

boolean類型存儲 true和 false,用于邏輯判斷。

3. 常用到的數據類型

1）用于存儲數值常用到的數據類型有：int、long、double， int類型占用內存空間較小，程序運行速度快，double類型占用內存空間較大，程序運行速度相對慢。

2）用于存儲文本的常用數據類型：String（非原始數據類型）和char

3）用于決策的 boolean數據類型比較常用：

可以保存在-128到127之間的整數。主要用于節省內存。

默認大小：1個字節

class ByteExample {
    public static void main(String[] args) {
        byte num;
          System.out.println("存儲最大值：" + Byte.MAX_VALUE);
        System.out.println("存儲最小值：" + Byte.MIN_VALUE);
        System.out.println("默認存儲字節：" + Byte.BYTES);
        num = 113;
        System.out.println(num);
          //num = 160;//編譯會拋出錯誤：不兼容的類型: 從int轉換到byte可能會有損失num = 160;
    }
}

輸出：

存儲最大值：127
存儲最小值：-128
默認存儲字節：1
113

如果 num 的值超出范圍會在編譯時候拋出錯誤：不兼容的類型: 從int轉換到byte可能會有損失

它的存儲數值范圍是 -32,768 到 32767。

數據類型默認大小：2個字節。

class ShortExample {
    public static void main(String[] args) {
        short num;
        System.out.println("存儲最大值：" + Short.MAX_VALUE);
        System.out.println("存儲最小值：" + Short.MIN_VALUE);
        System.out.println("默認存儲字節：" + Short.BYTES);
        num = 150;
        System.out.println(num);
    }
}

輸出：

存儲最大值：32767
存儲最小值：-32768
默認存儲字節：2
150

存儲數值范圍：-2147483648 到 2147483647

默認大小：4 字節

class IntExample {
    public static void main(String[] args) {
        int num;
        System.out.println("存儲最大值：" + Integer.MAX_VALUE);
        System.out.println("存儲最小值：" + Integer.MIN_VALUE);
        System.out.println("默認存儲字節：" + Integer.BYTES);
        num = 1500;
        System.out.println(num);
          num = -1500;
        System.out.println(num);
    }
}

輸出：

存儲最大值：2147483647
存儲最小值：-2147483648
默認存儲字節：4
1500
-1500

數值存儲范圍：-9223372036854775808 到 9223372036854775807

默認大小：8 字節

class LongExample {
    public static void main(String[] args) {
        long num;
        System.out.println("存儲最大值：" + Long.MAX_VALUE);
        System.out.println("存儲最小值：" + Long.MIN_VALUE);
        System.out.println("默認存儲字節：" + Long.BYTES);
        num = 150000000000L;
        System.out.println(num);
        num = -150000000000L;
        System.out.println(num);
    }
}

注意：long類型變量賦值時，數值后面要加上字母L或者小寫l

輸出：

存儲最大值：9223372036854775807
存儲最小值：-9223372036854775808
默認存儲字節：8
150000000000
-150000000000

總結：

從 byte到 long 類型變量存儲范圍越來越大，存儲空間（字節數）越來越大，程序運行速度越來越小。所以編碼過程中根據數值大小選擇合適數據類型變量，可以優化程序運行速度。

足夠保存15位十進制數字

默認大小：8 字節

class DoubleExample {
    public static void main(String[] args) {
        System.out.println("存儲最大值：" + Double.MAX_VALUE);
        System.out.println("存儲最小值：" + Double.MIN_VALUE);
        System.out.println("默認存儲字節" + Double.BYTES);
        double num = -42937737.9d;
    }
}

注意：double 類型變量賦值時，數值后面要加上字母D或者小寫d

輸出：

存儲最大值：1.7976931348623157E308
存儲最小值：4.9E-324
默認存儲字節8
-4.29377379E7

足夠保存6至7位十進制數字

默認大小：4 字節

class DoubleExample {
    public static void main(String[] args) {
        System.out.println("存儲最大值：" + Double.MAX_VALUE);
        System.out.println("存儲最小值：" + Double.MIN_VALUE);
        System.out.println("默認存儲字節" + Double.BYTES);
        double num = -42937737.9d;
    }
}

注意：float 類型變量賦值時，數值后面要加上字母F或者小寫f

輸出：

存儲最大值：3.4028235E38
存儲最小值：1.4E-45
默認存儲字節4
-18.9

只存儲 true 和 false

class BooleanExample {
    public static void main(String[] args) {
        boolean b = true;
        System.out.println(b);
        b = false;
        System.out.println(b);
    }
}

輸出：

true
false

只存儲一個字符

默認存儲大小：2 個字節

class CharExample {
    public static void main(String[] args) {
        char ch = "z";
        System.out.println("默認存儲字節：" + Character.BYTES);
        System.out.println(ch);
        ch = "1";
        System.out.println(ch);
        //ch = "10";//編譯不過，因為char 類型只能存儲一個字符
    }
}

輸出：

默認存儲字節：2
z
1

byte、short、int和long都可以用十進制、二進制、八進制以及十六進制的方式來表示。當使用常量字面量時，前綴0b表示二進制，0表示八進制，而前綴0x代表十六進制。比如：

int decimal = 174;
int binary = 0b10101110;
int octal = 0256;
int hexa =  0xAE;

為什么174用二進制表示就是10101110呢？

174是由個位數的4、十位數的7和百位數的1構成：

如果使用二進制，則可以表達為：

上面圖片中所有紅色的數字就構成了二進制表示10101110。

哪如何將一個十進制數轉換為二進制數呢？

將十進制數不斷除以2，直到等于0，每次除法產生的余數從后往前合并在一起就是對應的二進制表示：

對于八進制和十六進制，原理是類似的。

一個浮點數字面量默認是double類型，如果要定義float類型則要在字面量最后添加f或者F：

double a = 1.23;
float b = 1.23F;
float c = 1.23; // 編譯錯誤

以上代碼中，第三行代碼將出現編譯錯誤，因為1.23這個字面量是double類型的，不能將其賦值給float類型。

一個整數字面量默認是int類型，如果要定義長整形(long)則要在字面量最后添加l或者L。但是

int a = 100;
long b = 100000L;
long c = 100000;

第三行代碼long c = 100000;不會有編譯錯誤，雖然字面量100000是int類型的，但是當int類型賦值給long類型時，可以自動轉換為long類型。

占用內存空間小的類型可以自動轉換為占用空間大的類型，反之則不成立。你把一個變量的想象成一個箱子，更小的箱子里的東西可以放入到更大的箱子中，將更大的箱子里的東西放到更小的箱子則可能裝不下。比如：

b = a;是合法的賦值

a = b;則是非法的賦值，會有編譯錯誤，這其實也是代碼float c = 1.23;會發生編譯錯誤的原因

如果一定要將b的值(long類型)賦值給a，則要進行強制轉換：

a = (int)b;

b變量前的(int)表示將b的值強制轉換為int類型。注意強制類型轉換時，可能導致數據錯誤，比如b的值超過了int類型的表示范圍，此時就會進行數據截斷（丟掉箱子裝不下的東西），我們應該盡量避免這種情況。

基本類型之間的自動轉換關系如下：

以上8種基本類型都不是類，Java提供了對應的類，稱之為包裝類。包裝類可以認為是將基本類型轉換成的一個引用類型。

每種基本類型所占用的內存空間大小，最大值和最小值，可以通過其包裝類來訪問。比如為了我們可以這樣訪問int類型的相關信息：

 System.out.println("int類型的二進制位數：" + Integer.SIZE);  
 System.out.println("int類型的最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);  
 System.out.println("int類型的最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE); 

注意，將一個整數和字符串通過+號拼接起來，整數可以自動轉換為字符串。

以Integer和int為例，我們可以將兩者進行轉換，例如：

Integer in = new Integer(100); // 將int轉換為包裝類
int m = in.intValue(); // 獲取Integer的int值
String s = “123”;
int n = Integer.parseInt(s); // 將字符串轉換為整數
String s2 = Integer.toString(n); // 將整數轉換為字符串

其它數據類型的操作是類似的，不再一一贅述。

Integer in = new Integer(100);將int轉換為包裝類，本質就是通過new創建包裝類Integer，調用Integer的構造函數并將100這個int類型的數作為參數傳給構造函數。關于構造函數的細節在后續教程中講解。

數組（Array）是程序設計語言中必不可少的一種結構，它用來描述一系列相同類型的數據。一個數組一旦創建后，它的長度是固定的。

下面的代碼，定義了一個長度為10的數組，數據的下標編號從0開始，9是最后一個元素。下面是一個Java語言數組的例子：

int[] anArray;
anArray = new int[10];//初始化一個長度為10的整形數組

anArray[0] = 100;//初始化第一個變量
anArray[1] = 200;
anArray[2] = 300;
anArray[3] = 400;
anArray[4] = 500;
anArray[5] = 600;
anArray[6] = 700;
anArray[7] = 800;
anArray[8] = 900;
anArray[9] = 1000;

數組下標和元素的關系如下所示：

這樣初始化數組比較麻煩，下面是另外一種更加便捷的方式：

int[] anArray = { 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000};

這樣會自動創建一個長度為10的int數組。我們通過anArray.length可以得到數組的長度。

一個字符串就是一個字符序列，字符串被廣泛應用于 Java 編程。Java語言將字符串作為String類型的對象進行處理。

String并不是基本的數據類型，是一個類。最常用的創建字符串對象的方法如下：

String str = "abc";

字符串可以通過+和+=操作符進行拼接，比如：

String str1 = "abc";    
String str2 = str1 + "def";
str1 += "def";

最后str1和str2所指向的字符串內容為"abcdef"。

字符串和基本數據類型也能通過+進行拼接操作，比如：

int a = 100;
String str = "a=" + a;

str字符串的內容為"a=100"。即基本類型和字符串類型相加時，基本類型會自動轉換為其字符串表示，在這個例子中相當于：

String str = "a=" + "100";

回顧包裝類這一小節的代碼：

System.out.println("int類型的最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE); 

就是將字符串和數據類型的拼接。

String類的實例是一個不可變的對象，意味著對String的操作都會產生一個新的String對象。

例如，String有一個substring()方法

String str = "123456";
str.substring(3); // 從下標3（注意下標從0開始）開始截取一個子字符串
System.out.println(str); // str本身不可變，所以打印出來依然是123456
String str2 = str.substring(3); // 將產生的新對象賦值給一個新的引用變量
System.out.println(str2); // str2的內容為456