一、集合框架的概述
背景：一方面，面向對象語言對事物的體現都是以對象的形式，為了方便對多個對象的操作，就要對對象進行存儲，另一方面，使用Array存儲對象方面具有一些弊端，而Java集合就像一種容器，可以動態的把多個對象的引用放入容器中。
1.集合、數組都是對多個數據進行存儲操作的結構，簡稱Java容器。
說明:此時的存儲，主要指的是內存層面的存儲，不涉及到持久化的存儲(.txt,.jpg,.avi,數據庫中)
2. 數組在存儲多個數據方法的特點：
> 一旦初始化以后，其長度就確定了。
> 數組一旦定義好，其元素的類型也就確定了。我們也就只能操作指定類型的數據了。
比如：String[] arr;int[] arr1;Object[] arr2(多態：數組中也可存放子類類型的數據(String等));
3. 數組在存儲多個數據方面的缺點：
> 一旦初始化以后，其長度就不可修改。
> 數組中提供的方法非常有限，對于添加、刪除、插入數組等操作，非常不便，同時效率不高
> 獲取數組中實際元素的個數的需求，數組沒有現成的屬性或方法可用
> 數組存儲數據的特點：有序、可重復。對于無序、不可重復的需求，不能滿足
二、集合框架(Java集合可分為Collection 和 Map 兩種體系)
A. Collection接口：單列集合，用來存儲一個一個的對象
a.List接口：存儲有序的、可重復的數據。--->"動態"數組
|---ArrayList、LinkedList、Vector
b.Set接口：存儲無序的、不可重復的數據 --->高中講的"集合"
|---HashSet、LinkedHashSet、TreeSet
B. Map接口：雙列集合，用來存儲一對(key - value)一對的數據 --->高中函數：y = f(x)
|---HashMap、LinkedHashMap、TreeMap、Hashable、Properties
三、Collection接口中的方法的使用
public void test1(){ Collection coll = new ArrayList(); //add(Object e):將元素e添加到集合coll中 coll.add("AA"); coll.add("BB"); coll.add(123);//自動裝箱 coll.add(new Date()); //size():獲取添加的元素的個數 System.out.println(coll.size());//4 //addAll(Collection coll1):將coll1集合中的元素添加到當前的集合中 Collection coll1 = new ArrayList(); coll1.add(456); coll1.add("CC"); coll.addAll(coll1); System.out.println(coll.size());//6 System.out.println(coll); //clear():清空集合元素(對象還在，只是元素沒了) coll.clear(); //isEmpty():判斷當前集合是否為空 System.out.println(coll.isEmpty()); } //結論：向Collection接口的實現類的對象中添加數據obj時，要求obj所在類要重寫equals(). public void test2(){ Collection coll = new ArrayList(); coll.add(123); coll.add(456); coll.add(new Person("Jerry",20)); coll.add(new String("Tom")); coll.add(false); //1.contains(Object obj):判斷當前集合中是否包含obj //我們在判斷時會調用obj對象所在類的equals() boolean contains = coll.contains(123); System.out.println(contains); System.out.println(coll.contains(new String("Tom")));//true System.out.println(coll.contains(new Person("Jerry",20)));//false-->ture //2.containsAll(Collection coll1):判斷形參coll1中的所有元素是否都存在于當前集合中 Collection coll1 = Arrays.asList(123,456); System.out.println(coll.containsAll(coll1)); }
public void test3(){ //3.remove(Object obj):從當前集合中移除obj元素 Collection coll = new ArrayList(); coll.add(123); coll.add(456); coll.add(new Person("Jerry",20)); coll.add(new String("Tom")); coll.add(false); coll.remove(1234); System.out.println(coll);//[123, 456, Person{name='Jerry', age=20}, Tom, false] coll.remove(new Person("Jerry",20)); System.out.println(coll);//[123, 456, Tom, false] //4.removeAll(Collection coll1)://從當前集合中移除coll1中所有的元素 Collection coll1 = Arrays.asList(123,4567); coll.removeAll(coll1); System.out.println(coll);//[456, Tom, false] } public void test4(){ Collection coll = new ArrayList(); coll.add(123); coll.add(456); coll.add(new Person("Jerry",20)); coll.add(new String("Tom")); coll.add(false); //5.retainAll(Collection coll1):獲取帶那個前集合和coll1集合的交集，并返回給當前集合 // Collection coll1 = Arrays.asList(123.456,789); // coll.retainAll(coll1); // System.out.println(coll); //6.equals(Object obj):要想返回true,需要當前集合和形參集合的元素都相同 Collection coll1 = new ArrayList(); coll1.add(123); coll1.add(456); coll1.add(new Person("Jerry",20)); coll1.add(new String("Tom")); coll1.add(false); System.out.println(coll.equals(coll1));//true } public void test5(){ Collection coll = new ArrayList(); coll.add(123); coll.add(456); coll.add(new Person("Jerry",20)); coll.add(new String("Tom")); coll.add(false); //7.hashCode():返回當前對象的哈希值 System.out.println(coll.hashCode()); //8.集合 --> 數組：toArray() Object[] arr = coll.toArray(); for(int i = 0;i < arr.length;i++){ System.out.println(arr[i]); } //拓展：數組 --> 集合：調用Arrays類的靜態方法asList() List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"}); System.out.println(list); List arr1 = Arrays.asList(new int[]{123, 456}); System.out.println(arr1.size());//1 List arr2 = Arrays.asList(new Integer[]{123, 456}); System.out.println(arr2.size());//2 }
四、集合元素的遍歷操作
A. 使用(迭代器)Iterator接口
1.內部的方法：hasNext() 和 next()
2.集合對象每次調用iterator()方法都得到一個全新的迭代器對象，默認游標都在集合的第一個元素 之前。
3.內部定義了remove().可以在遍歷的時候，刪除集合中的元素，此方法不同于集合直接調用 remove()
注意：在調用it.next()方法之前必須要調用it.hasNext()進行檢測，若不調用，且下一條記錄無效，直接調用it.next()會拋出NoSuchEiementException異常。
public class IteratorTest { @Test 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); Iterator iterator = coll.iterator(); //方式一：不推薦 // System.out.println(iterator.next()); // System.out.println(iterator.next()); // System.out.println(iterator.next()); // System.out.println(iterator.next()); // System.out.println(iterator.next()); //報異常：NoSuchElementException // System.out.println(iterator.next()); //方式二：不推薦 // for(int i = 0;i < coll.size();i++){ // System.out.println(iterator.next()); // } //方式三：推薦 //hasNext():判斷是否還有下一個元素 while (iterator.hasNext()){ //next():A 指針下移 B 將下移以后集合位置上的元素返回 System.out.println(iterator.next()); } } @Test public void test2(){ Collection coll = new ArrayList(); coll.add(123); coll.add(456); coll.add(new Person("Jerry",20)); coll.add(new String("Tom")); coll.add(false); //錯誤方式一： // Iterator iterator = coll.iterator(); // while((iterator.next()) != null){ // System.out.println(iterator.next());//456 Tom//跳著輸出 // }//還會報異常：NoSuchElementException //錯誤方式二： //集合對象每次調用iterator()方法都得到一個全新的迭代器對象，默認游標都在集合的第一個元素之前。 // while(coll.iterator().hasNext()){ // System.out.println(coll.iterator().next());//123死循環 // } } //測試Iterator中的remove() @Test public void test3(){ Collection coll = new ArrayList(); coll.add(123); coll.add(456); coll.add(new Person("Jerry",20)); coll.add(new String("Tom")); coll.add(false); //刪除集合中的"Tom" Iterator iterator = coll.iterator(); while(iterator.hasNext()){ Object obj = iterator.next(); if("Tom".equals(obj)){ iterator.remove(); } } //遍歷集合 iterator = coll.iterator(); while (iterator.hasNext()){ System.out.println(iterator.next()); } } }
B. jdk5.0新增foreach循環，用于遍歷集合、數組
@Test//訪問Collection 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); } } @Test//訪問數組 public void test2(){ int[] arr = new int[]{1,3,4,5,6}; //for(數組元素的類型 局部變量：數組對象) for(int i : arr){ System.out.println(i); } }
一道筆試題
//筆試題 @Test public void test3(){ String[] arr = new String[]{"MM","MM","MM"}; //方式一：普通for賦值//輸出：GG//拿著數組修改，數組存儲在堆中，可修改 // for(int i = 0;i < arr.length;i++){ // arr[i] = "GG"; // } //方式二：增強for循環//輸出:MM//將數組中的元素一個個賦給字符型變量s，而s存儲在常量區，不可被修改 for(String s : arr){ s = "GG"; } for(int i = 0;i < arr.length;i++){ System.out.println(arr[i]); } }
五、Collection子接口之一：List接口
簡介：鑒于Java中數組用來存儲數據的局限性，我們通過使用List代替數組
List集合類中元素有序、且可重復，集合中的每個元素都有其對應的順序索引。
List容器中的元素都對應一個整型的序號記載其在容器中的位置，可以根據序號存取容器中的元素。
List接口方法
public void test1(){ ArrayList list = new ArrayList(); list.add(123); list.add(456); list.add("AA"); list.add(new Person("Jerry",20)); list.add(456); System.out.println(list);//[123, 456, AA, Person{name='Jerry', age=20}, 456] //void add(int index,Object ele):在index位置插入ele元素 list.add(1,"BB"); System.out.println(list);//[123, BB, 456, AA, Person{name='Jerry', age=20}, 456] //boolean addAll(int index,Collection eles):從index位置上開始將eles中的所有元素添加進來 List list1 = Arrays.asList(1,2,3); list.addAll(list1); System.out.println(list.size());//9 //Object get(int index):獲取指定index位置的元素 System.out.println(list.get(0));//123 } public void test2(){ ArrayList list = new ArrayList(); list.add(123); list.add(456); list.add("AA"); list.add(new Person("Jerry",20)); list.add(456); //int indexOf(Object obj):返回obj在集合中首次出現的位置，如果不存在，返回-1 int index = list.indexOf(4567); System.out.println(index);//-1 //int LastIndexOf(Object obj):返回obj在當前集合中末次出現的位置 System.out.println(list.lastIndexOf(456));//4 //Object remove(int index):移除指定index位置的元素，并返回此元素 Object obj = list.remove(0);//123 System.out.println(list);//[456, AA, Person{name='Jerry', age=20}, 456] //Object set(int index,Object ele):設置指定index位置的元素為ele list.set(1,"CC");//[456, CC, Person{name='Jerry', age=20}, 456] System.out.println(list); // //List subList(int formIndex,int toIndex):返回從formIndex到toIndex位置的左閉右開的子集合 List subList = list.subList(2,4); System.out.println(subList);//[Person{name='Jerry', age=20}, 456] System.out.println(list);//[456, AA, Person{name='Jerry', age=20}, 456] }
遍歷List的方式
public void test3(){ ArrayList list = new ArrayList(); list.add(123); list.add(456); list.add("AA"); //方式一：Iterator迭代器的方式 Iterator iterator = list.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next()); } //方式二：增強for循環 for(Object obj : list){ System.out.println(obj); } //方式三：普通for循環 for(int i = 0;i < list.size();i++){ System.out.println(list.get(i)); }
區分List中remove(int index)和remove(Object obj)
@Test public void test4(){ ArrayList list = new ArrayList(); list.add(1); list.add(2); list.add(3); updateList(list); System.out.println(list); } public static void updateList(List list){ list.remove(2);//[1, 2]//刪掉角標為2的元素 list.remove(new Integer(2));//刪掉字符2 }
面試題:ArrayList、LinkedList、Vector三者的異同？
同：三個類都是實現了List接口，存儲數據的特點相同：存儲有序的、可重復的數據
不同: |---ArrayList:作為List接口的主要實現類：線程不安全的,效率高;底層使用Object[] elementData存儲
|---LinkedList：對于頻繁的插入、刪除操作,使用此類效率比ArrayList高;底層使用雙向鏈表存 儲
|---Vector：作為List接口的古老的實現類；線程安全的，效率低；底層使用Object[] elementData存儲
ArrayList的源碼分析：
JDK 7情況下：
ArrayList list = new ArrayList();//底層創建了長度是10的Object[]數組elementData
list.add(123);//elementData[0] = new Integer(123);
...
List.add(11);//如果此次的添加導致底層elementData數組容量不夠，則擴容。
默認情況下，擴容為原來的容量的1.5倍，同時需要將原有的數組中的數據復制到新的數組中。
結論：建議開發中使用帶參的構造器：ArrayList list = new ArrayList(int capacity)
JDK 8中ArrayList的變化：
ArrayList list = new ArrayList();//底層Object[] elementData初始化為{}.并沒有創建長度為10的數組
list.add(123);//第一次使用add()時，底層才創建了長度為10的數組，并將數據123添加到elementData[0]
后續的添加和擴容操作與JDK 7相同
小結：jdk7中的ArrayList的對象的創建類似于單例的餓漢式,而jdk8中的ArrayList的對象的創建類似于單例的懶漢式，延遲了數組的創建，節省內存
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倍。
六、Collection子接口之一：Set接口
一、Set接口概述
> Set接口是Collection的子接口，set接口沒有提供額外的方法
> Set集合不允許包含相同的元素，如果試把兩個相同的元素加入同一個Set集合中，則添加操作失敗。
> Set判斷兩個對象是否相同不是使用 == 運算符，而是根據 equals() 方法
> 注意點：
1.Set接口中沒有額外定義新的方法，使用的都是Collection中聲明過的方法。
2.要求：向Set中添加的數據，其所在的類一定要重寫hashCode()和equals()
要求：重寫的hashCode()和equals()盡可能保持一致性：相等的對象必須是具有相等的數列碼
重寫兩個方法的小技巧:對象中用作equals()方法比較的Field,都應該用來計算hashCode值
二、set接口的框架：
Collection接口：單列集合，用來存儲一個一個的對象
> Set接口：存儲無序的、不可重復的數據 --->高中講的"集合"
A.HashSet:作為Set接口的主要實現類：線程不安全的，可以存儲null值
B.LinkedHashSet：作為HashSet的子類：遍歷其內部數據時，可以按照添加的順序遍歷
對于頻繁的遍歷操作，LinkedHashSet效率高于HashSet
C.TreeSet:可以按照添加對象的指定屬性，進行排序
三、Set的三個實現類
重寫hashCode()方法的基本原則
> 在程序運行時，同一個對象多次調用hashCode()方法應該返回相同的值。
> 當兩個對象的equals()方法比較返回true時，這兩個對象的hashCode()方法的返回值也應相等
> 對象中用作equals()方法比較的Field,都應該用來計算hashCode值。
public void test1(){ HashSet set = new HashSet(); set.add(456); set.add(123); set.add(123); set.add("AA"); set.add("CC"); set.add(new User("Tom",12)); set.add(new User("Tom",12)); set.add(129); Iterator iterator = set.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next()); // AA // CC // 129 // 456 // 123 // User{name='Tom', age=12} }
Set：存儲無序的、不可重復的數據
以HashSet為例說明：
1.無序性：不等于隨機性。存儲的數據在底層數組中并非按照數組索引的順序添加，而是根據數據的哈希值決定的
2.不可重復性：保證添加的元素按照equals()判斷時，不能返回true.即：相同的元素只添加一個
二、添加元素的過程：以HashSet為例：
我們向HashSet中添加元素a,首先調用元素a所在類的hashCode()方法，計算元素a的哈希值，此哈希值接著通過
某種算法計算出在HashSet底層數組中的存放位置(即為：索引位置)，判斷此位置上是否已經有元素：
如果此位置上沒有其他元素，則元素a添加成功。--->情況1
如果此位置上有其他元素b(或以鏈表形式存在的多個元素),則比較元素a與元素b的has值。
如果hash值不相同，則元素a添加成功。---->情況2
如果hash值相同，進而需要調用元素a所在類的equals()方法：
equals()返回true,元素a添加失敗
equals()返回false,則元素a添加成功。----情況3
對于添加成功的情況2和情況3而言：元素a與已經存在指定索引位置上數據以鏈表的方式存儲。
JDK 7:元素a放到數組中，指向原來的元素。
LDK 8:原來的元素在數組中，指向元素a
總結:七上八下
HashSet底層：數組 + 鏈表的結構(前提：JDK 7之前)
LinkedHashSet的使用
linkedHashSet作為HashSet的子類，在添加數據的同時，每個數據還維護了兩個引用，記錄此數據前一個數據和后一個數據
優點：對于頻繁的遍歷操作，LinkedHashSet效率高于HashSet
public void test2(){ HashSet set = new LinkedHashSet(); set.add(456); set.add(123); set.add(123); set.add("AA"); set.add("CC"); set.add(new User("Tom",12)); set.add(new User("Tom",12)); set.add(129); Iterator iterator = set.iterator(); while(iterator.hasNext()) { System.out.println(iterator.next()); } }
注意點：
1.向TreeSet中添加的數據，要求是相同類的對象。
2.兩種排序方式：自然排序(實現Comparable接口) 和 定制排序(Comparator)
3.自然排序中，比較兩個對象是否相同的標準為：compareTo()返回0.不再是equals().
定制排序中，比較兩個對象是否相同的標準為：compare()返回0.不再是equals().
4.TreeSet和后面要講的TreeMap采用紅黑樹的存儲結構；特點：有序，查詢速度比List快
public void test1(){ TreeSet set = new TreeSet(); //報錯：ClassCastException 不能添加不同類的對象 // 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",22)); set.add(new User("Jack",62)); Iterator iterator = set.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next()); } } @Test 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",22)); set.add(new User("Mike",65)); set.add(new User("Jack",22)); set.add(new User("Jack",62)); Iterator iterator = set.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next()); } }
到此這篇關于深入淺出講解Java集合之Collection接口的文章就介紹到這了,更多相關Java Collection內容請搜索服務器之家以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持服務器之家！
原文鏈接：https://blog.csdn.net/weixin_49329785/article/details/119722477
