基本資料型別介紹

Java 中定義了 3 類 8 種基本資料型別

• 數值型：byte、short、int、long、float、double
• 字元型（文字型）：char
• 布林型：boolean

資料型別分類如下：

其中：

• 引用資料型別：4 個位元組，其代表物件的地址
• 字元型（char）：2 個位元組
• 布林型（boolean）：1 bit（1 位 ）
• 數值型：
  • 整數型別：
    1. byte：1 個位元組
    2. short：2 個位元組
    3. int：4 個位元組
    4. long：8 個位元組
  • 浮點型別：
    1. float：4 個位元組
    2. double：8 個位元組

整型變數/常量

整型用於沒有小數部分的數值，其允許是負數。

一個位元組表示範圍是 2 的 8 次方（即 256 個數：-128 ~ 127）。
兩個位元組表示範圍是 2 的 16 次方（-23768 ~ 32767），範圍大約在正負 3 萬之間。
三個位元組表示範圍是 2 的 32 次方，範圍大約在正負 21 億之間。

Java 語言的整型常量預設為 int 型，宣告 long 型常量可以後加 ‘l’ 或 ‘L’

假如定義的資料型別變數值超出範圍，會報錯。

byte age = 300;  // 報錯，因為 byte 的範圍是 -128~127（2 的 8 次方）
byte age1 = 30;   // 正常
short salary = 300000000;  // 報錯，short 資料型別的表數範圍是 2 個位元組(2 的 16 次方)
short salary1 = 30000;     // 正常
int pop = 20000000000;     // 報錯（200億），int 表數範圍是 4 個位元組，範圍大約在正負21億之間
int pop1 = 2000000000;     // 正常（20億），
// 定義 long 長整型常量
long one = 74000000000;    // 報錯，因為整型常量預設是 int 型別，所以此處超出範圍了
long one1 = 74000000000L;   // 在數值後面加上一個 L / l 字母，就代表這是一個 long 型別常量
long one2 = 74000000000l;   // 最好是加 L，方便辨別
 

Java 語言整型常量的四種表現形式

1. 十進位制整數，如：99，-500,0
2. 八進位制整數，要求以 0 開頭，如 015
3. 十六進位制數，要求 0x 或 0X 開頭，如：0x15
4. 二進位制數，要求 0b 或 0B 開頭，如：0b01110011

// 測試整型常量
int a = 15;
int b = 015;  // 這是八進位制數
int c = 0x15;  // 這是十六進位制
int d = 0b011101;  // 這是二進位制
int e = 0B011101;  // 這是二進位制
System.out.println(a);   // 結果為 15
System.out.println(b);   // 結果為 13
System.out.println(c);   // 結果為 21
System.out.println(d);   // 結果為 29
System.out.println(e);   // 結果為 29
 

浮點型變數/常量

帶小數的資料在 Java 中稱為浮點型。
浮點資料型別分兩種：float、double
float 佔 4 個位元組，double 佔 8 個位元組。
浮點型常量的預設型別是 double。
浮點數存在舍入誤差，數字不能精確表示。如果需要進行不產生舍入誤差的精確數字計算，需要使用 BigDecimal 類

float 稱為單精度型別，尾數可精確到 7 位有效數字，多數情況，float 型別的精度很難滿足需求。
double 稱為雙精度型別，數值精度約是 float型別 的兩倍。絕大部分應用程式都採用 double 型別。

Java 浮點型別常量的兩種表現形式：

• 十進位制數形式，如：3.14、314.0、0.314
• 科學計數法形式，如：314e2、314E2、314E-2

科學計數法示例：

double f = 314e2; // 314*10^2 -->> 31400.0
double f2 = 314e-2; // 314*10^(-2) -->> 3.14

flaot 型別賦值時需要新增字尾 F/f

// 浮點型若未宣告，預設是 double。
// float 加 F/f 進行宣告，才能放進 float 型別中。float 和 double 的位元組數不同，所以報錯
float a = 3.14;   // 報錯，定義 float，需要加 F/f 進行宣告
float a1 = 3.14F; // 正常
float a2 = 3.14f; // 正常

注意點

浮點型別float、double 的資料不適合在不容許舍入誤差的金融計算領域，如果需要進行不產生舍入誤差的精確數字計算，需要使用 BigDecimal 類。
float 型別字尾為 F/f，沒有 F/f 則預設為 double 型別。
可在浮點數值後新增 D/d 字尾，以明確其為 double 型別。

float f = 3.14F;
double d1 = 3.14;
double d2 = 3.14D;

浮點數比較（錯誤示範）

浮點數是不精確的，不能用於數值比較

// 浮點數是不精確的，不能用於數值比較
// 此處結果為 false
float f = 0.1f;
double d = 1.0/10;
System.out.println(f==d);   // 結果為 false。利用 == ，對兩個變數進行數值比較

浮點數運算比較驗證

