學習筆記day03-day04

常見的數據結構：棧 ,隊列 ,數組 ,鏈表和紅黑樹

棧: stack,又稱堆棧,是一種  運算受限 的線性表
   特色: 1.先進後出
            2.棧的入口,出口都是棧的頂端位置
   隊列: queue 也是一種  運算受限  的線性表
   特色: 1.先進先出
            2.隊列的入口,出口各佔一側
   數組: Array,有序的元素序列
   特色: 1.查找元素快(經過索引)
            2.增刪元素慢(須要建立新數組)
   鏈表: linked list,由節點node(鏈表中每一個元素稱爲節點)組成,節點能夠在運行時i動態生成.
           每一個節點包括兩個部分: 一個是存儲數據元素的數據域
                                              另外一個是存儲下一個節點地址的指針域.包括單向和雙向鏈表.
   特色: 1. 多個節點之間,經過地址進行連接
            2. 查找元素慢
            3. 增刪元素快
   紅黑樹: binary tree,是每一個節點不超過2的有序樹(tree)
   紅黑樹的約束:
           1. 節點能夠是紅色的或者黑色的
           2. 根節點是黑色的
           3. 葉子節點(特指空節點)是黑色的
           4. 每一個紅色節點的子節點都是黑色的
           5. 任何一個節點到其每個葉子節點的全部路徑上黑色節點數相同
   特色:  速度特別快,趨近平衡樹,查找葉子元素最少和最屢次數很少於二倍

List接口:

特色:
      1. 它是一個存取有序的集合;
      2. 帶有索引
      3. 集合中能夠有重複的元素,經過元素的equals方法.來比較是否爲重複的元素
  經常使用方法:

[Java] 純文本查看 複製代碼
?
1
2
3
4
pubilc void add (int index, E element) : 將指定的元素,添加到該集合中的指定位置上.
public E get (int index) : 返回集合中指定位置的元素.
public E remove (int index) : 移除列表中指定位置的元素,返回的是被移除的元素.
Public E set (int index, E element) : 用指定元素替換集合中指定位置的元素,返回值的更新前的元素.

ArrayList集合的特色:

ArrayList底層的數據結構:數組
            特色:
                      查詢快
                      增刪慢
                      線程不安全,效率高
           使用場景:
                      存儲的數據查詢多,增刪少的場景

LinkedList集合的特色：

LinkedList底層的數據結構:鏈表
             特色:
                      查詢慢
                      增刪快
                      線程不安全, 效率高
            適用場景:
                      存儲的數據查詢少, 增刪多的場景

特有成員方法(主要操做開頭和末尾元素):
[Java] 純文本查看 複製代碼
?
1
2
3
4
5
6
7
void addFirst(E e): 將指定元素插入此列表的開頭/size/alignfont=微軟雅黑void addLast(E e): 將指定元素添加到此列表的結尾
E getFirst(): 返回此列表的第一個元素
E getLast(): 返回此列表的最後一個元素
E removeFirst(): 移除並返回此列表的第一個元素
E removeLast(): 移除並返回此列表的最後一個元素
E pop(): (其實就是removeFirst())今後列表所表示的棧中彈出一個元素
void push(E e): (其實就是addFirst())將元素添加到此列表所表示的棧中

Vector集合

Vector底層的數據結構:數組
             Vector的特色:
                      查詢慢
                      增刪快
                      線程安全, 效率低
             Vector目前幾乎沒人使用

Set集合體系

HashSet集合
             Set集合體系特色:
                      1. 元素不可重複
                      2. 沒有索引
             HashSet特色:
                      1. 元素不可重複
                      2. 沒有索引
                      3. 元素存取無序 (存入和取出順序有可能不一致)
                      4. 底層採用 哈希表 結構. (查詢快)
             哈希表 = 數組 + 鏈表或紅黑樹
             經常使用方法:

[Java] 純文本查看 複製代碼
?
1
2
boolean add(E e): 添加元素, 根據元素的
hashCode()和equals()方法判斷是否重複. 重複則不添加並返回false, 不重複則添加並返回true
哈希值:

一個十進制數值, 通常是經過將該對象的內部地址轉換成一個整數來實現的
         public native int hashCode();
         能夠調用系統本地代碼(C++)計算出一個對象地址的哈希值hashCode()方法的做用
         方法內部的算法用於將對象計算爲一個哈希值, 便於根據哈希值比較對象是否"相等"
         哈希值主要是爲了提升對象存儲在 哈希表 中的效率
         注意:
                      1. 若是咱們不滿意Object中的哈希值計算方法, 能夠重寫hashCode()方法.
                          但在Java代碼中不能直接重寫帶有 native 的方法, 重寫時應該將native 去掉
                          @Override
                          public int hashCode() {}
                      2. hashCode() 方法有可能將"不一樣的對象"計算出"相同的哈希值", 這稱爲"哈希衝突",
                          在出現衝突後, 通常再經過 equals() 方法來繼續判斷對象是否"相等

         HashSet集合存儲數據的結構: 哈希表
         哈希表 = 數組+鏈表/紅黑樹

可變參數

JDK 5 出現. 指同一個類型參數個數可變的參數
                      可變參數的本質就是一個"數組"
         格式: 用在方法的參數中
                      修飾符 返回值類型 方法名(參數類型... 變量名) {
                                   // 能夠直接將 變量名 看成 數組名 使用
                      }
         注意事項:
                      1. 可變參數能夠傳遞的參數個數, 能夠是 0個, 1個, 多個
                      2. 一個方法的參數列表中, 只能有一個可變參數
                      3. 若是方法的參數有多個, 可變參數必須寫在參數列表的最後

Collections集合工具類

Collections集合工具類: addAll(), shuffle()
         java.util.Collections類: 操做集合的工具類
         靜態方法：

[Java] 純文本查看 複製代碼
?
1
2
3
4
static <T> boolean addAll(Collection<T> c, T... elements) :往集合中添加一些元素
static void shuffle(List<?> list) :打亂集合順序
static <T> void sort(List<T> list) :將集合中元素按照默認規則排序
static <T> void sort(List<T> list，Comparator<? super T> ) :將集合中元素按照指定規則排序

Collections集合工具類: sort(List list)
                      sort(List<T> list): 默認按照"升序"將元素排序. 數字, 字母, 均可以按照升序排序
                      自定義JavaBean對象默認不能排序, 由於不知道如何比較哪一個對象大, 哪一個對象小
                      自定義JavaBean對象要想排序, 須要實現 Comparable<E> 接口, 重寫 int compareTo(E e) 方法
                      大小的比較經過 compareTo() 方法的返回值肯定:

                      負數: 當前元素比被比較元素小
                      0: 當前元素與被比較元素相等
                      正數: 當前元素比被比較元素大
         規則:
                      this-參數: 升序
                      參數-this: 降序

Comparable接口和Comparator接口區別

Comparable: 讓JavaBean自身具備可比較性 (本身和其餘人比)
         Comparator: 定義一個比較器類, 用比較器對象比 (讓第三我的來幫兩我的比較)
         Comparator使用方式:
         定義類做爲比較器, 實現Comparator接口, 重寫int compare(E o1, E o2)方法, 泛型爲要比較的元素的類型
         在Collections.sort(List<T> list，Comparator<? super T>)方法中傳入自定義比較器對象
         規則:
                      o1-o2: 升序
                      o2-o1: 降序

java.util.Map接口: 雙列集合的頂層

成員方法：

