1 - Java集合介紹

/*

1. 一方面， 面向對象語言對事物的體現都是以對象的形式，為了方便對多個對象 的操作，就要對對象進行存儲。

2. 另一方面，使用Array存儲對象方面具有一些弊 端，而Java 集合就像一種容器，可以動態地把多個對象的引用放入容器中。

①數組在內存存儲方面的特點：

數組初始化以后，長度就確定了。

數組聲明的類型，就決定了進行元素初始化時的類型

②數組在存儲數據方面的弊端：

數組初始化以后，長度就不可變了，不便于擴展

數組中提供的屬性和方法少，不便于進行添加、刪除、插入等操作，且效率不高。 同時無法直接獲取存儲元素的個數

數組存儲的數據是有序的、可以重復的。---->存儲數據的特點單一

3. Java 集合類可以用于存儲數量不等的多個對象，還可用于保存具有映射關系的關聯數組

*/

packagecom.lzh.java1;/*集合框架概述：

1. 集合、數組都是對多個數據進行存儲操作的結構，簡稱Java容器。說明：此時的存儲，主要指的是內存層面的存儲，不涉及到硬盤層面的存儲。

2. 數組在存儲多個數據方面的特點：

> 一旦初始化以后，其長度就確定了

> 數組一旦定義好，其元素的類型也確定了，也就只能操作指定類型的數據了，比如：String[] array;int[] arr

3. 數組在存儲多個數據方面的缺點：

> 一旦初始化以后，其長度就不可修改

> 數組中提供的方法非常有限，對于添加、刪除、插入數據等操作，非常不便

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

> 數組存儲數據的特點：有序、可重復。對于無序、不可重復的需求，不能滿足*/

public classCollectionTest {

}

集合框架概述

2 - Java集合的使用場景

3 - Java集合Collection 和 Map 兩種體系

/*

Java 集合可分為 Collection 和 Map 兩種體系：

1 Collection接口：單列數據，定義了存取一組對象的方法的集合

①List：元素有序、可重復的集合 --> "動態"數組

②Set：元素無序、不可重復的集合 --> 數學層面的集合(無序，確定，互異)

2 Map接口：雙列數據，保存具有映射關系“key-value對”的集合 --> 數學函數 y = f(x)

*/

Collection接口：單列集合，用來存儲一個一個的對象。其中List接口：用來存儲，有序可重復的數據，Set接口：用來存儲，無序，不可重復的數據

Map接口：雙列集合，用來存儲一對(key - value)的一對數據

4 - Collection接口方法

/*

Collection接口

1 Collection 接口是 List、Set 和 Queue 接口的父接口，該接口里定義的方法 既可用于操作 Set 集合，也可用于操作 List 和 Queue 集合。

2JDK不提供此接口的任何直接實現，而是提供更具體的子接口(如：Set和List)實現。

3 在Java5 之前，Java 集合會丟失容器中所有對象的數據類型，把所有對象都 當成 Object 類型處理；從 JDK 5.0 增加了泛型以后，Java 集合可以記住容器中對象的數據類型

4結論：向Collection接口的實現類的對象中添加數據obj時，要求obj所在類要重寫equals()

*/

/*1、添加

① add(Object obj)

② addAll(Collection coll)

2、獲取有效元素的個數

① int size()

3、清空集合

① void clear()

4、是否是空集合

① boolean isEmpty()

5、是否包含某個元素

① boolean contains(Object obj)：是通過元素的equals方法來判斷是否 是同一個對象

② boolean containsAll(Collection c)：也是調用元素的equals方法來比 較的。拿兩個集合的元素挨個比較。

6、刪除

① boolean remove(Object obj) ：通過元素的equals方法判斷是否是 要刪除的那個元素。只會刪除找到的第一個元素

② boolean removeAll(Collection coll)：取當前集合的差集

7、取兩個集合的交集

① boolean retainAll(Collection c)：把交集的結果存在當前集合中，不 影響c

8、集合是否相等

① boolean equals(Object obj)

9、轉成對象數組

① Object[] toArray()

10、獲取集合對象的哈希值

① hashCode()

11、遍歷

① iterator()：返回迭代器對象，用于集合遍歷*/

Collection接口中的方法

