圖的深度優先遍歷和廣度優先遍歷

阿新 • • 發佈：2020-08-01

集合與陣列儲存資料概述：
集合、陣列都是對多個數據進行記憶體儲存操作的結構，簡稱Java容器。

陣列儲存的特點：

一旦初始化以後，其長度就確定了。
陣列一旦定義好，元素型別也就確定了，我們也就只能操作指定型別的資料了。
比如：String[] arr;int[] arr1;Object[] arr2;

陣列儲存的弊端：

 一旦初始化以後，其長度就不可修改。

 陣列中提供的方法非常限，對於新增、刪除、插入資料等操作，非常不便，同時效率不高。

 獲取陣列中實際元素的個數的需求，陣列沒有現成的屬性或方法可用

 陣列儲存資料的特點：有序、可重複。對於無序、不可重複的需求，不能滿足。

Java集合分為兩個體系：

Collection介面，單列集合，用來儲存一個一個的物件

List：有序，可重複 --->相當於”動態“陣列
- ArrayList、LinkedList、Vector
Set：無序，不可重複
- HashSet、LinkedHashSet、TreeSet

Map介面，雙列集合，key-value
- HashMap、LinkedHashMap、TreeMap、HashTable、Properties

一、Collection

Collection介面

1、Collection介面常用方法：

add(Object obj),

addAll(Collection coll),
size(),
isEmpty(),
clear();
contains(Object obj), 預設呼叫obj中的equals()方法進行比較
containsAll(Collection coll),形參中的所有元素都存在於當前集合中
remove(Object obj), 移除物件可能需要重寫equals()方法，移除時要進行比較再刪除。
removeAll(Collection coll),
retainsAll(Collection coll), 求兩個集合的交集，直接當前物件上修改（保留一樣的），返回void
equals(Object obj); 對於無序集合（ArrayList）

（兩個集合中內容一個一個的比較，順序不同也會影響，不同false；）視情況而定！
hasCode(),
toArray(), 集合--->陣列陣列-->集合 Arrays.asList(new String[]{"AA","BB"});
iterator();遍歷

結論：向Collection中新增物件，一般需要重寫equals()方法！

2、迭代器Iterator介面

遍歷集合

Iterator iterator = coll.iterator();
//hasNext():判斷是否還下一個元素
while(iterator.hasNext()){
    //next():①指標下移 ②將下移以後集合位置上的元素返回
    System.out.println(iterator.next());
}

remove()的使用

內部定義了remove(),可以在遍歷的時候，刪除集合中的元素。此方法不同於集合直接呼叫remove()

3、使用foreach遍歷集合、陣列

JDK5.0新增

遍歷集合舉例（內部仍然呼叫了迭代器）

public void test1(){
    Collection coll = new ArrayList();
    coll.add(123);
    coll.add(456);
    coll.add(new Person("Jerry",20));
    coll.add(new String("Tom"));
    coll.add(false);

    //for(集合元素的型別 區域性變數 : 集合物件)
    for(Object obj : coll){
        System.out.println(obj);
    }
}

2、List介面

ArrayList，LinkedList、Vector三者異同？（面試題）

相同：都實現了List介面，儲存的是有序，可重複的資料。

不同：

ArrayList：主要的List實現類，執行緒不安全，效率高，底層使用Object[] 儲存
LinkedList：底層使用雙向連結串列儲存，對於頻繁的插入、刪除操作，使用此類效率較高
Vector：一個古老的實現類，執行緒安全，效率低。底層使用Object[] 儲存

ArrayList原始碼分析

在JDK7之前

ArrayList list = new ArrayList(); //底層建立了長度為10的Object[]

list.add() ; //每次新增時，判斷容量是否足夠，不夠則擴容！為原來的1.5倍

在JDK8之後

ArrayList list = new ArrayList(); //底層初始化Object[] elementData= {} 容量為0

list.add() ; //第一次新增時，初始化容量為10的陣列。後面每次新增時，與JDK7相同

結論兩者相比，JDK7相當於單例模式的惡漢式，先造後用，JDK類似懶漢式，隨用隨造，延遲了陣列的建立，節省記憶體！

建議開發中使用帶參的構造器：ArrayList list = new ArrayList(int capacity)，減少陣列的擴容次數。

LinkedList的原始碼分析：

LinkedList list = new LinkedList(); 內部聲明瞭Node型別的first和last屬性，預設值為null
      list.add(123);//將123封裝到Node中，建立了Node物件。

      其中，Node定義為：體現了LinkedList的雙向連結串列的說法
      private static class Node<E> {
            E item;
            Node<E> next;
            Node<E> prev;

            Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
            }
        }

Vector的原始碼分析（瞭解）：

jdk7和jdk8中通過Vector()構造器建立物件時，底層都建立了長度為10的陣列。
在擴容方面，預設擴容為原來的陣列長度的2倍。

List介面中常用的方法：

