基本資料型別

Java的資料型別分為兩類：

• 基本資料型別：整數、浮點數、字元、布林。
• 引用資料型別：陣列、字串、類、介面、Lambda。

基本資料型別

• 位元組型：byte，1個位元組
• 短整型：short，2個位元組
• 整型：int，4個位元組（預設）
• 長整型：long，8個位元組（建議定義時加L表示long a = 12345678L;）
• 單精度浮點數：float，4個位元組（建議定義時加F表示float a = 10.2F;）
• 雙精度浮點數：double，8個位元組（預設）
• 字元型：char，2個位元組（單引號表示byte A = 'A';）
• 布林型：boolean，1個位元組

兩個特例

例1：

short s = 1;
s += 1;
System.out.println(s);

正常來說，1是整型，s是short型，會出錯。但是+=是運演算法，只計算一次，並帶有強制轉換的特點，所以不會出錯。

例2：

byte b1 = 1;
byte b2 = 2;
byte b3 = 1 + 2;
byte b4 = b1 + b2;

b3不會出錯，因為b3是在1+2計算完成之後再賦值；b4會出錯，因為b1+b2有可能超出b4的範圍。

陣列

陣列是引用資料型別，陣列需要指定長度和儲存資料型別。

陣列初始化方法：

1. 動態初始化（指定長度）：int[] arr = new int[3]
2. 靜態初始化（指定內容）：char[] arr = new char[]{'a', 'b', 'c'}
3. 省略格式的靜態初始化：int[] arr = {1, 2, 3}

包裝類

基本資料型別在於效率，引用資料型別可以提供更多功能。把基本資料型別裝起來，稱為包裝類，兩個過程：裝箱/拆箱。

裝箱：

Integer i1 = new Integer(4); // 構造方法
Integer i2 = Integer.valueOf(4); // 類中的方法

拆箱：

int num = i.intValue();

JAVA5之後，可以自動裝箱拆箱：

Integer i = 4;  // 自動裝箱
int a = i + 5; // <==> int a = i.intValue() + 5;
 

基本資料型別都可以通過包裝類和字串轉換

String s1 = 100 + ""; // 第一種方式
String s2 = Integer.toString(100); // 第二種方式
String s3 = String.valueOf(100); // 第三種
int a = Integer.parseInt(s1);

泛型

未知的資料型別，可以應用於類、方法、介面。

類：

public class Test {
    public static void main(String[] args) {
        Person<String> p = new Person<>();
        p.setName("字串");
        System.out.println(p.getName());
    }
}

class Person<E> {
    private E name;

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }
}

方法：

public class Test {
    public static void main(String[] args) {
        // 方法
        Person p = new Person();
        p.method1(100);
        p.method1("字串");
        // 靜態方法
        Person.method2("任意資料型別");
    }
}

class Person {
    public <M> void method1(M m) {
        System.out.println(m);
    }

    public static <S> void method2(S s) {
        System.out.println(s);
    }
}

介面：

public class Test {
    public static void main(String[] args) {
        TestImp<String> t = new TestImp<>();
        t.method("字串");
    }
}

interface TestInterface<E> {
    public abstract void method(E e);
}

class TestImp<E> implements TestInterface<E> {	// 這裡可以指定，也可以不指定泛型
    public void method(E e) {
        System.out.println(e);
    }
}

泛型的萬用字元

當使用泛型類或者介面時，傳遞的資料中，泛型型別不確定，可以通過萬用字元<?>表示。但是一旦使用泛型的萬用字元後，只能使用Object類中的共性方法，集合中元素自身方法無法使用。

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> list1 = new ArrayList<>();
        list1.add(1);
        list1.add(2);

        ArrayList<String> list2 = new ArrayList<>();
        list2.add("a");
        list2.add("b");

        printArray(list1);
        printArray(list2);
    }

    public static void printArray(ArrayList<?> list) {
        for (Object x : list) {
            System.out.println(x);
        }
    }
}

泛型的上限限定：? extends E 代表使用的泛型只能是E型別的子類或本身

泛型的下限限定：? super E 代表使用的泛型之只能是E型別的父類或本身

比如：Object類，String 類，Number類，Integer類，其中Number是Integer的父類

public static void main(String[] args) {
    Collection<Integer> list1 = new ArrayList<Integer>();
    Collection<String> list2 = new ArrayList<String>();
    Collection<Number> list3 = new ArrayList<Number>();
    Collection<Object> list4 = new ArrayList<Object>();
    
    getElement(list1);
    getElement(list2);//報錯
    getElement(list3);
    getElement(list4);//報錯
  
    getElement2(list1);//報錯
    getElement2(list2);//報錯
    getElement2(list3);
    getElement2(list4);
  
}
// 泛型的上限：此時的泛型?，必須是Number型別或者Number型別的子類
public static void getElement1(Collection<? extends Number> coll){}
// 泛型的下限：此時的泛型?，必須是Number型別或者Number型別的父類
public static void getElement2(Collection<? super Number> coll){}

Iterator迭代器

通用的迭代元素的方法，實際上是指標在移動。可以使用增強for迴圈。增強for只能遍歷collection和陣列。

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Test {
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>(); // 多型
        coll.add("張三");
        coll.add("李四");
        coll.add("老王");
        /*Iterator<String> it = coll.iterator();  // 多型
        while (it.hasNext()) {
            System.out.println(it.next());
        }*/
        // 增強for訓練
        for (String s : coll) {
            System.out.println(s);
        }
    }
}

JVM記憶體劃分：