一、簡單認識泛型

1.什么是泛型

Java 泛型（generics）是 JDK 5 中引入的一個新特性, 泛型提供了編譯時型別安全檢測機制，該機制允許程式員在編譯時檢測到非法的型別，

泛型的本質是引數化型別，也就是說所操作的資料型別被指定為一個引數，這種引數型別可以用在類、介面和方法中，分別被稱為泛型類、泛型介面、泛型方法，

怎么理解這句話呢？我們舉個例子：

創建一個通用順序表：

class MyArrayList{
    private int[]elem;
    private int usedSize;

    public MyArrayList(){
        this.elem=new int[10];
    }

    public void add(int val){
        this.elem[usedSize]=val;
        usedSize++;
    }
    public int get(int pos){
        return this.elem[pos];
    }
}

上面的順序表看起來好像沒什么問題，但細究，我們會發現這個順序表存在以下問題

1. 不通用，它只能存放int型別的資料，
2. 我們想的是所有型別的資料都能存放

有同學說，我們可以添加一個Object，Object不是所有類 的父類嗎？

class MyArrayList{
    private Object[]elem;
    private int usedSize;

    public MyArrayList(){
        this.elem=new Object[10];
    }

    public void add(Object val){
        this.elem[usedSize]=val;
        usedSize++;
    }
    public Object get(int pos){
        return this.elem[pos];
    }
}

這個順序表貌似各種元素都能存放，但是也存在以下問題：

1. 存放元素，不能指定存放什么元素，也就是說什么都可以放
2. 每次取出資料，都需要強制型別轉換，

但是我們想要的效果是這樣的：

1. 我們可以指定順序表的型別
2. 指定型別后，只能存放相應的資料型別
3. 取資料的時候，不進行型別轉換

很簡單，使用泛型，

class MyArrayList<E>{
		在順序表上添加<E>，這代表當前類是一個泛型類，而這個E本質上僅僅是一個占位符
}

那么當我參考的時候，就變成了這樣，可以把型別作為引數傳遞：

public static void main(String[] args) {
        MyArrayList<String> myArrayList1=new MyArrayList<>();
        MyArrayList<Integer> myArrayList2=new MyArrayList<>();
    }

這就是一開始所說的，泛型把型別引數化了，

那么我們使用泛型之后，一開始的代碼就需要更改了：

class MyArrayList<E>{
    private E[]elem;
    private int usedSize;

    public MyArrayList(){
        //this.elem=new E[10];//泛型不能實體化物件
    }

    public void add(E val){
        this.elem[usedSize]=val;
        usedSize++;
    }
    public E get(int pos){
        return this.elem[pos];
    }
}

【注意】上面注釋，泛型不能實體化

2.泛型的意義

1. 增加編譯期間的型別檢查
2. 取消型別轉換的使用

3.泛型是如何編譯的

1. 泛型是一種編譯時期的機制——擦除機制

Java 語言中的泛型，它只在程式原始碼中存在，在編譯后的位元組碼檔案中，就已經替換為原來的原生型別（RawType，也稱為裸類 型）了，并且在相應的地方插入了強制轉型代碼，因此，對于運行期的 Java 語言來說，ArrayList＜int＞與 ArrayList＜String＞就是同一 個類

將一段 Java 代碼編譯成 Class 檔案，然后再用位元組碼反編譯工具進行反編譯后，將會發現泛型都不見了，程式又變回了 Java 泛型 出現之前的寫法，因為泛型型別都變回了原生型別

—————————————————————————————

4.泛型總結

1. 泛型是為了解決某些容器、演算法等代碼的通用性而引入，并且能在編譯期間做型別檢查，
2. 泛型利用的是 Object 是所有類的祖先類，并且父類的參考可以指向子類物件的特定而作業，
3. 泛型是一種編譯期間的機制，即 MyArrayList 和 MyArrayList 在運行期間是一個型別
4. 泛型是 java 中的一種合法語法，標志就是尖括號 <>

二、包裝類

