引言
在這裡主要介紹一些比較重要的演算法：棧、佇列、陣列、連結串列、Hash、樹以及集合的概念
棧：先進後出
佇列：先進先出，橫向佇列，存入取出
有關棧和佇列的具體儲存資料的過程，可以通過有關圖片進行理解：

連結串列：通過一個鏈子把多個結點（元素）連線起來，由資料和地址組成的一個元素，
節點本身必須有一個地址值（就是下一個元素的地址值）
特點：查詢慢，增刪快
連結串列與陣列剛好相反，對於陣列而言，陣列的特點是：查詢快，增刪慢
連結串列和陣列的關係同樣可以通過圖示來進行理解：

連結串列分類：
單向連結串列：資料+下一個元素的地址
雙向連結串列 ：資料+下一個元素的地址+上一個元素的地址
單向迴圈連結串列 ：最後一個元素儲存的地址是第一個元素的地址值
雙向迴圈連結串列：儲存的是兩個地址，最後一個元素所儲存的兩個地址分別是上一個元素的地址和第一個元素的地址
hash

:一般翻譯做“雜湊”，也有直接音譯為“雜湊”的，就是把任意長度的輸入（又叫做預對映， pre-image），通過雜湊演算法，變換成固定長度的輸出，該輸出就是雜湊值。這種轉換是一種壓縮對映，也就是，雜湊值的空間通常遠小於輸入的空間，不同的輸入可能會雜湊成相同的輸出，所以不可能從雜湊值來唯一的確定輸入值。簡單的說就是一種將任意長度的資訊壓縮到某一固定長度的訊息摘要的函式。這個概念理解起來有點困難，但是後面遇到有關hash的使用後，就不會太難了。
二叉樹，有關二叉樹的概念，在這裡，通過一張圖解進行理解：

集合
為什麼會用到集合呢？那麼就有必要強調一下集合與陣列的區別，因為陣列不適應變化的需求，用一個案例來理解。
需求：儲存5個學生物件，並輸出學生物件的資料資訊。
用陣列的思想去分析:
A:定義學生類(name,age)
B:定義學生陣列，用於儲存學生物件
C:建立學生物件，給學生物件的成員變數賦值
D:把建立好的學生物件新增到陣列中
E:遍歷陣列。
如果換成集合來理解：
在集合中儲存3個學生物件，並遍歷,拿出每一個學生物件的屬性。
1.建立學生物件
2.建立集合
3.將學生物件新增到集合中
4.遍歷集合
有關程式碼實現如下：
在這裡，程式碼部分共用一個學生類，在自己進行編寫的時候，分開來寫，在不同包下進行測試。

//學生的javabean
package com.stu01;
public class Student {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge
 
(int age) {
        this.age = age;
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
}
//陣列
package com.stu02;
public class StudentTest {
    private static final Student[] Student = null;
    public static void main(String[] args) {
        Student s1 = new Student("薛之謙",35);
        Student s2 = new Student("周杰倫",36);
        Student[] arr=new Student[2];
        arr[0]=s1;
        arr[1]=s2;
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i].getName()+" "+arr[i].getAge());
        }
    }
}
//集合
package com.stu01;
import java.util.ArrayList;
import java.util.Collection;
//在集合中儲存5個學生物件，並遍歷,拿出每一個學生物件的屬性。
public class StudentTest {
    public static void main(String[] args) {
        Student s1 = new Student("章子怡",45);
        Student s2 = new Student("郭德綱",55);
        Student s3 = new Student("岳雲鵬",44);
        Student s4 = new Student("汪峰",44);
        Student s5 = new Student("那英",44);
        Collection c=new ArrayList();
        c.add(s1);
        c.add(s2);
        c.add(s3);
        c.add(s4);
        c.add(s5);
        //Object[] toArray():把集合轉成陣列，然後遍歷陣列，其實就相當於遍歷了集合。
        Object[] arr=c.toArray();
        for(int i=0;i<arr.length;i++){
            Student s=(Student) arr[i];
            System.out.println(s.getName()+" "+s.getAge());
        }   
    }
}

