枚舉

什么是枚舉

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

定義枚舉的格式：

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

訪問枚舉值：

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

案例：季節(jié)枚舉

//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：嚴(yán)重問題，不需要處理
Exception：稱為異常類，它表示程序本身可以處理的問題

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

1.2 JVM的默認(rèn)處理方案

如果程序出現(xiàn)了問題，我們沒有做任何處理，最終JVM會做默認(rèn)的處理

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

1.3 異常處理try…catch…

• 格式：

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

• 執(zhí)行流程

程序從try里面的代碼開始執(zhí)行

出現(xiàn)異常，會自動生成一個異常類對象，該異常對象將被提交給Java運(yùn)行時系統(tǒng)

當(dāng)Java運(yùn)行時系統(tǒng)接收到異常對象時，會到catch中去找匹的異常類，找到后進(jìn)行異常的處理

執(zhí)行完畢之后，程序還可以繼續(xù)往下執(zhí)行

package demo_01;/*try{可能出現(xiàn)異常的代碼 }catch（異常類名 變量名）{異常的處理代碼 }*/ public class ExceptionDemo {public static void main(String[] args) {System.out.println("開始");method();System.out.println("結(jié)束");}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的詳細(xì)消息字符串
public String toString()	返回此可拋出的簡短描述
public void printStackTrace()	把異常的錯誤信息輸出在控制臺

package demo_01;/*try{可能出現(xiàn)異常的代碼 }catch（異常類名 變量名）{異常的處理代碼 }*/ public class ExceptionDemo {public static void main(String[] args) {System.out.println("開始");method();System.out.println("結(jié)束");}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的詳細(xì)消息字符串System.out.println(e.getMessage());System.out.println("------------");//public void printStackTrace()把異常的錯誤信息輸出在控制臺e.printStackTrace();}} } //運(yùn)行結(jié)果 開始 java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 4 ------------ Index 4 out of bounds for length 4 ------------ 結(jié)束 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 編譯時異常和運(yùn)行時異常的區(qū)別

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

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

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();}}//運(yùn)行異常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…可以對異常進(jìn)行處理，但是并不是所有的情況我們都有權(quán)限進(jìn)行異常的處理
也就是說，有些時候可能出現(xiàn)的異常是我們處理不了的，這個時候該怎么辦呢？
針對這種情況，Java提供了throws的處理方案

• 格式：

throws 異常類名;

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

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

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("結(jié)束");}//拋出異常等待調(diào)用者去處理 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關(guān)鍵字

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

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

產(chǎn)生異常的意義

• 在方法中，當(dāng)傳遞的參數(shù)有誤，程序沒有運(yùn)行下去的意義時，可以直接拋出異常，結(jié)束方法
• 告知調(diào)用者方法中出現(xiàn)了問題，讓調(diào)用者修改代碼邏輯

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

1. 8 throws和throw的區(qū)別

throwsthrow

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

1.9 自定義異常

• 格式

//格式 public class 異常類名 extends Exception{//無參構(gòu)造//帶參構(gòu)造 } //范例 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("分?jǐn)?shù)輸入的不正確");}else {System.out.println("分?jǐn)?shù)正確");}} }//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("請輸入分?jǐn)?shù)：");int score = sc.nextInt();Teacher t= new Teacher();try {t.checkScore(score);} catch (ScoreException e) {e.printStackTrace();}} } //運(yùn)行結(jié)果 請輸入分?jǐn)?shù)：98 分?jǐn)?shù)正確請輸入分?jǐn)?shù)：150 scoreDemo.ScoreException: 分?jǐn)?shù)輸入的不正確at scoreDemo.Teacher.checkScore(Teacher.java:6)at scoreDemo.TeacherDemo.main(TeacherDemo.java:13)

2.Collection

集合的特點(diǎn)：提供一種存儲空間可變的存儲模型，存儲的數(shù)據(jù)容量可以隨時發(fā)生改變

2.1 集合體系結(jié)構(gòu)

2.2 Collection集合概述和使用

Collection集合概述

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

創(chuàng)建Collection集合的對象

• 多態(tài)的方式
• 具體的實(shí)現(xiàn)類ArrayList

package collectionDemo_01;import java.util.ArrayList; import java.util.Collection;/* 創(chuàng)建Collection集合對象 多態(tài)的方式 */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);} } //運(yùn)行結(jié)果 [張三, 李四, 王五]

