泛型,數據結構,List,Set

• 泛型使用

• 數據結構

• List

• Set

1 泛型

1.1 泛型的介紹

• 泛型是一種類型參數，專門用來保存類型用的
  • 最早接觸泛型是在ArrayList，這個E就是所謂的泛型了。使用ArrayList時，只要給E指定某一個類型，里面所有用到泛型的地方都會被指定對應的類型

1.2 使用泛型的好處

• 不用泛型帶來的問題
  • 集合若不指定泛型，默認就是Object。存儲的元素類型自動提升為Object類型。獲取元素時得到的都是Object，若要調用特有方法需要轉型，給我們編程帶來麻煩.
• 使用泛型帶來的好處
  • 可以在編譯時就對類型做判斷，避免不必要的類型轉換操作，精簡代碼，也避免了因為類型轉換導致的代碼異常

//泛型沒有指定類型，默認就是Object ArrayList list = new ArrayList(); list.add("Hello"); list.add("World"); list.add(100); list.add(false); //集合中的數據就比較混亂，會給獲取數據帶來麻煩 for (Object obj : list) {String str = (String) obj;//當遍歷到非String類型數據，就會報異常出錯System.out.println(str + "長度為：" + str.length()); }

1.3 泛型的注意事項

• 泛型在代碼運行時，泛型會被擦除。后面學習反射的時候，可以實現在代碼運行的過程中添加其他類型的數據到集合

  • 泛型只在編譯時期限定數據的類型 , 在運行時期會被擦除

1.4 自定義泛型類

• 當一個類定義其屬性的時候，不確定具體是什么類型時，就可以使用泛型表示該屬性的類型

• 定義的格式

  • 在類型名后面加上一對尖括號，里面定義泛型。一般使用一個英文大寫字母表示，如果有多個泛型使用逗號分隔
  • public class 類名<泛型名>{ … }
  舉例 : public class Student<X,Y>{ X xObj; }

• 泛型的確定

  • 當創建此泛型類是 , 確定泛型類中泛型的具體數據類型

• 練習

