Java基礎（三）—— 集合

開始記錄集合啦！

首先看看整體的

集合框架圖

從上面的集合框架圖可以看到，Java 集合框架主要包括兩種類型的容器，一種是集合（Collection），存儲一個元素集合，另一種是圖（Map），存儲鍵/值對映射。Collection 接口又有 3 種子類型，List、Set 和 Queue，再下面是一些抽象類，最後是具體實現類，常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。
集合框架體系如圖：

首先開始講解詳細的用法：

List集合

方法細節可以參考官網上的描述：List
首先開始講解ArrayList，底層採用的數組。該類也是實現了List的接口，實現了可變大小的數組，隨機訪問和遍歷元素時，提供更好的性能。該類也是非同步的,在多線程的情況下不要使用。ArrayList 增長當前長度的50%，插入刪除效率低。

方法細節如下代碼：

package list;

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

public class ArraylistDemo {
    public static void main(String[] args){
        ArrayList<String> list = new ArrayList<>();
        list.add("Hello");
        list.add("World");
        list.add("HAHAHAHA");

        //從集合中獲取元素：get。索引值從0開始
        String getString = list.get(2);

        //從集合中刪除元素：remove。索引值從0開始
        String removeString = list.remove(2);

        //獲取集合長度
        int size = list.size();

        //ArrayList遍歷
        //第一種遍歷方法使用 For-Each 遍歷 List
        for (String str : list){        //也可以改寫 for(int i=0;i<list.size();i++) 這種形式
            System.out.println(str);    //System.out.println(list.get(i));
        }
        //第二種遍歷，把鏈表變爲數組相關的內容進行遍歷
        String[] strArray = new String[list.size()];
        list.toArray(strArray);
        for (int i=0; i < strArray.length; i++){ //這裏也可以改寫爲  for(String str:strArray) 這種形式
            System.out.println(strArray[i]);
        }
        //第三種遍歷 使用迭代器進行相關遍歷
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

再來介紹LinkedList，底層採用鏈表實現，可參考官方文檔LinkedList
該類實現了List接口，允許有null（空）元素。主要用於創建鏈表數據結構，該類沒有同步方法，如果多個線程同時訪問一個List，則必須自己實現訪問同步，解決方法就是在創建List時候構造一個同步的List。例如：

List list=Collections.synchronizedList(newLinkedList(...));

切記一定不要使用普通for循環去遍歷LinkedList。因爲LinkedList在get任何一個位置的數據的時候，都會把前面的數據走一遍。使用迭代器或者foreach循環（foreach循環的原理就是迭代器）去遍歷LinkedList即可，這種方式是直接按照地址去找數據的，將會大大提升遍歷LinkedList的效率。（LinkedList 查找效率低。）

import java.util.Iterator;
import java.util.LinkedList;

public class LinkedListDemo {
    public static void main(String[] args){
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("java");

        //在該列表開頭插入指定的元素
        linkedList.addFirst("first");
        //將指定的元素追加到死列表的末尾
        linkedList.addLast("last");

        //返回此列表中的第一個元素
        String strFirst = linkedList.getFirst();
        //返回此列表中的最後一個元素
        String strLast = linkedList.getLast();

        //從列表中刪除並返回第一個元素
        String removeFirst = linkedList.removeFirst();
        //從列表中刪除並返回最後一個元素
        String removeLast = linkedList.removeLast();

        //LinkedList遍歷方式(只記錄常用的)
        //第一種遍歷方法使用 For-Each 遍歷 List
        for (String str : linkedList){
            System.out.println(str);
        }
        //第二種遍歷 使用迭代器進行相關遍歷
        Iterator<String> iterator = linkedList.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

Set集合

Set集合不包含重複元素的集合；沒有帶索引的方法，所以不能使用普通的for循環遍歷
下面講解的是Set集合的實現類：HashSet.
HashSet
該類實現了Set接口，不允許出現重複元素，不保證集合中元素的順序，允許包含值爲null的元素，但最多隻能一個。

具體實現方法可參考官方文檔：HashSet

import java.util.Iterator;
import java.util.Set;

public class HashSetDemo {
    public static void main(String[] args){
        Set<String> set = new HashSet<>();
        set.add("hello");
        set.add("world");
        set.add("java");

        //Set遍歷方式
        //第一種遍歷方法使用 For-Each 遍歷 Set
        for (String str : set){
            System.out.println(str);
        }
        //第二種遍歷 使用迭代器進行相關遍歷
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

那麼HashSet爲什麼集合是如何保證元素唯一的呢？以下是根據部分源碼進行簡單的分析：

//HashSet如何保證元素唯一
//點開add()進行跟進
  public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

  public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

  static final int hash(Object key) {
          int h;
          return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
      }

  //Hash值和元素的HashCode()方法相關
  final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                     boolean evict) {
          Node<K,V>[] tab; Node<K,V> p; int n, i;
          //如果哈希表未初始化，就對其進行初始化
          if ((tab = table) == null || (n = tab.length) == 0)
              n = (tab = resize()).length;

          //根據對象的哈希值進行計算對象的存儲位置，如果該位置沒有元素，就存儲元素
          if ((p = tab[i = (n - 1) & hash]) == null)
              tab[i] = newNode(hash, key, value, null);
          else {
              Node<K,V> e; K k;
              /*
              存入的元素和以前的元素進行比較哈希值
                 如果哈希值不相同，會繼續向下執行，把元素添加到集合
                 如果哈希值相同,會繼續調用對象的equals()方法比較
                    如果返回false，會繼續向下執行，把元素添加到集合
                    如果返回true，說明元素重複，不存儲
              */
              if (p.hash == hash &&
                  ((k = p.key) == key || (key != null && key.equals(k))))
                  e = p;
              else if (p instanceof TreeNode)
                  e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
              else {
                  for (int binCount = 0; ; ++binCount) {
                      if ((e = p.next) == null) {
                          p.next = newNode(hash, key, value, null);
                          if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                              treeifyBin(tab, hash);
                          break;
                      }
                      if (e.hash == hash &&
                          ((k = e.key) == key || (key != null && key.equals(k))))
                          break;
                      p = e;
                  }
              }
              if (e != null) { // existing mapping for key
                  V oldValue = e.value;
                  if (!onlyIfAbsent || oldValue == null)
                      e.value = value;
                  afterNodeAccess(e);
                  return oldValue;
              }
          }
          ++modCount;
          if (++size > threshold)
              resize();
          afterNodeInsertion(evict);
          return null;
      }

HashSet集合添加一個元素的流程：

LinkedHashSet：
由哈希表和鏈表實現的Set接口，具有可預知迭代順序。
由鏈表保證元素有序，也就是說元素的存儲和取出順序是一致的。是由鏈表決定。
有哈希表保證元素唯一，也就是說沒有重複的元素。由哈希表決定的(hashCode()和equals())。
同樣，具體實現方法可以參考官網：LinkedHashSet

import java.util.LinkedHashSet;

public class LinkedHashSetdemo {
    public static void main(String[] args){
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add("hello");
        linkedHashSet.add("world");
        linkedHashSet.add("java");

        for (String str : linkedHashSet) {
            System.out.println(str);
        }
    }
}

TreeSet集合：
該類實現了Set接口，可以實現排序等功能。
元素有序，這裏的順序不是指存儲和取出的順序，而是按照一定的規則進行排序，具體方式取決於構造方法。
TreeSet():根據其元素的自然順序進行排序
TreeSet(Comparator comparator):根據指定的比較器進行排序
沒有帶索引的方法，所以不能使用普通for循環遍歷。
由於是Set集合，所以不包含重複元素的集合。
同樣可以參考官方文檔：TreeSet

import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args){
        TreeSet<Integer> treeSet = new TreeSet<>();
        treeSet.add(10);
        treeSet.add(20);
        treeSet.add(100);
        treeSet.add(25);
        treeSet.add(15);
        treeSet.add(100);
        treeSet.add(200);

        for (Integer number: treeSet){
            System.out.println(number);
        }
    }
}

輸出結果：

如果一個學生對象（姓名，年齡）按照年齡從小到大排序，年齡相同時按照姓名的字母順序進行排序，需要重寫compareTo(to)方法：

public int compareTo(Student s){
	int num = this.age - s.age;
	int num2 = num == 0 ? this.name.compareTo(s.name):num;
	return num2;
}

同樣也可以採用比較器Comparator進行排序，重寫compare()方法：

import java.util.Comparator;
import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args){
        TreeSet<Student> treeSet = new TreeSet<>(new Comparator<Student>(){
			@override
			public int compare(Student s1, Student s2){
				int num = s1.getAge() - s2.getAge();
				int num2 = num == 0 ? s.getName.compareTo(s2.getName)) : num;
				return num2;
			}
		});
    }
}