增：add(Object obj)
刪：remove(int index) / remove(Object obj)
改：set(int index, Object ele)
查：get(int index)
插：add(int index, Object ele)

3、Set介面

HashSet：作為Set介面的主要實現類，執行緒不安全，可以儲存null

LinkedHashSet：作為HashSet子類，遍歷時，根據新增順序輸出。

TreeSet：可以更加新增物件的指定屬性進行排序。

理解：無序不可重複？

以HashSet說明

無序性：不等於隨機性，並非按照陣列的索引挨個新增，而是按照hash值進行新增。

不可重複性：相同的元素只能新增一個。

元素新增過程：(以HashSet為例)

我們向HashSet中新增元素a,首先呼叫元素a所在類的hashCode()方法，計算元素a的雜湊值，
此雜湊值接著通過某種演算法計算出在HashSet底層陣列中的存放位置（即為：索引位置，判斷
陣列此位置上是否已經元素：
如果此位置上沒其他元素，則元素a新增成功。 --->情況1
如果此位置上其他元素b(或以連結串列形式存在的多個元素，則比較元素a與元素b的hash值：
如果hash值不相同，則元素a新增成功。--->情況2
如果hash值相同，進而需要呼叫元素a所在類的equals()方法：
equals()返回true,元素a新增失敗
equals()返回false,則元素a新增成功。--->情況2

對於新增成功的情況2和情況3而言：元素a 與已經存在指定索引位置上資料以連結串列的方式儲存。
jdk 7 :元素a放到陣列中，指向原來的元素。
jdk 8 :原來的元素在陣列中，指向元素a
總結：七上八下

HashSet底層：陣列+連結串列的結構。（前提：jdk7)

Set介面儲存物件所在類的要求：

HashSet/LinkedHashSet:

要求：向Set(主要指：HashSet、LinkedHashSet)中新增的資料，其所在的類一定要重寫hashCode()和equals()
要求：重寫的hashCode()和equals()儘可能保持一致性：相等的物件必須具有相等的雜湊碼（HashCode）

重寫兩個方法的小技巧：物件中用作 equals() 方法比較的 Field，都應該用來計算 hashCode 值。

直接使用編譯器自動生成的程式碼！！

LinkedHashSet

作為HashSet的子類；遍歷其內部資料時，可以按照新增的順序遍歷在新增資料的同時，每個資料還維護了兩個引用（pre next），記錄此資料前一個數據和後一個數據。對於頻繁的遍歷操作，LinkedHashSet效率高於HashSet.

TreeSet

向TreeSet中新增，必須是同類物件
兩種排序方式：自然排序（實現介面），定製排序

TreeSet:
1.自然排序中，比較兩個物件是否相同的標準為：compareTo()返回0.不再是equals().
2.定製排序中，比較兩個物件是否相同的標準為：compare()返回0.不再是equals().

方式一：自然排序

    public void test1(){
        TreeSet set = new TreeSet();

        //失敗：不能新增不同類的物件
//        set.add(123);
//        set.add(456);
//        set.add("AA");
//        set.add(new User("Tom",12));

            //舉例一：
//        set.add(34);
//        set.add(-34);
//        set.add(43);
//        set.add(11);
//        set.add(8);

        //舉例二：
        set.add(new User("Tom",12));
        set.add(new User("Jerry",32));
        set.add(new User("Jim",2));
        set.add(new User("Mike",65));
        set.add(new User("Jack",33));
        set.add(new User("Jack",56));

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }

方式二：定製排序

public void test2(){
        Comparator com = new Comparator() {
            //照年齡從小到大排列
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof User && o2 instanceof User){
                    User u1 = (User)o1;
                    User u2 = (User)o2;
                    return Integer.compare(u1.getAge(),u2.getAge());
                }else{
                    throw new RuntimeException("輸入的資料型別不匹配");
                }
            }
        };

        TreeSet set = new TreeSet(com);
        set.add(new User("Tom",12));
        set.add(new User("Jerry",32));
        set.add(new User("Jim",2));
        set.add(new User("Mike",65));
        set.add(new User("Mary",33));
        set.add(new User("Jack",33));
        set.add(new User("Jack",56));


        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

關於Set的面試題

答案：

最後一題，AA可以加進去。

解題思路：參考set的新增執行的流程

二、Map

HashMap：主要的Map實現類，執行緒不安全，效率高。可儲存null

----linkedHashMap：遍歷map元素時，可以按照新增的順序輸出。在HashMap的基礎上，添加了指標。對於頻繁的遍歷，可以使用此類。

TreeMap：按照新增的key-value進行排序，此時考慮key的自然排序和定製排序。底層使用紅黑樹。

HashTable：古老的實現類，執行緒安全，效率低。不可以儲存null

------Properties：用來處理配置檔案。

HashMap的底層：陣列+連結串列（jdk7及之前)
陣列+連結串列+紅黑樹（jdk 8)

[面試題]

1. HashMap的底層實現原理？
1. HashMap 和 Hashtable的異同？

儲存結構的理解：