package com.itheima.genericity_demo.genericity_class;import java.time.Period;/*需求 : 定義一個人類，定義一個屬性表示愛好，但是具體愛好是什么不清楚，可能是游泳，乒乓，籃球。*/ public class GenericityDemo {public static void main(String[] args) {Person<BasketBall> person = new Person<>();person.setHobby(new BasketBall());Person<Swim> person2 = new Person<>();person2.setHobby(new Swim());Person person3 = new Person<>();// 如果沒有指定泛型 , 那么默認使用Object數據類型} }class Person<H> {// 定義屬性表達愛好private H hobby;public H getHobby() {return hobby;}public void setHobby(H hobby) {this.hobby = hobby;} }class Swim { }class PingPang { }class BasketBall { }

1.3 自定義泛型接口

• 當定義接口時，內部方法中其參數類型，返回值類型不確定時，就可以使用泛型替代了。

• 定義泛型接口

  • 在接口后面加一對尖括號 , 尖括號中定義泛型 , 一般使用大寫字母表示, 多個泛型用逗號分隔
  • public interface<泛型名> { … }
  • 舉例 :
  public interface Collection<E>{public boolean add(E e); }

• 泛型的確定

  • 實現類去指定泛型接口的泛型
  • 實現了不去指定泛型接口的泛型 , 進行延續泛型 , 回到泛型類的使用

package com.itheima.genericity_demo.genericity_interface; /*需求:模擬一個Collection接口，表示集合，集合操作的數據不確定。定義一個接口MyCollection具體表示。*/ // 泛型接口 public interface MyCollection<E> {// 添加功能public abstract void add(E e);// 刪除功能public abstract void remove(E e); }// 指定泛型的第一種方式 : 讓實現類去指定接口的泛型 class MyCollectionImpl1 implements MyCollection<String>{@Overridepublic void add(String s) {}@Overridepublic void remove(String s) {} } // 指定泛型的第二種方式 : 實現類不確定泛型,延續泛型,回到泛型類的使用 class MyCollectionImpl2<E> implements MyCollection<E>{@Overridepublic void add(E a) {}@Overridepublic void remove(E a) {} }

1.4 自定義泛型方法

• 當定義方法時，方法中參數類型，返回值類型不確定時，就可以使用泛型替代了

• 泛型方法的定義

  • 可以在方法的返回值類型前定義泛型
  • 格式 : public <泛型名> 返回值類型 方法名(參數列表){ … }
  • 舉例 : public void show(T t) { … }

• 泛型的確定

  • 當調用一個泛型方法 , 傳入的參數是什么類型, 那么泛型就會被確定

• 練習

  package com.itheima.genericity_demo.genericity_method;import java.util.ArrayList; import java.util.Arrays;public class Test {public static void main(String[] args) {// Collection集合中 : public <T> T[] toArray(T[] a) : 把集合中的內容存儲到一個數組中 , 進行返回ArrayList<String> list = new ArrayList<>();list.add("abc");list.add("ads");list.add("qwe");String[] array = list.toArray(new String[list.size()]);System.out.println(Arrays.toString(array));}// 接收一個集合 , 往集合中添加三個待指定類型的元素public static <X> void addElement(ArrayList<X> list, X x1, X x2, X x3) {list.add(x1);list.add(x2);list.add(x3);} }

1.5 通配符

• 當我們對泛型的類型確定不了，而是表達的可以是任意類型，可以使用泛型通配符給定

  符號就是一個問號：? 表示任意類型，用來給泛型指定的一種通配值。如下

public static void shuffle(List<?> list){//… } 說明：該方法時來自工具類Collections中的一個方法，用來對存儲任意類型數據的List集合進行亂序

• 泛型通配符結合集合使用

  • 泛型通配符搭配集合使用一般在方法的參數中比較常見。在集合中泛型是不支持多態的，如果為了匹配任意類型，我們就會使用泛型通配符了。
  • 方法中的參數是一個集合,集合如果攜帶了通配符，要特別注意如下
    • 集合的類型會提升為Object類型
    • 方法中的參數是一個集合,集合如果攜帶了通配符,那么此集合不能進行添加和修改操作 , 可以刪除和獲取
  package com.itheima.genericity_demo;import java.util.ArrayList; import java.util.List;public class Demo {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();list.add("abc");list.add("asd");list.add("qwe");// 方法的參數是一個集合 , 集合的泛型是一個通配符 , 可以接受任意類型元素的集合show(list);}public static void show(List<?> list) {// 如果集合的泛型是一個通配符 , 那么集合中元素以Object類型存在Object o = list.get(0);// 如果集合的泛型是一個通配符 , 那么此集合不能進行添加和修改操作 , 可以刪除和獲取// list.add(??);// 刪除可以list.remove(0);// 獲取元素可以for (Object o1 : list) {System.out.println(o1);}} } package com.itheima.genericity_demo;import java.util.ArrayList;/*已知存在繼承體系：Integer繼承Number，Number繼承Object。定義一個方法，方法的參數是一個ArrayList。要求可以接收ArrayList<Integer>,ArrayList<Number>,ArrayList<Object>,ArrayList<String>這些類型的數據。結論 : 具體類型的集合,不支持多態 , 要想接收任意類型集合 , 需要使通配符集合*/ public class Test1 {public static void main(String[] args) {ArrayList<Integer> list1 = new ArrayList<>();ArrayList<Number> list2 = new ArrayList<>();ArrayList<String> list3 = new ArrayList<>();ArrayList<Object> list4 = new ArrayList<>();useList5(list1);useList5(list2);useList5(list3);useList5(list4);}// 此方法只能接收存儲Integer類型數據的集合public static void useList1(ArrayList<Integer> list) {}// 此方法只能接收存儲Number類型數據的集合public static void useList2(ArrayList<Number> list) {}// 此方法只能接收存儲String類型數據的集合public static void useList3(ArrayList<String> list) {}// 此方法只能接收存儲Object類型數據的集合public static void useList4(ArrayList<Object> list) {}public static void useList5(ArrayList<?> list) {}}

1.6 受限泛型

• 受限泛型是指，在使用通配符的過程中 , 對泛型做了約束，給泛型指定類型時，只能是某個類型父類型或者子類型

• 分類 :

  • 泛型的下限 :
    • <? super 類型> //只能是某一類型，及其父類型，其他類型不支持
  • 泛型的上限 :
    • <? extends 類型> //只能是某一個類型，及其子類型，其他類型不支持
  package com.itheima.genericity_demo.wildcard_demo;import java.util.ArrayList;/*wildcardCharacter基于上一個知識點，定義方法show1方法，參數只接收元素類型是Number或者其父類型的集合show2方法，參數只接收元素類型是Number或者其子類型的集合*/ public class Test2 {public static void main(String[] args) {ArrayList<Integer> list1 = new ArrayList<>();ArrayList<Number> list2 = new ArrayList<>();ArrayList<Object> list3 = new ArrayList<>();show1(list3);show1(list2);show2(list2);show2(list1);}// 此方法可以接受集合中存儲的是Number或者Number的父類型 , 下限泛型public static void show1(ArrayList<? super Number> list) {}// 此方法可以接受集合中存儲的是Number或者Number的子類型 , 上限泛型public static void show2(ArrayList<? extends Number> list) {} }

2 數據結構

• 棧結構 : 先進后出

• 隊列結構 : 先進先出

• 數組結構 : 查詢快 , 增刪慢

• 鏈表結構 : 查詢慢 , 增刪快

• 二叉樹

  • 二叉樹 : 每個節點最多有兩個子節點

  • 二茬查找樹 : 每個節點的左子節點比當前節點小 , 右子節點比當前節點大

  • 二茬平衡樹 : 在查找樹的基礎上, 每個節點左右子樹的高度不超過1

  • 紅黑樹 :

    • 每一個節點或是紅色的，或者是黑色的

    • 根節點必須是黑色

    • 如果一個節點沒有子節點或者父節點，則該節點相應的指針屬性值為Nil，這些Nil視為葉節點，每個葉節點(Nil)是黑色的

    • 不能出現兩個紅色節點相連的情況

    • 對每一個節點，從該節點到其所有后代葉節點的簡單路徑上，均包含相同數目的黑色節點

    • 添加元素 :

• 哈希表結構 :

  • 哈希值：是JDK根據對象的地址或者字符串或者數字算出來的int類型的數值
  • Object類中有一個方法可以獲取對象的哈希值
    public int hashCode()：返回對象的哈希碼值
  • 對象的哈希值特點
    • 同一個對象多次調用hashCode()方法返回的哈希值是相同的
    • 默認情況下，不同對象的哈希值是不同的。而重寫hashCode()方法，可以實現讓不同對象的哈希值相同

3 List集合

• List集合是Collection集合子類型，繼承了所有Collection中功能，同時List增加了帶索引的功能

• 特點 :

  • 元素的存取是有序的【有序】
  • 元素具備索引 【有索引】
  • 元素可以重復存儲【可重復】

• 常見的子類

  • ArrayList：底層結構就是數組【查詢快，增刪慢】
  • Vector：底層結構也是數組（線程安全，同步安全的，低效，用的就少)
  • LinkedList：底層是鏈表結構（雙向鏈表）【查詢慢，增刪快】

• List中常用的方法

List繼承了Collection中所有方法，元素具備索引特性，因此新增了一些含有索引的特有方法

• public void add(int index, E element): 將指定的元素，添加到該集合中的指定位置上。
• public E get(int index):返回集合中指定位置的元素
• public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
• public E set(int index, E element):用指定元素替換集合中指定位置的元素,返回值的更新前的元素

package com.itheima.list_demo;import java.util.ArrayList; import java.util.Iterator; import java.util.List;/*List繼承了Collection中所有方法，元素具備索引特性，因此新增了一些含有索引的特有方法，如下：- public void add(int index, E element): 將指定的元素，添加到該集合中的指定位置上。- public E get(int index):返回集合中指定位置的元素。- public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。- public E set(int index, E element):用指定元素替換集合中指定位置的元素,返回值的更新前的元素*/ public class ListDemo1 {public static void main(String[] args) {// 可以采用多態的形式創建對象List<String> list = new ArrayList<>();// [周瑜 黃蓋 周泰 甘寧 陸遜 呂蒙]list.add("周瑜");list.add("黃蓋");list.add("周泰");list.add("甘寧");list.add("陸遜");list.add("呂蒙");// - public void add(int index, E element): 將指定的元素，添加到該集合中的指定位置上。// list.add(3 , "魯肅");// - public E get(int index):返回集合中指定位置的元素。 // System.out.println(list.get(0)); // System.out.println(list.get(1)); // System.out.println(list.get(2)); // System.out.println(list.get(3)); // System.out.println(list.get(4)); // System.out.println(list.get(5)); // for (int i = 0; i < list.size(); i++) { // System.out.println(list.get(i)); // }// - public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。// System.out.println(list.remove(1));// - public E set(int index, E element):用指定元素替換集合中指定位置的元素,返回值的更新前的元素// System.out.println(list.set(3 , "孫權"));// ArrayList<Integer> list2 = new ArrayList<>(); // list2.add(1);//刪除 ? // list2.add(2);//刪除 ? // list2.add(3); // list2.remove((Integer) 1); // System.out.println(list2);// 1 3Iterator<String> it = list.iterator();while(it.hasNext()){String s = it.next();System.out.print(s + " ");}} }

• LinkedList類

  • LinkedList底層結構是雙向鏈表。每個節點有三個部分的數據，一個是保存元素數據，一個是保存前一個節點的地址，一個是保存后一個節點的地址。可以雙向查詢，效率會比單向鏈表高。
  • LinkedList特有方法
    • public void addFirst(E e):將指定元素插入此列表的開頭。
    • public void addLast(E e):將指定元素添加到此列表的結尾。
    • public E getFirst():返回此列表的第一個元素。
    • public E getLast():返回此列表的最后一個元素。
    • public E removeFirst():移除并返回此列表的第一個元素。
    • public E removeLast():移除并返回此列表的最后一個元素。

package com.itheima.list_demo;import java.util.LinkedList;/*LinkedList特有功能public void addFirst(E e):將指定元素插入此列表的開頭。public void addLast(E e):將指定元素添加到此列表的結尾。public E getFirst():返回此列表的第一個元素。public E getLast():返回此列表的最后一個元素。public E removeFirst():移除并返回此列表的第一個元素。public E removeLast():移除并返回此列表的最后一個元素。*/ public class LinkedListDemo {public static void main(String[] args) {LinkedList<String> list = new LinkedList<>(); // [黃忠, 關羽, 張飛, 趙云, 馬超]list.add("黃忠");list.add("關羽");list.add("張飛");list.add("趙云");list.add("馬超");// public void addFirst(E e):將指定元素插入此列表的開頭。// list.addFirst("劉備");// public void addLast(E e):將指定元素添加到此列表的結尾// list.addLast("劉禪");// public E getFirst():返回此列表的第一個元素// System.out.println(list.getFirst());// public E getLast():返回此列表的最后一個元素。// System.out.println(list.getLast());// public E removeFirst():移除并返回此列表的第一個元素。// System.out.println(list.removeFirst());// public E removeLast():移除并返回此列表的最后一個元素。System.out.println(list.removeLast());System.out.println(list);// 內容} }

ArrayList集合擴容分析

F:\黑馬\01-JavaSE進階面授\day05【泛型，數據結構，List接口，Set接口】\資料

package com.itheima.list_demo;import java.util.ArrayList; import java.util.Arrays;public class ArrayListDemo {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();list.add("于禁");list.add("華佗");list.add("潘鳳");/*ArrayList集合是屬于 -- 數組結構研究集合如何進行擴容 ？空參構造方法 : Object[] elementData = {};*/int[] arr = {};int[] newArr = Arrays.copyOf(arr, 10);System.out.println(Arrays.toString(newArr));} }

4 Set集合

• Set集合也是Collection集合的子類型，沒有特有方法。Set比Collection定義更嚴謹
• 特點 :
  • 元素不能保證插入和取出順序（無序）
  • 元素是沒有索引的(無索引)
  • 元素唯一(元素唯一)
• Set常用子類

  • HashSet：底層由HashMap，底層結構哈希表結構。
    去重，無索引，無序。
    哈希表結構的集合，操作效率會非常高。

  • LinkedHashSet:底層結構鏈表加哈希表結構。
    具有哈希表表結構的特點，也具有鏈表的特點。
    鏈表結構：是為了保證插入順序
    哈希表結構：是為了去重
    存儲元素的時候，先過哈希表，如果哈希表能夠接受數據，進一步存到鏈表結構表結構實實現
    

  • TreeSet：底層是有TreeMap，底層數據結構 紅黑樹。
    去重，讓存入的元素具有排序（升序排序）

• HashSet概述 :

  • java.util.HashSet是Set接口的實現類，沒有特有方法。 底層是哈希表結構，具有去重特點。

package com.itheima.set_demo;import java.util.HashSet;/*練習 : 使用HashSet集合存儲字符串并遍歷HashSet特點 :1 無序2 沒有索引3 保證元素唯一*/ public class HashSetDemo1 {public static void main(String[] args) {HashSet<String> set = new HashSet<>();set.add("abc");set.add("abc");for (String s : set) {System.out.println(s);}} } package com.itheima.set_demo;public class Student {private String name;private int age;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;if (age != student.age) return false;return name != null ? name.equals(student.name) : student.name == null;}// @Override // public int hashCode() { // return 1; // }// 減少equals方法的執行次數 , 從而提高效率 // @Override // public int hashCode() { // /* // s1 = 7 + 3 = 10 // s2 = 3 + 7 = 10 // */ // return name.hashCode() + age; // }@Overridepublic int hashCode() {/*s1 = 217 + 3 = 220s2 = 93 + 7 = 10031 常量 : 1,質數 2,不大不小 3, 2的五次方-1*/int result = name != null ? name.hashCode() : 0;result = 31 * result + age;return result;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';} }package com.itheima.set_demo;import java.util.HashSet;/*練習 : 使用HashSet集合存儲自定義對象并遍歷HashSet特點 :1 無序2 沒有索引3 保證元素唯一HashSet集合要想保證元素的唯一 , 那么存儲元素所在的類 , 必須重寫hashCode和equals方法*/ public class HashSetDemo2 {public static void main(String[] args) {// 創建集合對象HashSet<Student> set = new HashSet<>();// { s1 }// 創建元素對象Student s1 = new Student("柳巖", 3);Student s2 = new Student("景甜", 7);// Student s3 = new Student("李四", 24);// 把元素添加到集合中set.add(s1);set.add(s2);// set.add(s3);// 遍歷集合for (Student s : set) {System.out.println(s);}} } // public V put(K key, V value) {// key代表的是HashSet集合添加的元素 // // int hash = hash(key); // 獲取添加元素的哈希值 // // // 遍歷當前集合中已經存在的元素 // for (Entry<K,V> e = table[i]; e != null; e = e.next) { // Object k; // if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { // V oldValue = e.value; // e.value = value; // e.recordAccess(this); // return oldValue; // } // } // // modCount++; // // 添加元素的方法 // addEntry(hash, key, value, i); // return null; // }

• 哈希值

  • 哈希值：是JDK根據對象的地址或者字符串或者數字算出來的int類型的數值
  • Object類中有一個方法可以獲取對象的哈希值
    • public int hashCode?()：返回對象的哈希碼值
  • 對象的哈希值特點
    • 同一個對象多次調用hashCode()方法返回的哈希值是相同的
    • 默認情況下，不同對象的哈希值是不同的。而重寫hashCode()方法，可以實現讓不同對象的哈希值相同

• 哈希表

  • JDK8之前，底層采用數組+鏈表實現，可以說是一個元素為鏈表的數組
  • JDK8以后，在長度比較長的時候，底層實現了優化

package com.itheima.set_demo;/*哈希值 :1 通過對象的地址獲取 , 不同對象的哈希值不同2 重寫了hashCode方法 , 不同的對象, 但是獲取的哈希值是有可能相等的Object類中有一個方法可以獲取對象的哈希值public int hashCode?()：返回對象的哈希碼值對象的哈希值特點同一個對象多次調用hashCode()方法返回的哈希值是相同的默認情況下，不同對象的哈希值是不同的。而重寫hashCode()方法，可以實現讓不同對象的哈希值相同哈希表結構JDK8之前 :哈希表 : 數組 + 鏈表JDK8版本及之后 :哈希表 : 數組 + 鏈表/紅黑樹*/ public class HashCodeDemo {public static void main(String[] args) {Student s1 = new Student();System.out.println(s1.hashCode()); // System.out.println(s.hashCode()); // System.out.println(s.hashCode());Student s2 = new Student();System.out.println(s2.hashCode());System.out.println("你好".hashCode());// 652829// 哈希沖突System.out.println("通話".hashCode());// 1179395System.out.println("重地".hashCode());// 1179395} }

• LinkedHashSet

package com.itheima.set_demo;import java.util.LinkedHashSet;public class LinkedHashSetDemo {public static void main(String[] args) {LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>();linkedHashSet.add(10);linkedHashSet.add(10);linkedHashSet.add(20);linkedHashSet.add(30);System.out.println(linkedHashSet);} }

4 集合總結

package com.itheima.test; /*集合 :單列集合 : Collection接口List接口 : 1 有序 , 2 有索引 , 3 元素可以重復ArrayList類 : 數組結構(查詢快 , 增刪慢)LinkedList類 : 鏈表結構(查詢滿 , 增刪快)Set 接口 : 1 無序 , 2 無索引 , 3 元素唯一HashSet類 : 哈希表結構(JDK8之前 : 數組 + 鏈表 )(JDK8包含及之后 : 數組 + 鏈表/紅黑樹)LinkedHashSet類 : 元素唯一并有序 . 哈希表 + 鏈表TreeSet類 : 紅黑樹(可以對元素進行排序 , 還可以保證元素唯一) , 今天不學雙列集合 : Map接口TreeMap類 : 紅黑樹(可以對元素進行排序 , 還可以保證元素唯一)HashMap類 : 哈希表結構(JDK8之前 : 數組 + 鏈表 )(JDK8包含及之后 : 數組 + 鏈表/紅黑樹)集合的遍歷 : 單列集合的遍歷1 普通for循環(根據所以獲取元素值)只能遍歷List集合體系2 迭代器所有的單列集合3 增強for所有的單列集合,和數組*/ public class Test {public static void main(String[] args) {} } package com.itheima.test;import java.util.ArrayList; import java.util.Iterator;public class ArrayListDemo {public static void main(String[] args) {// 創建集合對象ArrayList<String> list = new ArrayList<>();// 直接添加元素list.add("馬云祿");list.add("關鳳");list.add("關銀屏");list.add("貂蟬");list.add("孫尚香");// 迭代器Iterator<String> it = list.iterator();while (it.hasNext()) {String s = it.next();System.out.println(s);}System.out.println("===========");// 增強forfor (String s : list) {System.out.println(s);}System.out.println("===========");// 普通for循環for (int i = 0; i < list.size(); i++) {String s = list.get(i);System.out.println(s);}} } package com.itheima.test;import java.util.Iterator; import java.util.LinkedList; /*因為底層為雙向鏈表public void addFirst(E e):將指定元素插入此列表的開頭。public void addLast(E e):將指定元素添加到此列表的結尾。public E getFirst():返回此列表的第一個元素。public E getLast():返回此列表的最后一個元素。public E removeFirst():移除并返回此列表的第一個元素。public E removeLast():移除并返回此列表的最后一個元素。*/ public class LinkedListDemo {public static void main(String[] args) {// 創建集合對象LinkedList<String> list = new LinkedList<>();// 直接添加元素list.add("馬云祿");list.add("關鳳");list.add("關銀屏");list.add("貂蟬");list.add("孫尚香");// 遍歷集合// 迭代器Iterator<String> it = list.iterator();while(it.hasNext()){String s = it.next();System.out.println(s);}System.out.println("============");// 增強forfor (String s : list) {System.out.println(s);}System.out.println("============");// 普通forfor (int i = 0; i < list.size(); i++) {String s = list.get(i);System.out.println(s);}} } package com.itheima.test;import java.util.HashSet; import java.util.Iterator;/*HashSet要想保證元素的唯一 , 那么元素所在的類必須重寫hashCode和equals方法 !!!!!!*/ public class HashSetDemo {public static void main(String[] args) {HashSet<String> hs = new HashSet<>();hs.add("abs");hs.add("abc");hs.add("abs");hs.add("abc");// 遍歷方式// 迭代器Iterator<String> it = hs.iterator();while(it.hasNext()){String s = it.next();System.out.println(s);}System.out.println("===============");// 增強forfor (String h : hs) {System.out.println(h);}} } package com.itheima.test;public class Student {private String name;private int age;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;if (age != student.age) return false;return name != null ? name.equals(student.name) : student.name == null;}@Overridepublic int hashCode() {int result = name != null ? name.hashCode() : 0;result = 31 * result + age;return result;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';} } package com.itheima.test;import java.util.HashSet; import java.util.Iterator;/*HashSet要想保證元素的唯一 , 那么元素所在的類必須重寫hashCode和equals方法 !!!!!!*/ public class HashSetDemo2 {public static void main(String[] args) {// 創建集合對象HashSet<Student> hs = new HashSet<>();// 創建元素對象Student s1 = new Student("張三" , 23);Student s2 = new Student("張三" , 23);Student s3 = new Student("李四" , 24);// 添加到集合中hs.add(s1);hs.add(s2);hs.add(s3);// 迭代器Iterator<Student> it = hs.iterator();while(it.hasNext()){Student s = it.next();System.out.println(s);}System.out.println("===========");// 增強forfor(Student s : hs){System.out.println(s);}} } package com.itheima.test;import java.util.Iterator; import java.util.LinkedHashSet;public class LinkedHashSetDemo {public static void main(String[] args) {LinkedHashSet<Student> linkedHashSet = new LinkedHashSet<>();// 創建元素對象Student s1 = new Student("張三" , 23);Student s2 = new Student("張三" , 23);Student s3 = new Student("李四" , 24);linkedHashSet.add(s1);linkedHashSet.add(s2);linkedHashSet.add(s3);// 迭代器Iterator<Student> it = linkedHashSet.iterator();while(it.hasNext()){Student s = it.next();System.out.println(s);}System.out.println("======================");// 增強forfor (Student s : linkedHashSet) {System.out.println(s);}} }

總結

以上是生活随笔為你收集整理的【泛型，数据结构，List接口，Set接口】的全部內容，希望文章能夠幫你解決所遇到的問題。

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