packagecom.lzh.java1;importorg.junit.Test;import java.util.*;/*Collection接口中聲明的方法測試

結論：

向Collection接口的實現類的對象中添加數據obj時，要求obj所在類要重寫equals()*/

public classCollectionTest {//Collection接口中方法的使用

@Testpublic voidtest1(){

Collection coll= newArrayList();//add(Object e) 將元素e添加到集合中

coll.add(123); //自動裝箱

coll.add("a");

coll.add("b");

coll.add(newDate());//size() 獲取集合中元素的個數

System.out.println(coll.size());//addAll(Collection coll1) 將集合coll1中的所有元素添加到當前的集合中

Collection coll1 = newArrayList();

coll1.add(222);

coll1.addAll(coll);

System.out.println(coll1.size());//5

System.out.println(coll1);//isEmpty() 判斷當前集合是否為空

System.out.println(coll.isEmpty()); //false//clear() 清空集合元素

coll.clear();

System.out.println(coll.isEmpty());//true

}

@Testpublic voidtest2(){

Collection collection1= newArrayList();

collection1.add(13);

collection1.add(22);

collection1.add(new String("alex"));

collection1.add(false);

collection1.add(new Person("alex",22));//System.out.println(collection1);//contains(Object obj)：是通過元素的equals方法來判斷是否 是同一個對象

boolean isContains = collection1.contains(13);

System.out.println(isContains);

System.out.println(collection1.size());

System.out.println(collection1.contains(new Person("alex",22))); //true//containsAll(Collection coll1) 判斷形參coll1中的所有元素是否都存在于當前集合中。

Collection collection2 = Arrays.asList(13,false);

System.out.println(collection1.containsAll(collection2));//true

}

@Testpublic voidtest3(){//集合 --> 數組 toArray() 返回值為 Object[]

Collection collection = newArrayList();for(int i = 0;i < 5;i++){

collection.add(i);

}

Object[] arrays=collection.toArray();

System.out.println(arrays.getClass());//class [Ljava.lang.Object;//遍歷數組

for(int i = 0;i < arrays.length;i++){

System.out.println(arrays[i]);

}//數組 --> 集合 調用Arrays類的靜態方法asList()

Collection collection1 = Arrays.asList(11,"adf",22);

System.out.println(collection1.getClass());//class java.util.Arrays$ArrayList

}

@Testpublic voidtest4(){//iterator() 返回Iterator接口的實例，用于遍歷集合元素。

Collection collection = newArrayList();for(int i = 0;i < 5;i++){

collection.add("list"+1);

}

Iterator iterator=collection.iterator();//集合元素的遍歷操作，使用迭代器Iterator接口

}

}classPerson{privateString name;private intage;publicPerson(){}public Person(String name,intage){this.name =name;this.age =age;

}

@Overridepublic booleanequals(Object o) {

System.out.println("執行 equals()...");if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;

Person person=(Person) o;return age == person.age &&Objects.equals(name, person.name);

}

@Overridepublic inthashCode() {returnObjects.hash(name, age);

}

}

Collection接口中聲明的方法測試

5 - Iterator迭代器接口

/*

Iterator迭代器介紹：

1 Iterator對象稱為迭代器(設計模式的一種)，主要用于遍歷 Collection 集合中的元素。

2 GOF給迭代器模式的定義為：提供一種方法訪問一個容器(container)對象中各個元 素，而又不需暴露該對象的內部細節。迭代器模式，就是為容器而生。類似于“公 交車上的售票員”、“火車上的乘務員”、“空姐”。

3 Collection接口繼承了java.lang.Iterable接口，該接口有一個iterator()方法，那么所 有實現了Collection接口的集合類都有一個iterator()方法，用以返回一個實現了 Iterator接口的對象。

4 Iterator 僅用于遍歷集合，Iterator 本身并不提供承裝對象的能力。如果需要創建 Iterator 對象，則必須有一個被迭代的集合。

5 集合對象每次調用iterator()方法都得到一個全新的迭代器對象，默認游標都在集合 的第一個元素之前

*/

Iterator接口的方法