// 浮點數運算比較驗證，此處輸出結果為 d1==d2 ,由此說明浮點數是不精確的。
float d1 = 423432143f;
float d2 = d1 + 1;   // 在原來的基礎上加個 1
if(d1==d2){
  System.out.println("d1==d2"); // 輸出結果為 d1==d2
}else{
  System.out.println("d1 != d2"); 
}

數值之間如何計算？

java.math 包中有兩個類：BigInteger 和 BigDecimal
這兩個類可以處理任意長度的數值。

程式碼示例：使用 BigDecimal 進行浮點數的比較

import java.math.BigDecimal;
public class testNumericalJ {
    public static void main(String[] args){
        // 使用精確浮點運算，推薦 BigDecimal
        BigDecimal bd = BigDecimal.valueOf(1.0);  // 定義了 bd 值為 1.0  ，即 bd = 1.0
        bd = bd.subtract(BigDecimal.valueOf(0.1));
        bd = bd.subtract(BigDecimal.valueOf(0.1));
        bd = bd.subtract(BigDecimal.valueOf(0.1));
        bd = bd.subtract(BigDecimal.valueOf(0.1));
        bd = bd.subtract(BigDecimal.valueOf(0.1));
        // 兩者對比，上方 subtract 詞義是 減，進行了 5 次減 0.1 的操作。
        System.out.println(bd);  // 輸出結果為 0.5
        System.out.println(1.0 - 0.1 - 0.1 - 0.1 - 0.1 - 0.1); // 輸出結果為 0.5000000000000001

        // 定義 bd2，bd3，做比較驗證
        BigDecimal bd2 = BigDecimal.valueOf(0.1);    // 定義 bd2 初值為 0.1
        BigDecimal bd3 = BigDecimal.valueOf(1.0/10); // 定義 bd3 初值為 1.0/10
        // 比較 bd2 和 bd3
        System.out.println(bd2.equals(bd3));         // 輸出結果為 true
    }
}

字元型變數/常量

字元型在記憶體中佔兩個位元組，在 Java 中使用單引號來表示字元常量。
例如：單引號包裹的 'A' 表示一個字元，而雙引號包裹的 "A" 表示含有一個字元的字串
char 型別用來表示在 Unicode 編碼表中的字元。
Unicode 編碼被設計用來處理各種語言的文字，其佔 2 個位元組，可允許 65536 個字元。
多個字母，如 'abc'，這種就需要用 String 型別來進行宣告，無法使用 char 進行宣告。char 只適用於單個字元或數字
String 即字元序列。

可以用單引號包裹表示字元型，也可以用 Unicode 編碼去表示字元型

示例：字元型舉例

char a = 'T';
char b = '中';
char c = '\u0061';  // 表示字元 a

Unicode 具有從 0 到 65535 之間的編碼，其通常從 ‘\u0000’ 到 ‘\uFFFF’ 之間的十六進位制數來表示（字首為 u 則說明是 Unicode）

轉義字元 '\'

Java 語言中允許使用轉義字元 '' 來將其後的字元轉變為其他的含義
常見轉義字元的含義和 Unicode 值如圖：

程式碼示例：轉義字元

// 轉義字元
public class testPrimitiveDateType2 {
    public static void main(String[] args){
        // 轉義字元
        // 遇到符號 + 時，a 和 b 會自動轉化為數字
        System.out.println('a'+'b');  // 結果為 195
        // 通過在前方增加一個空字串，讓語句識別為字串拼接，最終獲得結果為 ab
        System.out.println(""+'a'+'b');  // 結果為 ab
        // 在 a 和 b 之間換行，使用 \n 換行符
        System.out.println(""+'a'+'\n'+'b');  // 一行輸出 a，後一行輸出 b
        // 在 a 和 b 之間增加一個 \t 製表符長度
        System.out.println(""+'a'+'\t'+'b');  // 輸出結果為 a  b，中間有一段為製表符佔位
        // 在 a 和 b 之間增加一個單引號 '
        System.out.println(""+'a'+'\''+'b');  // 輸出結果為 a'b，使用 \ 來對單引號 ' 進行轉義輸出
    }
}

boolean 型別變數/常量

boolean 型別有兩個常量值：true 、false
在記憶體中佔一位（不是一個位元組）
不可以使用 0 或 非0 的整數來代替 true 和 false，這點與 C 語言有所不同
boolean 型別用來判斷邏輯條件，一般用於程式流程控制。

程式碼示例：boolean 型別

// 測試布林型別，測試結果為 “這裡是 flag 是 true 的列印”
boolean flag;
flag = true; // 或者 flag = false
if (flag){
    System.out.println("這裡是 flag 是 true 的列印");  // 列印這個結果
}else{
    System.out.println("這裡是 flag 是 false 的列印");
}

細節程式碼記錄：第一時間我誤判了

// 說出程式執行結果

boolean man = false;

if (man=true){
    System.out.println("男性");
}else{
    System.out.println("女性");
}

// 列印結果為男性，因為 if 判斷語句中對 man 進行了重新賦值。值由 false 變為了 true

至此，基本資料型別結束