[Java] 純文本查看 複製代碼
?
1
2
3
4
5
6
V put(K key, V value): 添加/修改鍵值對. 若是鍵存在, 則用新值替換已有值
V remove(Object key): 根據鍵刪除鍵值對, 返回被刪除元素的值
V get(Object key): 根據鍵獲取值. 若是鍵不存在, 則返回null
boolean containsKey(Object key): 判斷是否包含指定的鍵
Set<K> keySet(): 獲取Map集合中全部的鍵, 存儲到Set集合中
Set<Map.Entry<K,V>> entrySet(): 獲取到Map集合中全部的鍵值對對象的集合(Set集合)

JDK 9對於集合初始化的優化
            java.util.List
                    靜態方法
                    static List<E> of(E... e): 返回包含指定元素的 不可變List 集合
                    
            java.util.Set
                    靜態方法
                    static Set<E> of(E... e): 返回包含指定元素的 不可變Set 集合
                    
            java.util.Map
                    靜態方法
                    static Map<K, V> of(K k1, V v1): 返回包含指定鍵值對的 不可變Map 集合


    Map集合概述：
            java.util.Map<K, V>接口
            Map集合特色:
                    1. 是雙列集合, 一個元素包含兩個值 (鍵key, 值value)
                    2. key和value的類型能夠相同, 也能夠不一樣
                    3. key不容許重複, value能夠重複
                    4. key和value是一一對應的, 一個鍵只能對應一個值
            Map集合適合存儲一對一關係的數據
    Map經常使用子類：
            java.util.Map<K, V>接口: 雙列集合的根接口, 規定了共性的方法
                    |_ HashMap<K, V>類: 底層哈希表. key存取無序不可重複
                            |_ LinkedHashMap類: 底層哈希表+鏈表. key存取有序不可重複
                    映射: 鍵和值的對應關係 mapping
                    HashSet底層使用的就是HashMap
                    LinkedHashSet底層使用的就是LinkedHashMap
    Map中經常使用方法：
            Map<String, Phone> map = new HashMap<>();
            map.put("張三", p1);
            map.put("張三", p2);
            java.util.Map接口: 雙列集合的頂層
                    成員方法

[Java] 純文本查看 複製代碼
?
1
2
3
4
5
6
V put(K key, V value): 添加/修改鍵值對. 若是鍵存在, 則用新值替換已有值
V remove(Object key): 根據鍵刪除鍵值對, 返回被刪除元素的值
V get(Object key): 根據鍵獲取值. 若是鍵不存在, 則返回null
boolean containsKey(Object key): 判斷是否包含指定的鍵
Set<K> keySet(): 獲取Map集合中全部的鍵, 存儲到Set集合中
Set<Map.Entry<K,V>> entrySet(): 獲取到Map集合中全部的Entry對象的集合(Set集合)

Map遍歷方式一：keySet()方法實現經過鍵找值
            Set<K> keySet(): 獲取Map集合中全部的鍵, 存儲到Set集合中
            keySet()遍歷步驟:
                    1. Map對象調用 keySet() 方法, 獲取包含全部key的Set集合
                    2. 遍歷Set集合, 獲取每一個key
                    3. 經過Map對象調用 get(Object key) 方法根據key獲取到value

[Java] 純文本查看 複製代碼
?
1
2
3
4
5
6
7
8
9
Map<String, String> map = new HashMap<>();
// keySet()遍歷
Set<String> keys = map.keySet();
for (String key : keys) {

// 經過每一個鍵獲取值
   String value = map.get(key);
   // 打印當前鍵值對
   System.out.println(key + "=" + value);
   }

    Entry鍵值對對象介紹：
             java.util.Map.Entry接口:
                    經常使用成員方法：
                    K getKey(): 獲取Entry對象中的鍵
                    V getValue(): 獲取Entry對象中的值
            Entry對象就是一個節點, 節點中存儲了key和value
            拿到一個Entry對象就能夠從中獲取key和value
    HashMap中Entry實現類

[Java] 純文本查看 複製代碼
?
01
02
03
04
05
06
07
08
09
10
11
12
static class Node<K,V> implements Map.Entry<K,V> {

final int hash;
      final K key;
      V value;
      Node<K,V> next;
      public final K getKey() {
            return key;
      }
      public final V getValue() {
            return value;
      }

}