2.3 Collection集合常用方法

方法名說明

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

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;/* 創(chuàng)建Collection集合對象 多態(tài)的方式 */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循環(huán)改進(jìn)判斷while(it.hasNext()){String n = it.next();System.out.println(n);}} } //運(yùn)行結(jié)果 張三 李四 王五

2.5 集合的使用步驟

2.6 Collection集合存儲學(xué)生對象并遍歷

需求：創(chuàng)建一個存儲學(xué)生對象的集合，存儲3個學(xué)生對像，使用程序?qū)崿F(xiàn)在控制臺遍歷該集合

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

//1.定義學(xué)生類 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) {//創(chuàng)建Colection集合對象Collection<Student> c = new ArrayList<Student>();//創(chuàng)建學(xué)生對象Student sc1 = new Student("張三", 18);Student sc2 = new Student("李四", 19);Student sc3 = new Student("王五", 10);//把學(xué)生添加到集合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());}} } //運(yùn)行結(jié)果 張三, 18 李四, 19 王五, 10

3. List

3.1 List集合概述和特點(diǎn)

List集合概述：

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

List集合特點(diǎn)：

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

package listDemo_03;/*List集合特點(diǎn)：有序：存儲和取出的元素順序一致可重復(fù)：存儲的元素可以重復(fù)*/import java.util.ArrayList; import java.util.Iterator; import java.util.List;public class ListDemo {public static void main(String[] args) {//創(chuàng)建集合對象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);}} } //運(yùn)行結(jié)果 [張三, 李四, 王五, 王五] 張三 李四 王五 王五

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集合存儲學(xué)生對象并遍歷

需求：創(chuàng)建一個存儲學(xué)生對象的集合，存儲3個學(xué)生對像，使用程序?qū)崿F(xiàn)在控制臺遍歷該集合
思路：
①定義學(xué)生類
②創(chuàng)建List集合對象
③創(chuàng)建學(xué)生對象
④把學(xué)生添加到集合
⑤遍歷集合（迭代器方式，for循環(huán)方式）

//1.創(chuàng)建學(xué)生對象 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集合特點(diǎn)：有序：存儲和取出的元素順序一致可重復(fù)：存儲的元素可以重復(fù)*/public class ListDemo {public static void main(String[] args) {//創(chuàng)建list集合List<Student> list = new ArrayList<>();//創(chuàng)建學(xué)生對象Student sc1 = new Student("張三", 18);Student sc2 = new Student("李四", 19);Student sc3 = new Student("王五", 10);//把學(xué)生添加到集合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循環(huán)遍歷for (int i = 0;i<list.size(); i++){Student s = list.get(i);System.out.println(s.getName()+", "+s.getAge());}} } //運(yùn)行結(jié)果 張三, 18 李四, 19 王五, 10 ------------ 張三, 18 李四, 19 王五, 10

3.4 Listlterator

Listlterator:列表迭代器

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

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) {//創(chuàng)建集合對象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);}} } //運(yùn)行結(jié)果 張三 李四 王五 ---------- 王五 李四 張三

3.5 增強(qiáng)for循環(huán)

增強(qiáng)for:簡化數(shù)組和Collection集合的遍歷

• 實(shí)現(xiàn)Iterable接口的類允許其對象成為增強(qiáng)型for語句的目標(biāo)
• 它是DKS之后出現(xiàn)的，其內(nèi)部原理是一個lterator迭代器

增強(qiáng)for的格式：

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

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

需求：創(chuàng)建一個存儲學(xué)生對象的集合，存儲3個學(xué)生對像，使用程序?qū)崿F(xiàn)在控制臺遍歷該集合
思路：
①定義學(xué)生類
②創(chuàng)建List集合對象
③創(chuàng)建學(xué)生對象
④把學(xué)生添加到集合
⑤遍歷集合
迭代器：集合特有的遍歷方式
普通for:帶有索引的遍歷方式
增強(qiáng)for:最方使的遍歷方式

