枚舉

什么是枚舉

• 枚舉是逐一列舉的意思，枚舉的作用是進行取值的規范和分類。
• 有限數據的集合，可以使用枚舉表示，比如性別，季節，星期，月份等數據。

定義枚舉的格式：

public enum 枚舉名稱{枚舉1，枚舉2，枚舉3...; } //舉例（表示季節的枚舉類） public enum Season{SPRING,SUMMER,AUTUMN,WINTER; }

訪問枚舉值：

//枚舉名.枚舉值; Season.SPRING

案例：季節枚舉

//1.定義枚舉 package com.demo_05枚舉;public enum Season {SPRING,SUMER,AUTUMN,WINTER; }//2. package com.demo_05枚舉;public class MyCalendar {private int year;private int mouth;private int data;private Season season;public MyCalendar(int year, int mouth, int data, Season season) { this.year = year;this.mouth = mouth;this.data = data;this.season = season;}public void show(){System.out.println(year+"年"+mouth+"月"+data+"日"+season);} }//3.測試類 package com.demo_05枚舉;public class Demo {public static void main(String[] args) {MyCalendar m = new MyCalendar(2022,07,10, Season.SPRING);m.show();} }

1. 異常

1.1 異常的概述

Error：嚴重問題，不需要處理
Exception：稱為異常類，它表示程序本身可以處理的問題

• RuntimeException：在編譯期是不檢查的，出現問題后，需要我們回來修改代碼
• 非RuntimeException：編譯期就必須處理的，否則程序不能粉通過編譯，就更不能正常運行了

1.2 JVM的默認處理方案

如果程序出現了問題，我們沒有做任何處理，最終JVM會做默認的處理

• 把異常的名稱，異常原因及異常出現的位置等信息輸出在了控制臺
• 程序停止執行

1.3 異常處理try…catch…

• 格式：