練習題：隨機產生在1-20之間的10個不重複的數。

import java.util.HashSet;
import java.util.Random;
import java.util.Set;

public class TreeSetRandom {
    public static void mian(String[] args){
        Set<Integer> set = new HashSet<>();

        Random random = new Random();

        while (set.size() < 10){
            //產生一個隨機數，添加到集合
            int number = random.nextInt(20) + 1; //1-20的隨機數
            set.add(number);
        }

        for (Integer integer : set){
            System.out.println(integer);
        }
    }
}

Map集合

鐺鐺鐺鐺，重中之重的map來啦！
現附上官方文檔鏈接：Map
首先講解HashMap，官方文檔：HashMap
HashMap 是一個散列表，它存儲的內容是鍵值對(key-value)映射。
該類實現了Map接口，根據鍵的HashCode值存儲數據，具有很快的訪問速度，最多允許一條記錄的鍵爲null；允許多條記錄的值爲 Null；不支持線程同步。

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class HashMapDemo {
    public static void main(String[] args){
        HashMap<String,String> map = new HashMap<>();
        map.put("1","hello");
        map.put("2","world");
        map.put("3","java");

		 //根絕鍵刪除鍵值對元素
        map.remove("1");

        //判斷集合是否包含指定的鍵
        map.containsKey("1");

        //判斷集合是否包含指定的值
        map.containsValue("Java");

        //判斷集合是否爲空
        System.out.println(map.isEmpty());
        
        //Map遍歷方式
        //第一種：普遍使用，二次取值
        System.out.println("通過Map.keySet遍歷key和value：");
        for (String key : map.keySet()){
            System.out.println("key= " + key + " and value=" + map.get(key));
        }

        //第二種
        System.out.println("通過Map.entrySet使用iterator遍歷key和value");
        Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
        while (it.hasNext()){
            Map.Entry<String,String> entry = it.next();
            System.out.println("key= " + entry.getKey() + " and value= "+ entry.getValue());
        }

        //第三種：推薦，尤其是容量大時
        System.out.println("通過Map.entrySet遍歷key和value");
        for (Map.Entry<String,String> entry : map.entrySet()){
            System.out.println("key= " + entry.getKey() + " and value = " +entry.getValue());
        }

        //第四種
        System.out.println("通過Map.value()遍歷所有的value，但不能遍歷key");
        for (String v : map.values()){
            System.out.println("value= " + v);
        }
    }
}