//1.創(chuàng)建學(xué)生類 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集合特點(diǎn)：有序：存儲和取出的元素順序一致可重復(fù)：存儲的元素可以重復(fù)*/public class ListDemo {public static void main(String[] args) {//創(chuàng)建list集合List<Student> list = new ArrayList<>();//創(chuàng)建學(xué)生對象Student sc1 = new Student("張三", 18);Student sc2 = new Student("李四", 19);Student sc3 = new Student("王五", 10);//把學(xué)生添加到集合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循環(huán)遍歷for (int i = 0; i < list.size(); i++) {Student s = list.get(i);System.out.println(s.getName() + ", " + s.getAge());}System.out.println("------------");//增強(qiáng)for循環(huán)for (Student sc : list) {System.out.println(sc.getName() + ", " + sc.getAge());}} } //3.運(yùn)行結(jié)果 張三, 18 李四, 19 王五, 10 ------------ 張三, 18 李四, 19 王五, 10 ------------ 張三, 18 李四, 19 王五, 10

3.7 數(shù)據(jù)結(jié)構(gòu)

• 數(shù)據(jù)結(jié)構(gòu)是計算機(jī)存儲、組織數(shù)據(jù)的方式。是指相互之間存在一種或多種特定關(guān)系的數(shù)據(jù)元素的集合
• 通常情況下，精心選擇的數(shù)據(jù)結(jié)構(gòu)可以帶來更高的運(yùn)行或者存儲效率

3.8 常見數(shù)據(jù)結(jié)構(gòu)之棧

• 數(shù)據(jù)進(jìn)入棧模型的過程稱為：壓/進(jìn)棧
• 數(shù)據(jù)離開棧模型的過程稱為：彈/出棧
• 棧是一種數(shù)據(jù)先進(jìn)后出的模型

3.9 常見數(shù)據(jù)結(jié)構(gòu)之隊(duì)列

• 數(shù)據(jù)從后端進(jìn)入隊(duì)列模型的過程稱為：入隊(duì)列
• 數(shù)據(jù)從前端離開隊(duì)列模型的過程稱為：出隊(duì)列
• 隊(duì)列是一種數(shù)據(jù)先進(jìn)先出的模型

3.10 常見數(shù)據(jù)結(jié)構(gòu)之?dāng)?shù)組

• 數(shù)組是一種查詢快，增刪慢的模型
• 查詢數(shù)據(jù)通過索引定位，查詢?nèi)我鈹?shù)據(jù)耗時相同，查詢效率高
• 刪除數(shù)據(jù)時，要將原始數(shù)據(jù)刪除，同時后面每個數(shù)據(jù)前移，刪除效率低
• 添加數(shù)據(jù)時，添加位置后的每個數(shù)據(jù)后移，再添加元素，添加效率極低
  

3.11 常見數(shù)據(jù)結(jié)構(gòu)之鏈表

3.11.1 添加數(shù)據(jù)

在數(shù)據(jù)AC之間添加一個數(shù)據(jù)B，保存在地址54位置

在數(shù)據(jù)B對應(yīng)的下一個數(shù)據(jù)地址指向數(shù)據(jù)C

在數(shù)據(jù)A對應(yīng)的下一個數(shù)據(jù)地址指向數(shù)據(jù)B

3.11.2 刪除數(shù)據(jù)

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

數(shù)據(jù)B對應(yīng)的下一個數(shù)據(jù)地址指向數(shù)據(jù)D

數(shù)據(jù)C刪除

3.11.3 鏈表查詢

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

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

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

3.12 List集合子類特點(diǎn)

List集合常用子類：ArrayList, LinkedList

• ArrayList:：底層數(shù)據(jù)結(jié)構(gòu)是數(shù)組，查詢快，增刪慢
• LinkedList:底層數(shù)據(jù)結(jié)構(gòu)是鏈表，查詢慢，增刪快

練習(xí)：

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