編譯執行後結果如下：
陣列部分：
薛之謙 35
周杰倫 36
集合部分：
章子怡 45
郭德綱 55
岳雲鵬 44
汪峰 44
那英 44
所以，總的來說，陣列和集合的區別如下：
陣列：
1.長度固定
2.可以儲存基本型別，也可以儲存引用型別
3.儲存元素型別一致
集合：
1.長度可變
2.只可以儲存引用型別
3.可以儲存多種型別
為了滿足不同的需求，Java提供了不同的集合類。而這些集合類由於資料結構不同，才可以滿足不通的需求。資料結構指的就是儲存元素的方式。 而無論這些集合的結構是什麼樣子的，都是要裝水的，所以，他們應該有共性的內容。通過不斷的向上提取，最終會形成一個集合的繼承體系圖。
java API 集合類圖介紹
Collction體系結構圖
Collection
List
ArrayList
Vector
LinkedList
Set
HashSet
TreeSet
他們之間的關係，可以通過一個圖來進行理解：

下面主要介紹集合的有關介面和類：
Collection是集合的頂層結構，定義了集合的共性功能。可以儲存物件，這些物件也被稱為元素。
成員方法：
A:新增功能
boolean add(Object obj):往集合中新增一個元素
boolean addAll(Collection c):往集合中新增多個元素
B:刪除功能
void clear():清空所有元素
boolean remove(Object o):從集合中刪除一個元素
boolean removeAll(Collection c):從集合中刪除另一個集合的元素
C:判斷功能
boolean contains(Object o):判斷集合中是否包含指定的元素
boolean containsAll(Collection c):判斷集合中是否包含另一個集合的元素
boolean isEmpty():判斷集合是否為空。
D:交集功能
boolean retainAll(Collection c)
E:長度功能
int size():返回集合中元素的個數
在這裡，我寫了一段簡單的程式碼來介紹這些功能：

package com.stu.collection;
import java.util.ArrayList;
import java.util.Collection;
/*
 *      成員方法：(看到E我們先把它理解為Object即可)
 *      A:新增功能
 *          boolean add(Object obj):往集合中新增一個元素
 *          boolean addAll(Collection c):往集合中新增多個元素
 *      B:刪除功能
 *          void clear():清空所有元素
 *          boolean remove(Object o):從集合中刪除一個元素
 *          boolean removeAll(Collection c):從集合中刪除另   一個集合的元素
 *      C:判斷功能
 *          boolean contains(Object o):判斷集合中是否包含指定的元素
 *          boolean containsAll(Collection c):判斷集合中是否包含另一個集合的元素
 *          boolean isEmpty():判斷集合是否為空。
        D:交集功能
 *          boolean retainAll(Collection c)
 *      
 *      E:長度功能
 *          int size():返回集合中元素的個數
 */