1.什么是包裝類

我們知道，Object 參考可以指向任意型別的物件，但有例外出現了，8 種基本資料型別不是物件，那豈不是剛才的泛型機制要失效了？

實際上也確實如此，為了解決這個問題，java 引入了一類特殊的類，即這 8 種基本資料型別的包裝類，在使用程序中，會將類似 int 這樣的值包裝到一個物件中去，

2.基本資料型別與對應的包裝型別

常用的包裝類可以分為三類：Character、Number、Boolean，繼承結構圖如下：

3.裝箱和拆箱

裝箱：

基本型別向對應的包裝類轉換稱為裝箱，例如把 char包裝成 Character類的物件，

Character i = Character.valueOf(1); //手動裝箱
Character j = 1; //自動裝箱

拆箱：
包裝類向對應的基本型別轉換稱為拆箱，例如把 Integer 類的物件重新簡化為 int，

Integer a= new Integer(1);
int a1= a; //自動拆箱
int a2= a.intValue(); //手動拆箱

4.關于拆箱和裝箱常見面試題

equals方法比較的是真正的值，基本資料型別和包裝類比較時，會先把基本資料型別包裝成對應的包裝型別，再進行比較，

double a= 0.1;
Double b= new Double(0.1);
Double c= new Double(0.1);
System.out.println(a.equals(b)); //true 2個包裝類比較，比較的是包裝的基本資料型別的值
System.out.println(b.equals(a)); //true 基本資料型別和包裝型別比較時，會先把基本資料型別包裝后再比較

==（雙等號）

對于基本資料型別，（雙等號）比較的是值，而對于包裝型別，（雙等號）比較的則是2個物件的記憶體地址，

double a= 0.1;
Double b= new Double(0.1);
Double c= new Double(0.1);
System.out.println(b== c);    //false ,new出來的都是新的物件
System.out.println(b== a);    //true ,基本資料型別和包裝類比較，會先把包裝類拆箱

new出來的都是新的物件，2個新的物件記憶體地址不同，那么==號比較的結果肯定是false，

基本資料型別和包裝型別比較時，會先把包裝類拆箱再進行值比較（和equals是反的）

3:

Double a= Double.valueOf(0.1);
Double b= Double.valueOf(0.1);
System.out.println(a== b); //false valueOf方法內部實際上也是new

valueOf內部也是用的new方法來構造物件的，2個new出來的物件，記憶體地址肯定是不一樣的，

接著來看下一個陷阱：

public static void main(String[] args) {
        System.out.println(Integer.valueOf(1) ==Integer.valueOf(1)); //true
        System.out.println(Integer.valueOf(999) ==Integer.valueOf(999)); //false 
    }

看到結果，你可能很疑惑，我們看看原始碼：
1.查看Integer.valueOf方法的原始碼
可以看到，當i的值在low和high范圍內是，回傳的是一個cache里的Integer物件，

2.追蹤IntegerCache.cache的原始碼：

可以看到從-128到到127之間的值都被快取到cache里了，這個叫做包裝類的快取，

Java對部分經常使用的資料采用快取技術，在類第一次被加載時換創建快取和資料，當使用等值物件時直接從快取中獲取，從而提高了程式執行性能，（通常只對常用資料進行快取）

Integer默認快取是-128到127之間的物件，上限127可以通過修改JVM引數來更改，

回到我們的示例代碼中，可以看到Integer.valueOf(1)是會直接從快取中去取被快取的同一個物件，所以比較的值是true，而Integer.valueOf(999)是快取范圍外的值，那么就會new一個新的物件出來，所以比較的結果是false，

實際上，包裝類中整數型的型別基本上都有快取資料，可以通過閱讀原始碼了解，不過只有Integer類可以通過修改JVM引數來更改快取上限，

其他型別的快取范圍為：

1. Integer型別有快取-128-127的物件，快取上限可以通過配置jvm更改
2. Byte,Short,Long型別有快取(-128-127)
3. Character快取0-127
4. Boolean快取TRUE、FALSE