java.util.Map接口
            Set<Map.Entry<K,V>> entrySet(): 獲取到Map集合中全部的鍵值對對象的集合(Set集合)
                    
Map遍歷方式二：經過entrySet()獲取對象形式遍歷：
     java.util.Map接口
           Set<Map.Entry<K,V>> entrySet(): 獲取到Map集合中全部的鍵值對對象的集合(Set集合)
     entrySet()方法遍歷Map步驟:
                    1. Map對象調用 entrySet() 獲取包含全部Entry對象的Set集合
                    2. 遍歷Set集合, 獲取每一個Entry對象
                    3. 調用Entry對象的 getKey() 和 getValue() 方法獲取鍵和值

[Java] 純文本查看 複製代碼
?
1
2
3
4
5
6
7
8
9
Map<String, String> map = new HashMap<>();

// keySet()遍歷
    Set<Map.Entry<String, String>> entries = map.entrySet();
    for (Map.Entry<String, String> entry : entries) {
    // 經過Entry對象獲取每一個鍵值對
    String value = entry.getKey();
    String value = entry.getValue();
    // 打印當前鍵值對
    System.out.println(key + "=" + value);

    JDK9對集合添加的優化：
            使用集合添加大量元素時, 反覆add(...)比較麻煩.
            JDK 9 爲集合提供了一些靜態方法, 能夠方便的對集合進行初始化
                    java.util.List
                            靜態方法：
                          static List<E> of(E... e): 返回包含指定元素的 不可變List 集合
                    java.util.Set
                            靜態方法
                           static Set<E> of(E... e): 返回包含指定元素的 不可變Set 集合
                    java.util.Map
                            靜態方法
                          static Map<K, V> of(K k1, V v1, ...): 返回包含指定鍵值對的 不可變Map 集合
           注意:
                 1. of() 方法只適用於List接口, Set接口, Map接口, 不適用於接接口的實現類
                 2. of() 方法的返回值是一個不能改變的集合, 集合不能再使用 add(), put() 方法添加元素, 會拋出異常
                 3. Set接口和Map接口在調用 of() 方法的時候, 不能有重複的元素, 不然會拋出異常
            將 不可變集合 的元素轉移到常見集合實現類中:
                   List

[AppleScript] 純文本查看 複製代碼
?
1
2
3
4
ArrayList<Integer> list = new ArrayList<>(List.of(1,2,3));[/align] Set

HashSet<Integer> set = new HashSet<>(Set.of(1,2,3));
                Map
               HashMap<Integer, String> map = new HashMap<>(Map.of(1,"a",2,"b"));
    今日目標：
            可以說出Map集合特色：
                    Map接口雙列集合的頂層
                    特色:
                    Map存儲元素是鍵值對方式(key-value)
                    Map中key不能重複(惟一), 鍵值對是一一對應的, 一個鍵對應一個值
            使用Map集合添加方法保存數據：
                    map.put(鍵, 值);
                    添加鍵值對: map中沒有這個鍵時, 返回null
                    修改鍵值對: map中已經有該鍵, 返回的是被替換的值
            使用」鍵找值」的方式遍歷Map集合：

[Java] 純文本查看 複製代碼
?
1
2
3
4
5
6
keySet()
Set keySet = map.keySet();
for (鍵的類型 key : keySet) {

// 經過鍵獲取值
      值的類型 value = map.get(key);
      }

            使用」鍵值對」的方式遍歷Map集合：

[Java] 純文本查看 複製代碼?123456Entry對象/alignSet<Entry> entrySet = map.entrySet();[/align][align=left]for (Entry entry : entrySet) {[/align][align=left]// 經過entry對象獲取鍵和值[/align][align=left]鍵的類型 key = entry.getKey();[/align][align=left]值的類型 value = entry.getValue();[/align][align=left]}