有關HashMap源碼的詳解也可以查看自己的另外一篇博客：HashMap源碼詳解

再來講解LinkedHashMap，同樣可以參考官方文檔：LinkedHashMap
LinkedHashMap也是一個HashMap,但是內部維持了一個雙向鏈表,可以保持順序。
用法基本上和HashMap是類似的，就不做過多的講解。
如果想更多瞭解LinkHashMap，可以參考這篇文章，相對容易理解，但是是基於jdk1.7的：LinkHashMap詳解

再來講解TreeMap，同樣可以參考官方文檔：TreeMap
TreeMap 可以用於排序, 默認根據其鍵的自然順序來排序的，或者根據Comparator在映射創建時提供的來排序，這取決於所使用的構造函數。
如何選擇合適的Map
HashMap可實現快速存儲和檢索，但其缺點是其包含的元素是無序的，這導致它在存在大量迭代的情況下表現不佳。
LinkedHashMap保留了HashMap的優勢，且其包含的元素是有序的。它在有大量迭代的情況下表現更好。
TreeMap能便捷的實現對其內部元素的各種排序，但其一般性能比前兩種map差。
LinkedHashMap映射減少了HashMap排序中的混亂，且不會導致TreeMap的性能損失。

Java基礎（三）—— 集合

集合框架圖

List集合

Set集合

Map集合

RabbitMQ的簡單用法

實體類對象轉String

springboot-mybatis多數據源配置

mysql查詢整個json中具體某個字段的數據

Java基礎（三）—— 集合

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結