public class CollectionStu01 {
    public static void main(String[] args) {
       //建立集合
        Collection c=new ArrayList();
        c.add("hello");
        c.add("world");
        c.add("java");
//      boolean add(Object obj):往集合中新增一個元素
//      boolean flag1 = c.add("fg");
//      System.out.println(flag1);
        //boolean addAll(Collection c):往集合中新增多個元素
        Collection c2=new ArrayList();
        c2.add("nihao");
        c2.add("shijie");
        boolean flag2=c.addAll(c2);
        //System.out.println(flag2);
//      void clear():清空所有元素
//      c.clear();
//      
//      boolean remove(Object o):從集合中刪除一個元素
//      boolean flag3 = c.remove("hello");
//      System.out.println(flag3);
//      boolean removeAll(Collection c):從集合中刪除另一個集合的元素
//      boolean flag4=c.removeAll(c2);
//      System.out.println(flag4);
        //boolean contains(Object o):判斷集合中是否包含指定的元素
//      boolean flag5 = c.contains("java");
//      System.out.println(flag5);
        //boolean containsAll(Collection c):判斷集合中是否包含另一個集合的元素
//      boolean flag6=c.containsAll(c2);
//      System.out.println(flag6);
        //boolean isEmpty():判斷集合是否為空。
//      boolean empty = c.isEmpty();
//      System.out.println(empty);
        //boolean retainAll(Collection c)交集功能
//      boolean flag7=c.retainAll(c2);
//      System.out.println(flag7);
        //int size():返回集合中元素的個數
        int size = c.size();
        System.out.println(size);   
        Object[] arr = c.toArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

有關上述一些方法的執行結果在這裡就不多做介紹了。
迭代器： 為了可以更好地理解迭代器，在這裡，分別建立String物件，Student物件新增集合遍歷練習。
Iterator iterator()
Object next():返回迭代的下一個元素,並移動指向的位置
boolean hasNext():判斷是否有元素
可以用一張圖來介紹一下迭代器：

NoSuchElementException:沒有這樣的元素異常。
原因是：你已經獲取到元素的末尾了，你還要繼續獲取元素，已經沒有了，所以就報錯了。
解決方案：你不要再拿了。我哪知道什麼就不拿了啊?怎麼辦呢?就應該在拿之前判斷一下是否有元素。
迭代器遍歷集合：
迭代器是依賴於集合而存在的。所以，要想得到迭代器物件，必須先有集合物件。
迭代步驟：
A:通過集合物件獲取到迭代器物件
B:通過迭代器物件的hasNext()方法判斷是否有元素
C:通過迭代器物件的next()方法獲取元素
需求：建立狗物件（帶引數），儲存到集合，用迭代器進行遍歷並列印物件的屬性資料

//狗
package com.stu03;
// 需求：建立狗物件（帶引數），儲存到集合，用迭代器進行遍歷並列印物件的屬性資料
public class Dog {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Dog(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Dog() {
        super();
        // TODO Auto-generated constructor stub
    }
}
//dogtest
package com.stu03;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class DogTest {
    public static void main(String[] args) {
        //建立狗物件
        Dog d1 = new Dog("旺旺",2);
        Dog d2 = new Dog("小花",3);
        //建立集合物件
        Collection c=new ArrayList();
        c.add(d1);
        c.add(d2);
        //建立迭代器物件
        Iterator it = c.iterator();
        while(it.hasNext()){
            //強制型別轉換
            Dog d=(Dog) it.next();
            System.out.println(d.getName()+" "+d.getAge());
        }
    }
}

編譯執行後如下：
旺旺 2
小花 3
List
List集合的元素有序(儲存和取出順序一致),元素可重複
List的特有功能：
A:新增功能
void add(int index,Object obj):在指定的位置新增元素
B:刪除功能
Object remove(int index):通過指定的索引刪除元素，並把刪除的元素返回
C:獲取功能
get(int index) 返回列表中指定位置的元素。
D:替換功能
Object set(int index,Object obj)
用一部分程式碼簡單介紹一下這些功能

package com.stu.list;

import java.util.ArrayList;
import java.util.List;

/*
 *      List的特有功能：
        A:新增功能
        void add(int index,Object obj):在指定的位置新增元素
        B:刪除功能
        Object remove(int index):通過指定的索引刪除元素，並把刪除的元素返回
        C:獲取功能
        get(int index) 返回列表中指定位置的元素。
        D:替換功能
        Object set(int index,Object obj)
 */
public class ListStu01 {
    public static void main(String[] args) {
        List list=new ArrayList();
        list.add("hello");
        list.add("world");
        list.add("java");
        //void add(int index,Object obj):在指定的位置新增元素
        list.add(1, "nihao");
        //Object remove(int index):通過指定的索引刪除元素，並把刪除的元素返回
        Object remove = list.remove(1);
        System.out.println(remove);
        //get(int index) 返回列表中指定位置的元素。
        Object object = list.get(2);
        System.out.println(object);
        //Object set(int index,Object obj)替換功能
        list.set(2, "C++"); 
        System.out.println("---------------");
        for(Object obj:list){
            System.out.println(obj.toString());
        }
    }
}

相關執行結果不多做說明
有關List的其他功能
案例：
A:List儲存字串並遍歷
B:List儲存自定義物件並遍歷
List的倒序與洗牌
List中元素順序可以被洗牌Collections.shuffle(list)
List中元素順序可以被倒序Collections.reverse(list)
Collections.sort(list)對List元素排序

package com.stu.list;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

/*
 * 案例：
        A:List儲存字串並遍歷(迭代器,普通for)
        B:List儲存自定義物件並遍歷(迭代器,普通for)
   List的倒序與洗牌
        List中元素順序可以被洗牌Collections.shuffle(list)
        List中元素順序可以被倒序Collections.reverse(list)
        Collections.sort(list)對List元素排序
 */
public class ListStu02 {
    public static void main(String[] args) {
        List list=new ArrayList();
        list.add("hello");
        list.add("world");
        list.add("java");
        //A:List儲存字串並遍歷(迭代器,普通for)
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        //List中元素順序可以被洗牌Collections.shuffle(list)
        //Collections.shuffle(list);
        //List中元素順序可以被倒序Collections.reverse(list)
//      Collections.reverse(list);      
        //Collections.sort(list)對List元素排序（字母數字分別進行測試）
        Collections.sort(list);     
        Iterator it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

編譯執行結果如下：
hello
world
java
hello
java
world
在這裡做一個需求來理解List
需求：用List集合儲存3個汽車物件，然後遍歷。
在遍歷過程中，介紹三種遍歷方式，具體程式碼實現如下：

//Car
package com.stu05;
public class Car {
    private String brand;
    private int price;
    private String color;
    public Car(String brand, int price, String color) {
        super();
        this.brand = brand;
        this.price = price;
        this.color = color;
    }
    public Car() {
        super();
        // TODO Auto-generated constructor stub
    }
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }   
}
//測試
package com.stu05;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
//用List集合儲存3個汽車物件，然後遍歷。
public class CarTest {
    public static void main(String[] args) {
        Car c1 = new Car("大眾",120000,"黑色");
        Car c2 = new Car("賓士",200000,"白色");
        Car c3 = new Car("勞斯萊斯",3000000,"紅色");
        List list=new ArrayList();
        list.add(c1);
        list.add(c2);
        list.add(c3);
        //迭代器
        Iterator it = list.iterator();
        while(it.hasNext()){
            Car c=(Car) it.next();
            System.out.println(c.getBrand()+" "+c.getColor()+" "+c.getPrice());
        }
        System.out.println("（---------------------------------）");
        //for迴圈
        for(int i=0;i<list.size();i++){
            Car c=(Car) list.get(i);
            System.out.println(c.getBrand()+" "+c.getColor()+" "+c.getPrice());
        }
        System.out.println("（---------------------------------）");
        //強制for迴圈
        for(Object obj:list){
            Car c=(Car)obj;
            System.out.println(c.getBrand()+" "+c.getColor()+" "+c.getPrice());
        }
    }
}

編譯執行後結果如下：
大眾 黑色 120000
賓士 白色 200000
勞斯萊斯 紅色 3000000
（—————————————————）
大眾 黑色 120000
賓士 白色 200000
勞斯萊斯 紅色 3000000
（————————————————–）
大眾 黑色 120000
賓士 白色 200000
勞斯萊斯 紅色 3000000
ArrayList
其實就是List介面的一個實現類，簡單的用一個案例介紹一下
案例：儲存字串並遍歷

package com.stu.arraylist;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
//儲存字串並遍歷
public class ArrayListStu01 {
    public static void main(String[] args) {
        //建立集合物件
        List list=new ArrayList();
        list.add("hello");
        list.add("world");
        list.add("java");
        //遍歷字串
        /*1、普通for迴圈
         *2、加強for迴圈
         *3、迭代器
         */
        //1、普通for迴圈
        //Object[] arr = list.toArray();
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        System.out.println("（--------------------）");
        //2、加強for迴圈
        for(Object obj:list){
            System.out.println(obj);
        }   
        System.out.println("（---------------------------）");
        //3、迭代器
        Iterator it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

編譯執行結果如下：
hello
world
java
（——————–）
hello
world
java
（—————————）
hello
world
java
LinkedList
同ArrayList相同，也是List介面的一個實現類
LinkedList特有功能:
public void addFirst(E e)
public void addLast(E e)
public E getFirst()
public E getLast()
public E removeFirst()
public E removeLast()
ArrayList與LinkedList的相同點與不同點
相同點：有順序的，元素可以重複
(1)ArrayList特點:
底層資料結構是陣列,查詢快,增刪慢
執行緒不安全,效率高
(2)LinkedList特點:
底層資料結構是連結串列,查詢慢,增刪快
執行緒不安全,效率高
在最後，還需要掌握一點，在前面程式碼編譯過程中，會遇到或多或少的警告，那麼要取消這些警告，就要引入泛型的概念。
泛型
是一種把明確資料型別的工作推遲到建立物件或者呼叫方法的時候才去明確型別的特殊型別
格式：
<資料型別>
預設情況下，是Object型別。
這裡資料型別只能是引用型別。如果你看到寫基本型別也行，其實這裡使用了自動裝箱。
好處：
A:把執行時期問題提前到了編譯時期
B:避免了強制型別轉換
C:優化程式設計，解決了黃色警告線問題
在哪裡用?
一般來說就是在集合中用的多。
看API,如果類或者介面或者方法出現了<>說明這裡就有泛型。
用一個簡單的例子來理解：

package com.stu.generic;
public class GenericTest01 {
    public static void main(String[] args) {
        GenericStu01<String> gs = new GenericStu01<String>();
        gs.show("hello");   
    }
}

編譯執行結果如下：
hello