packagecom.lzh.java1;importorg.junit.Test;importjava.util.ArrayList;importjava.util.Collection;importjava.util.Iterator;/*集合元素的遍歷操作，使用迭代器Iterator接口

1. 內部的方法：hasNext() 和 next()

2. 集合對象每次調用iterator()方法都得到一個全新的迭代器對象，默認游標都在集合的第一個元素之前

3. 內部定義了remove(),可以在遍歷的時候，刪除集合中的元素，此方法不同于集合直接調用remove()*/

public classIteratorTest {

@Testpublic voidtest1(){//iterator() 返回Iterator接口的實例，用于遍歷集合元素。

Collection collection = newArrayList();for(int i = 0;i < 5;i++){

collection.add("list"+i);

}

Iterator iterator=collection.iterator();//遍歷集合：方式1 不推薦使用

for(int i = 0;i < collection.size();i++){

System.out.println(iterator.next());//超過5次就報錯(局限性)

}//遍歷集合：方式2 推薦使用//hasNext()與next()搭配使用

while(iterator.hasNext()){

System.out.println(iterator.next());

}

}

@Testpublic voidtest2(){//iterator中的remove()

Collection collection = newArrayList();for(int i = 0;i < 5;i++){

collection.add("list"+i);

}

Iterator iterator=collection.iterator();while(iterator.hasNext()){if("list2".equals(iterator.next())){

iterator.remove();

}

}

Iterator iterator1= collection.iterator(); //重新獲取迭代器

while(iterator1.hasNext()) {

System.out.println(iterator1.next());

}/*注意：

1 Iterator可以刪除集合的元素，但是是遍歷過程中通過迭代器對象的remove方 法，不是集合對象的remove方法。

2 如果還未調用next()或在上一次調用 next 方法之后已經調用了 remove 方法， 再調用remove都會報IllegalStateException。*/}

}

迭代器Iterator接口的使用

迭代器的執行原理

6 - 使用 foreach 循環遍歷集合元素

/*

foreach循環：

1 Java 5.0 提供了 foreach 循環迭代訪問 Collection和數組。

2 遍歷操作不需獲取Collection或數組的長度，無需使用索引訪問元素。

3 遍歷集合的底層調用Iterator完成操作。

4 foreach還可以用來遍歷數組。

*/

packagecom.lzh.java1;importorg.junit.Test;importjava.util.ArrayList;importjava.util.Collection;importjava.util.Iterator;/*1 Java 5.0 提供了 foreach 循環迭代訪問 Collection和數組。

2 遍歷操作不需獲取Collection或數組的長度，無需使用索引訪問元素。

3 遍歷集合的底層調用Iterator完成操作。

4 foreach還可以用來遍歷數組。*/

public classforeachTest {

@Testpublic voidtest1(){

Collection collection= newArrayList();for(int i = 0;i < 5;i++){

collection.add("list"+i);

}//for(集合中元素的類型 局部變量 : 集合對象/數組){}//內部任然調用迭代器

for(Object i:collection){

System.out.println(i);

}

}//遍歷數組

@Testpublic voidtest2(){int[] intArray = new int[]{1,2,3,4,5,6,7,8,9,10};for(inti:intArray){

System.out.println(i);

}

}//面試題：輸出結果？

@Testpublic voidtest3(){

String[] arr= new String[3];for(String i:arr){

i= "mm";

System.out.println(i);

}for(int i = 0;i < arr.length;i++){

System.out.println(arr[i]);//null

}

}

}

foreach循環的使用

7 - Collection子接口之一：List接口

/*

List接口：

1 鑒于Java中數組用來存儲數據的局限性，我們通常使用List替代數組

2 List集合類中元素有序、且可重復，集合中的每個元素都有其對應的順序索引。

3 List容器中的元素都對應一個整數型的序號記載其在容器中的位置，可以根據 序號存取容器中的元素。

4 JDK API中List接口的實現類常用的有：ArrayList、LinkedList和Vector。

*/

