學習目標

能夠說出List集合特點1.有序2.允許存儲重復的元素3.有帶索引的方法(練習 add,remove,set,get)
能夠使用集合工具類Collections類:static void sort(List<T> list) 根據元素的自然順序 對指定列表按升序進行排序。static <T> void sort(List<T> list, Comparator<? super T> c) 根據指定比較器產生的順序對指定列表進行排序。static void shuffle(List<?> list)  隨機打亂集合中元素的順序
能夠使用Comparator比較器進行排序Collections.sort(list01, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {//降序: o2-o1  升序:o1-o2return o2-o1;}});
能夠使用可變參數public static void method(int...arr){}調用method方法,參數是一個可變參數,可以接收任意個同種數據類型的數據method(),method(10),method(10,20)...
能夠說出Set集合的特點1.不允許存儲重復的元素2.不包含帶索引的方法
能夠說出哈希表的特點JDK1.8之前:數組+單向鏈表JDK1.8之后:數組+單向鏈表|數組+紅黑樹查詢的效率高
使用HashSet集合存儲自定義元素(重點)想要保證存儲的元素(Person對象,Student對象...)同名和同年齡的人視為同一個人自定義類型(Person對象,Student對象...)必須重寫hashCode和equals方法

第一章 List接口

1.List接口的概述

/*java.uil.List<E>接口 extends Collection<E>接口List接口的特點:1.是一個有序的集合:存儲元素和取出元素的順序是一致的  存儲:123  取出:1232.允許存儲重復的元素  add(10)  add(10)3.包含一些帶索引的特有方法List接口特有的帶索引的方法:void add(int index, E element)  在指定索引處,添加一個新的元素E get(int index)  獲取指定索引處的元素E remove(int index)  移除并返回指定索引處的元素,返回的就是被移除的元素E set(int index, E element)  替換并返回指定索引處的元素,返回的是被替換的元素注意:使用帶索引的方法,必須防止索引越界異常(不要超過集合索引的使用范圍:0-->集合的長度-1)         */

2.List接口中常用的方法(重點)

package com.itheima.demo01List;import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;/*索引越界異常:IndexOutOfBoundsException:索引越界異常,集合會報ArrayIndexOutOfBoundsException:數組索引越界異常StringIndexOutOfBoundsException:字符串的索引越界異常*/
public class Demo01List {public static void main(String[] args) {//創建List集合對象,給集合添加元素List<String> list = new ArrayList<>();list.add("aaa");list.add("bbb");list.add("ccc");list.add("aaa");list.add("ddd");         //  0    1   2    3     4System.out.println(list);//[aaa, bbb, ccc, aaa, ddd]//void add(int index, E element)  在指定索引處,添加一個新的元素//在索引2處添加一個新的元素"哈哈"list.add(2,"哈哈");System.out.println(list);//[aaa, bbb, 哈哈, ccc, aaa, ddd]//E get(int index)  獲取指定索引處的元素String s1 = list.get(0);System.out.println("s1:"+s1);//s1:aaaString s2 = list.get(1);System.out.println("s2:"+s2);//s2:bbb//list.get(10);//IndexOutOfBoundsException: Index: 10, Size: 6//E remove(int index)  移除并返回指定索引處的元素,返回的就是被移除的元素System.out.println(list);//[aaa, bbb, 哈哈, ccc, aaa, ddd]//刪除集合中第二個aaaString s3 = list.remove(4);System.out.println("s3:"+s3);//s3:aaaSystem.out.println(list);//[aaa, bbb, 哈哈, ccc, ddd]//E set(int index, E element)  替換并返回指定索引處的元素,返回的是被替換的元素//把索引2處哈哈,替換為呵呵String s4 = list.set(2, "呵呵");System.out.println("s4:"+s4);//s4:哈哈System.out.println(list);//[aaa, bbb, 呵呵, ccc, ddd]System.out.println("------------------------------------------");//使用普通for循環遍歷List集合  list.forifor (int i = 0; i < list.size(); i++) {String s = list.get(i);System.out.println(s);}System.out.println("------------------------------------------");//使用增強for循環遍歷List集合 list.forfor (String s : list) {System.out.println(s);}System.out.println("------------------------------------------");//使用迭代器遍歷List集合Iterator<String> it = list.iterator();while (it.hasNext()){String s = it.next();System.out.println(s);}}
}

3.ArrayList集合(數組)

/*java.util.ArrayList<E>集合 implements List<E>接口List 接口的大小可變數組的實現。ArrayLis集合底層采用的就是數組結構:查詢快,增刪慢工作中:查詢多的時候使用,不對集合的長度進行修改(添加,刪除)
*/
public class ArrayList<E>{transient Object[] elementData = {};add方法:list.add("aaa");	public boolean add(E e) {ensureCapacityInternal(size + 1);  // Increments modCount!!elementData[size++] = e;return true;}...//add方法底層:創建一個新的數組,長度是源數組長度+1,把源數組中的元素使用System類中的arraycopy方法復制到新的數組中    public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {@SuppressWarnings("unchecked")T[] copy = ((Object)newType == (Object)Object[].class)? (T[]) new Object[newLength]: (T[]) Array.newInstance(newType.getComponentType(), newLength);System.arraycopy(original, 0, copy, 0,Math.min(original.length, newLength));return copy;}   }

4.LinkedList集合(雙向鏈表)

a.LinkedList集合概述

/*java.util.LinkedList<E> implements List<E>接口List 接口的鏈接列表實現。LinkedList集合底層是一個雙向鏈表:查詢慢,增刪快雙向:是一個有序的集合LinkedList集合中含有一些操作鏈表首尾元素的方法:public void addFirst(E e) :將指定元素插入此列表的開頭。public void push(E e) :將元素推入此列表所表示的堆棧。public void addLast(E e) :將指定元素添加到此列表的結尾。public E getFirst() :返回此列表的第一個元素。public E getLast() :返回此列表的最后一個元素。public boolean isEmpty() ：如果列表不包含元素，則返回truepublic E removeFirst() :移除并返回此列表的第一個元素。public E pop() :從此列表所表示的堆棧處彈出一個元素。public E removeLast() :移除并返回此列表的最后一個元素。注意:使用LinkedList集合特有的方法,不能使用多態創建對象List<String> list = new LinkedList<>();弊端:不能是實現類特有的方法LinkedList<String> linked = (LinkedList<String>)list; 向下轉型Collection<String> list = new LinkedList<>();弊端:不能是實現類特有的方法LinkedList<String> list = new LinkedList<>();
*/

b.LinkedList集合特有的方法(使用)

package com.itheima.demo01List;import java.util.LinkedList;/*LinkedList集合特有的方法*/
public class Demo02LinkedList {public static void main(String[] args) {show04();}/*public E removeFirst() :移除并返回此列表的第一個元素。public E pop() :從此列表所表示的堆棧處彈出一個元素。 此方法等效于 removeFirst()。public E removeLast() :移除并返回此列表的最后一個元素。*/private static void show04() {LinkedList<String> linked = new LinkedList<>();linked.add("aaa");linked.add("bbb");linked.add("ccc");linked.add("ddd");System.out.println(linked);//[aaa, bbb, ccc, ddd]if(linked.size()!=0){//String first = linked.removeFirst();String first = linked.pop();System.out.println("first:"+first);//first:aaaString last = linked.removeLast();System.out.println("last:"+last);//last:dddSystem.out.println(linked);//[bbb, ccc]}}/*public E getFirst() :返回此列表的第一個元素。public E getLast() :返回此列表的最后一個元素。public boolean isEmpty() ：如果列表不包含元素，則返回true*/private static void show03() {LinkedList<String> linked = new LinkedList<>();linked.add("aaa");linked.add("bbb");linked.add("ccc");linked.add("ddd");linked.clear();//清空集合//為了防止NoSuchElementException:沒有元素異常,增加一個判斷,集合不是空的在獲取if(!linked.isEmpty()){//return size() == 0;String first = linked.getFirst();System.out.println("first:"+first);//first:aaaString last = linked.getLast();System.out.println("last:"+last);//last:ddd}if(linked.size()!=0){String first = linked.getFirst();System.out.println("first:"+first);//first:aaaString last = linked.getLast();System.out.println("last:"+last);//last:ddd}}private static void show02() {LinkedList<String> linked = new LinkedList<>();linked.addFirst("1");linked.addFirst("2");linked.addFirst("3");linked.addLast("a");linked.addLast("b");linked.addLast("c");System.out.println(linked);//[3, 2, 1, a, b, c]}/*public void addFirst(E e) :將指定元素插入此列表的開頭。public void push(E e) :將元素推入此列表所表示的堆棧。此方法等效于 addFirst(E)。public void addLast(E e) :將指定元素添加到此列表的結尾。此方法等效于add()*/private static void show01() {LinkedList<String> linked = new LinkedList<>();linked.add("aaa");linked.add("bbb");linked.add("ccc");linked.add("ddd");System.out.println(linked);//[aaa, bbb, ccc, ddd]//public void addFirst(E e) :將指定元素插入此列表的開頭。//linked.addFirst("www");linked.push("www");System.out.println(linked);//[www, aaa, bbb, ccc, ddd]//public void addLast(E e) :將指定元素添加到此列表的結尾。此方法等效于add()//linked.addLast("com");linked.add("com");System.out.println(linked);//[www, aaa, bbb, ccc, ddd, com]}
}

c.LinkedList源碼分析(了解即可)

5.Vector集合(面試)

/*java.util.Vector<E> implements List<E>(jdk1.2之后)Vector是JDK1.0時期存在的單列集合,Collection下邊的其他集合(ArrayList,LinkedList...)是JDK1.2之后出現的Vector 類可以實現可增長的對象數組。Vector集合底層和ArrayList集合是一樣的,也是一個數組結構(查詢快,增刪慢)Vector集合1.0時期有一些特有的方法:void addElement(E obj)  往集合中添加元素Enumeration<E> elements() 返回此向量的組件的枚舉。 Enumeration<E>接口:向量枚舉,是1.0時期的迭代器boolean hasMoreElements()  判斷集合中還有沒有元素==>hasNextE nextElement()  取出集合的元素==>next與新 collection 實現不同，Vector 是同步的。 同步技術:可以保證多線程的安全同步技術:集合存儲數據效率低所以Vector集合被效率更高的ArrayList集合取代了
*/

第二章 Collections類

1.Collections的常用功能(重點)

package com.itheima.demo02Collections;import java.util.ArrayList;
import java.util.Collections;/*java.util.Collections:操作集合的工具類,里邊的方法都是靜態的通過類名.方法名(參數)可以直接使用常用的方法:static void  sort(List<T> list) 根據元素的自然順序 對指定集合按升序進行排序。static <T> void sort(List<T> list, Comparator<? super T> c)  根據指定比較器產生的順序對指定列表進行排序。static void shuffle(List<?> list)  隨機打亂集合中元素的順序注意:以上3個方法,參數都是List,只能傳遞List接口下的實現類對象(ArrayList,LinkedList),不能使用Set接口下的集合*/
public class Demo01Collections {public static void main(String[] args) {//創建ArrayList集合對象ArrayList<Integer> list01 = new ArrayList<>();list01.add(1);list01.add(3);list01.add(2);list01.add(4);System.out.println(list01);//[1, 3, 2, 4]/*static void  sort(List<T> list) 根據元素的自然順序 對指定集合按升序進行排序。升序: 小->大降序: 大->小*/Collections.sort(list01);System.out.println(list01);//[1, 2, 3, 4]/*static void shuffle(List<?> list)  隨機打亂集合中元素的順序*/Collections.shuffle(list01);System.out.println(list01);//[4, 1, 3, 2]  [3, 4, 1, 2]  [2, 4, 1, 3]...ArrayList<String> list02 = new ArrayList<>();list02.add("ab");list02.add("aa");list02.add("12");list02.add("AB");list02.add("CC");System.out.println(list02);//[ab, aa, 12, AB, CC]/*static void  sort(List<T> list) 根據元素的自然順序 對指定集合按升序進行排序。升序: 小->大降序: 大->小自然順序:編碼表的順序  ASCII  0:48   A:65   a:97*/Collections.sort(list02);System.out.println(list02);//[12, AB, CC, aa, ab]}
}

2.Comparator比較器(重點)

package com.itheima.demo02Collections;import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;/*static <T> void sort(List<T> list, Comparator<? super T> c)  根據指定比較器產生的順序對指定列表進行排序。參數:List<T> list:要排序的List集合Comparator<? super T> c:對集合進行排序的比較器jav.util.Comparator<T>接口強行對某個對象 collection 進行整體排序 的比較函數。Comparator接口中抽象方法:int compare(T o1, T o2) 比較用來排序的兩個參數。參數:T o1, T o2:依次比較的集合中的元素[1,1,3, 2, 4]比較的規則:(重點)升序: o1-o2降序: o2-o1兩個元素相等: o1==o2*/
public class Demo02Collections {public static void main(String[] args) {//創建ArrayList集合對象ArrayList<Integer> list01 = new ArrayList<>();list01.add(1);list01.add(3);list01.add(2);list01.add(4);System.out.println(list01);//[1, 3, 2, 4]//使用Collections集合中工具類中的sort方法,對集合中的元素根據比較器產生的規則排序Collections.sort(list01, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {//降序: o2-o1return o2-o1;}});System.out.println(list01);//[4, 3, 2, 1]//使用Collections集合中工具類中的sort方法,對集合中的元素根據比較器產生的規則排序Collections.sort(list01, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {//升序: o1-o2return o1-o2;}});System.out.println(list01);//[1, 2, 3, 4]}
}

擴展:

package com.itheima.demo02Collections;import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;public class Demo03Collections {public static void main(String[] args) {//創建ArrayList集合,泛型使用PersonArrayList<Person> list = new ArrayList<>();list.add(new Person("azhansan",18));list.add(new Person("lisi",20));list.add(new Person("wangwu",19));list.add(new Person("bzhaoliu",18));list.add(new Person("tianqi",21));//使用Collections集合工具類中的方法sort,根據比較器產生的規則進行排序(年齡升序排序)Collections.sort(list, new Comparator<Person>() {@Overridepublic int compare(Person o1, Person o2) {//年齡升序排序return o1.getAge()-o2.getAge();}});System.out.println(list);//[Person{name='zhansan', age=18}, Person{name='zhaoliu', age=18}, Person{name='wangwu', age=19}, Person{name='lisi', age=20}, Person{name='tianqi', age=21}]//按照兩個人年齡升序排序,如果兩個人年齡相同,按照姓名的首字母降序排序Collections.sort(list, new Comparator<Person>() {@Overridepublic int compare(Person o1, Person o2) {//按照兩個人年齡升序排序int a = o1.getAge()-o2.getAge();//判斷兩個人的年齡是否相等if(a==0){//按照姓名的首字母降序排序a = o2.getName().charAt(0)-o1.getName().charAt(0);}return a;}});System.out.println(list);//System.out.println("aaa".charAt(0)-"bbb".charAt(0));//int compareTo(String anotherString) 按字典(編碼表)順序比較兩個字符串。//按照兩個人年齡升序排序,如果兩個人年齡相同,按照姓名進行排序Collections.sort(list, new Comparator<Person>() {@Overridepublic int compare(Person o1, Person o2) {//按照兩個人年齡升序排序int a = o1.getAge()-o2.getAge();//判斷兩個人的年齡是否相等if(a==0){//按照姓名進行排序a = o2.getName().compareTo(o1.getName());}return a;}});System.out.println(list);}
}

package com.itheima.demo02Collections;public class Person {private String name;private int age;public Person() {}public Person(String name, int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", 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;}
}

3.可變參數

package com.itheima.demo03VarArgs;import java.util.ArrayList;/*可變參數是JDK1.5之后出現的新特性作用:當我們定義一個方法的時候,方法的參數類型已經確定了,但是參數的個數不確定,就可以使用可變參數格式:修飾符 返回值類型 方法名(數據類型...變量名){方法體;}數據類型...變量名:叫可變參數,代表形式參數可以接收任意個數據調用參數是可變參數的方法,參數的個數可以傳遞任意個(不傳遞,1,2,3,4,5,6....n...)原理:可變參數底層就是一個數組,傳遞不同個數個參數,就會創建不同長度的數組,來接收這些參數*/
public class Demo01VarArgs {public static void main(String[] args) {//getSum();//getSum(10);//getSum(10,20);int s = getSum(10, 20, 30, 40, 50, 60, 70, 80, 90, 100);System.out.println(s);//550int[] arr = {1,2,3};int s2 = getSum(arr);System.out.println(s2);ArrayList<Integer> list = new ArrayList<>();list.add(1);list.add(2);//int s3 = getSum(list);//System.out.println(s3);method1(10,1.1,"aaa",1,2,3,4,4,5,65,6,7,7,8,8,8);method2(1,2,3,4,4,5,65,6,7,7,8,8,8);method2("a","v","c");}//可變參數的注意事項//1.一個方法的參數只能寫一個可變參數//public static void method(int...a,String...s){}//2.方法的參數列表有多個參數,可變參數必須寫在末尾//public static void method(int a,double b,int...d,String c){}//Vararg parameter must be the last in the list//public static void method(int a,double b,String c,int...d){}//可變參數終極寫法public static void method1(Object...obj){}public static <T> T[] method2(T...t){return t;}/*定一個計算n個(不知道傳遞多少個整數,0,1,2,3,4,..)int類型整數和的方法已知:參數的數據類型:int類型未知:不知道計算多少個整數的和所以我們就可以使用可變參數,作為方法的參數使用,可以接收任意個同種數據類型的參數getSum();傳遞0個參數,那么可變參數就會創建一個長度為0的數組,用來接收參數 new int[]{ };getSum(10);傳遞1個參數,那么可變參數就會創建一個長度為1的數組,用來接收參數 new int[]{10};getSum(10,20);傳遞2個參數,那么可變參數就會創建一個長度為2的數組,用來接收參數 new int[]{10,20};...getSum(10,20,30,40,50,60,70,80,90,100);傳遞10個參數,那么可變參數就會創建一個長度為10的數組,用來接收參數 new int[]{10,20,30,40,50,60,70,80,90,100};*/public static int getSum(int...arr){//System.out.println(arr);//[I@4554617c 數組的地址值//System.out.println(arr.length);//0,1,2...數組的長度//對數組中的元素進行求和//定義一個變量,初始值為0,記錄累加求和int sum = 0;//遍歷數組(可變參數),獲取數組中的每一個元素for (int i : arr) {//累加求和sum+=i;}//把和返回return sum;}/*定義計算四個int類型整數和的方法*//*public static int getSum(int a,int b,int c,int d){return a+b+c+d;}*//*定義計算三個int類型整數和的方法*//*public static int getSum(int a,int b,int c){return a+b+c;}*//*定義計算兩個int類型整數和的方法*//*public static int getSum(int a,int b){return a+b;}*/
}

重點:記住可變參數可以接收任意個同種數據類型的元素

4.Collections集合工具類中的方法addAll

package com.itheima.demo03VarArgs;import java.util.ArrayList;
import java.util.Collections;/*java.util.Collections:操作集合的工具類,里邊的方法都是靜態的static <T> boolean  addAll(Collection<T> c, T... elements) 將所有指定元素添加到指定 collection 中。給集合添加多個元素*/
public class Demo02Collections {public static void main(String[] args) {ArrayList<Integer> list = new ArrayList<>();//list.add(1);//list.add(2);//list.add(3);//list.add(4);//list.add(5);Collections.addAll(list,1,2,3,4,5);System.out.println(list);ArrayList<String> list02 = new ArrayList<>();Collections.addAll(list02,"a","b","c","d","e");System.out.println(list02);//可變參數底層就是一個數組,傳遞可變參數的地方都可以傳遞數組String[] arr = {"aaa","bbb","ccc","ddd"};Collections.addAll(list02,arr);System.out.println(list02);//[a, b, c, d, e, aaa, bbb, ccc, ddd]}
}

第三章 Set接口

1.Set接口的介紹(記住)

/*java.util.Set<E>接口 extends Collection<E>接口Set接口的特點:1.不允許存儲重復的元素  add(1) add(1) ==>集合中只有一個12.不包含帶索引的方法,里邊的方法和Collection接口是一樣
*/

2.HashSet集合的介紹和基本使用(重點)

package com.itheima.demo04Set;import java.util.HashSet;
import java.util.Iterator;/*java.util.HashSet<E>集合 implements Set<E>接口此類實現 Set 接口，由哈希表（實際上是一個 HashMap 實例）支持。它不保證 set 的迭代順序；特別是它不保證該順序恒久不變。此類允許使用 null 元素。HashSet集合的特點:1.不允許存儲重復的元素2.不包含帶索引的方法(不能使用普通的for循環遍歷Set集合)3.是一個無序的集合(存儲的元素和取出的元素順序有可能不一致)4.底層是一個哈希表JDK1.8之前:數組+單向鏈表JDK1.8之后:數組+單向鏈表|數組+紅黑樹(可以提高查詢的效率)*/
public class Demo01HashSet {public static void main(String[] args) {show02();}private static void show02() {//創建HashSet集合對象HashSet<String> set = new HashSet<>();boolean b1 = set.add("aaa");System.out.println("b1:"+b1);//b1:trueset.add("bbb");set.add("ccc");boolean b2 = set.add("aaa");System.out.println("b2:"+b2);//b2:falseset.add("ddd");//使用增強for循環遍歷Set集合for (String s : set) {System.out.println(s);}}private static void show01() {//創建HashSet集合對象HashSet<Integer> set = new HashSet<>();set.add(1);set.add(3);set.add(2);set.add(4);set.add(1);//使用迭代器遍歷Set集合Iterator<Integer> it = set.iterator();while (it.hasNext()){Integer s = it.next();System.out.println(s);}}
}

3.哈希值(了解)

package com.itheima.demo04Set;/*哈希值:是一個十進制的整數,由操作系統隨機給出,我們打印對象的地址值,使用的就是哈希值(邏輯地址)對象在內存中實際存儲的地址,并不是哈希值的地址(物理地址)Object類有獲取對象哈希值的方法:int hashCode() 返回該對象的哈希碼值。hashCode方法的底層源碼:public native int hashCode();native:調用的是操作系統底層的方法,不是由java語言編寫的*/
public class Demo02HashCode {public static void main(String[] args) {//Person類默認繼承了Object類,所以可以使用Object類中的hashCode方法Person p1 = new Person();int h1 = p1.hashCode();System.out.println(h1);//1163157884==>1Person p2 = new Person();int h2 = p2.hashCode();System.out.println(h2);//1956725890==>1/*Object類的toString方法String toString() 返回該對象的字符串表示。底層源碼:public String toString() {return getClass().getName() + "@" + Integer.toHexString(hashCode());}getClass().getName():使用反射技術,獲取包名+類名  com.itheima.demo04Set.Person"@":字符串原樣輸出Integer.toHexString(hashCode()):把hashCode方法返回的十進制的整數,轉換為十六進制*/System.out.println(p1.toString());//com.itheima.demo04Set.Person@4554617c==>1System.out.println(p2.toString());//com.itheima.demo04Set.Person@74a14482==>1System.out.println(p1==p2);//比較的是對象的地址值 false}
}

package com.itheima.demo04Set;public class Person extends Object {@Overridepublic int hashCode() {return 1;}
}

4.String類的哈希值(了解)

package com.itheima.demo04Set;/*String類的哈希值(了解)String類重寫了Object類的hashCode方法規則:相同的字符串返回的哈希值是一樣的不同的字符串,計算出的哈希值也有可能是一樣*/
public class Demo03StringHashCode {public static void main(String[] args) {String s1 = new String("abc");String s2 = new String("abc");System.out.println(s1.hashCode());//96354System.out.println(s2.hashCode());//96354System.out.println(s1==s2);//falseSystem.out.println("重地".hashCode());//1179395System.out.println('重'+0);//37325System.out.println('地'+0);//22320System.out.println("通話".hashCode());//1179395}
}

5.HashSet集合存儲數據的結構（哈希表）

6.使用HashSet集合存儲String不重復的原理(了解)

package com.itheima.demo04Set;/*String類的哈希值(了解)String類重寫了Object類的hashCode方法規則:相同的字符串返回的哈希值是一樣的不同的字符串,計算出的哈希值也有可能是一樣*/
public class Demo03StringHashCode {public static void main(String[] args) {String s1 = new String("abc");String s2 = new String("abc");System.out.println(s1.hashCode());//96354System.out.println(s2.hashCode());//96354System.out.println(s1==s2);//falseSystem.out.println("重地".hashCode());//1179395System.out.println('重'+0);//37325System.out.println('地'+0);//22320System.out.println("通話".hashCode());//1179395}
}

7.HashSet存儲自定義類型元素(重點中的重點)

package com.itheima.demo05HashSet;import java.util.HashSet;/*HashSet存儲自定義類型元素(重點中的重點)要求:同名同年齡的人,視為同一個人,只能存儲一次保證:HashSet集合存儲Person類必須重寫hashCode和equals方法,來保證元素唯一重點:使用HashSet集合存儲自定義類型的元素(Person,Student,Animal...),自定義元素必須重寫hashCode和equals方法,來保證元素唯一快捷鍵: alt+insert  選擇 equals and hashCode思考:使用ArrayList集合存儲Person,Person需要重寫hashCode和equals方法嗎? 1需要 2不需要(正確)ArrayList集合元素是允許重復,add方法也不會調用元素hashCode和equals方法*/
public class Demo02HashSetSavePerson {public static void main(String[] args) {//創建HashSet集合對象,泛型使用PersonHashSet<Person> set = new HashSet<>();Person p1 = new Person("a",10);Person p2 = new Person("a",10);System.out.println(p1.hashCode());//1163157884System.out.println(p2.hashCode());//1956725890set.add(p1);set.add(p2);set.add(new Person("b",11));set.add(new Person("c",12));set.add(new Person("d",13));set.add(new Person("e",14));set.add(new Person("f",15));set.add(new Person("b",9));//遍歷Set集合for (Person p : set) {System.out.println(p);}}
}

package com.itheima.demo05HashSet;import java.util.Objects;public class Person {private String name;private int age;public Person() {}public Person(String name, int age) {this.name = name;this.age = age;}/*重寫Object類的hashCode方法:模擬String類name本身就是一個字符串,可以直接調用String類的hashCode方法,獲取字符串的哈希值name.hashCode()+age;set.add(new Person("a",10));  哈希值:97+10=107set.add(new Person("a",10));  哈希值:97+10=107兩個人的哈希值都是107,使用equals方法,比較兩個人,equals返回true==>認定兩個元素相同,只能存儲一個----------------------------------------------------name.hashCode()+age;set.add(new Person("a",10));  哈希值:97+10=107set.add(new Person("b",9));   哈希值:98+9=107兩個人的哈希值都是107,使用equals方法,比較兩個人,equals返回false==>認定兩個元素不同,都會存儲到集合中----------------------------------------------------降低相同哈希值出現的幾率:可以避免兩個元素比較equals方法,可以提高程序的效率name.hashCode()*2+age;set.add(new Person("a",10));  哈希值:97*2+10=204set.add(new Person("b",9));   哈希值:98*2+9=205name.hashCode()*31+age;*/@Overridepublic int hashCode() {int result = name != null ? name.hashCode() : 0;result = 31 * result + age;return result;}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Person person = (Person) o;if (age != person.age) return false;return name != null ? name.equals(person.name) : person.name == null;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", 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;}
}

2.LinkedHashSet集合(了解)

package com.itheima.demo06Set;import java.util.HashSet;
import java.util.LinkedHashSet;/*java.util.LinkedHashSet<E> extends HashSet<E>具有可預知迭代順序的 Set 接口的哈希表和鏈接列表實現。此實現與 HashSet 的不同之外在于，后者維護著一個運行于所有條目的雙重鏈接列表。LinkedHashSet特點:1.不允許存儲重復元素2.沒有帶索引的方法3.底層是哈希表+單向鏈表JDK1.8之前:數組+單向鏈表+單向鏈表JDK1.8之后:數組+單向鏈表+單向鏈表|數組+紅黑樹+單向鏈表(可以提高查詢的效率)結構就是一個雙向鏈表,可以保證迭代的順序,是一個有序的集合*/
public class Demo01LinkedHashSet {public static void main(String[] args) {HashSet<String> set = new HashSet<>();set.add("aaa");set.add("bbb");set.add("ccc");set.add("ddd");set.add("aaa");System.out.println(set);//[aaa, ccc, bbb, ddd]  不允許存儲重復元素,是一個無序集合LinkedHashSet<String> linked = new LinkedHashSet<>();linked.add("aaa");linked.add("bbb");linked.add("ccc");linked.add("ddd");linked.add("aaa");System.out.println(linked);//[aaa, bbb, ccc, ddd] 不允許存儲重復元素,是一個有序集合}
}

3.TreeSet集合(使用)

package com.itheima.demo06Set;import java.util.Comparator;
import java.util.TreeSet;/*java.util.TreeSet<E>集合 implements Set<E>接口基于Set接口的紅黑樹的實現使用元素的自然順序對元素進行排序(內部會使用Comparator比較器對元素進行默認的升序排序)或者根據創建TreeSet集合時提供的 Comparator 進行排序，具體取決于使用的構造方法。構造方法:TreeSet() 構造一個新的空 set，該 set 根據其元素的自然順序進行排序。TreeSet(Comparator<? super E> comparator) 構造一個新的空 TreeSet，它根據指定比較器進行排序。TreeSet集合特點:1.不允許存儲重復元素2.沒有帶索引的方法3.底層是一個紅黑樹結構(元素是有序的)4.可以根據比較器產生的規則對元素進行排序*/
public class Demo02TreeSet {public static void main(String[] args) {//使用空參數構造方法創建TreeSet集合對象TreeSet<Integer> set1 = new TreeSet<>();set1.add(100);set1.add(1);set1.add(-100);set1.add(88);set1.add(66);set1.add(77);set1.add(11);System.out.println(set1);//[-100, 1, 11, 66, 77, 88, 100]//使用帶比較器的構造方法創建TreeSet集合對象TreeSet<Integer> set2 = new TreeSet<>(new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {//o1-o2:升序  o2-o1:降序return o2-o1;}});set2.add(100);set2.add(1);set2.add(-100);set2.add(88);set2.add(66);set2.add(77);set2.add(11);System.out.println(set2);//[100, 88, 77, 66, 11, 1, -100]}
}