基本數據類型
數據值是存儲在自己的空間中。
特點：賦值給其他變量，也是賦的真實的值。
引用數據類型
數據值是存儲在其他空間中，自己空間中存儲的是地址值。
特點：賦值給其他變量，賦的地址值。
綜合練習
使用 ctrl + alt + M 自動抽取方法
1.買飛機票
import java.util.Scanner;public class 買飛機票 {public static void main(String[] args) {// 機票價格按照淡季旺季、頭等艙和經濟艙收費、輸入機票原價、月份和頭等艙或經濟艙。// 按照如下規則計算機票價格：旺季（5-10 月）頭等艙 9 折，經濟艙 8.5 折，淡季（11 月到來年 4 頭）頭等艙 7 折，經濟艙 6.5 折。 */// 分析
// 1.鍵盤錄入機票原價、月份、頭等艙或經濟艙Scanner sc = new Scanner(System.in);System.out.println("請輸入機票的原價");int ticket = sc.nextInt();System.out.println("請輸入當前的月份");int month = sc.nextInt();System.out.println("請輸入當前購買的艙位 0頭等艙 1經濟艙");int seat = sc.nextInt();
// 2.先判斷月份是旺季還是淡季if (month >= 5 && month <= 10) {
// 旺季 繼續判斷當前機票是經濟艙還是頭等艙ticket = getPrice(seat, ticket, 0.9, 0.85);} else if ((month >= 1 && month <= 4) || (month >= 11 && month <= 12)) {
// 淡季ticket = getPrice(seat, ticket, 0.7, 0.65);} else {
// 表示鍵盤錄入的月份是一個非法數據System.out.println("鍵盤錄入的月份不合法");}System.out.println(ticket);}public static int getPrice(int seat, int ticket, double v0, double v1) {if (seat == 0) {
// 頭等艙ticket = (int) (ticket * v0);} else if (seat == 1) {
// 經濟艙ticket = (int) (ticket * v1);} else {System.out.println("沒有這個艙位");}return ticket;}
}
2.找質數
public class 找質數 {public static void main(String[] args) {
// 判斷 101 ~ 200 之間有多少個素數，并輸出所有素數int count = 0;for (int i = 101; i <= 200; i++) {//i 依次表示循環中的每一個數字//繼續判斷i是否為一個質數boolean flag = true;for (int j = 2; j < i; j++) {//j 表示2~99之間的每一個數字if (i % j == 0) {flag = false;break;}}if (flag) {System.out.println("當前數字" + i + "是質數");count++;}}System.out.println("一共有" + count + "個質數");}
}
3.開發驗證碼
import java.util.Random;public class 開發驗證碼 {public static void main(String[] args) {
/*
需求：
定義方法實現隨機產生一個 5 位的驗證碼
驗證碼格式：
長度為 5
前四位是大寫字母或者小寫字母
最后一位是數字
*/
// 1.大寫字母和小寫字母都放到數組當中char[] chs = new char[52];for (int i = 0; i < chs.length; i++) {
// ASCII碼表if (i <= 25) {
// 添加小寫字母chs[i] = (char) (97 + i);} else {
// 添加大寫字母chs[i] = (char) (65 + i - 26);}}
// 定義一個字符串類型的變量，用來記錄最終的結果String result = "";
// 2.隨機抽取四次Random r = new Random();for (int i = 0; i < 4; i++) {int randomIndex = r.nextInt(chs.length);
// 利用隨機索引，獲取對應的元素
// System.out.println(chs[randomIndex]);result += chs[randomIndex];}
// System.out.println(result);
// 3.隨機抽取一個數字0~9result += r.nextInt(10);System.out.println(result);}
}
4.數組元素的復制
public class 數組元素的復制 {public static void main(String[] args) {/* 需求：
把一個數組中的元素復制到另一個新數組中去。*/
// 分析：
//1. 定義一個老數組并存儲一些元素int[] arr = {1, 2, 3, 4, 5};
//2. 定義一個新數組的長度跟老數組一致int[] newArr = new int[arr.length];
//3. 遍歷老數組，得到老數組中的每一個元素，依次存入到新數組當中for (int i = 0; i < arr.length; i++) {newArr[i]=arr[i];}for (int i = 0; i < newArr.length; i++) {System.out.println(newArr[i]);}}
}
5.評委打分
選中一個變量 shift + F6 替換以下所有相同變量
import java.util.Scanner;public class 評委打分 {public static void main(String[] args) {// 在唱歌比賽中，有6名評委給選手打分，分數范圍是[0 - 100]之間的整數。// 選手的最后得分為：去掉最高分、最低分后的4個評委的平均分，請完成上述過程并計算出選手的得分。// 分析：
//1. 定義一個數組，用來存儲 6 名評委的打分（0~100）int[] scoreArr = getScores();for (int i = 0; i < scoreArr.length; i++) {System.out.println(scoreArr[i]);}
//2. 求出數組中的最大值int max = getMax(scoreArr);
//3. 求出數組中的最小值int min = getMin(scoreArr);
//4. 求出數組中 6 個分數的總和int sum = getSum(scoreArr);
//5.（總和 - 最大值 - 最小值 ）/4int avg = (sum - max - min) / (scoreArr.length - 2);
//6.打印結果System.out.println("選手的最總得分為" + avg);}public static int getSum(int[] scoreArr) {int sum = 0;for (int i = 0; i < scoreArr.length; i++) {sum = sum + scoreArr[i];}return sum;}//求數組的最大值public static int getMax(int[] scoreArr) {int max = scoreArr[0];for (int i = 1; i < scoreArr.length; i++) {if (scoreArr[i] > max) {max = scoreArr[i];}}return max;}//求數組的最小值public static int getMin(int[] scoreArr) {int min = scoreArr[0];for (int i = 1; i < scoreArr.length; i++) {if (scoreArr[i] < min) {min = scoreArr[i];}}return min;}public static int[] getScores() {//定義數組int[] scores = new int[6];//使用鍵盤錄入的形式，輸入分數：0~100Scanner sc = new Scanner(System.in);for (int i = 0; i < scores.length; ) {System.out.println("請輸入評委的打分");int score = sc.nextInt();if (score >= 0 && score <= 100) {scores[i] = score;i++;} else {System.out.println("成績超出了范圍，繼續錄入，當前的i為：" + i);}}return scores;}
}
6.數字加密
public class 數字加密 {public static void main(String[] args) {
/*
某系統的數字密碼（大于 0）。比如 1983，采用加密方式進行傳輸，規則如下：
每位數加上 5
再對 10 求余
最后將所有數字反轉
得到一串新數。
*///分析：
//1.把整數里面的每一位放到數組當中int[] arr = {1, 9, 8, 3};
//2.加密
//每位數加上5for (int i = 0; i < arr.length; i++) {arr[i] = arr[i] + 5;}
//再對10求余，for (int i = 0; i < arr.length; i++) {arr[i] = arr[i] % 10;}
//將所有數字反轉for (int i = 0, j = arr.length - 1; i < j; i++, j--) {int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}
//3.把數組里面的每一個數字進行拼接，變成加密之后的結果int number = 0;for (int i = 0; i < arr.length; i++) {number = number * 10 + arr[i];}System.out.println(number);}
}
7.數字解密
public class 數字解密 {public static void main(String[] args) {
/* 某系統的數字密碼（大于 0）。比如 1983，采用加密方式進行傳輸，
規則如下：
每位數加上 5
再對 10 求余，
最后將所有數字反轉，
得到一串新數。
按照以上規則進行解密：
比如 1983 加密之后變成 8346，解密之后變成 1983
*/
//1. 定義數組記錄解密之后的結果int[] arr = {8, 3, 4, 6};
//2. 反轉for (int i = 0, j = arr.length - 1; i < j; i++, j--) {int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}
//3.由于加密是通過對10取余的方式進行獲取的
//所以在解密的時候就需要判斷，0~4之間+10 5~9數字不變for (int i = 0; i < arr.length; i++) {if (arr[i] >= 0 && arr[i] <= 4) {arr[i] = arr[i] + 10;}}
//4.每一位減5for (int i = 0; i < arr.length; i++) {arr[i] = arr[i] - 5;}
//5.獲取數組里面的每一位數字拼接成最終的結果int number = 0;for (int i = 0; i < arr.length; i++) {number = number * 10 + arr[i];}System.out.println(number);}
}
8.搶紅包
import java.util.Random;public class 搶紅包 {public static void main(String[] args) {
/*
需求：
一個大 V 直播抽獎，獎品是現金紅包，分別有 {2, 588, 888, 1000, 10000} 五個獎金。
請使用代碼模擬抽獎，打印出每個獎項，獎項的出現順序要隨機且不重復。
打印效果如下：（隨機順序，不一定是下面的順序）
888 元的獎金被抽出
588 元的獎金被抽出
10000 元的獎金被抽出
1000 元的獎金被抽出
2 元的獎金被抽出
*///分析：
//1.定義數組表示獎池int[] arr = {2, 588, 888, 1000, 10000};
//2.定義新數組用于存儲抽獎的結果int[] newArr = new int[arr.length];
//3.抽獎Random r = new Random();
//因為有5個獎項，所以這里要循環5次for (int i = 0; i < 5; ) {//獲取隨機索引int randomIndex = r.nextInt(arr.length);//獲取獎項int prize = arr[randomIndex];//判斷當前的獎項是否存在，如果存在則重新抽取，如果不存在，就表示是有效獎項boolean flag = contains(newArr, prize);if(!flag){//把當前抽取到的獎項添加到newArr當中newArr[i] = prize;//添加完畢之后，移動索引i++;}}
//4.遍歷newArrfor (int i = 0; i < newArr.length; i++) {System.out.println(newArr[i]);}}
//判斷prize在數組當中是否存在
//存在：true
//不存在：falsepublic static boolean contains(int[] arr, int prize) {for (int i = 0; i < arr.length; i++) {if (arr[i] == prize) {return true;}}return false;}
}
代碼優化
import java.util.Random;public class 搶紅包代碼優化 {public static void main(String[] args) {
/*
需求：
一個大 V 直播抽獎，獎品是現金紅包，分別有 {2, 588, 888, 1000, 10000} 五個獎金。
請使用代碼模擬抽獎，打印出每個獎項，獎項的出現順序要隨機且不重復。
打印效果如下：（隨機順序，不一定是下面的順序）
888 元的獎金被抽出
588 元的獎金被抽出
10000 元的獎金被抽出
1000 元的獎金被抽出
2 元的獎金被抽出
*///1.把獎池里面的所有獎項打亂順序int[] arr = {2, 588, 888, 1000, 10000};Random r = new Random();for (int i = 0; i < arr.length; i++) {//獲取隨機索引int randomIndex = r.nextInt(arr.length);//拿著i跟隨機索引randomIndex上的值進行交換int temp = arr[i];arr[i] = arr[randomIndex];arr[randomIndex] = temp;}
//2.遍歷獎池，從0索引開始獲取每一個獎項for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);}}
}
9.雙色球彩票系統
import java.util.Random;
import java.util.Scanner;public class 雙色球彩票系統 {public static void main(String[] args) {
//1.生成中獎號碼int[] arr = createNumber();
//2.用戶輸入彩票號碼（紅球 + 藍球）int[] userInputArr = userInputNumber();
//3.判斷用戶的中獎情況
//紅球 藍球int redCount = 0;int blueCount = 0;//判斷紅球for (int i = 0; i < userInputArr.length - 1; i++) {int redNumber = userInputArr[i];for (int j = 0; j < arr.length - 1; j++) {if (redNumber == arr[j]) {redCount++;//如果找到了，那么后面的數字就沒有必要繼續比較了//跳出內循環，繼續判斷下一個紅球號碼是否中獎break;}}}//判斷藍球int blueNumber = userInputArr[userInputArr.length - 1];if (blueNumber == arr[arr.length - 1]) {blueCount++;}//根據紅球的個數以及藍球的個數來判斷中獎情況if(redCount == 6 && blueCount == 1){System.out.println("恭喜你，中獎1000萬");}else if(redCount == 6 && blueCount == 0){System.out.println("恭喜你，中獎500萬");}else if(redCount == 5 && blueCount == 1){System.out.println("恭喜你，中獎3000");}else if((redCount == 5 && blueCount == 0) || (redCount == 4 && blueCount == 1)){System.out.println("恭喜你，中獎200");}else if((redCount == 4 && blueCount == 0) || (redCount == 3 && blueCount == 1)){System.out.println("恭喜你，中獎10");}else if((redCount == 2 && blueCount == 1) || (redCount == 1 && blueCount == 1) || (redCount == 0 && blueCount == 1)){System.out.println("恭喜你，中獎5");}else{System.out.println("謝謝參與");}}public static int[] userInputNumber() {//1.創建數組用于添加用戶購買的彩票號碼//6個紅球 1個藍球 數組長度: 7int[] arr = new int[7];//2.利用鍵盤錄入讓用戶輸入Scanner sc = new Scanner(System.in);//讓用戶輸入紅球號碼for (int i = 0; i < 6; ) {System.out.println("請輸入第 " + (i + 1) + " 個紅球號碼");int redNumber = sc.nextInt();//redNumber在1~33 唯一不重復if (redNumber >= 1 && redNumber <= 33) {boolean flag = contains(arr, redNumber);if (!flag) {//不存在//有效的，可以添加到數組當中arr[i] = redNumber;i++;}} else {System.out.println("當前紅球號碼超出范圍");}}//讓用戶輸入藍球號碼System.out.println("請輸入藍球號碼");
//1~16while (true) {int blueNumber = sc.nextInt();if (blueNumber >= 1 && blueNumber <= 16) {arr[arr.length - 1] = blueNumber;break;} else {System.out.println("當前藍球號碼超出范圍");}}return arr;}public static int[] createNumber() {//1.創建數組用于添加中獎號碼//6個紅球 1個藍球 數組長度: 7int[] arr = new int[7];//2.隨機生成號碼并添加到數組當中//紅球: 不能重復的 1 2 3 4 5 6//藍球: 可以跟紅球號碼重復 5//生成紅球號碼并添加到數組當中Random r = new Random();for (int i = 0; i < 6; ) {//獲取紅球號碼int redNumber = r.nextInt(33) + 1;boolean flag = contains(arr, redNumber);if (!flag) {//把紅球號碼添加到數組當中arr[i] = redNumber;i++;}}//生成藍球號碼并添加到數組當中int blueNumber = r.nextInt(16) + 1;arr[arr.length - 1] = blueNumber;return arr;}//用于判斷數字在數組中是否存在public static boolean contains(int[] arr, int number) {for (int i = 0; i < arr.length; i++) {if (arr[i] == number) {return true;}}return false;}
}
10.二維數組
public class 二維數組 {public static void main(String[] args) {
// 二維數組的靜態初始化
// 格式：數據類型 [][] 數組名 = new 數據類型 [][]{{元素 1, 元素 2},{元素 1, 元素 2}};
// 范例：int [][] arr = new int [][]{{11,22},{33,44}};
// 簡化格式：數據類型 [][] 數組名 = {{元素 1, 元素 2},{元素 1, 元素 2}};
// 范例：int [][] arr = {{11,22},{33,44}};
// 范例：int arr [][] = {{11,22},{33,44}};//1.二維數組靜態初始化格式
//數據類型[][] 數組名 = new 數據類型[][]{{元素1,元素2},{元素1, 元素2}};int[][] arr1 = new int[][]{{1, 2, 3}, {4, 5, 6, 7, 8}};int[][] arr2 = {{1, 2, 3}, {4, 5, 6, 7, 8}};
//以后建議這樣定義，把每一個一維數組，單獨寫成一行
//注意：每一個一維數組其實是二維數組中的元素，所以每一個一維數組之間需要用逗號隔開。最后一個一維數組后面不需要加逗號int[][] arr3 = {{1, 2, 3},{4, 5, 6, 7, 8}};//2.獲取元素
//System.out.println(arr3[0]);//表示獲取二維數組中的第一個一維數組
//arr3[0]:二維數組中的第一個一維數組
//arr3[0][0]:獲取第一個一維數組中0索引的元素System.out.println(arr3[0][0]);//1//3、二維數組遍歷
//外循環：遍歷二維數組，得到里面的每一個一維數組for (int i = 0; i < arr3.length; i++) {//i: 表示二維數組中的每一個索引//arr3[i]: 表示二維數組中的每一個元素（一維數組）//內循環：遍歷一維數組，得到里面的每一個元素for (int j = 0; j < arr3[i].length; j++) {//j:表示一維數組中的每一個元素System.out.print(arr3[i][j] + " ");}System.out.println();}// 二維數組的動態初始化
// 格式：數據類型 [][] 數組名 = new 數據類型 [m][n];
// m 表示這個二維數組，可以存放多少個一維數組
// n 表示每一個一維數組，可以存放多少個元素
// 范例：int [][] arr = new int [2][3];
// 該數組可以存放 2 個一維數組，每個一維數組中可以存放 3 個 int 類型元素//1.利用動態初始化格式創建二維數組
//3:表示二維數組長度為3，可以裝3個一維數組
//5: 表示每一個一維數組的長度都是5，可以裝5個int類型的元素int[][] arr = new int[3][5];//給二維數組賦值一個元素arr[0][0] = 10;//遍歷二維數組
//外循環：遍歷二維數組獲取里面的每一個一維數組
//內循環：遍歷一維數組獲取每一個元素for (int i = 0; i < arr.length; i++) {for (int j = 0; j < arr[i].length; j++) {System.out.print(arr[i][j] + " ");}System.out.println();}}
}
面向對象
1.類和對象
類（設計圖）：是對象共同特征的描述 對象：是真實存在的具體東西 在 Java 中，必須先設計類，才能獲得對象
創建一個類
public class Phone {//屬性String brand;double price;//行為public void call(){System.out.println("手機在打電話");}public void playGame(){System.out.println("手機在玩游戲");}
}
使用?
// 如何得到類的對象 // 類名 對象名 = new 類名 (); // Phone p = new Phone();// 創建手機的對象Phone p = new Phone();// 如何使用對象 // 訪問屬性：對象名.成員變量 // 訪問行為：對象名.方法名 (...)//給手機賦值p.brand = "小米";p.price = 1999.98;//獲取手機對象中的值System.out.println(p.brand);System.out.println(p.price);//調用手機中的方法p.call();p.playGame();
定義類的補充注意事項 用來描述一類事物的類，專業叫做：Javabean 類。在 Javabean 類中，是不寫 main 方法的 在以前，編寫 main 方法的類，叫做測試類。我們可以在測試類中創建 javabean 類的對象并進行賦值調用
類名首字母建議大寫，需要見名知意，駝峰模式。 一個 Java 文件中可以定義多個 class 類，且只能一個類是 public 修飾，而且 public 修飾的類名必須成為代碼文件名。實際開發中建議還是一個文件定義一個 class 類。 成員變量的完整定義格式是：修飾符 數據類型 變量名稱 = 初始化值；一般無需指定初始化值，存在默認值。
2.封裝
1. 什么是封裝？ 告訴我們，如何正確設計對象的屬性和方法。 原則：對象代表什么，就得封裝對應的的數據，并提供數據對應的行為 2. 理解封裝思想的好處？ 讓編程變得很簡單，有什么事，找對象，調方法就行。 降低我們的學習成本，可以少學、少記，或者說壓根不用學，不用記對象有哪些方法，有需要時去找就行
private 關鍵字 是一個權限修飾符 可以修飾成員（成員變量和成員方法） 被 private 修飾的成員只能在本類中才能訪問
public class GirlFriend {private String name;private int age;private String gender;//針對于每一個私有化的成員變量，都要提供get和set方法//set方法：給成員變量賦值//get方法：對外提供成員變量的值//作用：給成員變量name進行賦值public void setName(String n){name = n;}//作用：對外提供name屬性public String getName(){return name;}public void setAge(int a){if(a >= 18 && a <= 50){age = a;}else{System.out.println("非法參數");}}public int getAge(){return age;}public void setGender(String g){gender = g;}public String getGender(){return gender;}
}
//創建女朋友的對象GirlFriend gf1 = new GirlFriend();
//使用類中的方法賦值gf1.setName("小詩詩");gf1.setAge(18);gf1.setGender("女");System.out.println(gf1.getName());System.out.println(gf1.getAge());System.out.println(gf1.getGender());
3.就近原則和this關鍵字
public class GirlFriend2 {//屬性private int age;//0 成員變量public void method() {int age = 10;//局部變量System.out.println(age);//10 只用age 就近原則System.out.println(this.age);//0}
}
4.構造方法
構造方法概述構造方法也叫作構造器、構造函數。作用：在創建對象的時候給成員變量進行賦值的。構造方法的格式public class Student {修飾符 類名(參數) {方法體;}}特點：方法名與類名相同，大小寫也要一致沒有返回值類型，連 void 都沒有沒有具體的返回值（不能由 return 帶回結果數據）執行時機：創建對象的時候由虛擬機調用，不能手動調用構造方法每創建一次對象，就會調用一次構造方法
public class Student {private String name;private int age;//如果我們自己沒有寫任何的構造方法
//那么虛擬機給我們加一個空參構造方法public Student(){System.out.println("看看我執行了嗎？");}
//帶參構造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;}
}
//創建對象
//Student s = new Student(); //調用的空參構造// 帶參構造Student s = new Student("zhangsan", 23);System.out.println(s.getName());System.out.println(s.getAge());
構造方法注意事項構造方法的定義如果沒有定義構造方法，系統將給出一個默認的無參數構造方法如果定義了構造方法，系統將不再提供默認的構造方法構造方法的重載帶參構造方法，和無參數構造方法，兩者方法名相同，但是參數不同，這叫做構造方法的重載推薦的使用方式無論是否使用，都手動書寫無參數構造方法，和帶全部參數的構造方法
5.標準的javabean類
標準的 JavaBean 類 ① 類名需要見名知意 ② 成員變量使用 private 修飾 ③ 提供至少兩個構造方法無參構造方法帶全部參數的構造方法 ④ 成員方法提供每一個成員變量對應的 setXxx ()/getXxx ()如果還有其他行為，也需要寫上
生成javabean類的快捷鍵：alt + insertalt + fn + insert
public class User {//屬性private String username;private String password;private String email;private String gender;private int age;public User() {}public User(String username, String password, String email, String gender, int age) {this.username = username;this.password = password;this.email = email;this.gender = gender;this.age = age;}public String getUsername() {return username;}public void setUsername(String username) {this.username = username;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}public String getEmail() {return email;}public void setEmail(String email) {this.email = email;}public String getGender() {return gender;}public void setGender(String gender) {this.gender = gender;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}
6.對象內存圖
Student s = new Student();1.加載 class 文件2.申明局部變量3.在堆內存中開辟一個空間4.默認初始化5.顯示初始化6.構造方法初始化7.將堆內存中的地址值賦值給左邊的局部變量
7.基本數據類型和引用數據類型
從內存的角度去解釋：基本數據類型：數據值是存儲在自己的空間中特點：賦值給其他變量，也是賦的真實的值。引用數據類型：數據值是存儲在其他空間中，自己空間中存儲的是地址值。特點：賦值給其他變量，賦的地址值。
8.this的內存原理
this 的本質：所在方法調用者的地址值
9.成員變量和局部變量
成員變量和局部變量的區別區別 成員變量 局部變量類中位置不同 類中，方法外 方法內、方法申明上初始化值不同 有默認初始化值 沒有，使用之前需要完成賦值內存位置不同 堆內存 棧內存生命周期不同 隨著對象的創建而存在，隨著對象的消失而消失 隨著方法的調用而存在，隨著方法的運行結束而消失作用域 整個類中有效 當前方法中有效
String name;//成員變量
public void study() {int i = 0;//局部變量System.out.println("好好學習");
}
public void doHomework() {int j = 0;//局部變量System.out.println("多做練習");
}
int age;//成員變量
面向對象綜合訓練
1.文字版格斗游戲
package 文字版格斗游戲.test2;import java.util.Random;public class Role {private String name;private int blood;private char gender;private String face;//長相是隨機的String[] boyfaces = {"風流俊雅", "氣宇軒昂", "相貌英俊", "五官端正", "相貌平平", "一塌糊涂", "面目猙獰"};String[] girlfaces = {"美奐絕倫", "沉魚落雁", "婷婷玉立", "身材嬌好", "相貌平平", "相貌簡陋", "慘不忍睹"};//attack 攻擊描述:String[] attacks_desc={"%s使出了一招【背心釘】，轉到對方的身后，一掌向%s背心的靈臺穴拍去。","%s使出了一招【游空探爪】，飛起身形自半空中變掌為抓鎖向%s。","%s大喝一聲，身形下伏，一招【劈雷墜地】，捶向%s雙腿。","%s運氣于掌，一瞬間掌心變得血紅，一式【掌心雷】，推向%s。","%s陰手翻起陽手跟進，一招【沒遮攔】，結結實實的捶向%s。","%s上步搶身，招中套招，一招【劈掛連環】，連環攻向%s。"};//injured 受傷描述:String[] injureds_desc={"結果%s退了半步，毫發無損","結果給%s造成一處瘀傷","結果一擊命中，%s痛得彎下腰","結果%s痛苦地悶哼了一聲，顯然受了點內傷","結果%s搖搖晃晃，一跤摔倒在地","結果%s臉色一下變得慘白，連退了好幾步","結果「轟」的一聲，%s口中鮮血狂噴而出","結果%s一聲慘叫，像灘軟泥般塌了下去"};public Role() {}public Role(String name, int blood,char gender) {this.name = name;this.blood = blood;this.gender = gender;//隨機長相setFace(gender);}public char getGender() {return gender;}public void setGender(char gender) {this.gender = gender;}public String getFace() {return face;}public void setFace(char gender) {Random r = new Random();//長相是隨機的if(gender == '男'){//從boyfaces里面隨機長相int index = r.nextInt(boyfaces.length);this.face = boyfaces[index];}else if(gender == '女'){//從girlfaces里面隨機長相int index = r.nextInt(girlfaces.length);this.face = girlfaces[index];}else{this.face = "面目猙獰";}}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getBlood() {return blood;}public void setBlood(int blood) {this.blood = blood;}//定義一個方法用于攻擊別人
//思考：誰攻擊誰？
//Role r1 = new Role();
//Role r2 = new Role();
//r1.攻擊(r2);
//方法的調用者去攻擊參數public void attack(Role role) {Random r = new Random();int index = r.nextInt(attacks_desc.length);String KungFu = attacks_desc[index];//輸出一個攻擊的效果System.out.printf(KungFu,this.getName(),role.getName());System.out.println();//計算造成的傷害 1 ~ 20int hurt = r.nextInt(20) + 1;//剩余血量int remainBlood = role.getBlood() - hurt;//對剩余血量做一個驗證，如果為負數了，就修改為0remainBlood = remainBlood < 0 ? 0 : remainBlood;//修改一下挨揍的人的血量role.setBlood(remainBlood);//受傷的描述//血量> 90 0索引的描述//80 ~ 90 1索引的描述//70 ~ 80 2索引的描述//60 ~ 70 3索引的描述//40 ~ 60 4索引的描述//20 ~ 40 5索引的描述//10 ~ 20 6索引的描述//小于10的 7索引的描述if (remainBlood > 90) {System.out.printf(injureds_desc[0], role.getName());} else if(remainBlood > 80 && remainBlood <= 90){System.out.printf(injureds_desc[1], role.getName());} else if(remainBlood > 70 && remainBlood <= 80){System.out.printf(injureds_desc[2], role.getName());} else if(remainBlood > 60 && remainBlood <= 70){System.out.printf(injureds_desc[3], role.getName());} else if(remainBlood > 40 && remainBlood <= 60){System.out.printf(injureds_desc[4], role.getName());} else if(remainBlood > 20 && remainBlood <= 40){System.out.printf(injureds_desc[5], role.getName());} else if(remainBlood > 10 && remainBlood <= 20){System.out.printf(injureds_desc[6], role.getName());} else{System.out.printf(injureds_desc[7], role.getName());}System.out.println();}public void showRoleInfo() {System.out.println("姓名為：" + getName());System.out.println("血量為：" + getBlood());System.out.println("性別為：" + getGender());System.out.println("長相為：" + getFace());}}
package 文字版格斗游戲.test2;public class GameTest {public static void main(String[] args) {//1.創建第一個角色Role r1 = new Role("喬峰", 100,'男');//2.創建第二個角色Role r2 = new Role("鳩摩智", 100,'男');//展示一下角色的信息r1.showRoleInfo();r2.showRoleInfo();//3.開始格斗 回合制游戲while(true){//r1開始攻擊r2r1.attack(r2);//判斷r2的剩余血量if(r2.getBlood() == 0){System.out.println(r1.getName() + " K.O了" + r2.getName());break;}//r2開始攻擊r1r2.attack(r1);if(r1.getBlood() == 0){System.out.println(r2.getName() + " K.O了" + r1.getName());break;}}}
}
2.兩個對象數組練習
test1
package 兩個對象數組練習.test1;public class Goods {private String id;private String name;private double price;private int count;public Goods() {}public Goods(String id, String name, double price, int count) {this.id = id;this.name = name;this.price = price;this.count = count;}public String getId() {return id;}public void setId(String id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public double getPrice() {return price;}public void setPrice(double price) {this.price = price;}public int getCount() {return count;}public void setCount(int count) {this.count = count;}
}
package 兩個對象數組練習.test1;public class GoodsTest {public static void main(String[] args) {
// 對象數組 1
// 定義數組存儲 3 個商品對象。
// 商品的屬性：商品的 id，名字，價格，庫存。
// 創建三個商品對象，并把商品對象存入到數組當中。//1.創建一個數組Goods[] arr = new Goods[3];//2.創建三個商品對象Goods g1 = new Goods("001", "華為P40", 5999.0, 100);Goods g2 = new Goods("002", "保溫杯", 227.0, 50);Goods g3 = new Goods("003", "枸杞", 12.7, 70);//3.把商品添加到數組中arr[0] = g1;arr[1] = g2;arr[2] = g3;//4.遍歷for (int i = 0; i < arr.length; i++) {//i 索引 arr[i] 元素Goods goods = arr[i];System.out.println(goods.getId() + ", " + goods.getName() + ", " + goods.getPrice() + ", " + goods.getCount());}}
}
鍵盤錄入
鍵盤錄入： 第一套體系: nextInt(); 接收整數 nextDouble();接收小數 next();接收字符串 遇到空格，制表符，回車就停止接受。這些符號后面的數據就不會接受了第二套體系: nextLine();接收字符串 可以接收空格，制表符，遇到回車才停止接受數據
Scanner sc = new Scanner(System.in);System.out.println("請輸入一個整數");int num1 = sc.nextInt();//輸入 123 123System.out.println(num1);//123System.out.println("請輸入第二個整數");int num2 = sc.nextInt();//不會讓你輸入 直接接收內存中剩余的123System.out.println(num2);//123
Scanner sc = new Scanner(System.in);System.out.println("請輸入一個字符串");String line1 = sc.nextLine();//輸入123 bcdSystem.out.println(line1);//輸出123 bcdSystem.out.println("請輸入第二個字符串");String line2 = sc.nextLine();System.out.println(line2);
//鍵盤錄入的兩套體系不能混用
//弊端：先用nextInt，再用nextLine會導致下面的nextLine接受不到數據Scanner sc = new Scanner(System.in);System.out.println("請輸入一個整數");int num = sc.nextInt();//輸入123 + 回車System.out.println(num);//123 nextInt只接收到123 回車被下面的nextLine接收了System.out.println("請輸入一個字符串");String line = sc.nextLine();System.out.println(line);
test2
package 兩個對象數組練習.test2;public class Car {private String brand;//品牌private int price;//價格private String color;//顏色public Car() {}public Car(String brand, int price, String color) {this.brand = brand;this.price = price;this.color = color;}public String getBrand() {return brand;}public void setBrand(String brand) {this.brand = brand;}public int getPrice() {return price;}public void setPrice(int price) {this.price = price;}public String getColor() {return color;}public void setColor(String color) {this.color = color;}
}
package 兩個對象數組練習.test2;import java.util.Scanner;public class CarTest {public static void main(String[] args) {
// 對象數組 2
// 定義數組存儲 3 部汽車對象。
// 汽車的屬性：品牌，價格，顏色。
// 創建三個汽車對象，數據通過鍵盤錄入而來，并把數據存入到數組當中。//1.創建一個數組用來存3個汽車對象Car[] arr = new Car[3];//2.創建汽車對象，數據來自于鍵盤錄入Scanner sc = new Scanner(System.in);for (int i = 0; i < arr.length; i++) {//創建汽車的對象Car c = new Car();//錄入品牌System.out.println("請輸入汽車的品牌");String brand = sc.next();c.setBrand(brand);//錄入價格System.out.println("請輸入汽車的價格");int price = sc.nextInt();c.setPrice(price);//錄入顏色System.out.println("請輸入汽車的顏色");String color = sc.next();c.setColor(color);//把汽車對象添加到數組當中arr[i] = c;}//3.遍歷數組for (int i = 0; i < arr.length; i++) {Car car = arr[i];System.out.println(car.getBrand() + ", " + car.getPrice() + ", " + car.getColor());}}
}
3.對象數組練習判斷并統計
test1
package 對象數組練習判斷并統計;public class Phone {private String brand;//品牌private int price;//價格private String color;//顏色public Phone() {}public Phone(String brand, int price, String color) {this.brand = brand;this.price = price;this.color = color;}public String getBrand() {return brand;}public void setBrand(String brand) {this.brand = brand;}public int getPrice() {return price;}public void setPrice(int price) {this.price = price;}public String getColor() {return color;}public void setColor(String color) {this.color = color;}
}
package 對象數組練習判斷并統計;public class PhoneTest {public static void main(String[] args) {
// 對象數組 3
// 定義數組存儲 3 部手機對象。
// 手機的屬性：品牌，價格，顏色。
// 要求，計算出三部手機的平均價格//1.創建一個數組Phone[] arr = new Phone[3];//2.創建手機的對象Phone p1 = new Phone("小米", 1999, "白色");Phone p2 = new Phone("華為", 4999, "藍色");Phone p3 = new Phone("魅族", 3999, "紅色");//3.把手機對象添加到數組當中arr[0] = p1;arr[1] = p2;arr[2] = p3;//4.獲取三部手機的平均價格int sum = 0;for (int i = 0; i < arr.length; i++) {//i 索引 arr[i] 元素（手機對象）Phone phone = arr[i];sum = sum + phone.getPrice();}
//5.求平均值//數據能不寫死，盡量不寫死//int avg = sum / arr.length;double avg2 = sum * 1.0 / arr.length;System.out.println(avg2);}
}
test2
package 對象數組練習判斷并統計.test2;public class GirlFriend {private String name;//姓名private int age;//年齡private String gender;//性別private String hobby;//愛好public GirlFriend() {}public GirlFriend(String name, int age, String gender, String hobby) {this.name = name;this.age = age;this.gender = gender;this.hobby = hobby;}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;}public String getGender() {return gender;}public void setGender(String gender) {this.gender = gender;}public String getHobby() {return hobby;}public void setHobby(String hobby) {this.hobby = hobby;}
}
package 對象數組練習判斷并統計.test2;public class GirlFriendTest {public static void main(String[] args) {
//1.定義數組存入女朋友的對象GirlFriend[] arr = new GirlFriend[4];//2.創建女朋友對象GirlFriend gf1 = new GirlFriend("小濤濤", 18, "萌妹子", "吃零食");GirlFriend gf2 = new GirlFriend("小丹丹", 19, "萌妹子", "玩游戲");GirlFriend gf3 = new GirlFriend("小惠惠", 20, "萌妹子", "看書，學習");GirlFriend gf4 = new GirlFriend("小莉莉", 21, "憨妹子", "睡覺");//3.把對象添加到數組當中arr[0] = gf1;arr[1] = gf2;arr[2] = gf3;arr[3] = gf4;
//4.求和int sum = 0;for (int i = 0; i < arr.length; i++) {//i 索引 arr[i] 元素（女朋友對象）GirlFriend gf = arr[i];//累加sum = sum + gf.getAge();}//5.平均值int avg = sum / arr.length;
//6.統計年齡比平均值低的有幾個，打印他們的信息int count = 0;for (int i = 0; i < arr.length; i++) {GirlFriend gf = arr[i];if (gf.getAge() < avg) {count++;System.out.println(gf.getName() + ", " + gf.getAge() + ", " + gf.getGender() + ", " + gf.getHobby());}}System.out.println(count + "個");}
}
4.復雜對象數組練習
package 復雜對象數組練習;public class Student {private int id;private String name;private int age;public Student() {}public Student(int id, String name, int age) {this.id = id;this.name = name;this.age = age;}public int getId() {return id;}public void setId(int id) {this.id = id;}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;}
}
package 復雜對象數組練習;public class Test {public static void main(String[] args) {
// 對象數組 5
// 定義一個長度為 3 的數組，數組存儲 1~3 名學生對象作為初始數據，學生對象的學號，姓名各不相同。
// 學生的屬性：學號，姓名，年齡。
// 要求 1：再次添加一個學生對象，并在添加的時候進行學號的唯一性判斷。
// 要求 2：添加完畢之后，遍歷所有學生信息。
// 要求 3：通過 id 刪除學生信息
// 如果存在，則刪除，如果不存在，則提示刪除失敗。
// 要求 4：刪除完畢之后，遍歷所有學生信息。
// 要求 5：查詢數組 id 為 “2” 的學生，如果存在，則將他的年齡 + 1 歲//1.創建一個數組用來存儲學生對象Student[] arr = new Student[3];
//2.創建學生對象并添加到數組當中Student stu1 = new Student(1, "zhangsan", 23);Student stu2 = new Student(2, "lisi", 24);Student stu3 = new Student(3, "wangwu", 25);
//3.把學生對象添加到數組當中arr[0] = stu1;arr[1] = stu2;arr[2] = stu3;//要求1：再次添加一個學生對象，并在添加的時候進行學號的唯一性判斷。Student stu4 = new Student(4, "zhaoliu", 26);
//唯一性判斷
//已存在 --- 不用添加
//不存在 --- 就可以把學生對象添加進數組boolean flag = contains(arr, stu4.getId());if(flag){//已存在 --- 不用添加System.out.println("當前id重復，請修改id后再進行添加");}else{//不存在 --- 就可以把學生對象添加進數組//把stu4添加到數組當中//1.數組已經存滿 --- 只能創建一個新的數組，新數組的長度 = 老數組 + 1//2.數組沒有存滿 --- 直接添加int count = getCount(arr);if(count == arr.length){//已經存滿//創建一個新的數組，長度 = 老數組的長度 + 1//然后把老數組的元素，拷貝到新數組當中Student[] newArr = creatNewArr(arr);//把stu4添加進去newArr[count] = stu4;//要求2：添加完畢之后，遍歷所有學生信息。printArr(newArr);}else{//沒有存滿//[stu1,stu2,null]//getCount獲取到的是2，表示數組當中已經有了2個元素//還有一層意思：如果下一次要添加數據，就是添加到2索引的位置arr[count] = stu4;//要求2：添加完畢之后，遍歷所有學生信息。printArr(arr);}}/*要求3：通過id刪除學生信息
如果存在，則刪除，如果不存在，則提示刪除失敗。*/
//要找到id在數組中對應的索引int index = getIndex(arr, 4);if (index >= 0){//如果存在，則刪除arr[index] = null;//遍歷數組printArr(arr);}else{//如果不存在，則提示刪除失敗System.out.println("當前id不存在，刪除失敗");}//5.判斷索引if(index >= 0){//存在，則將他的年齡+1歲Student stu = arr[index];//把原來年齡拿出來int newAge = stu.getAge() + 1;//把+1之后的年齡塞回去stu.setAge(newAge);//遍歷數組printArr(arr);}else{//不存在，則直接提示System.out.println("當前id不存在，修改失敗");}}//1.我要干嘛？ 找到id在數組中的索引
//2.我需要什么？ 數組 id
//3.調用處是否需要繼續使用方法的結果？ 要public static int getIndex(Student[] arr , int id){for (int i = 0; i < arr.length; i++) {//依次得到每一個學生對象Student stu = arr[i];//對stu進行一個非空判斷if(stu != null){int sid = stu.getId();if(sid == id){return i;}}}//當循環結束之后，還沒有找到就表示不存在return -1;}public static void printArr(Student[] arr){for (int i = 0; i < arr.length; i++) {Student stu = arr[i];if(stu != null){System.out.println(stu.getId() + ", " + stu.getName() + ", " + stu.getAge());}}}//創建一個新的數組，長度 = 老數組的長度 + 1
//然后把老數組的元素，拷貝到新數組當中public static Student[] creatNewArr(Student[] arr){Student[] newArr = new Student[arr.length + 1];//循環遍歷得到老數組中的每一個元素for (int i = 0; i < arr.length; i++) {//把老數組中的元素添加到新數組當中newArr[i] = arr[i];}//把新數組返回return newArr;}//定義一個方法判斷數組中已經存了幾個元素public static int getCount(Student[] arr){//定義一個計數器用來統計int count = 0;for (int i = 0; i < arr.length; i++) {if(arr[i] != null){count++;}}//當循環結束之后，我就知道了數組中一共有幾個元素return count;}//1.我要干嘛？ 唯一性判斷
//2.我干這件事情，需要什么才能完成？ 數組 id
//3.調用處是否需要繼續使用方法的結果？ 必須返回public static boolean contains(Student[] arr, int id) {for (int i = 0; i < arr.length; i++) {//依次獲取到數組里面的每一個學生對象Student stu = arr[i];if(stu != null){//獲取數組中學生對象的idint sid = stu.getId();//比較if(sid == id){return true;}}}//當循環結束之后，還沒有找到一樣的，那么就表示數組中要查找的id是不存在的。return false;}
}
字符串
1.API和API幫助文檔
API 和 API 幫助文檔API：目前是 JDK 中提供的各種功能的 Java 類。這些類將底層的實現封裝了起來，我們不需要關心這些類是如何實現的，只需要學習這些類如何使用即可。API 幫助文檔：幫助開發人員更好的使用 API 和查詢 API 的一個工具。
2.String概述
String 的注意點字符串的內容是不會發生改變的，它的對象在創建后不能被更改。Strin 是 Java 定義好的一個類。定義在 java.lang 包中，所以使用的時候不需要導包。Java 程序中的所有字符串文字（例如 “abcdefg” ）都被實為此類的對象。字符串不可變，它們的值在創建后不能被更改
3.String構造方法代碼實現和內存分析
使用直接賦值的方式獲取一個字符串對象
String s1 = "abc"; System.out.println(s1);//abc
使用new的方式來獲取一個字符串對象 空參構造：可以獲取一個空白的字符串對象
String s2 = new String();
System.out.println("@" + s2 + "!");//""
傳遞一個字符串，根據傳遞的字符串內容再創建一個新的字符串對象
String s3 = new String("abc");
System.out.println(s3);
傳遞一個字符數組，根據字符數組的內容再創建一個新的字符串對象
需求：我要修改字符串的內容。 abc Qbc
abc --> {'a','b','c'} --> {'Q','b','c'} --> "Qbc"
char[] chs = {'a','b','c','d'};
String s4 = new String(chs);
System.out.println(s4);//abcd
傳遞一個字節數組，根據字節數組的內容再創建一個新的字符串對象 應用場景：以后在網絡當中傳輸的數據其實都是字節信息 我們一般要把字節信息進行轉換，轉成字符串，此時就要用到這個構造了。
byte[] bytes = {97, 98, 99, 100};
String s5 = new String(bytes);
System.out.println(s5);//abcd
當使用雙引號直接賦值時，系統會檢查該字符串在串池中是否存在。不存在：創建新的存在：復用
4.字符串的比較
== 號比的到底是什么？
// 基本數據類型int a = 10;int b = 20;System.out.println(a == b); //false // 基本數據類型比較的是數據值
// 引用數據類型String s1 = new String("abc");String s2 = new String("abc");System.out.println(s1 == s2); //false
// 引用數據類型比較的是地址值
字符串比較boolean equals 方法 (要比較的字符串)：完全一樣結果才是 true，否則為 falseboolean equalsIgnoreCase (要比較的字符串)：忽略大小寫的比較
//創建兩個字符串對象String s3 = new String("abc");String s4 = "Abc";//比較字符串對象中的內容是否相等boolean result1 = s3.equals(s4);System.out.println(result1);//false//比較字符串對象中的內容是否相等，忽略大小寫boolean result2 = s3.equalsIgnoreCase(s4);System.out.println(result2);//true
5.練習用戶登錄
import java.util.Scanner;public class 練習用戶登錄 {// 需求：已知正確的用戶名和密碼，請用程序實現模擬用戶登錄。// 總共給三次機會，登錄之后，給出相應的提示public static void main(String[] args) {
//1.定義兩個變量記錄正確的用戶名和密碼String rightUsername = "zhangsan";String rightPassword = "123456";Scanner sc = new Scanner(System.in);
//2.鍵盤錄入用戶名和密碼for (int i = 0; i < 3; i++) { // 0 1 2System.out.println("請輸入用戶名");String username = sc.next();System.out.println("請輸入密碼");String password = sc.next();//3.比較if (username.equals(rightUsername) && password.equals(rightPassword)) {System.out.println("用戶登錄成功");break;} else {if(i == 2){//最后一次機會也輸入錯誤，此時要提示賬號被鎖定System.out.println("賬號" + username + "被鎖定，請聯系黑馬程序員官方客服小姐姐:XXXX-XXXXX");}else{System.out.println("用戶登錄失敗，用戶名或密碼有誤,您還剩下" + (2 - i) + "次機會");//2 1 0}}}}
}
?6.練習遍歷字符串和統計字符個數
public char charAt (int index)：根據索引返回字符public int length ()：返回此字符串的長度數組的長度：數組名.length字符串的長度：字符串對象.length ()
// 需求：鍵盤錄入一個字符串，使用程序實現在控制臺遍歷該字符串//1.鍵盤錄入一個字符串Scanner sc = new Scanner(System.in);System.out.println("請輸入一個字符串");String str = sc.next();
//2.進行遍歷for (int i = 0; i < str.length(); i++) {//i 依次表示字符串的每一個索引char c = str.charAt(i);System.out.println(c);
// 統計字符次數
// 鍵盤錄入一個字符串，統計該字符串中大寫字母字符，小寫字母字符，數字字符出現的次數（不考慮其他字符）//1.鍵盤錄入一個字符串Scanner sc = new Scanner(System.in);System.out.println("請輸入一個字符串");String str = sc.next();
//2.統計--- 計數器思想
//定義三個計數器int bigCount = 0;int smallCount = 0;int numberCount = 0;for (int i = 0; i < str.length(); i++) {//i 依次表示字符串中的每一個索引char c = str.charAt(i);if(c >= 'a' && c <= 'z'){//char類型的變量在參與計算的時候自動類型提升為int 查詢ascii碼表smallCount++;}else if(c >= 'A' && c <= 'Z'){bigCount++;}else if(c >= '0' && c <= '9'){numberCount++;}}
//3.輸出打印System.out.println("小寫字母有: " + smallCount + "個");System.out.println("大寫字母有: " + bigCount + "個");System.out.println("數字字母有: " + numberCount + "個");
7.練習字符串拼接和反轉
public class 練習字符串拼接和反轉 {public static void main(String[] args) {
// 定義一個方法，把 int 數組中的數據按照指定的格式拼接成一個字符串返回，調用該方法，并在控制臺輸出結果。
// 例如：
// 數組為 int [] arr = {1,2,3};
// 執行方法后的輸出結果為：[1, 2, 3]int[] arr = {1, 2, 3};String str = arrToString(arr);System.out.println(str);//[1, 2, 3]// 字符串反轉
// 定義一個方法，實現字符串反轉。
// 鍵盤錄入一個字符串，調用該方法后，在控制臺輸出結果。
// 例如，鍵盤錄入 abc，輸出結果 cbaString result = reverser("abc");System.out.println(result);//cba}//1. 我要干嘛？ --- 遍歷數組并把數組拼接成一個字符串
//2. 我干這件事情需要什么才能完成？ --- 數組
//3. 我干完了是否要把結果返回給調用處 --- 返回一個拼接之后的字符串
// 如果調用處需要繼續使用，那么必須返回
// 如果調用處不需要繼續使用，那么可以返回也可以不返回public static String arrToString(int[] arr) {if (arr == null) {return "";}if (arr.length == 0) {return "[]";}String result = "[";//當代碼執行到這里表示什么？//表示數組不是null，也不是長度為0的for (int i = 0; i < arr.length; i++) {//i 索引 arr[i] 元素if (i == arr.length - 1) {result = result + arr[i];} else {result = result + arr[i] + ", ";}}//此時拼接右括號result = result + "]";return result;}//1.我要干嘛？ --- 字符串的反轉
//2.我干這件事情，需要什么才能完成？ --- 需要一個字符串
//3.調用處是否需要繼續使用方法的結果呢？ ---需要結果進行輸出public static String reverser(String str){String result = "";for (int i = str.length() - 1; i >= 0; i--) {//i 依次表示字符串中的每一個索引（倒著的）char c = str.charAt(i);result = result + c;}return result;}
}
8.練習金額轉換
import java.util.Scanner;public class 練習金額轉換 {public static void main(String[] args) {//1.鍵盤錄入一個金額Scanner sc = new Scanner(System.in);int money;while (true) {System.out.println("請錄入一個金額");money = sc.nextInt();if(money >= 0 && money <= 9999999){break;}else{System.out.println("金額無效");}}//定義一個變量用來表示錢的大寫String moneyStr = "";//2.得到money里面的每一位數字，再轉成中文while (true) { //2135//從右往左獲取數據，因為右側是數據的個位int ge = money % 10;String capitalNumber = getCapitalNumber(ge);//把轉換之后的大寫拼接到moneyStr當中moneyStr = capitalNumber + moneyStr;//第一次循環 ： "伍" + "" = "伍"//第二次循環 ： "叁" + "伍" = "叁伍"//去掉剛剛獲取的數據money = money / 10;//如果數字上的每一位全部獲取到了，那么money記錄的就是0，此時循環結束if (money == 0) {break;}}//3.在前面補0，補齊7位int count = 7 - moneyStr.length();for (int i = 0; i < count; i++) {moneyStr = "零" + moneyStr;}System.out.println(moneyStr);//4.插入單位//定義一個數組表示單位String[] arr = {"佰","拾","萬","仟","佰","拾","元"};// 零 零 零 貳 壹 叁 伍//遍歷moneyStr，依次得到 零 零 零 貳 壹 叁 伍//然后把arr的單位插入進去String result = "";for (int i = 0; i < moneyStr.length(); i++) {char c = moneyStr.charAt(i);//把大寫數字和單位拼接到result當中result = result + c + arr[i];}//5.打印最終結果System.out.println(result);}//定義一個方法把數字變成大寫的中文
//1 -- 壹public static String getCapitalNumber(int number){//定義數組，讓數字跟大寫的中文產生一個對應關系String[] arr = {"零","壹","貳","叁","肆","伍","陸","柒","捌","玖"};//返回結果return arr[number];}}
9.練習手機號屏蔽
String substring (int beginIndex, int endIndex) 截取注意點：包頭不包尾，包左不包右只有返回值才是截取的小串String substring (int beginIndex) 截取到末尾
//1.獲取一個手機號碼String phoneNumber = "13112349468"; //2.截取手機號碼前面三位String start = phoneNumber.substring(0, 3); //3.截取手機號碼后面四位String end = phoneNumber.substring(7); //4.拼接String result = start + "****" + end; //5.打印System.out.println(result);//131****9468
10.練習身份證號碼信息查看
public class 練習身份證號碼信息查看 {public static void main(String[] args) {
//1.定義一個字符串記錄身份證號碼String id = "321281202001011234";
//2.獲取出生年月日String year = id.substring(6, 10);String month = id.substring(10, 12);String day = id.substring(12, 14);System.out.println("人物信息為: ");System.out.println("出生年月日:" + year + "年" + month + "月" + day + "日");//3.獲取性別char gender = id.charAt(16);//'3' ---> 3
//利用ASCII碼表進行轉換
//'0' ---> 48
//'1' ---> 49
//'2' ---> 50
//'3' ---> 51
//'4' ---> 52
//'5' ---> 53
//'6' ---> 54
//'7' ---> 55
//'8' ---> 56
//'9' ---> 57int num = gender - 48;if(num % 2 == 0){System.out.println("性別為:女");}else{System.out.println("性別為:男");}}
}
11.練習敏感詞替換
String replace (舊值，新值) 替換注意點：只有返回值才是替換之后的結果
public class 練習敏感詞替換 {public static void main(String[] args) {
// String replace (舊值，新值) 替換
// 注意點：只有返回值才是替換之后的結果//1.獲取到說的話String talk = "你玩的真好，以后不要再玩了，TMD,CNM";//2.定義一個敏感詞庫String[] arr = {"TMD","CNM","SB","MLGB"};//3.循環得到數組中的每一個敏感詞，依次進行替換for (int i = 0; i < arr.length; i++) {talk = talk.replace(arr[i], "***");}
//4.打印結果System.out.println(talk);}
}
12.StringBuilder的基本操作
StringBuilder 概述StringBuilder 可以看成是一個容器，創建之后里面的內容是可變的作用：提高字符串的操作效率
StringBuilder 構造方法方法名 說明public StringBuilder() 創建一個空白可變字符串對象，不含有任何內容public StringBuilder(String str) 根據字符串的內容，來創建可變字符串對象
StringBuilder 常用方法方法名 說明public StringBuilder append (任意類型) 添加數據，并返回對象本身public StringBuilder reverse() 反轉容器中的內容public int length() 返回長度（字符出現的個數）public String toString() 通過 toString () 就可以實現把 StringBuilder 轉換為 String
//1.創建對象StringBuilder sb = new StringBuilder("abc");//2.添加元素sb.append(1);sb.append(2.3);sb.append(true);//反轉sb.reverse();
//獲取長度int len = sb.length();System.out.println(len);//打印
//普及：
//因為StringBuilder是Java已經寫好的類
//java在底層對他做了一些特殊處理。
//打印對象不是地址值而是屬性值。System.out.println(sb);//abc
//1.創建對象StringBuilder sb = new StringBuilder();//StringBuilder是個容器
//2.添加字符串sb.append("aaa").append("bbb").append("ccc").append("ddd");System.out.println(sb);//aaabbbcccddd//3.再把StringBuilder變回字符串String str = sb.toString();System.out.println(str);//aaabbbcccddd
13.練習StringBuilder對稱字符串
使用StringBuilder的場景: 1.字符串的拼接 2.字符串的反轉
import java.util.Scanner;public class 練習StringBuilder對稱字符串 {public static void main(String[] args) {
// 對稱字符串
// 需求：鍵盤接受一個字符串，程序判斷出該字符串是否是對稱字符串，并在控制臺打印是或不是
// 對稱字符串：123321、111
// 非對稱字符串：123123//1.鍵盤錄入一個字符串Scanner sc = new Scanner(System.in);System.out.println("請輸入一個字符串");String str = sc.next();//2.反轉鍵盤錄入的字符串String result = new StringBuilder().append(str).reverse().toString();//3.比較if(str.equals(result)){System.out.println("當前字符串是對稱字符串");}else{System.out.println("當前字符串不是對稱字符串");}}
}
14.練習StringBuilder拼接字符串
public class 練習StringBuilder拼接字符串 {public static void main(String[] args) {
// 拼接字符串
// 需求：定義一個方法，把 int 數組中的數據按照指定的格式拼接成一個字符串返回。調用該方法，并在控制臺輸出結果。
// 例如：數組為 int [] arr = {1,2,3};
// 執行方法后的輸出結果為：[1, 2, 3]//1.定義數組int[] arr = {1, 2, 3};//2.調用方法把數組變成字符串String str = arrToString(arr);System.out.println(str);}public static String arrToString(int[] arr) {StringBuilder sb = new StringBuilder();sb.append("[");for (int i = 0; i < arr.length; i++) {if (i == arr.length - 1) {sb.append(arr[i]);} else {sb.append(arr[i]).append(", ");}}sb.append("]");return sb.toString();}
}
15.Stringjoiner
StringJoiner 概述StringJoiner 跟 StringBuilder 一樣，也可以看成是一個容器，創建之后里面的內容是可變的。作用：提高字符串的操作效率，而且代碼編寫特別簡潔，但是目前市場上很少有人用。JDK8 出現的
StringJoiner 的構造方法方法名 說明public StringJoiner (間隔符號) 創建一個 StringJoiner 對象，指定拼接時的間隔符號public StringJoiner (間隔符號，開始符號，結束符號) 創建一個 StringJoiner 對象，指定拼接時的間隔符號、開始符號、結束符號
StringJoiner 的成員方法方法名 說明public StringJoiner add (添加的內容) 添加數據，并返回對象本身public int length() ????返回長度（字符出現的個數）public String toString() 返回一個字符串（該字符串就是拼接之后的結果）
//1.創建一個對象，并指定中間的間隔符號
StringJoiner sj1 = new StringJoiner("---");
//2.添加元素
sj1.add("aaa").add("bbb").add("ccc");
//3.打印結果
System.out.println(sj1);//aaa---bbb---ccc
//1.創建對象StringJoiner sj2 = new StringJoiner(",", "[", "]");
//2.添加元素sj2.add("aaa").add("bbb").add("ccc");int len = sj2.length();System.out.println(len);//15//3.打印System.out.println(sj2);//[aaa, bbb, ccc]String str = sj2.toString();System.out.println(str);//[aaa, bbb, ccc]
16.字符串相關類的底層原理
擴展底層原理 1：字符串存儲的內存原理直接賦值會復用字符串常量池中的new 出來不會復用，而是開辟一個新的空間
擴展底層原理 2：== 號比較的到底是什么？基本數據類型比較數據值引用數據類型比較地址值
擴展底層原理 3：字符串拼接的底層原理拼接的時候沒有變量，都是字符串。觸發字符串的優化機制。在編譯的時候就已經是最終的結果了。如果沒有變量參與，都是字符串直接相加，編譯之后就是拼接之后的結果，會復用串池中的字符串。字符串拼接的時候，如果有變量：JDK8 以前：系統底層會自動創建一個 StringBuilder 對象，然后再調用其 append 方法完成拼接。拼接后，再調用其 toString 方法轉換為 String 類型，而 toString 方法的底層是直接 new 了一個字符串對象。JDK8 版本：系統會預估算字符串拼接之后的總大小，把要拼接的內容都放在數組中，此時也是產生一個新的字符串。字符串拼接的時候有變量參與：在內存中創建了很多對象浪費空間，時間也非常慢結論：如果很多字符串變量拼接，不要直接 +。在底層會創建多個對象，浪費時間，浪費性能。
擴展底層原理 4：StringBuilder 提高效率原理圖所有要拼接的內容都會往 StringBuilder 中放，不會創建很多無用的空間，節約內存
擴展底層原理 5：StringBuilder 源碼分析默認創建一個長度為 16 的字節數組添加的內容長度小于 16，直接存添加的內容大于 16 會擴容（原來的容量 * 2+2）如果擴容之后還不夠，以實際長度為準
StringBuilder sb = new StringBuilder(); //容量：最多裝多少 System.out.println(sb.capacity());//16 //長度：已經裝了多少 System.out.println(sb.length());//0
sb.append("abcdefghijklmnopqrstuvwxyz");System.out.println(sb.capacity());//34System.out.println(sb.length());//26
sb.append("abcdefghijklmnopqrstuvwxyz0123456789");
System.out.println(sb.capacity());//36
System.out.println(sb.length());//36
17.較難練習轉換羅馬數字
轉換羅馬數字鍵盤錄入一個字符串，要求 1：長度為小于等于 9要求 2：只能是數字將內容變成羅馬數字下面是阿拉伯數字跟羅馬數字的對比關系：I - 1、II - 2、III - 3、IV - 4、V - 5、VI - 6、VII - 7、VIII - 8、IX - 9注意點：羅馬數字里面是沒有 0 的如果鍵盤錄入的數字包含 0，可以變成 “”（長度為 0 的字符串）
import java.util.Scanner;public class 較難練習轉換羅馬數字 {public static void main(String[] args) {
//1.鍵盤錄入一個字符串
//書寫Scanner的代碼Scanner sc = new Scanner(System.in);String str;while (true) {System.out.println("請輸入一個字符串");str = sc.next();//2.校驗字符串是否滿足規則boolean flag = checkStr(str);if (flag) {break;} else {System.out.println("當前的字符串不符合規則，請重新輸入");continue;}}
//查表法：數字跟數據產生一個對應關系
// StringBuilder sb = new StringBuilder();
// for (int i = 0; i < str.length(); i++) {
// char c = str.charAt(i);
// int number = c - 48; // 1 2 3 4 5
// String s = changeLuoMa(number);
// sb.append(s);
// }
// System.out.println(sb);StringBuilder sb = new StringBuilder();for (int i = 0; i < str.length(); i++) {char c = str.charAt(i);String s = changeLuoMa(c);sb.append(s);}System.out.println(sb);}
// public static String changeLuoMa(int number) {
// //定義一個數組，讓索引跟羅馬數字產生一個對應關系
// String[] arr = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
// return arr[number];
// }// 利用switch進行匹配public static String changeLuoMa(char number) {String str = switch (number) {case '0' -> "";case '1' -> "Ⅰ";case '2' -> "Ⅱ";case '3' -> "Ⅲ";case '4' -> "Ⅳ";case '5' -> "Ⅴ";case '6' -> "Ⅵ";case '7' -> "Ⅶ";case '8' -> "Ⅷ";case '9' -> "Ⅸ";default -> "";};return str;}public static boolean checkStr(String str) {//123456//要求1：長度為小于等于9if (str.length() > 9) {return false;}//要求2：只能是數字for (int i = 0; i < str.length(); i++) {char c = str.charAt(i);//0~9if (c < '0' || c > '9') {return false;}}//只有當字符串里面所有的字符全都判斷完畢了，我才能認為當前的字符串是符合規則return true;}
}
18.較難練習調整字符串
調整字符串給定兩個字符串，A 和 B。A 的旋轉操作就是將 A 最左邊的字符移動到最右邊。例如，若 A = 'abcde'，在移動一次之后結果就是 'bcdea'。如果在若干次調整操作之后，A 能變成 B，那么返回 True。如果不能匹配成功，則返回 false
public class 較難練習調整字符串 {public static void main(String[] args) {
//1.定義兩個字符串String strA = "abcde";String strB = "cdeab";
//2.調用方法進行比較boolean result = check(strA, strB);
//3.輸出System.out.println(result);}public static boolean check(String strA, String strB) {for (int i = 0; i < strA.length(); i++) {strA = rotate(strA);if(strA.equals(strB)){return true;}}//所有的情況都比較完畢了，還不一樣那么直接返回falsereturn false;}//作用：旋轉字符串，把左側的字符移動到右側去
//形參：旋轉前的字符串
//返回值：旋轉后的字符串public static String rotate(String str){//套路：//如果我們看到要修改字符串的內容//可以有兩個辦法：//1.用subString進行截取，把左邊的字符截取出來拼接到右側去//2.可以把字符串先變成一個字符數組，然后調整字符數組里面數據，最后再把字符數組變成字符串。// //1.截取思路
// //獲取最左側那個字符
// char first = str.charAt(0);
// //獲取剩余的字符
// String end = str.substring(1);
// return end + first;//2.數組思路
// toCharArray方法：
// "ABC" 變為 ['A','B','C'];char[] arr = str.toCharArray();
//拿到0索引上的字符char first = arr[0];
//把剩余的字符依次往前挪一個位置for (int i = 1; i < arr.length; i++) {arr[i - 1] = arr[i];}
//把原來0索引上的字符放到最后一個索引arr[arr.length - 1] = first;
//利用字符數組創建一個字符串對象String result = new String(arr);return result;}
}
ArrayList
1.集合的基本使用
集合和數組的對比數組:長度固定可以存基本數據類型可以存引用數據類型集合:長度可變可以存引用數據類型基本數據類型 需要變為 包裝類 再存
//1.創建集合的對象 //泛型：限定集合中存儲數據的類型 //JDK7前: //ArrayList<String> list = new ArrayList<String>(); //JDK7后: //ArrayList<String> list = new ArrayList<>();//此時我們創建的是ArrayList的對象，而ArrayList是java已經寫好的一個類 //這個類在底層做了一些處理 //打印對象不是地址值，而是集合中存儲數據內容 //在展示的時候會拿[]把所有的數據進行包裹ArrayList<String> list = new ArrayList<>();System.out.println(list);//[]
2.ArrayList 成員方法方法名 說明增 boolean add(E e) 添加元素，返回值表示是否添加成功刪 boolean remove(E e) 刪除指定元素，返回值表示是否刪除成功E remove(int index) 刪除指定索引的元素，返回被刪除元素改 E set(int index,E e) 修改指定索引下的元素，返回原來的元素查 E get(int index) 獲取指定索引的元素int size() 集合的長度，也就是集合中元素的個數
//添加元素
list.add("aaa");
list.add("aaa");
list.add("bbb");
list.add("ccc");
//刪除元素
boolean result1 = list.remove("aaa");
System.out.println(result1);//true
boolean result2 = list.remove("ddd");
System.out.println(result2);//false
System.out.println(list);//[aaa, bbb, ccc]String str = list.remove(0);
System.out.println(str);//aaa
System.out.println(list);//[bbb, ccc]
//修改元素 String result = list.set(1, "ddd"); System.out.println(result);//ccc System.out.println(list);//[bbb, ddd]
//查詢元素 String s = list.get(0); System.out.println(s);//bbb System.out.println(list);//[bbb, ddd]
for (int i = 0; i < list.size(); i++) {//i 索引//list.get(i) 元素String str1 = list.get(i);System.out.println(str1);
2.添加字符串和數字并遍歷
// 集合的遍歷方式
// 需求：定義一個集合，添加字符串，并進行遍歷
// 遍歷格式參照：[元素 1, 元素 2, 元素 3]。//1.創建集合ArrayList<String> list = new ArrayList<>();
//2.添加元素list.add("點贊了嗎？");list.add("收藏了嗎？");list.add("投幣了嗎？");list.add("轉發了嗎？");
//3.遍歷System.out.print("[");for (int i = 0; i < list.size(); i++) {if(i == list.size() - 1){System.out.print(list.get(i));}else{System.out.print(list.get(i) + ", ");}}System.out.println("]");
添加數字并遍歷需求：定義一個集合，添加數字，并進行遍歷。遍歷格式參照：[元素 1, 元素 2, 元素 3]。基本數據類型對應的包裝類byte Byteshort Shortchar Characterint Integerlong Longfloat Floatdouble Doubleboolean Boolean
//1.創建集合ArrayList<Integer> list = new ArrayList<>();
//2.添加元素
//jdk5以后 int Integer 之間是可以互相轉化的list.add(1);list.add(2);list.add(3);list.add(4);list.add(5);
//3.遍歷集合System.out.print("[");for (int i = 0; i < list.size(); i++) {if(i == list.size() - 1){System.out.print(list.get(i));}else{System.out.print(list.get(i) + ", ");}}System.out.println("]");
3.練習添加學生對象并遍歷
import java.util.ArrayList;public class 練習添加學生對象并遍歷 {public static void main(String[] args) {
// 添加學生對象并遍歷
// 需求：定義一個集合，添加一些學生對象，并進行遍歷
// 學生類的屬性為：姓名，年齡。//1.創建集合ArrayList<Student> list = new ArrayList<>();
//2.創建學生對象Student s1 = new Student("zhangsan", 23);Student s2 = new Student("lisi", 24);Student s3 = new Student("wangwu", 25);
//3.添加元素list.add(s1);list.add(s2);list.add(s3);
//4.遍歷集合for (int i = 0; i < list.size(); i++) {//i 索引 list.get(i) 元素/學生對象Student stu = list.get(i);System.out.println(stu.getName() + ", " + stu.getAge());}}
}
4.練習鍵盤添加學生對象并遍歷
import java.util.ArrayList;
import java.util.Scanner;public class 練習鍵盤添加學生對象并遍歷 {public static void main(String[] args) {
//1.創建集合ArrayList<Student> list = new ArrayList<>();
//長度為0
//2.鍵盤錄入學生的信息并添加到集合當中Scanner sc = new Scanner(System.in);for (int i = 0; i < 3; i++) {Student s = new Student();System.out.println("請輸入學生的姓名");String name = sc.next();System.out.println("請輸入學生的年齡");int age = sc.nextInt();//把name和age賦值給學生對象s.setName(name);s.setAge(age);//把學生對象添加到集合當中list.add(s);}//3.遍歷for (int i = 0; i < list.size(); i++) {//i 索引 list.get(i) 元素/學生對象Student stu = list.get(i);System.out.println(stu.getName() + ", " + stu.getAge());}}
}
5.練習查找用戶是否存在
import java.util.ArrayList;public class 練習查找用戶是否存在 {public static void main(String[] args) {
// 添加用戶對象并判斷是否存在
// 需求：
// main 方法中定義一個集合，存入三個用戶對象。
// 用戶屬性為：id，username，password
// 要求：定義一個方法，根據 id 查找對應的用戶信息。
// 如果存在，返回 索引
// 如果不存在，返回 -1//1.創建集合ArrayList<User> list = new ArrayList<>();
//2.創建三個用戶對象User u1 = new User("heima001", "zhangsan", "123456");User u2 = new User("heima002", "lisi", "12345678");User u3 = new User("heima003", "wangwu", "1234qwer");//3.把用戶對象添加到集合當中list.add(u1);list.add(u2);list.add(u3);//4.查找索引int index = getIndex(list, "heima001");
//5.打印System.out.println(index);}public static int getIndex(ArrayList<User> list, String id) {for (int i = 0; i < list.size(); i++) {User u = list.get(i);String uid = u.getId();if(uid.equals(id)){return i;}}return -1;}
}
6.練習返回多個數據
import java.util.ArrayList;public class 練習返回多個數據 {public static void main(String[] args) {
// 添加手機對象并返回要求的數據
// 需求：
// 定義 Javabean 類：Phone
// Phone 屬性：品牌，價格。
// main 方法中定義一個集合，存入三個手機對象。
// 分別為：小米，1000。蘋果，8000。錘子 2999。
// 定義一個方法，將價格低于 3000 的手機信息返回。//1.創建集合對象ArrayList<Phone> list = new ArrayList<>();
//2.創建手機的對象Phone p1 = new Phone("小米", 1000);Phone p2 = new Phone("蘋果", 8000);Phone p3 = new Phone("錘子", 2999);
//3.添加數據list.add(p1);list.add(p2);list.add(p3);
//4.調用方法ArrayList<Phone> phoneInfoList = getPhoneInfo(list);
//5.遍歷集合for (int i = 0; i < phoneInfoList.size(); i++) {Phone phone = phoneInfoList.get(i);System.out.println(phone.getBrand() + ", " + phone.getPrice());}}
//1.我要干嘛？ 查詢手機信息
//2.我干這件事情，需要什么才能完成？ 集合
//3.我干完了，方法的調用處是否需要繼續使用結果？ 返回//技巧：
//如果我們要返回多個數據，可以把這些數據先放到一個容器當中，再把容器返回
//集合 數組public static ArrayList<Phone> getPhoneInfo(ArrayList<Phone> list){//定義一個集合用于存儲價格低于3000的手機對象ArrayList<Phone> resultList = new ArrayList<>();//遍歷集合for (int i = 0; i < list.size(); i++) {Phone p = list.get(i);int price = p.getPrice();//如果當前手機的價格低于3000，那么就把手機對象添加到resultList中if(price < 3000){resultList.add(p);}}//返回resultListreturn resultList;}
}
?學生管理系統
import java.util.ArrayList;
import java.util.Scanner;public class StudentSystem {public static void main(String[] args) {ArrayList<Student> list = new ArrayList<>();
// 給循環起名為looploop: while (true) {System.out.println("--------------歡迎來到黑馬學生管理系統--------------");System.out.println("1:添加學生");System.out.println("2:刪除學生");System.out.println("3:修改學生");System.out.println("4:查詢學生");System.out.println("5:退出");System.out.println("請輸入您的選擇：");Scanner sc = new Scanner(System.in);String choose = sc.next();switch (choose) {case "1" -> addStudent(list);case "2" -> deleteStudent(list);case "3" -> updateStudent(list);case "4" -> queryStudent(list);case "5" -> {System.out.println("退出");
// break loop; //退出叫做loop的循環System.exit(0); //停止虛擬機運行}default -> System.out.println("沒有這個選項");}}}//添加學生public static void addStudent(ArrayList<Student> list){//利用空參構造先創建學生對象Student s = new Student();Scanner sc = new Scanner(System.in);String id = null;while (true) {System.out.println("請輸入學生的id");id = sc.next();boolean flag = contains(list, id);if(flag){//表示id已經存在，需要重新錄入System.out.println("id已經存在，請重新錄入");}else{//表示id不存在，表示可以使用s.setId(id);break;}}System.out.println("請輸入學生的姓名");String name = sc.next();s.setName(name);System.out.println("請輸入學生的年齡");int age = sc.nextInt();s.setAge(age);System.out.println("請輸入學生的家庭住址");String address = sc.next();s.setAddress(address);//把學生對象添加到集合當中list.add(s);//提示一下用戶System.out.println("學生信息添加成功");}//刪除學生public static void deleteStudent(ArrayList<Student> list){Scanner sc = new Scanner(System.in);System.out.println("請輸入要刪除的id");String id = sc.next();
//查詢id在集合中的索引int index = getIndex(list, id);
//對index進行判斷
//如果-1，就表示不存在，結束方法，回到初始菜單if(index >= 0){//如果大于等于0的，表示存在，直接刪除list.remove(index);System.out.println("id為：" + id + "的學生刪除成功");}else{System.out.println("id不存在，刪除失敗");}}//修改學生public static void updateStudent(ArrayList<Student> list){Scanner sc = new Scanner(System.in);System.out.println("請輸入要修改學生的id");String id = sc.next();int index = getIndex(list, id);if(index == -1){System.out.println("要修改的id" + id + "不存在，請重新輸入");return;}
//當代碼執行到這里，表示什么？表示當前id是存在的。
//獲取要修改的學生對象Student stu = list.get(index);//輸入其他的信息并修改System.out.println("請輸入要修改的學生姓名");String newName = sc.next();stu.setName(newName);System.out.println("請輸入要修改的學生年齡");int newAge = sc.nextInt();stu.setAge(newAge);System.out.println("請輸入要修改的學生家庭住址");String newAddress = sc.next();stu.setAddress(newAddress);System.out.println("學生信息修改成功");}//查詢學生public static void queryStudent(ArrayList<Student> list){if(list.size() == 0){System.out.println("當前無學生信息，請添加后再查詢");//結束方法return;}//打印表頭信息System.out.println("id\t姓名\t年齡\t家庭住址");//當代碼執行到這里，表示集合中是有數據的for (int i = 0; i < list.size(); i++) {Student stu = list.get(i);System.out.println(stu.getId() + "\t" + stu.getName() + "\t" + stu.getAge() + "\t" + stu.getAddress());}}//判斷id在集合中是否存在public static boolean contains(ArrayList<Student> list, String id) {//循環遍歷集合得到里面的每一個學生對象
// for (int i = 0; i < list.size(); i++) {
// //拿到學生對象后，獲取id并進行判斷
// Student stu = list.get(i);
// String sid = stu.getId();
// if(sid.equals(id)){
// //存在，true
// return true;
// }
// }
// // 不存在false
// return false;return getIndex(list, id) >= 0;}//通過id獲取索引的方法public static int getIndex(ArrayList<Student> list, String id){//遍歷集合for (int i = 0; i < list.size(); i++) {//得到每一個學生對象Student stu = list.get(i);//得到每一個學生對象的idString sid = stu.getId();//拿著集合中學生id跟要查詢的id進行比較if(sid.equals(id)){//如果一樣，那么就返回索引return i;}}//當循環結束之后還沒有找到，就表示不存在，返回-1.return -1;}
}
??學生管理系統升級
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;public class APP {public static void main(String[] args) {ArrayList<User> list = new ArrayList<>();Scanner sc = new Scanner(System.in);while (true) {System.out.println("歡迎來到學生管理系統");System.out.println("請選擇操作：1登錄 2注冊 3忘記密碼");String choose = sc.next();switch (choose) {case "1" -> login(list);case "2" -> register(list);case "3" -> forgetPassword(list);case "4" -> {System.out.println("謝謝使用，再見");System.exit(0);}default -> System.out.println("沒有這個選項");}}}private static void login(ArrayList<User> list) {Scanner sc = new Scanner(System.in);for (int i = 0; i < 3; i++) {System.out.println("請輸入用戶名");String username = sc.next();//判斷用戶名是否存在boolean flag = contains(list, username);if (!flag) {System.out.println("用戶名" + username + "未注冊，請先注冊再登錄");return;}System.out.println("請輸入密碼");String password = sc.next();while (true) {String rightCode = getCode();System.out.println("當前正確的驗證碼為: " + rightCode);System.out.println("請輸入驗證碼");String code = sc.next();if(code.equalsIgnoreCase(rightCode)){System.out.println("驗證碼正確");break;}else{System.out.println("驗證碼錯誤");continue;}}//驗證用戶名和密碼是否正確
//集合中是否包含用戶名和密碼
//定義一個方法驗證用戶名和密碼是否正確//封裝思想的應用：
//我們可以把一些零散的數據，封裝成一個對象
//以后傳遞參數的時候，只要傳遞一個整體就可以了，不需要管這些零散的數據。User useInfo = new User(username, password, null, null);boolean result = checkUserInfo(list, useInfo);if (result) {System.out.println("登錄成功，可以開始使用學生管理系統了");//創建對象調用方法，啟動學生管理系統StudentSystem ss = new StudentSystem();ss.startStudentSystem();break;} else {System.out.println("登錄失敗，用戶名或密碼錯誤");if (i == 2) {System.out.println("當前賬號" + username + "被鎖定，請聯系黑馬程序員客服: XXX-XXXXX");//當前賬號鎖定之后，直接結束方法即可return;} else {System.out.println("用戶名或密碼錯誤，還剩下" + (2 - i) + "次機會");}}}}private static boolean checkUserInfo(ArrayList<User> list, User useInfo) {//遍歷集合，判斷用戶是否存在，如果存在登錄成功，如果不存在登錄失敗for (int i = 0; i < list.size(); i++) {User user = list.get(i);if (user.getUsername().equals(useInfo.getUsername()) && user.getPassword().equals(useInfo.getPassword())) {return true;}}return false;}private static void forgetPassword(ArrayList<User> list) {Scanner sc = new Scanner(System.in);System.out.println("請輸入用戶名");String username = sc.next();boolean flag = contains(list, username);if(!flag){System.out.println("當前用戶" + username + "未注冊，請先注冊");return;}//鍵盤錄入身份證號碼和手機號碼System.out.println("請輸入身份證號碼");String personID = sc.next();System.out.println("請輸入手機號碼");String phoneNumber = sc.next();//需要把用戶對象通過索引先獲取出來。int index = findIndex(list, username);User user = list.get(index);//比較用戶對象中的手機號碼和身份證號碼是否相同if(!(user.getPersonID().equalsIgnoreCase(personID) && user.getPhoneNumber().equals(phoneNumber))){System.out.println("身份證號碼或手機號碼輸入有誤，不能修改密碼");return;}//當代碼執行到這里，表示所有的數據全部驗證成功，直接修改即可String password;while (true) {System.out.println("請輸入新的密碼");password = sc.next();System.out.println("請再次輸入新的密碼");String againPassword = sc.next();if(password.equals(againPassword)){System.out.println("兩次密碼輸入一致");break;}else{System.out.println("兩次密碼輸入不一致，請重新輸入");continue;}}//直接修改即可user.setPassword(password);System.out.println("密碼修改成功");}private static int findIndex(ArrayList<User> list, String username) {for (int i = 0; i < list.size(); i++) {User user = list.get(i);if(user.getUsername().equals(username)){return i;}}return -1;}private static void register(ArrayList<User> list) {//用戶名，密碼，身份證號碼，手機號碼放到用戶對象中//把用戶對象添加到集合中//1.鍵盤錄入用戶名Scanner sc = new Scanner(System.in);String username;while (true) {System.out.println("請輸入用戶名");username = sc.next();//開發細節：先驗證格式是否正確，再驗證是否唯一// 因為在以后所有的數據，都是存在數據庫中，如果我們要校驗，需要使用到網絡資源。boolean flag1 = checkUsername(username);if(!flag1){System.out.println("用戶名格式不滿足條件，需要重新輸入");continue;}//校驗用戶名唯一//username到集合中判斷是否有存在boolean flag2 = contains(list,username);if(flag2){//用戶名已存在，那么當前用戶名無法注冊，需要重新輸入System.out.println("用戶名" + username + "已存在，請重新輸入");}else{//不存在，表示當前用戶名可用，可以繼續錄入下面的其他數據System.out.println("用戶名" + username + "可用");break;}}//2.鍵盤錄入密碼//密碼鍵盤輸入兩次，兩次一致才可以進行注冊。String password;while (true) {System.out.println("請輸入要注冊的密碼");password = sc.next();System.out.println("請再次輸入要注冊的密碼");String againPassword = sc.next();if(!password.equals(againPassword)){System.out.println("兩次密碼輸入不一致，請重新輸入");continue;}else{System.out.println("兩次密碼一致，繼續錄入其他數據");break;}}//3.鍵盤錄入身份證號碼String personID;while (true) {System.out.println("請輸入身份證號碼");personID = sc.next();boolean flag = checkPersonID(personID);if(flag){System.out.println("身份證號碼滿足要求");break;}else{System.out.println("身份證號碼格式有誤，請重新輸入");continue;}}//4.鍵盤錄入手機號碼String phoneNumber;while (true) {System.out.println("請輸入手機號碼");phoneNumber = sc.next();boolean flag = checkPhoneNumber(phoneNumber);if(flag){System.out.println("手機號碼格式正確");break;}else{System.out.println("手機號碼格式有誤，請重新輸入");continue;}}//用戶名，密碼，身份證號碼，手機號碼放到用戶對象中User u = new User(username, password, personID, phoneNumber);
//把用戶對象添加到集合中list.add(u);System.out.println("注冊成功");
//遍歷集合printList(list);}private static void printList(ArrayList<User> list) {for (int i = 0; i < list.size(); i++) {//i 索引User user = list.get(i);System.out.println(user.getUsername() + ", " + user.getPassword() + ", "+ user.getPersonID() + ", " + user.getPhoneNumber());}}private static boolean checkPhoneNumber(String phoneNumber) {//長度為11位if (phoneNumber.length() != 11) {return false;}//不能以0為開頭if (phoneNumber.startsWith("0")) {return false;}//必須都是數字for (int i = 0; i < phoneNumber.length(); i++) {char c = phoneNumber.charAt(i);if (!(c >= '0' && c <= '9')) {return false;}}//當循環結束之后，表示每一個字符都在0-9之間return true;}private static boolean checkPersonID(String personID) {
//長度為18位if (personID.length() != 18) {return false;}
//不能以0為開頭if (personID.startsWith("0")) {//如果以0開頭，那么返回falsereturn false;}
//前17位，必須都是數字for (int i = 0; i < personID.length() - 1; i++) {char c = personID.charAt(i);//如果有一個字符不在0-9之間，那么直接返回falseif (!(c >= '0' && c <= '9')) {return false;}}
//最為一位可以是數字，也可以是大寫X或小寫xchar endChar = personID.charAt(personID.length() - 1);if ((endChar >= '0' && endChar <= '9') || (endChar == 'x') || (endChar == 'X')) {return true;} else {return false;}}private static boolean contains(ArrayList<User> list, String username) {
//循環遍歷集合得到每一個用戶對象
//拿著用戶對象中的用戶名進行比較for (int i = 0; i < list.size(); i++) {//i 索引User user = list.get(i);String rightUsername = user.getUsername();if(rightUsername.equals(username)){return true;}}
//當循環結束了，表示集合里面所有的用戶都比較完畢了，還沒有一樣的，則返回falsereturn false;}private static boolean checkUsername(String username) {
//用戶名長度必須在3~15位之間int len = username.length();if (len < 3 || len > 15) {return false;}
//當代碼執行到這里，表示用戶名的長度是符合要求的。
//繼續校驗：只能是字母加數字的組合
//循環得到username里面的每一個字符，如果有一個字符不是字母或者數字，那么就返回falsefor (int i = 0; i < username.length(); i++) {//i 索引char c = username.charAt(i);if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9'))) {return false;}}
//當代碼執行到這里,表示什么？
//用戶名滿足兩個要求：1長度滿足 2內容也滿足（字母+數字）
//但是不能是純數字
//統計在用戶名中，有多少字母就可以了。int count = 0;for (int i = 0; i < username.length(); i++) {//i 索引char c = username.charAt(i);if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {count++;break;}}return count > 0;}private static String getCode(){//1.創建一個集合添加所有的大寫和小寫字母ArrayList<Character> list = new ArrayList<>();for (int i = 0; i < 26; i++) {list.add((char)('a' + i));list.add((char)('A' + i));}StringBuilder sb = new StringBuilder();//2.要隨機抽取4個字符Random r = new Random();for (int i = 0; i < 4; i++) {//獲取隨機索引int index = r.nextInt(list.size());//利用隨機索引獲取字符char c = list.get(index);//把隨機字符添加到sb當中sb.append(c);}//3.把一個隨機數字添加到末尾int number = r.nextInt(10);sb.append(number);//4.如果我們要修改字符串中的內容//先把字符串變成字符數組，在數組中修改，然后再創建一個新的字符串char[] arr = sb.toString().toCharArray();//拿著最后一個索引，跟隨機索引進行交換int randomIndex = r.nextInt(arr.length);//最大索引指向的元素 跟隨機索引指向的元素交換char temp = arr[randomIndex];arr[randomIndex] = arr[arr.length - 1];arr[arr.length - 1] = temp;return new String(arr);}
}
ldconfig)