package myList;import java.util.ArrayList; import java.util.LinkedList;public class ListDemo {public static void main(String[] args) {//創(chuàng)建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("--------------");//創(chuàng)建LinkedList集合對象LinkedList<String> linkedList = new LinkedList<String>();linkedList.add("hello");linkedList.add("world");linkedList.add("java");//遍歷集合for (String c : linkedList){System.out.println(c);}} } //運(yùn)行結(jié)果 張三 李四 hello -------------- hello world java

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

需求：創(chuàng)建一個存儲學(xué)生對象的集合，存儲3個學(xué)生對像，使用程序?qū)崿F(xiàn)在控制臺遍歷該集合
思路：
①定義學(xué)生類
②創(chuàng)建ArrayList集合對像
③創(chuàng)建學(xué)生對象
④把學(xué)生添加到集合
⑤遍歷集合
迭代器：集合特有的遍歷方式
普通for:帶有索引的遍歷方式
增強(qiáng)for:最方便的遍歷方式

//1.創(chuàng)建學(xué)生類 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.測試類（創(chuàng)建ArrayList集合對象） package demo_02;import java.util.ArrayList; import java.util.Iterator;public class ArrayListDemo {public static void main(String[] args) {//創(chuàng)建ArrayList集合對象ArrayList<Student> array = new ArrayList<Student>();//創(chuàng)建學(xué)生對象Student sc1 = new Student("張三", 18);Student sc2 = new Student("李四", 19);Student sc3 = new Student("王五", 10);//把學(xué)生添加到集合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循環(huán)遍歷for (int i = 0; i<array.size(); i++){Student s1 = array.get(i);System.out.println(s1.getName()+", "+ s1.getAge());}System.out.println("-----------");//增強(qiáng)forfor (Student s2 : array){System.out.println(s2.getName()+", "+ s2.getAge());}} } //運(yùn)行結(jié)果 張三, 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) {//創(chuàng)建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());} } //運(yùn)行結(jié)果 javase javaee javase javaee

4. set

4.1 set集合的概述和特點(diǎn)

Set集合特點(diǎn)

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

Set集合練習(xí)：

• 存儲字符串并遍歷

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

4.2 哈希值

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

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

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

對象的哈希值特點(diǎn)

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

//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) {//創(chuàng)建學(xué)生對象Student s1 = new Student("張三",18);//同一個對象多次調(diào)用HashCode()方法返回的哈希值是相同的System.out.println(s1.hashCode()); //1239731077System.out.println(s1.hashCode()); //1239731077Student s2 = new Student("張三",18);//默認(rèn)情況下，不同對象的哈希值不同//通過方法重寫，可以實(shí)現(xiàn)不同對象的哈希值相同（重寫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:集合概述和特點(diǎn)

HashSet集合特點(diǎn)：

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

HashSet集合練習(xí)：

• 存儲字符串并遍歷

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

4.4 常見數(shù)據(jù)結(jié)構(gòu)之哈希表

哈希表

• JDK8之前，底層采用數(shù)組+鏈表實(shí)現(xiàn)，可以說是一個元素為鏈表的數(shù)組
• JDK8以后，在長度比較長的時候，底層實(shí)現(xiàn)了優(yōu)化
  

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

需求：創(chuàng)建一個存儲學(xué)生對象的集合，存儲多個學(xué)生對象，使用程序?qū)崿F(xiàn)在控制臺遍歷該集合
要求：學(xué)生對象的成員變量值相同，我們就認(rèn)為是同一個對像
思路：
①定義學(xué)生類
②創(chuàng)建HashSet集合對象
③創(chuàng)建學(xué)生對像
④把學(xué)生添加到集合
⑤遍歷集合（增強(qiáng)for)
⑥在學(xué)生類中重寫兩個方法
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) {//創(chuàng)建集合對象HashSet<Student> hs = new HashSet<Student>();//創(chuàng)建學(xué)生對象Student s1 =new Student("張三", 18);Student s2 =new Student("李四", 20);Student s3 =new Student("王五", 19);//重寫equals()和hashCode()方法，集合元素不會重復(fù)出現(xiàn)Student s4 =new Student("李四", 20);//添加學(xué)生元素到集合hs.add(s1);hs.add(s2);hs.add(s3);hs.add(s4);//遍歷for (Student sc:hs){System.out.println(sc.getName()+", "+sc.getAge());}} } //運(yùn)行結(jié)果 王五, 19 張三, 18 李四, 20

4.6 LinkedHashSet:集合概述和特點(diǎn)

LinkedHashSet集合特點(diǎn)

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

LinkedHashSet:集合練習(xí)

• 存儲字符串并遍歷

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

4.7 TreeSet集合概述和特點(diǎn)

TreeSet:集合特點(diǎn)：

• 元素有序，這里的順序不是指存儲和取出的順序，而是按照一定的規(guī)則進(jìn)行排序，具體排序方式取決于構(gòu)造方法

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

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

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

TreeSet集合練習(xí)：

• 存儲整數(shù)并遍歷

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

4.8 自然排序Comparable的使用

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

結(jié)論:

• 用TreeSet集合存儲自定義對像，無參構(gòu)造方法使用的是自然排序?qū)υ剡M(jìn)行排序的
• 自然排序，就是讓元素所屬的類實(shí)現(xiàn)Comparable接口，重寫compareTo(To)方法
• 重寫方法時，一定要注意排序規(guī)則必須按照要求的主要條件和次要條件來寫