/*List接口："動態"數組

List接口的3個實現類：ArrayList、LinkedList和Vector

面試題：ArrayList \ LinkedList \ Vector 3者之間的異同？

同：3個類都實現了List接口，存儲數據的特點相同(有序，可重復)

異：

ArrayList(List接口主要實現類)：線程不安全，執行效率高。底層用Object[] elementData數組進行存儲

LinkedList：對于頻繁的插入、刪除操作，使用此類效率比ArrayList高；底層使用雙向列表存儲

Vector(List接口古老實現類)：線程安全，執行效率偏低。底層用Object[] elementData數組進行存儲

ArrayList源碼分析：

JDK7

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);

JDK8 中ArrayList的變化

ArrayList list = new ArrayList(); // 底層Object[] elementData初始化為{}，并沒有創建長度為10的數組

list.add(123); // 第一次調用add()時，底層才創建了長度為10的數組，并將數據123添加到elementData[0]

...

后續的擴容問題與JDK7一樣

結論：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 item;

Node next;

Node prev;

Node(Node prev, E element, Node next) {

this.item = element;

this.next = next;

this.prev = prev;

}

}*/

面試題：ArrayList \ LinkedList \ Vector 3者之間的異同？

List實現類之一：ArrayList

1 ArrayList 是 List 接口的典型實現類、主要實現類

2 本質上，ArrayList是對象引用的一個”變長”數組

3 ArrayList的JDK1.8之前與之后的實現區別？

① JDK1.7：ArrayList像餓漢式，直接創建一個初始容量為10的數組

② JDK1.8：ArrayList像懶漢式，一開始創建一個長度為0的數組，當添加第一個元 素時再創建一個始容量為10的數組

4 Arrays.asList(…) 方法返回的 List 集合，既不是ArrayList 實例，也不是 Vector 實例。 Arrays.asList(…) 返回值是一個固定長度的 List 集合

List實現類之二：LinkedList

1 對于頻繁的插入或刪除元素的操作，建議使用LinkedList類，效率較高

2 新增方法：

1 void addFirst(Object obj)

2 void addLast(Object obj)

3 Object getFirst()

4 Object getLast()

5 Object removeFirst()

6 Object removeLast()

3 LinkedList：雙向鏈表，內部沒有聲明數組，而是定義了Node類型的first和last， 用于記錄首末元素。同時，定義內部類Node，作為LinkedList中保存數據的基 本結構。Node除了保存數據，還定義了兩個變量：

1 prev變量記錄前一個元素的位置

1 next變量記錄下一個元素的位置

List 實現類之三：Vector

1 Vector 是一個古老的集合，JDK1.0就有了。大多數操作與ArrayList 相同，區別之處在于Vector是線程安全的。

2 在各種list中，最好把ArrayList作為缺省選擇。當插入、刪除頻繁時， 使用LinkedList；Vector總是比ArrayList慢，所以盡量避免使用。

3 新增方法：

1 void addElement(Object obj)

2 void insertElementAt(Object obj,int index)

3?void setElementAt(Object obj,int index)

4 void removeElement(Object obj)

5 void removeAllElements()

/*List除了從Collection集合繼承的方法外，List 集合里添加了一些根據索引來 操作集合元素的方法。

1 void add(int index, Object ele) 在index位置插入ele元素

2 boolean addAll(int index, Collection eles) 從index位置開始將eles中 的所有元素添加進來

3 Object get(int index) 獲取指定index位置的元素

4 int indexOf(Object obj) 返回obj在集合中首次出現的位置

5 int lastIndexOf(Object obj) 返回obj在當前集合中末次出現的位置

6 Object remove(int index) 移除指定index位置的元素，并返回此元素

7 Object set(int index, Object ele) 設置指定index位置的元素為ele

8 List subList(int fromIndex, int toIndex) 返回從fromIndex到toIndex 位置的子集合*/

List接口方法