尤其需要特別注意的是，只有valueOf方法構造物件時會用到快取，new方法等不會使用快取！

這部分更詳細的內容可以參考借鑒參考的文章：深入淺出JAVA包裝類及面試題陷阱

三、List的使用

1.ArrayList簡單介紹

在集合框架中，ArrayList是一個普通的類，實作了List介面，具體框架圖如下：

1. ArrayList實作了RandomAccess介面，表明ArrayList支持隨機訪問
2. ArrayList實作了Cloneable介面，表明ArrayList是可以clone的 3. ArrayList實作了Serializable介面，表明ArrayList是支持序列化的
3. 和Vector不同，ArrayList不是執行緒安全的，在單執行緒下可以使用，在多執行緒中可以選擇Vector或者
   CopyOnWriteArrayList
4. ArrayList底層是一段連續的空間，并且可以動態擴容，是一個動態型別的順序表

2.ArrayList使用

我們通過IDEA點擊進去ArrayList可以發現其有三種方法：

public static void main(String[] args) {
 // ArrayList創建，推薦寫法 
 // 構造一個空的串列 
 List<Integer> list1 = new ArrayList<>();
 
  // 構造一個具有10個容量的串列
 List<Integer> list2 = new ArrayList<>(10);
 list2.add(1); 
 list2.add(2); 
 list2.add(3); 
 // list2.add("hello"); // 編譯失敗，List<Integer>已經限定了，list2中只能存盤整形元素 
 
 // list3構造好之后，與list中的元素一致
  ArrayList<Integer> list3 = new ArrayList<>(list2);
  
  // 避免省略型別，否則：任意型別的元素都可以存放，使用時將是一場災難 
  List list4 = new ArrayList();
  list4.add("111"); list4.add(100);
   }

3.ArrayList的常見操作

ArrayList雖然提供的方法比較多，但是常用方法如下所示，需要用到其他方法時，同學們自行查看ArrayList的幫助檔案，

public static void main(String[] args) {
 List<String> list = new ArrayList<>(); 
 list.add("JavaSE"); 
 list.add("JavaWeb");
 list.add("JavaEE"); 
 list.add("JVM"); 
 list.add("測驗課程"); 
 System.out.println(list); 
 // 獲取list中有效元素個數
  System.out.println(list.size());

 // 獲取和設定index位置上的元素，注意index必須介于[0, size)間
 System.out.println(list.get(1)); 
 list.set(1, "JavaWEB"); 
 System.out.println(list.get(1)); 
// 在list的index位置插入指定元素，index及后續的元素統一往后搬移一個位置 
list.add(1, "Java資料結構"); 
System.out.println(list); 

// 洗掉指定元素，找到了就洗掉，該元素之后的元素統一往前搬移一個位置 
list.remove("JVM"); System.out.println(list);

 // 洗掉list中index位置上的元素，注意index不要超過list中有效元素個數,否則會拋出下標越界例外 
list.remove(list.size()-1); 
System.out.println(list); 

// 檢測list中是否包含指定元素，包含回傳true，否則回傳false
if(list.contains("測驗課程")){
 list.add("測驗課程"); 
 }
 
// 查找指定元素第一次出現的位置：indexOf從前往后找，lastIndexOf從后往前找 
list.add("JavaSE");
 System.out.println(list.indexOf("JavaSE")); System.out.println(list.lastIndexOf("JavaSE")); 

// 使用list中[0, 4)之間的元素構成一個新的ArrayList回傳 
List<String> ret = list.subList(0, 4); 
 System.out.println(ret);
 list.clear();
 System.out.println(list.size());
 }

4.ArrayList的遍歷