Map中的key:無序的、不可重複的，使用Set儲存所的key ---> key所在的類要重寫equals()和hashCode() （以HashMap為例)
Map中的value:無序的、可重複的，使用Collection儲存所的value --->value所在的類要重寫equals()
一個鍵值對：key-value構成了一個Entry物件。
Map中的entry:無序的、不可重複的，使用Set儲存所的entry

HashMap的底層實現原理

HashMap在jdk7中

HashMap map = new HashMap():

在例項化以後，底層建立了長度是16的一維陣列Entry[] table。
可能已經執行過多次put...
map.put(key1,value1):
首先，呼叫key1所在類的hashCode()計算key1雜湊值，此雜湊值經過某種演算法計算以後，得到在Entry陣列中的存放位置。
如果此位置上的資料為空，此時的key1-value1新增成功。 ----情況1
如果此位置上的資料不為空，(意味著此位置上存在一個或多個數據(以連結串列形式存在)),比較key1和已經存在的一個或多個數據的雜湊值：
如果key1的雜湊值與已經存在的資料的雜湊值都不相同，此時key1-value1新增成功。----情況2
如果key1的雜湊值和已經存在的某一個數據(key2-value2)的雜湊值相同，繼續比較：呼叫key1所在類的equals(key2)方法，比較：
如果equals()返回false:此時key1-value1新增成功。----情況3
如果equals()返回true:使用value1替換value2。

補充：關於情況2和情況3：此時key1-value1和原來的資料以連結串列的方式儲存。

在不斷的新增過程中，會涉及到擴容問題，當超出臨界值(且要存放的位置非空)時，擴容。預設的擴容方式：擴容為原來容量的2倍，並將原的資料複製過來。

HashMap在jdk8中

new HashMap():底層沒有建立一個長度為16的陣列
jdk 8底層的陣列是：Node[],而非Entry[]
首次呼叫put()方法時，底層建立長度為16的陣列
jdk7底層結構只：陣列+連結串列。jdk8中底層結構：陣列+連結串列+紅黑樹。
4.1 形成連結串列時，七上八下（jdk7:新的元素指向舊的元素。jdk8：舊的元素指向新的元素）
4.2 當陣列的某一個索引位置上的元素以連結串列形式存在的資料個數 > 8 且當前陣列的長度 > 64時，此時此索引位置上的所資料改為使用紅黑樹儲存。 否則繼續擴容。

HashMap底層典型屬性的屬性的說明：
DEFAULT_INITIAL_CAPACITY : HashMap的預設容量，16
DEFAULT_LOAD_FACTOR：HashMap的預設載入因子：0.75
threshold：擴容的臨界值，=容量*填充因子：16 * 0.75 => 12
TREEIFY_THRESHOLD：Bucket中連結串列長度大於該預設值，轉化為紅黑樹:8
MIN_TREEIFY_CAPACITY：桶中的Node被樹化時最小的hash表容量:64

LinkedHashMap（瞭解）

LinkedHashMap底層使用的結構與HashMap相同，因為LinkedHashMap繼承於HashMap.
區別就在於：LinkedHashMap內部提供了Entry，替換HashMap中的Node.

Map中常用的方法

新增：put(Object key,Object value)
刪除：remove(Object key)
修改：put(Object key,Object value)
查詢：get(Object key)
長度：size()
遍歷：keySet() / values() / entrySet()

TreeMap的使用

向TreeMap中新增key-value，要求key必須是由同一個類建立的物件
因為要照key進行排序：自然排序（Comparable）、定製排序(Comparator)

使用Properties讀取配置檔案

public static void main(String[] args)  {
    FileInputStream fis = null;
    try {
        Properties pros = new Properties();

        fis = new FileInputStream("jdbc.properties");
        pros.load(fis);//載入流對應的檔案

        String name = pros.getProperty("name");
        String password = pros.getProperty("password");

        System.out.println("name = " + name + ", password = " + password);
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(fis != null){
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

三、Collections

概念：操作Collection和Map的工具類

reverse(List)：反轉 List 中元素的順序
shuffle(List)：對 List 集合元素進行隨機排序
sort(List)：根據元素的自然順序對指定 List 集合元素升序排序
sort(List，Comparator)：根據指定的 Comparator 產生的順序對 List 集合元素進行排序
swap(List，int， int)：將指定 list 集合中的 i 處元素和 j 處元素進行交換
Object max(Collection)：根據元素的自然順序，返回給定集合中的最大元素
Object max(Collection，Comparator)：根據 Comparator 指定的順序，返回給定集合中的最大元素
Object min(Collection)
Object min(Collection，Comparator)
int frequency(Collection，Object)：返回指定集合中指定元素的出現次數
void copy(List dest,List src)：將src中的內容複製到dest中
boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替換 List 物件的所舊值

說明：ArrayList和HashMap都是執行緒不安全的，如果程式要求執行緒安全，我們可以將ArrayList、HashMap轉換為執行緒安全的。