packagecom.lzh.java1;importorg.junit.Test;importjava.util.ArrayList;importjava.util.Arrays;importjava.util.List;public classListMethodTest {

@Testpublic voidtest1(){

ArrayList list1= newArrayList();for(int i = 0;i < 5;i++){

list1.add("list"+i);

}//1 void add(int index, Object ele) 在index位置插入ele元素

list1.add(0,"第一個元素");

System.out.println(list1);//[第一個元素, list0, list1, list2, list3, list4]//2 boolean addAll(int index, Collection eles) 從index位置開始將eles中 的所有元素添加進來

List list2 = Arrays.asList(1,2,3);

list1.addAll(list2);

System.out.println(list1.size());//9//3 Object get(int index) 獲取指定index位置的元素

System.out.println(list1.get(0)); //第一個元素

System.out.println(list2.get(0)); //0//4 int indexOf(Object obj) 返回obj在集合中首次出現的位置，如果不存在返回 -1

int index = list1.indexOf(3);

System.out.println(index);//8

}

@Testpublic voidtest2(){

ArrayList list= newArrayList();

List l= Arrays.asList("a",1,5,3);

list.addAll(l);

list.add(3);//System.out.println(list);//5 int lastIndexOf(Object obj) 返回obj在當前集合中末次出現的位置

int index = list.lastIndexOf(3);

System.out.println(index);//4//6 Object remove(int index) 移除指定index位置的元素，并返回此元素

Object remove = list.remove(0);

System.out.println(remove);//a

System.out.println(list); //[1, 5, 3, 3]//7 Object set(int index, Object ele) 設置指定index位置的元素為ele

Object p = list.set(1, "hello");

System.out.println(p);//5

System.out.println(list); //[1, hello, 3, 3]//8 List subList(int fromIndex, int toIndex) 返回從fromIndex到toIndex 位置的子集合

List newList = list.subList(2,4);

System.out.println(newList);//[3,3]

}

}

List接口方法測試

8 - Collection子接口之二：Set接口

/*

set接口：

1 Set接口是Collection的子接口，set接口沒有提供額外的方法(用的都是Collection聲明的方法)

2 Set 集合不允許包含相同的元素，如果試把兩個相同的元素加入同一個 Set 集合中，則添加操作失敗。

3 Set 判斷兩個對象是否相同不是使用 == 運算符，而是根據equals() 方法

4 存儲數據特點：無序、不可重復

*/

packagecom.lzh.java2;importorg.junit.Test;import java.util.*;/*1 Set接口框架：

/----Set接口：存儲無序、不可重復的數據 -->高中講的"集合"

/----HashSet:作為Set接口的主要實現類，線程不安全的，可以存儲null值

/----LinkedHashSet：Linked(鏈表)，作為HashSet的子類，遍歷其內部數據時，可以按照添加的順序遍歷

/----TreeSet：可以按照添加對象的指定屬性，進行排序，要求：添加的數據是相同類的對象

①兩種排序方式：自然排序(comparable) 和 定制排序(comparator)

②自然排序中，比較兩個對象是否相同的標準為：compareTo() 返回0，不再是equals()

③定制排序中，比較兩個對象是否相同的標準為：compare() 返回0，不再是equals()

要求：

1 向Set中添加的數據，其所在的類一定要重寫 hashCode() 和 equals()

2 重寫的 hashCode() 和 equals() 盡可能保持一致性：相等的對象必須具有相等的散列表

2 理解Set接口存儲數據：無序、不可重復性。

① 無序性：不等于隨機性。存儲的數據在底層數組中并非按照數組索引的順序添加，而是根據數據的哈希值進行存儲

② 不可重復：保證添加的元素按照equals()判斷時，不能返回true。即相同的元素只能添加一個

3 添加元素的過程：以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添加成功 --> 情況3

對于添加成功的情況2和情況3而言：元素a 與已經存在指定索引位置上數據已鏈表的方式存儲

JDK 7：元素a放到數組中，指向原來的元素

JDK 8：原來的元素在數組中，指向元素a

總結：HashSet底層：數組+鏈表的結構*/

public classSetTest {

@Testpublic voidtest1(){

Set set= newHashSet();for(int i = 0;i < 5;i++){

set.add("list"+i); //有序存儲

}

set.add(new User("howie",21));

set.add(new User("howie",21));

Iterator iterator=set.iterator();while(iterator.hasNext()){

System.out.println(iterator.next());//無序輸出

}

}//LinkedHashSet遍歷內部數據//LinkedHashSet作為HashSet的子類，在添加數據的同時，每個數據還維護了兩個引用，記錄此數據前一個數據和后一個數據//優點：對于頻繁遍歷操作，LinkedHashSet效率高于HashSet

@Testpublic voidtest2(){

Set set= newLinkedHashSet();for(int i = 0;i < 5;i++){

set.add("list"+i); //有序存儲

}

Iterator iterator=set.iterator();while(iterator.hasNext()){

System.out.println(iterator.next());//有序輸出

}

}

}classUser{privateString name;private intage;publicUser(){}public User(String name,intage){this.name =name;this.age =age;

}

@OverridepublicString toString() {return "User{" +

"name='" + name + '\'' +

", age=" + age +

'}';

}

@Overridepublic booleanequals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;

User user=(User) o;return age == user.age &&Objects.equals(name, user.name);

}