public static void main(String[] args) {
        ArrayList<String> list2 = new ArrayList<>();
        list2.add("我");
        list2.add("無敵");
        list2.add("存在");
        System.out.println(list2);
        System.out.println("================");
        // 使用下標+for遍歷
        for (int i = 0; i < list2.size(); i++) {
            System.out.print(list2.get(i) + " ");
        }
        System.out.println();
        System.out.println("==================");

			// 借助foreach遍歷
        for (String s : list2) {
            System.out.print(s + " ");
        }

			//迭代器列印
        System.out.println();
        System.out.println("========迭代器列印==========");
        Iterator<String> it = list2.iterator();
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }

		//迭代器List相關列印
        System.out.println();
        System.out.println("========迭代器List相關列印==========");
        ListIterator<String> it2 = list2.listIterator();
        while (it2.hasNext()) {
            System.out.print(it2.next() + " ");
        }
    }

有同學看到上面可能有疑問，Iterator與ListIterator都可以迭代輸出，那么二者有什么區別呢？

Iterator和ListIterator主要區別在以下方面：

1. ListIterator有add()方法，可以向List中添加物件，而Iterator不能

2. ListIterator和Iterator都有hasNext()和next()方法，可以實作順序向后遍歷，但是ListIterator有hasPrevious()和previous()方法，可以實作逆向（順序向前）遍歷，Iterator就不可以，

3. ListIterator可以定位當前的索引位置，nextIndex()和previousIndex()可以實作，Iterator沒有此功能，

4. 都可實作洗掉物件，但是ListIterator可以實作物件的修改，set()方法可以實作，Iierator僅能遍歷，不能修改，

因為ListIterator的這些功能，可以實作對LinkedList等List資料結構的操作，其實，陣列物件也可以用迭代器來實作，

更詳細內容可以參考這篇文章：Iterator和ListIterator區別

這里還有一個點需要注意：
我們在用迭代洗掉(Iterator.remove())時，可能會因為沒有“it.next();”這一行， 拋出java.lang.IllegalStateException例外，原因是通過Iterator來洗掉集合中某一個不滿足條件的元素時，

首先需要使用next方法迭代出集合中的元素 ，然后才能呼叫remove方法，否則集合可能會因為對同一個Iterator remove了多次而拋出java .lang.IllegalStateException例外，

public static void main(String[] args) {
        ArrayList<String> list2 = new ArrayList<>();
        list2.add("我");
        list2.add("無敵");
        list2.add("存在");
        System.out.println();
        System.out.println("========迭代器List相關列印==========");
        ListIterator<String> it2 = list2.listIterator();
        while (it2.hasNext()) {
            String ret = it2.next();
            if(ret.equals("hello")) {
                it2.remove();//首先需要使用next方法迭代出集合中的元素 ，然后才能呼叫remove方法
            }else {
                System.out.print(ret + " ");
            }
        }
    }

5.ArrayList的擴容機制

ArrayList是List介面的實作類，它是支持根據需要而動態增長的陣列，java中標準陣列是定長的，在陣列被創建之后，它們不能被加長或縮短，這就意味著在創建陣列時需要知道陣列的所需長度，但有時我們需要動態程式中獲取陣列長度，ArrayList就是為此而生的，
詳細內容參照：ArrayList的擴容機制

因此，了解它的擴容機制對使用它尤為重要，

ArrayList擴容發生在add()方法呼叫的時候，下面是add()方法的原始碼:
點進去add（）方法的原始碼：
根據意思可以看出ensureCapacityInternal()是用來擴容的，形參為最小擴容量，進入此方法后：
通過方法calculateCapacity(elementData, minCapacity)獲取：
如果傳入的是個空陣列則最小容量取默認容量與minCapacity之間的最大值

ensureExplicitCapacity方法可以判斷是否需要擴容：

如果最小需要空間比elementData的記憶體空間要大，則需要擴容

接下來重點來了，ArrayList擴容的關鍵方法grow():

決議：

從此方法中我們可以清晰的看出其實ArrayList擴容的本質就是計算出新的擴容陣列的size后實體化，并將原有陣列內容復制到新陣列中去，

到此擴容就基本完成了，

總結

害，不知該怎么辦，人生最難的就是選擇，還有堅持！不管怎么說，先一步一步做好該做好的事情，