//1.學(xué)生對象 package demo_05; //該接口對實(shí)現(xiàn)它的每個類的對象強(qiáng)加一個整體排序。 這個排序被稱為類的自然排序 ，類的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表示元素重復(fù)，只會添加第一個元素，不會添加其他元素//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; /* 存儲學(xué)生對像并遍歷，創(chuàng)建TreeSet集合使用無參構(gòu)造方法 要求：按照年齡從小到大排序，年齡相同時，按照姓名的字母順序排序 */ public class TreeSetDemo02 {public static void main(String[] args) {//創(chuàng)建集合對象TreeSet<Student> ts = new TreeSet<Student>();//創(chuàng)建學(xué)生對象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);//學(xué)生對象添加到集合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());}} } //運(yùn)行結(jié)果 yangyuhuan, 16 xishi, 18 wangzhaojun, 19 chenghanhan, 20 diaochan, 20

4.9 比較器排序Comparator的使用

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

結(jié)論：

• 用TreeSet集合存儲自定義對象，帶參構(gòu)造方法使用的是比較器排序?qū)υ剡M(jìn)行排序的
• 比較器排序，就是讓集合構(gòu)造方法接收Comparator的實(shí)現(xiàn)類對象，重寫compare(To1,To2)方法
• 重寫方法時，一定要注意排序規(guī)則必須按照要求的主要條件和次要條件來寫

//1.創(chuàng)建學(xué)生類 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; /* - 存儲學(xué)生對象并遍歷，創(chuàng)建TreeSet集合使用帶參構(gòu)造方法 - 要求：按照年齡從小到大排序，年齡相同時，按姓名的字母順序排序 */ public class TreeSetDemo {public static void main(String[] args) {//創(chuàng)建集合對象TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {//創(chuàng)建匿名對象@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;}});//創(chuàng)建學(xué)生對象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);//學(xué)生對象添加到集合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());}} } //運(yùn)行結(jié)果 xishi, 18 wangzhaojun, 19 chenghanhan, 20 diaochan, 20 yangyuhuan, 22

4.10 案例：成績排序

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

思路：

①定義學(xué)生類
②創(chuàng)建TreeSet集合對象，通過比較器排序進(jìn)行排序
③創(chuàng)建學(xué)生對象
④把學(xué)生對象添加到集合
⑤遍歷集合

//1.創(chuàng)建學(xué)生類 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:集合存儲多個學(xué)生信息（姓名，語文成績，數(shù)學(xué)成績，并遍歷該集合 - 要求：按照總分從高到低出現(xiàn) */ public class TreeSetDemo {public static void main(String[] args) {//創(chuàng)建集合對象,通過比較器排序進(jìn)行排序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;}});//創(chuàng)建學(xué)生對象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);//添加學(xué)生對象到集合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());}} } //運(yùn)行結(jié)果 李四, 95, 95, 190 王五, 95, 99, 194 逸樂, 95, 99, 194 張三, 98, 99, 197 小陳, 98, 100, 198 小尚, 100, 99, 199

4.11 案例：不重復(fù)的隨機(jī)數(shù)

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

思路：

①創(chuàng)建Set集合對象
②創(chuàng)建隨機(jī)數(shù)對象
③判斷集合的長度是不是小于10
是：產(chǎn)生一個隨機(jī)數(shù)，添加到集合
回到3繼續(xù)
④遍歷集合

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) {//創(chuàng)建集合對象//Set<Integer> set = new HashSet<Integer>();Set<Integer> set = new TreeSet<Integer>();//創(chuàng)建隨機(jī)數(shù)對象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);}} }

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

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

Java后續(xù)筆記將持續(xù)更新…

總結(jié)

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

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。