@Overridepublic inthashCode() {returnObjects.hash(name, age);

}

}

Set接口框架

1-Set實現類之一：HashSet

/*

HashSet介紹：

1HashSet 是 Set 接口的典型實現，大多數時候使用 Set 集合時都使用這個實現類。

2 HashSet 按 Hash 算法來存儲集合中的元素，因此具有很好的存取、查找、刪除 性能。

3 HashSet 具有以下特點：

① 不能保證元素的排列順序

② HashSet 不是線程安全的

③ 集合元素可以是null

4 HashSet集合判斷兩個元素相等的標準：兩個對象通過hashCode() 方法比較相 等，并且兩個對象的 equals() 方法返回值也相等。

5對于存放在Set容器中的對象，對應的類一定要重寫equals()和hashCode(Object obj)方法，以實現對象相等規則。即：“相等的對象必須具有相等的散列碼”

6 向HashSet中添加元素的過程：

①當向 HashSet 集合中存入一個元素時，HashSet 會調用該對象的 hashCode() 方法 來得到該對象的 hashCode 值，然后根據 hashCode 值，通過某種散列函數決定該對象 在 HashSet 底層數組中的存儲位置。(這個散列函數會與底層數組的長度相計算得到在 數組中的下標，并且這種散列函數計算還盡可能保證能均勻存儲元素，越是散列分布， 該散列函數設計的越好)

②如果兩個元素的hashCode()值相等，會再繼續調用equals方法，如果equals方法結果 為true，添加失敗；如果為false，那么會保存該元素，但是該數組的位置已經有元素了， 那么會通過鏈表的方式繼續鏈接。

7如果兩個元素的 equals() 方法返回 true，但它們的 hashCode() 返回值不相 等，hashSet 將會把它們存儲在不同的位置，但依然可以添加成功

*/

/*1 在程序運行時，同一個對象多次調用 hashCode() 方法應該返回相同的值。

2 當兩個對象的 equals() 方法比較返回 true 時，這兩個對象的 hashCode() 方法的返回值也應相等。

3 對象中用作 equals() 方法比較的 Field，都應該用來計算 hashCode 值*/

重寫 hashCode() 方法的基本原則

/*以自定義的Customer類為例，何時需要重寫equals()？

1 當一個類有自己特有的“邏輯相等”概念,當改寫equals()的時候，總是 要改寫hashCode()，根據一個類的equals方法(改寫后)，兩個截然不 同的實例有可能在邏輯上是相等的，但是，根據Object.hashCode()方法， 它們僅僅是兩個對象。

2 因此，違反了“相等的對象必須具有相等的散列碼”。

3 結論：復寫equals方法的時候一般都需要同時復寫hashCode方法。通 常參與計算hashCode的對象的屬性也應該參與到equals()中進行計算。*/

重寫 equals() 方法的基本原則

2-Set實現類之二：LinkedHashSet

/*

LinkedHashSet介紹：

1 LinkedHashSet 是 HashSet 的子類

2 LinkedHashSet 根據元素的 hashCode 值來決定元素的存儲位置， 但它同時使用雙向鏈表維護元素的次序，這使得元素看起來是以插入 順序保存的。

3 LinkedHashSet插入性能略低于HashSet，但在迭代訪問 Set 里的全 部元素時有很好的性能。

4 LinkedHashSet 不允許集合元素重復

*/

底層結構

3-Set實現類之三：TreeSet

1 TreeSet 是SortedSet 接口的實現類，TreeSet 可以確保集合元素處于排序狀態。

2 TreeSet底層使用紅黑樹結構存儲數據

3新增的方法如下： (了解)

1 Comparator comparator()

2 Object first() ?Object last()

3 Object lower(Object e)

4 Object higher(Object e)

5 SortedSet subSet(fromElement, toElement)

6 SortedSet headSet(toElement)

7 SortedSet tailSet(fromElement)

4 TreeSet 兩種排序方法：自然排序和定制排序。默認情況下，TreeSet 采用自然排序

總結

以上是生活随笔為你收集整理的java 集合 接口_Java集合之Collection接口的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。