try{//可能出現異常的代碼 }catch（異常類名 變量名）{//異常的處理代碼 }

• 執行流程

程序從try里面的代碼開始執行

出現異常，會自動生成一個異常類對象，該異常對象將被提交給Java運行時系統

當Java運行時系統接收到異常對象時，會到catch中去找匹的異常類，找到后進行異常的處理

執行完畢之后，程序還可以繼續往下執行

package demo_01;/*try{可能出現異常的代碼 }catch（異常類名 變量名）{異常的處理代碼 }*/ public class ExceptionDemo {public static void main(String[] args) {System.out.println("開始");method();System.out.println("結束");}public static void method() {int[] arr = {15, 22, 66, 88};try {System.out.println(arr[4]); //ArrayIndexOutOfBoundsException}catch(ArrayIndexOutOfBoundsException e){ //new ArrayIndexOutOfBoundsExceptionSystem.out.println("訪問的索引越界");e.printStackTrace();}} }

1.4 Throwable的成員方法

方法名說明

public String getMessage()	返回此throwable的詳細消息字符串
public String toString()	返回此可拋出的簡短描述
public void printStackTrace()	把異常的錯誤信息輸出在控制臺

package demo_01;/*try{可能出現異常的代碼 }catch（異常類名 變量名）{異常的處理代碼 }*/ public class ExceptionDemo {public static void main(String[] args) {System.out.println("開始");method();System.out.println("結束");}public static void method() {int[] arr = {15, 22, 66, 88};try {System.out.println(arr[4]); //ArrayIndexOutOfBoundsException} catch (ArrayIndexOutOfBoundsException e) { //new ArrayIndexOutOfBoundsException//public String toString()返回此可拋出的簡短描述System.out.println(e.toString());System.out.println("------------");//public String getMessage()返回此throwable的詳細消息字符串System.out.println(e.getMessage());System.out.println("------------");//public void printStackTrace()把異常的錯誤信息輸出在控制臺e.printStackTrace();}} } //運行結果 開始 java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 4 ------------ Index 4 out of bounds for length 4 ------------ 結束 java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 4at demo_01.ExceptionDemo.method(ExceptionDemo.java:18)at demo_01.ExceptionDemo.main(ExceptionDemo.java:11)

1.5 編譯時異常和運行時異常的區別

Java中的異常被分為兩大類：編譯時異常和運行時異常，也被稱為受檢異常和非受檢異常
所有的RuntimeException類及其子類被稱為運行時異常，其他的異常都是編譯時異常

• 編譯時異常：必須顯示處理，否則程序就會發生錯誤，無法通過編譯
• 運行時異常：無需顯示處理，也可以和編譯時異常一樣處理

package demo_01;import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date;public class ExceptionDemo_02 {public static void main(String[] args) {method();method2();}//編譯時異常public static void method() {try {String s = "2022-04-24";SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");Date d = sdf.parse(s);System.out.println(d);} catch (ParseException e) {e.printStackTrace();}}//運行異常public static void method2() {try {int[] arr = {55, 88, 99};System.out.println(arr[3]); //ArrayIndexOutOfBoundsException} catch (ArrayIndexOutOfBoundsException e) {System.out.println("訪問索引越界");}} }

1.6 異常處理之throws

雖然我們通過try…catch…可以對異常進行處理，但是并不是所有的情況我們都有權限進行異常的處理
也就是說，有些時候可能出現的異常是我們處理不了的，這個時候該怎么辦呢？
針對這種情況，Java提供了throws的處理方案

• 格式：

throws 異常類名;

注意：這個格式是跟在方法的括號后面的

• 編譯時異常必須要進行處理，兩種處理方案：try…catch…或者throws,如果采用throws這種方案，將來誰調用誰處理
• 運行時異常可以不處理，出現問題后，需要我們回來修改代碼

package demo_01;import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; /*throws 異常類名;這個格式跟在方法名的后面 */ public class ThrowsDemo {public static void main(String[] args) {System.out.println("開始");try {method();} catch (ParseException e) {e.printStackTrace();}System.out.println("結束");}//拋出異常等待調用者去處理 throws ParseException//編譯時異常public static void method() throws ParseException {String s = "2022-04-24";SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");Date d = sdf.parse(s);System.out.println(d);} }

1.7 throw關鍵字

Java中提供了throw關鍵字，可以在程序運行過程中，拋出某種特定的異常。

格式：throw new異常類名(); // 注意：throw異常以后，后面的代碼將停止執行

產生異常的意義

• 在方法中，當傳遞的參數有誤，程序沒有運行下去的意義時，可以直接拋出異常，結束方法
• 告知調用者方法中出現了問題，讓調用者修改代碼邏輯

public class Demo1 {public static void main(String[] args) {getResule(10,0);//調用testtry {test(10,0);} catch (Exception e) {e.printStackTrace();}}//throw是在內部的方法，根據業務情況，產生某種異常，讓程序停止public static int getResule(int a,int b){if (b!=0){return a / b;}else {//產生運行時異常，和return效果一樣，都可以讓方法停止，但是作用不一樣，throw是告知使用者代碼有問題，throw new RuntimeException("除數不能為0");}}public static int test(int a,int b) throws Exception{if (b!=0){return a / b;}else {//產生編譯時異常，需要在方法上面做聲明throw new Exception("除數不能為0");}}

1. 8 throws和throw的區別

throwsthrow

用在方法聲明后面，跟的是異常類名	用在方法體內，跟的是異常對象名
表示拋出異常，由該方法的調用者來處理	表示拋出異常，由方法體內的語句處理
表示出現異常的一種可能性，并不一定會發生這些異常	執行throw一定拋出了某種異常

1.9 自定義異常

• 格式

//格式 public class 異常類名 extends Exception{//無參構造//帶參構造 } //范例 public class ScoreException extends Exception{public ScoreException(){}public ScoreException(String message){super(message);} } //1. package scoreDemo;public class ScoreException extends Exception{public ScoreException() {}public ScoreException(String message) {super(message);} }//2. package scoreDemo;public class Teacher {public void checkScore(int score) throws ScoreException{if (score<0||score>100){throw new ScoreException("分數輸入的不正確");}else {System.out.println("分數正確");}} }//3. package scoreDemo;import java.util.Scanner;public class TeacherDemo {public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.print("請輸入分數：");int score = sc.nextInt();Teacher t= new Teacher();try {t.checkScore(score);} catch (ScoreException e) {e.printStackTrace();}} } //運行結果 請輸入分數：98 分數正確請輸入分數：150 scoreDemo.ScoreException: 分數輸入的不正確at scoreDemo.Teacher.checkScore(Teacher.java:6)at scoreDemo.TeacherDemo.main(TeacherDemo.java:13)

2.Collection

集合的特點：提供一種存儲空間可變的存儲模型，存儲的數據容量可以隨時發生改變

2.1 集合體系結構

2.2 Collection集合概述和使用

Collection集合概述

• 是單列集合的頂層接口，它表示一組對象，這些對象也稱為Collection的元素
• JDK不提供此接口的任何直接實現，它提供更具體的子接口（如Set和List)實現

創建Collection集合的對象

• 多態的方式
• 具體的實現類ArrayList

package collectionDemo_01;import java.util.ArrayList; import java.util.Collection;/* 創建Collection集合對象 多態的方式 */public class CollectionDemo {public static void main(String[] args) {Collection<String> c = new ArrayList<String>();c.add("張三");c.add("李四");c.add("王五");System.out.println(c);} } //運行結果 [張三, 李四, 王五]

2.3 Collection集合常用方法

方法名說明

boolean add(E e)	添加元素
boolean remove(Object o)	從集合中移除指定的元素
void clear()	清空集合中的元素
boolean contains(Object o)	判斷集合中是否存在指定的元素
boolean isEmpty()	判斷集合是否為空
int size()	集合的長度，也就是集合中元素的個數

2.4 Collection集合的遍歷

Iterator:迭代器，集合的專用遍歷方式

• Iterator iterator():返回此集合中元素的迭代器，通過集合的iterator()方法得到
• 迭代器是通過集合的iterator()方法得到的，所以我們說它是依賴于集合而存在的

Iterator中的常用方法

• E next():返回迭代中的下一個元素
• boolean hasNext():如果迭代具有更多元素，則返回true

package collectionDemo_01;import java.util.ArrayList; import java.util.Collection; import java.util.Iterator;/* 創建Collection集合對象 多態的方式 */public class CollectionDemo {public static void main(String[] args) {Collection<String> c = new ArrayList<String>();c.add("張三");c.add("李四");c.add("王五");Iterator<String> it = c.iterator();//用while循環改進判斷while(it.hasNext()){String n = it.next();System.out.println(n);}} } //運行結果 張三 李四 王五

2.5 集合的使用步驟

2.6 Collection集合存儲學生對象并遍歷

需求：創建一個存儲學生對象的集合，存儲3個學生對像，使用程序實現在控制臺遍歷該集合

思路：
①定義學生類
②創建Collection集合對像
③創建學生對象
④把學生添加到集合
⑤遍歷集合（迭代器方式）

//1.定義學生類 package demo_02;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;} }//2.測試類 package demo_02;import java.util.ArrayList; import java.util.Collection; import java.util.Iterator;public class CollectionDemo {public static void main(String[] args) {//創建Colection集合對象Collection<Student> c = new ArrayList<Student>();//創建學生對象Student sc1 = new Student("張三", 18);Student sc2 = new Student("李四", 19);Student sc3 = new Student("王五", 10);//把學生添加到集合c.add(sc1);c.add(sc2);c.add(sc3);//遍歷集合（迭代器方式）Iterator<Student> it = c.iterator();while(it.hasNext()){Student n = it.next();System.out.println(n.getName()+", "+n.getAge());}} } //運行結果 張三, 18 李四, 19 王五, 10

3. List

3.1 List集合概述和特點

List集合概述：

• 有序集合（也稱為序列），用戶可以精確控制列表中每個元素的插入位置。用戶可以通過整數索引訪問元素，并搜索列表中的元素
• 與Set集合不同，列表通常允許重復的元素

List集合特點：

• 有序：存儲和取出的元素順序一致
• 可重復：存儲的元素可以重復

package listDemo_03;/*List集合特點：有序：存儲和取出的元素順序一致可重復：存儲的元素可以重復*/import java.util.ArrayList; import java.util.Iterator; import java.util.List;public class ListDemo {public static void main(String[] args) {//創建集合對象List<String> list = new ArrayList<>();//添加元素list.add("張三");list.add("李四");list.add("王五");list.add("王五");//輸出集合對象System.out.println(list);//迭代器遍歷集合Iterator<String> it = list.iterator();while (it.hasNext()) {String s = it.next();System.out.println(s);}} } //運行結果 [張三, 李四, 王五, 王五] 張三 李四 王五 王五

3.2 List集合特有方法

方法名說明

void add(int index,E element)	在此集合中的指定位置插入指定的元素
E remove(int index)	刪除指定索引處的元素，返回被刪除的元素
E set(int index,E element)	修改指定索引處的元素，返回被修改的元素
E get(int index)	返回指定索引處的元素

3.3 list集合存儲學生對象并遍歷

需求：創建一個存儲學生對象的集合，存儲3個學生對像，使用程序實現在控制臺遍歷該集合
思路：
①定義學生類
②創建List集合對象
③創建學生對象
④把學生添加到集合
⑤遍歷集合（迭代器方式，for循環方式）

//1.創建學生對象 package demo_02;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;} }//2.測試類 package demo_02;import java.util.ArrayList; import java.util.Iterator; import java.util.List;/*List集合特點：有序：存儲和取出的元素順序一致可重復：存儲的元素可以重復*/public class ListDemo {public static void main(String[] args) {//創建list集合List<Student> list = new ArrayList<>();//創建學生對象Student sc1 = new Student("張三", 18);Student sc2 = new Student("李四", 19);Student sc3 = new Student("王五", 10);//把學生添加到集合list.add(sc1);list.add(sc2);list.add(sc3);//遍歷集合（迭代器方式）Iterator<Student> it = list.iterator();while(it.hasNext()){Student n = it.next();System.out.println(n.getName()+", "+n.getAge());}System.out.println("------------");//for循環遍歷for (int i = 0;i<list.size(); i++){Student s = list.get(i);System.out.println(s.getName()+", "+s.getAge());}} } //運行結果 張三, 18 李四, 19 王五, 10 ------------ 張三, 18 李四, 19 王五, 10

3.4 Listlterator

Listlterator:列表迭代器

• 通過List集合的listlterator()方法得到，所以說它是List集合特有的迭代器
• 用于允許程序員沿任一方向遍歷列表的列表迭代器，在迭代期間修改列表，并獲取巧列表中迭代器的當前位置

Listlterator中的常用方法：

方法名說明

E next()	返回迭代中的下一個元素
boolean hasNext()	如果迭代具有更多元素，則返回true
E previous()	返回列表中的上一個元素
boolean hasPrevious()	如果此列表迭代器在相反方向遍歷列表時具有更多元素，則返回true
void add(E e)	將指定的元素插入列表

package listDemo_03;import java.util.ArrayList; import java.util.List; import java.util.ListIterator;public class ListIteratorDemo {public static void main(String[] args) {//創建集合對象List<String> list = new ArrayList<>();//添加元素list.add("張三");list.add("李四");list.add("王五");//通過list集合的listIterator()方法得到ListIterator<String> lit = list.listIterator();while (lit.hasNext()){String n = lit.next();System.out.println(n);}System.out.println("----------");//反向遍歷while (lit.hasPrevious()){String b = lit.previous();System.out.println(b);}} } //運行結果 張三 李四 王五 ---------- 王五 李四 張三

3.5 增強for循環

增強for:簡化數組和Collection集合的遍歷

• 實現Iterable接口的類允許其對象成為增強型for語句的目標
• 它是DKS之后出現的，其內部原理是一個lterator迭代器

增強for的格式：

//格式： for(元素數據類型變量名:數組或者Collection集合){//在此處使用變量即可，該變量就是元素 }//范例： int[] arr={1,2,3,4,5}; for(int i:arr）{System.out.printIn(i) }

3.6 案例：List集合存儲學生對像用三種方式遍歷

需求：創建一個存儲學生對象的集合，存儲3個學生對像，使用程序實現在控制臺遍歷該集合
思路：
①定義學生類
②創建List集合對象
③創建學生對象
④把學生添加到集合
⑤遍歷集合
迭代器：集合特有的遍歷方式
普通for:帶有索引的遍歷方式
增強for:最方使的遍歷方式

//1.創建學生類 package demo_02;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;} }//2.測試類 package demo_02;import java.util.ArrayList; import java.util.Iterator; import java.util.List;/*List集合特點：有序：存儲和取出的元素順序一致可重復：存儲的元素可以重復*/public class ListDemo {public static void main(String[] args) {//創建list集合List<Student> list = new ArrayList<>();//創建學生對象Student sc1 = new Student("張三", 18);Student sc2 = new Student("李四", 19);Student sc3 = new Student("王五", 10);//把學生添加到集合list.add(sc1);list.add(sc2);list.add(sc3);//遍歷集合（迭代器方式）Iterator<Student> it = list.iterator();while (it.hasNext()) {Student n = it.next();System.out.println(n.getName() + ", " + n.getAge());}System.out.println("------------");//for循環遍歷for (int i = 0; i < list.size(); i++) {Student s = list.get(i);System.out.println(s.getName() + ", " + s.getAge());}System.out.println("------------");//增強for循環for (Student sc : list) {System.out.println(sc.getName() + ", " + sc.getAge());}} } //3.運行結果 張三, 18 李四, 19 王五, 10 ------------ 張三, 18 李四, 19 王五, 10 ------------ 張三, 18 李四, 19 王五, 10

3.7 數據結構

• 數據結構是計算機存儲、組織數據的方式。是指相互之間存在一種或多種特定關系的數據元素的集合
• 通常情況下，精心選擇的數據結構可以帶來更高的運行或者存儲效率

3.8 常見數據結構之棧

• 數據進入棧模型的過程稱為：壓/進棧
• 數據離開棧模型的過程稱為：彈/出棧
• 棧是一種數據先進后出的模型

3.9 常見數據結構之隊列

• 數據從后端進入隊列模型的過程稱為：入隊列
• 數據從前端離開隊列模型的過程稱為：出隊列
• 隊列是一種數據先進先出的模型

3.10 常見數據結構之數組

• 數組是一種查詢快，增刪慢的模型
• 查詢數據通過索引定位，查詢任意數據耗時相同，查詢效率高
• 刪除數據時，要將原始數據刪除，同時后面每個數據前移，刪除效率低
• 添加數據時，添加位置后的每個數據后移，再添加元素，添加效率極低
  

3.11 常見數據結構之鏈表

3.11.1 添加數據

在數據AC之間添加一個數據B，保存在地址54位置

在數據B對應的下一個數據地址指向數據C

在數據A對應的下一個數據地址指向數據B

3.11.2 刪除數據

在數據AC之間添加一個數據B,保存在地址54位置，刪除數據BD之間的數據C

數據B對應的下一個數據地址指向數據D

數據C刪除

3.11.3 鏈表查詢

• 查詢數據D是否存在，必須從頭(head)開始查詢
• 查詢第3個數據，必須從頭(head)開始查詢

鏈表是一種增刪快的模型（對比數組）

鏈表是一種查詢慢的模型（對比數組）

3.12 List集合子類特點

List集合常用子類：ArrayList, LinkedList

• ArrayList:：底層數據結構是數組，查詢快，增刪慢
• LinkedList:底層數據結構是鏈表，查詢慢，增刪快

練習：

分別使用ArrayLista和LinkedList完成存儲字符串并遍歷

package myList;import java.util.ArrayList; import java.util.LinkedList;public class ListDemo {public static void main(String[] args) {//創建ArrayList集合對象ArrayList<String> array= new ArrayList<String>();array.add("張三");array.add("李四");array.add("hello");//遍歷集合for (String s : array){System.out.println(s);}System.out.println("--------------");//創建LinkedList集合對象LinkedList<String> linkedList = new LinkedList<String>();linkedList.add("hello");linkedList.add("world");linkedList.add("java");//遍歷集合for (String c : linkedList){System.out.println(c);}} } //運行結果 張三 李四 hello -------------- hello world java

3.13 案例：ArrayList集合存儲學生對象用三種方式遍歷

需求：創建一個存儲學生對象的集合，存儲3個學生對像，使用程序實現在控制臺遍歷該集合
思路：
①定義學生類
②創建ArrayList集合對像
③創建學生對象
④把學生添加到集合
⑤遍歷集合
迭代器：集合特有的遍歷方式
普通for:帶有索引的遍歷方式
增強for:最方便的遍歷方式

//1.創建學生類 package demo_02;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;} }//2.測試類（創建ArrayList集合對象） package demo_02;import java.util.ArrayList; import java.util.Iterator;public class ArrayListDemo {public static void main(String[] args) {//創建ArrayList集合對象ArrayList<Student> array = new ArrayList<Student>();//創建學生對象Student sc1 = new Student("張三", 18);Student sc2 = new Student("李四", 19);Student sc3 = new Student("王五", 10);//把學生添加到集合array.add(sc1);array.add(sc2);array.add(sc3);//迭代器方式遍歷Iterator<Student> it = array.iterator();while (it.hasNext()){Student s = it.next();System.out.println(s.getName()+", "+ s.getAge());}System.out.println("-----------");//for循環遍歷for (int i = 0; i<array.size(); i++){Student s1 = array.get(i);System.out.println(s1.getName()+", "+ s1.getAge());}System.out.println("-----------");//增強forfor (Student s2 : array){System.out.println(s2.getName()+", "+ s2.getAge());}} } //運行結果 張三, 18 李四, 19 王五, 10 ----------- 張三, 18 李四, 19 王五, 10 ----------- 張三, 18 李四, 19 王五, 10

3.14 LinkedList集合的特有功能

方法名說明

public void addFirst(E e)	在該列表開頭插入指定的元素
public void addLast(E e)	將指定的元素追加到此列表的末尾
public E getFirst()	返回此列表中的第一個元素
public E getLast()	返回此列表中的最后一個元素
public E removeFirst()	從此列表中刪除并返回第一個元素
public E removeLast()	從此列表中刪除并返回最后一個元素

package myList;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 LinkdeListDemo {public static void main(String[] args) {//創建LinkdeList集合對象LinkedList<String> linkdeList = new LinkedList<String>();linkdeList.add("hello");linkdeList.add("world");linkdeList.add("java");/* public void addFirst(E e) 在該列表開頭插入指定的元素public void addLast(E e) 將指定的元素追加到此列表的末尾*/linkdeList.addFirst("javase");linkdeList.addLast("javaee");/* public E getFirst() 返回此列表中的第一個元素public E getLast() 返回此列表中的最后一個元素*/System.out.println(linkdeList.getFirst());System.out.println(linkdeList.getLast());/*public E removeFirst() 從此列表中刪除并返回第一個元素public E removeLast() 從此列表中刪除并返回最后一個元素*/System.out.println(linkdeList.removeFirst());System.out.println(linkdeList.removeLast());} } //運行結果 javase javaee javase javaee

4. set

4.1 set集合的概述和特點

Set集合特點

• 不包含重復元素的集合
• 沒有帶索引的方法，所以不能使用普通for循環遍歷

Set集合練習：

• 存儲字符串并遍歷

package demo_01;/* Set集合特點不包含重復元素的集合沒有帶索引的方法，所以不能使用普通o循環遍歷HashSet:對集合的迭代順序不作任何保證 */import java.util.HashSet; import java.util.Set;public class SetDemo {public static void main(String[] args) {//創建集合對象Set<String> set = new HashSet<String>();//添加元素set.add("hello");set.add("java");set.add("world");//不包含重復元素set.add("java");//遍歷for (String s : set) {System.out.println(s);}} } //運行結果 java world hello

4.2 哈希值

哈希值：是JDK根據對象的地址或者字符串或者數字算出來的int類型的數值

Object類中有一個方法可以獲取對象的哈希值

• public int hashCode():返回對象的哈希碼值

對象的哈希值特點

• 同一個對象多次調用hashCode()方法返回的哈希值是相同的
• 默認情況下，不同對象的哈希值是不同的。而重寫hashCode()方法，可以實現讓不同對象的哈希值相同

//1. package demo_02;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;}/* 重寫equals()和hashCode()方法@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;}*/ }//2. package demo_02;public class HashDemo {public static void main(String[] args) {//創建學生對象Student s1 = new Student("張三",18);//同一個對象多次調用HashCode()方法返回的哈希值是相同的System.out.println(s1.hashCode()); //1239731077System.out.println(s1.hashCode()); //1239731077Student s2 = new Student("張三",18);//默認情況下，不同對象的哈希值不同//通過方法重寫，可以實現不同對象的哈希值相同（重寫equals()和hashCode()方法）System.out.println(s2.hashCode()); //557041912System.out.println("-----------");System.out.println("java".hashCode()); //3254818System.out.println("world".hashCode()); //113318802System.out.println("java".hashCode()); //3254818System.out.println("-----------");System.out.println("重地".hashCode()); //1179395System.out.println("通話".hashCode()); //1179395} }

4.3 HashSet:集合概述和特點

HashSet集合特點：

• 底層數據結構是哈希表
• 對集合的迭代順序不作任何保證，也就是說不保證存儲和取出的元素順序一致
• 沒有帶索引的方法，所以不能使用普通for循環遍歷
• 由于是Set集合，所以是不包含重復元素的集合

HashSet集合練習：

• 存儲字符串并遍歷

package demo_03;import java.util.HashSet;public class HashSetDemo {public static void main(String[] args) {//創建集合對象HashSet<String> hs = new HashSet<String>();//添加元素hs.add("hello");hs.add("world");hs.add("java");//set集合，不包含重復的元素hs.add("world");//遍歷for (String s : hs) {System.out.println(s);}} } //運行結果 world java hello

4.4 常見數據結構之哈希表

哈希表

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

4.5 案例：HashSet集合存儲學生對像并遍歷

需求：創建一個存儲學生對象的集合，存儲多個學生對象，使用程序實現在控制臺遍歷該集合
要求：學生對象的成員變量值相同，我們就認為是同一個對像
思路：
①定義學生類
②創建HashSet集合對象
③創建學生對像
④把學生添加到集合
⑤遍歷集合（增強for)
⑥在學生類中重寫兩個方法
hashCode()和equals()
自動生成即可

//1. package demo_03;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;}//重寫equals()和hashCode()方法@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;} }//2. package demo_03;import java.util.HashSet;public class HashSetStuDemo {public static void main(String[] args) {//創建集合對象HashSet<Student> hs = new HashSet<Student>();//創建學生對象Student s1 =new Student("張三", 18);Student s2 =new Student("李四", 20);Student s3 =new Student("王五", 19);//重寫equals()和hashCode()方法，集合元素不會重復出現Student s4 =new Student("李四", 20);//添加學生元素到集合hs.add(s1);hs.add(s2);hs.add(s3);hs.add(s4);//遍歷for (Student sc:hs){System.out.println(sc.getName()+", "+sc.getAge());}} } //運行結果 王五, 19 張三, 18 李四, 20

4.6 LinkedHashSet:集合概述和特點

LinkedHashSet集合特點

• 哈希表和鏈表實現的Set接口，具有可預測的迭代次序
• 由鏈表保證元素有序，也就是說元素的存儲和取出順序是一致的
• 由哈希表保證元素唯一，也就是說沒有重復的元素

LinkedHashSet:集合練習

• 存儲字符串并遍歷

package demo_04;import java.util.LinkedHashSet;public class LinkedHashSetDemo {public static void main(String[] args) {//創建集合對象LinkedHashSet<String> linkedHashSet = new LinkedHashSet<String>();//添加元素linkedHashSet.add("hello");linkedHashSet.add("world");linkedHashSet.add("java");//哈希表保證元素的唯一性，也就是說沒有重復的元素linkedHashSet.add("world");//遍歷for (String s:linkedHashSet){System.out.println(s);}} } //運行結果 hello world java

4.7 TreeSet集合概述和特點

TreeSet:集合特點：

• 元素有序，這里的順序不是指存儲和取出的順序，而是按照一定的規則進行排序，具體排序方式取決于構造方法

? (1) TreeSet():根據其元素的自然排序進行排序

? (2) TreeSet(Comparator comparator):根據指定的比較器進行排序

• 沒有帶索引的方法，所以不能使用普通for循環遍歷
• 由于是Set集合，所以不包含重復元素的集合

TreeSet集合練習：

• 存儲整數并遍歷

package demo_05;import java.util.TreeSet;public class TreeSetDemo {public static void main(String[] args) {//創建集合對象TreeSet<Integer> treeSet = new TreeSet<Integer>();//TreeSet():根據其元素的自然排序進行排序//添加元素treeSet.add(10);treeSet.add(50);treeSet.add(30);treeSet.add(20);treeSet.add(40);//遍歷for (Integer s : treeSet) {System.out.println(s);}} } //運行結果 10 20 30 40 50

4.8 自然排序Comparable的使用

• 存儲學生對像并遍歷，創建TreeSet集合使用無參構造方法
• 要求：按照年齡從小到大排序，年齡相同時，按照姓名的字母順序排序

結論:

• 用TreeSet集合存儲自定義對像，無參構造方法使用的是自然排序對元素進行排序的
• 自然排序，就是讓元素所屬的類實現Comparable接口，重寫compareTo(To)方法
• 重寫方法時，一定要注意排序規則必須按照要求的主要條件和次要條件來寫

//1.學生對象 package demo_05; //該接口對實現它的每個類的對象強加一個整體排序。 這個排序被稱為類的自然排序 ，類的compareTo方法被稱為其自然比較方法 。 public class Student implements Comparable<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 int compareTo(Student s) {//return 0; 返回0表示元素重復，只會添加第一個元素，不會添加其他元素//return 1; 按照存儲的順序輸出（升序）//return -1; （降序）//按照年齡從小到大排序int num = this.age - s.age; //(升序)//int num = s.age - this.age;(降序)//年齡相同時，按照姓名的字母順序排序int num2 = num == 0?this.name.compareTo(s.name):num;return num2;} }//2.測試類 package demo_05;import java.util.TreeSet; /* 存儲學生對像并遍歷，創建TreeSet集合使用無參構造方法 要求：按照年齡從小到大排序，年齡相同時，按照姓名的字母順序排序 */ public class TreeSetDemo02 {public static void main(String[] args) {//創建集合對象TreeSet<Student> ts = new TreeSet<Student>();//創建學生對象Student s1 = new Student("xishi", 18);Student s2 = new Student("wangzhaojun", 19);Student s3 = new Student("diaochan", 20);Student s4 = new Student("yangyuhuan", 16);Student s5 = new Student("chenghanhan", 20);//學生對象添加到集合ts.add(s1);ts.add(s2);ts.add(s3);ts.add(s4);ts.add(s5);//遍歷for (Student s : ts) {System.out.println(s.getName() + ", " + s.getAge());}} } //運行結果 yangyuhuan, 16 xishi, 18 wangzhaojun, 19 chenghanhan, 20 diaochan, 20

4.9 比較器排序Comparator的使用

• 存儲學生對象并遍歷，創建TreeSet集合使用帶參構造方法
• 要求：按照年齡從小到大排序，年齡相同時，按姓名的字母順序排序

結論：

• 用TreeSet集合存儲自定義對象，帶參構造方法使用的是比較器排序對元素進行排序的
• 比較器排序，就是讓集合構造方法接收Comparator的實現類對象，重寫compare(To1,To2)方法
• 重寫方法時，一定要注意排序規則必須按照要求的主要條件和次要條件來寫

//1.創建學生類 package demo_06;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;} }//2.測試類 package demo_06;import java.util.Comparator; import java.util.TreeSet; /* - 存儲學生對象并遍歷，創建TreeSet集合使用帶參構造方法 - 要求：按照年齡從小到大排序，年齡相同時，按姓名的字母順序排序 */ public class TreeSetDemo {public static void main(String[] args) {//創建集合對象TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {//創建匿名對象@Overridepublic int compare(Student o1, Student o2) {//按照年齡從小到大排序int num = o1.getAge() - o2.getAge();//年齡相同時，按姓名的字母順序排序int num2 = num == 0?o1.getName().compareTo(o2.getName()):num;return num2;}});//創建學生對象Student s1 = new Student("xishi", 18);Student s2 = new Student("wangzhaojun", 19);Student s3 = new Student("diaochan", 20);Student s4 = new Student("yangyuhuan",22);Student s5 = new Student("chenghanhan", 20);//學生對象添加到集合ts.add(s1);ts.add(s2);ts.add(s3);ts.add(s4);ts.add(s5);//遍歷for (Student s : ts) {System.out.println(s.getName() + ", " + s.getAge());}} } //運行結果 xishi, 18 wangzhaojun, 19 chenghanhan, 20 diaochan, 20 yangyuhuan, 22

4.10 案例：成績排序

• 需求：用TreeSet集合存儲多個學生信息（姓名，語文成績，數學成績，并遍歷該集合）
• 要求：按照總分從高到低出現

思路：

①定義學生類
②創建TreeSet集合對象，通過比較器排序進行排序
③創建學生對象
④把學生對象添加到集合
⑤遍歷集合

//1.創建學生類 package demo_07;public class Student {private String name;private int chinese;private int math;public Student() {}public Student(String name, int chinese, int math) {this.name = name;this.chinese = chinese;this.math = math;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getChinese() {return chinese;}public void setChinese(int chinese) {this.chinese = chinese;}public int getMath() {return math;}public void setMath(int math) {this.math = math;}public int sum(){ //求和方法return chinese+math;} }//2.測試類 package demo_07;import java.util.Comparator; import java.util.TreeSet; /* - 需求：用TreeSet:集合存儲多個學生信息（姓名，語文成績，數學成績，并遍歷該集合 - 要求：按照總分從高到低出現 */ public class TreeSetDemo {public static void main(String[] args) {//創建集合對象,通過比較器排序進行排序TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {@Overridepublic int compare(Student o1, Student o2) {int num = o1.sum() - o2.sum();int num2 = num == 0?o1.getName().compareTo(o2.getName()):num;return num2;}});//創建學生對象Student s1 = new Student("張三",98,99);Student s2 = new Student("李四",95,95);Student s3 = new Student("王五",95,99);Student s4 = new Student("小陳",98,100);Student s5 = new Student("小尚",100,99);Student s6 = new Student("逸樂",95,99);//添加學生對象到集合ts.add(s1);ts.add(s2);ts.add(s3);ts.add(s4);ts.add(s5);ts.add(s6);//遍歷for (Student s:ts){System.out.println(s.getName()+", "+s.getChinese()+", "+s.getMath()+", "+s.sum());}} } //運行結果 李四, 95, 95, 190 王五, 95, 99, 194 逸樂, 95, 99, 194 張三, 98, 99, 197 小陳, 98, 100, 198 小尚, 100, 99, 199

4.11 案例：不重復的隨機數

需求：編寫一個程序，獲取10個1-20之間的隨機數，要求隨機數不能重復，并在控制臺輸出

思路：

①創建Set集合對象
②創建隨機數對象
③判斷集合的長度是不是小于10
是：產生一個隨機數，添加到集合
回到3繼續
④遍歷集合

package demo_07;import java.util.HashSet; import java.util.Random; import java.util.Set; import java.util.TreeSet;public class SetDemo {public static void main(String[] args) {//創建集合對象//Set<Integer> set = new HashSet<Integer>();Set<Integer> set = new TreeSet<Integer>();//創建隨機數對象Random r = new Random();//判斷集合長度是否小于10while (set.size() < 10) {int num = r.nextInt(20) + 1;set.add(num);}//遍歷for (Integer i : set) {System.out.println(i);}} }

更多內容請訪問博主博客：逸樂的博客 - 今晚一起吃火鍋

文章如有紕漏請指出，整理不易多多包涵。

Java后續筆記將持續更新…

總結

以上是生活随笔為你收集整理的Java笔记 - 黑马程序员_04（枚举，异常，Collection，List，Set）的全部內容，希望文章能夠幫你解決所遇到的問題。

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