一、包装类
1、包装类是什么？
-
其实就是8种基本数据类型对应的引用类型
基本数据类型 引用数据类型 byte Byte short Short int Integer long Long char Character float Float double Double boolean Boolean
2、为什么提供包装类？
- Java为了实现一切皆对象，为8种基本类型提供了对应的引用类型。
- 后面的集合和泛型其实也只能支持包装类型，不支持基本数据类型。
3、包装类的自动装、拆箱
-
自动装箱：基本类型的数据和变量可以直接赋值给包装类型的变量；
-
自动拆箱：包装类型的变量可以直接赋值给基本类型的变量。
4、包装类的特有功能
-
包装类的变量的默认值可以是null，容错率更高。
-
可以把基本类型的数据转换成字符串类型（用处不大）。
-
1、调用
toString()方法得到字符串结果； -
2、调用
Integer.toString(基本类型的数据)。
-
-
可以把字符串类型的数值转换成真实的数据类型（真的很有用）。
-
1、
Integer.parseInt("字符串类型的整数")； -
2、
Double.parseDouble("字符串类型的小数")。
-
总结
1、包装类是什么，目的是什么？
- 基本数据类型对应的引用数据类型；
- 实现了一切皆对象；
- 后期集合和泛型不支持基本类型，只能使用包装类。
2、包装类有哪些特殊功能？
- 可以把基本类型的数据转换成字符串类型（没啥用，因为加一个空字符串更方便）；
- 可以把字符串类型的数值转换成真实的数据类型（真的很有用）。
二、正则表达式
1、正则表达式是啥？
-
正则表达式可以用一些规定的字符来指定规则，并用来校验数据格式的合法性。
-
比如： 规定用户名只能用英文命名，密码规定只能6位，手机号是否合法，就需要用正则表达式来校验。
2、正则表达式初体验
-
需求：假如现在要求校验一个QQ号是否正确，6位及20位之内，必须全部是数字。
-
先使用目前所学知识完成校验需求；然后体验一下正则表达式校验。
package com.app.d6_regex; /** 正则表达式初体验 需求：校验QQ号，必须全部是数字，6-20位 */ public class RegexDemo1 { public static void main(String[] args) { // 模拟用户输入QQ号 String inputQQ1 = "323432234"; // 合法，true String inputQQ2 = "2234322sd34"; // 非法，false String inputQQ3 = "345634636436436433463"; // 非法，false String inputQQ4 = "12343"; // 非法，false String inputQQ5 = "342344"; // 合法，true String inputQQ6 = null; // 非法，false System.out.println(checkQQ(inputQQ1)); // true System.out.println(checkQQ(inputQQ2)); // false System.out.println(checkQQ(inputQQ3)); // false System.out.println(checkQQ(inputQQ4)); // false System.out.println(checkQQ(inputQQ5)); // true System.out.println(checkQQ(inputQQ6)); // false System.out.println("--------------------------"); // 正则表达式初体验：利用正则表达式校验QQ号是否合法 String input1 = "023432234"; // 合法，true String input2 = "2234322sd34"; // 非法，false String input3 = "345634636436436433463"; // 非法，false String input4 = "12343"; // 非法，false String input5 = "342344"; // 合法，true String input6 = null; // 非法，false System.out.println(regexCheckQQ(input1)); // true System.out.println(regexCheckQQ(input2)); // false System.out.println(regexCheckQQ(input3)); // false System.out.println(regexCheckQQ(input4)); // false System.out.println(regexCheckQQ(input5)); // true System.out.println(regexCheckQQ(input6)); // false } /** * 用正则表达式校验QQ是否合法的方法 * @param qq 接收用户输入的QQ号 * @return QQ号合法返回true，否则返回false */ public static boolean regexCheckQQ(String qq) { // "\\d"：第一个 "\" 是转义的意思，相当于是告诉第二个 "\" 你就是一个杠 // "\d"：代表全数字：0-9 // {6,20}：代表是6-20位之间 // 输入的QQ号不能为null 且 全部是0-9之间的数字，6-20位之间时，返回true，否则返回false return qq != null && qq.matches("\\d{6,20}"); } /** * 检验QQ号是否合法的方法 * @param qq 接收用户输入的QQ号 * @return QQ号合法返回true，否则返回false */ public static boolean checkQQ(String qq) { // 1、当用户输入的QQ为null 或 长度小于6 或 长度大于20 时： if (qq == null || qq.length() < 6 || qq.length() > 20){ // 说明符合判断条件，返回false return false; } // 假如输入QQ号：2345425af34 // 2、需要遍历这个QQ号，得到每位字符： for (int i = 0; i < qq.length(); i++) { // a、得到每位字符 char ch = qq.charAt(i); // b、当得到的字符不是数字时： if (ch < '0' || ch > '9') { // 说明超出了 0-9的范围，不是数字，返回false return false; } } // 3、遍历结束，说明全部是数字，返回true return true; } }true false false false true false -------------------------- true false false false true false Process finished with exit code 0
3、正则表达式的匹配规则
（1）字符类（默认匹配一个字符）
规则 说明
[abc] 只能是a, b, 或c
[^abc] 除了a, b, c之外的任何字符
[a-zA-Z] a到z A到Z，包括（范围）——>大小写英文字母
[a-d[m-p]] a到d，或m通过p：（[a-dm-p]联合）
[a-z&&[def]] d, e, 或f(交集)
[a-z&&[^bc]] a到z，除了b和c：（[ad-z]减法）
[a-z&&[^m-p]] a到z，除了m到p：（[a-lq-z]减法）
（2）预定义的字符类（默认匹配一个字符）
规则 说明
. 任何字符
\d 一个数字：[0-9]
\D 非数字：[^0-9]
\s 一个空白字符：[\t\n\x0B\f\r]
\S 非空白字符：[^\s]
\w [a-zA-Z_0-9]英文、数字、下划线
\W [^\w]一个非单词字符
（3）贪婪的量词（配合匹配多个字符）
规则 说明
X? X，一次或根本不
X* X，零次或多次
X+ X，一次或多次
X{n} X，正好n次
X{n,} X，至少n次
X{n,m} X，至少n次但不超过m次
（4）字符串对象提供了匹配正则表达式规则的API
| 方法 | 说明 |
|---|---|
| public boolean matches(String regex) | 判断是否匹配正则表达式，匹配返回true，不匹配返回false |
package com.app.d6_regex;
/**
目标：全面、深入学习正则表达式的匹配规则
*/
public class RegexDemo2 {
public static void main(String[] args) {
// public boolean matches(String regex): 判断是否与正则表达式匹配，匹配返回true，否则返回false
// 以下都是默认匹配一个字符：
// 只能是 a、b、c
System.out.println("a".matches("[abc]")); // true
System.out.println("z".matches("[abc]")); // false
// 不能出现 a、b、c
System.out.println("a".matches("[^abc]")); // false
System.out.println("z".matches("[^abc]")); // true
// 只能是一个数字
System.out.println("a".matches("\\d")); // false
System.out.println("12".matches("\\d")); // false
System.out.println("1".matches("\\d")); // true
// 只能是一个大小写英文字母、数字、下划线
System.out.println("a".matches("\\w")); // true
System.out.println("A".matches("\\w")); // true
System.out.println("z".matches("\\w")); // true
System.out.println("Z".matches("\\w")); // true
System.out.println("_".matches("\\w")); // true
System.out.println("3".matches("\\w")); // true
System.out.println("abc".matches("\\w")); // false
System.out.println("ABC".matches("\\w")); // false
System.out.println("32".matches("\\w")); // false
System.out.println("你".matches("\\w")); // false
System.out.println("--------------------------------------");
// 校验密码
// 必须是数字、字母、下划线 至少 6位
String regex1 = "\\w{6,}"; // \\w：代表字母、数字、下划线
System.out.println("123Abc_D".matches(regex1)); // true
System.out.println("你真6_Abb".matches(regex1)); // false
System.out.println("123Ab".matches(regex1)); // false
// 验证码：必须是数字、字符，必须是4位
/*
方式1：
[a-zA-Z0-9] ——>代表只要大小写英文字符，数字
{4} ——>代表只要4次
*/
String regex2 = "[a-zA-Z0-9]{4}"; // 字符、数字、正好4次，其他的都不要
System.out.println("43Gh".matches(regex2)); // true
System.out.println("@_2f".matches(regex2)); // false
/*
方式2：
[\\w&&[^_]] ——>代表从字符、数字、下划线中去掉下划线
{4} ——>代表只要4次
*/
String regex3 = "[\\w&&[^_]]{4}"; // 字符、数字，除了下划线，正好4次，其他都不要
System.out.println("5T7c".matches(regex2)); // true
System.out.println("4h_@".matches(regex2)); // false
}
}
true
false
false
true
false
false
true
true
true
true
true
true
true
false
false
false
false
--------------------------------------
true
false
false
true
false
true
false
Process finished with exit code 0
总结
1、String类的哪个方法可以与正则表达式进行匹配？
- String类的
matches()方法：判断是否与正则表达式匹配，是则返回true，否则返回false。
2、如果忘了匹配规则去哪里找啊？
-
官网找到开发文档下载位置：
-
下载成功后，解压之后，打开这个路径：
-
双击打开后，输入框输入
Pattern，按回车键
4、正则表达式的常见案例
案例一
-
请使用正则表达式完成如下需求：
- 请编写程序模拟用户输入手机号码、邮箱号码、电话号码，验证格式是否正确，并给出提示，直到格式输入正确为止。
-
分析实现：
1、创建键盘录入对象，用于录入用户输入的数据：手机号码、邮箱号码、电话号码； 2、定义校验手机号码的方法，验证格式是否正确，不正确给出提示，直到格式输入正确为止； 3、定义校验邮箱号码的方法，验证格式是否正确，不正确给出提示，直到格式输入正确为止； 4、定义校验电话号码的方法，验证格式是否正确，不正确给出提示，直到格式输入正确为止； 5、调用校验手机号码的方法，完成校验！ 6、调用校验邮箱号码的方法，完成校验！ 7、调用检验电话号码的方法，完成校验！package com.app.d6_regex; import java.util.Scanner; /** 目标：使用正则表达式校验：手机号码、邮箱号码、电话号码 */ public class RegexTest3{ public static void main(String[] args) { // 1、创建键盘录入对象，用于录入用户输入的数据：手机号码、邮箱号码、电话号码； Scanner sc = new Scanner(System.in); // 5、调用校验手机号码的方法，完成校验！ checkPhone(sc); // 6、调用校验邮箱号码的方法，完成校验！ checkEmail(sc); // 7、调用检验电话号码的方法，完成校验！ checkTel(sc); } /** * 4、定义校验电话号码(座机)的方法 * @param sc 接一个扫描器对象，用于用户输入数据 */ public static void checkTel(Scanner sc) { // a、定义循环：电话格式有误时重新输入，直到格式输入正确为止 while (true) { // b、用户输入电话 System.out.println("请输入您的电话号码(座机)："); String email = sc.next(); // c、定义校验电话的正则表达式 /* 021-2532555、03525245235、... 0 ——>代表第一位必须是0 \\d{2,6} ——>代表0之后的6位号码都是数字，必须至少2-6次 -? ——>代表中间的 "-" 可以1次或者没有，也就是可有可无 \\d{5,15} ——>代表6位号码之后的15位，必须至少5-15次 */ String regex = "0\\d{2,6}-?\\d{5,15}"; // d、校验电话 if (email.matches(regex)) { System.out.println("您输入的电话格式正确！^_^"); break; }else { System.out.println("电话格式有误！"); } } } /** * 3、定义校验邮箱号码的方法 * @param sc 接一个扫描器对象，用于用户输入数据 */ public static void checkEmail(Scanner sc) { // a、定义循环：邮箱格式有误时重新输入，直到格式输入正确为止 while (true) { // b、用户输入邮箱 System.out.println("请输入您的邮箱："); String email = sc.next(); // c、定义校验邮箱的正则表达式 /* 4234234@qq.com、acd123Ef@163.com、feg24244334@paic.com.cn、... \\w{6,20} ——>代表数字、字符、下划线，都至少6-20次之内 @ ——>代表@ [a-zA-Z0-9]{2,10} ——>代表数字、字母，都至少2-10次之内 (\\.[a-zA-Z0-9]{2,10}) ——>等同于 .com，代表数字、字母，都至少2-10次之内 {1,2} ——>等同于会出现 .com(一级域名) 或者会出现 .com.cn(二级域名) */ String regex = "\\w{6,20}@[a-zA-Z0-9]{2,10}(\\.[a-zA-Z0-9]{2,10}){1,2}"; // d、校验邮箱 if (email.matches(regex)) { System.out.println("您输入的邮箱格式正确！^_^"); break; }else { System.out.println("邮箱格式有误！"); } } } /** * 2、定义校验手机号码的方法 * @param sc 接一个扫描器对象，用于用户输入数据 */ public static void checkPhone(Scanner sc) { // a、定义循环：手机号码格式有误时重新输入，直到格式输入正确为止 while (true) { // b、用户输入手机号码 System.out.println("请输入您的手机号码："); String phone = sc.next(); // c、定义校验手机号码的正则表达式 /* 18845764546、13534643421 ... 1[3-9] ——>代表前两位号码：13、14、15、16、17、18、19 \\d ——>代表一个0-9的数字 {9} ——>代表后9位号码，只能正好9次，这样加上前2位总共就是11位的手机号码 */ String regex = "1[3-9]\\d{9}"; // d、校验手机号码 if (phone.matches(regex)) { System.out.println("您输入的手机号码格式正确！^_^"); break; }else { System.out.println("手机号码格式有误！"); } } } }请输入您的手机号码： 13534643421 您输入的手机号码格式正确！^_^ 请输入您的邮箱： 42342$_34@qq.com 邮箱格式有误！ 请输入您的邮箱： 4234234@qq.com 您输入的邮箱格式正确！^_^ 请输入您的电话号码(座机)： 027-2532555 您输入的电话格式正确！^_^ Process finished with exit code 0
案例二
-
需求：校验金额是否合法：
-
比如
242323、345.45、0.45、6.4、0.5、3、34这些都合法； -
比如
2342.243、34.3554、0.33.3、2.3.4、0.345这些都不合法。package com.app.d6_regex; import java.util.Scanner; /** 目标：校验金额 */ public class RegexTest4 { public static void main(String[] args) { // 2、调用校验金额方法，完成校验！ checkMoney(); } /** * 1、定义校验金额的方法 */ public static void checkMoney(){ // a、创建键盘录入对象，用于输入数据 Scanner sc = new Scanner(System.in); // b、定义死循环：校验金额非法时，重新输入 while (true) { // c、输入金额 System.out.println("请您输入金额："); String money = sc.next(); // d、定义校验金额的正则表达式 /* 合法：10、99.5、8.9、0.5。 非法：7.5.6、0.55.6。 [0-9]+ ——>代表0-9之间的数可以出现至少1次或多次 | ——>或的意思 [\\d]+\\. ——>代表小数点前的数字可以出现1次或多次 [\\d]{2} ——>代表小数点后的数字只能出现2次（保留两位小数） */ String regex = "[0-9]+|[\\d]+\\.[\\d]{2}"; // e、校验金额 if (money.matches(regex)) { System.out.println("合法金额！^_^"); break; }else { System.out.println("非法金额！"); } } } }请您输入金额： 0.343 非法金额！ 请您输入金额： 4.3.3 非法金额！ 请您输入金额： 0.343.323 非法金额！ 请您输入金额： 34.35353 非法金额！ 请您输入金额： 234234.342 非法金额！ 请您输入金额： 2342234 合法金额！^_^ Process finished with exit code 0
-
5、正则表达式在方法中的应用
| 方法 | 说明 |
|---|---|
| public String replaceAll(String regex,String newStr) | 按照正则表达式匹配的内容进行替换 |
| public String[] split(String regex) | 按照正则表达式匹配的内容进行分割字符串，返回一个字符串数组。 |
package com.app.d6_regex;
/**
目标：正则表达式在方法中的应用
1、public String[] split(String regex):
按照正则表达式匹配的内容进行分割字符串，返回一个字符串数组；
2、public String replaceAll(String regex, String newStr):
按照正则表达式匹配的内容进行替换，返回一个字符串结果；
*/
public class RegexDemo5 {
public static void main(String[] args) {
// 按照正则表达式匹配的内容进行分割字符串，返回一个字符串数组；
// 模拟得到一串混乱的数据，但是你想拿出这串里面的人物名字
String names = "唐僧SDgdgs3242fsd孙悟空sfdf3532猪八戒&43$#_fds沙和尚";
/*
\\w ——>代表数字、单词字符、下划线
\\p{Punct} ——>代表标点符号：其中之一!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
+ ——>代表出现1次或多次
[\\w\\p{Punct}]+ ——>将出现1次或多次的数字、单词字符、下划线、标点符号都分割掉
*/
String[] strArrays = names.split("[\\w\\p{Punct}]+");
// 遍历分割后得到的人物名字
for (int i = 0; i < strArrays.length; i++) {
System.out.println(strArrays[i]);
}
System.out.println("---------------------------");
// 按照正则表达式匹配的内容进行替换，返回一个字符串结果；
String names2 = names.replaceAll("[\\w\\p{Punct}]+", " ");
System.out.println(names2);
}
}
唐僧
孙悟空
猪八戒
沙和尚
---------------------------
唐僧 孙悟空 猪八戒 沙和尚
Process finished with exit code 0
6、正则表达式支持爬取信息
package com.app.d6_regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
目标：正则表达式爬取信息中的内容[拓展]。
*/
public class RegexTest6 {
public static void main(String[] args) {
// 模拟从网上爬到一段信息数据
String data = "来b站一起学习Java，电话：022-46568794，或者联系邮箱：" +
"bilibili@bili.com.cn，电话：18878566724，0246574564" +
"邮箱：bizhan@bili.com，400-100-4535，4001004534";
// 需求：从以上信息中爬取出 电话、邮箱
// 1、定义爬取电话、邮箱的正则表达式
/*
邮箱爬取规则：
\\w+ ：代表数字、单词字符出现1次或多次
@ ：代表@
\\.\\w+ ：代表 . 后的数字、单词字符出现1次或多次
{1,2} ：代表可以出现：.com(一级域名) 或 .com.cn(二级域名)
| ：或其他规则的意思
手机号爬取规则：
1[3-9] ：代表手机号的前2位号码
\\d{9} ：代表手机号的后9位号码，只能出现9次
| ：或其他规则的意思
电话(0开头座机)爬取规则：
0\\d{2,6} ：代表电话前3位号码，至少出现2-6次
-? ：代表 "-" 可有可无
\\d{5,15} ：代表电话后15位号码，至少出现5-15次
电话(4开头座机)爬取规则：
400 ：代表电话前3位号码
-? ：代表 "-" 可有可无
\\d{3,9} ：代表电话中间几位号码，至少出现3-9次
-?\\d{3,9} ：代表电话后几位号码，至少出现3-9次
*/
String regex = "(\\w+@\\w+(\\.\\w+){1,2})|" + "(1[3-9]\\d{9})|" +
"(0\\d{2,6}-?\\d{5,15})|(400-?\\d{3,9}-?\\d{3,9})";
// 2、把这个爬取规则编译成匹配对象
Pattern pattern = Pattern.compile(regex);
// 3、得到一个信息匹配器对象
Matcher matcher = pattern.matcher(data);
// 4、定义死循环，根据信息匹配器去爬取规则指定信息
while (matcher.find()) {
// 5、每爬取到一个指定信息，就分为一组
String result = matcher.group();
// 6、输出爬取到的信息
System.out.println(result);
}
}
}
022-46568794
bilibili@bili.com.cn
18878566724
0246574564
bizhan@bili.com
400-100-4535
4001004534
Process finished with exit code 0
三、Arrays类
1、Arrays是啥？
- 数组操作工具类，专门用于操作数组元素的。
2、Arrays类的常用API
| 方法 | 说明 |
|---|---|
| public static String toString(类型[] a) | 对数组进行排序 |
| public static void sort(类型[] a) | 对数组进行默认升序排序 |
| public static < T > void sort(类型[] a, Comparator<? super T> c) | 使用比较器对象自定义排序 |
| public static int binarySearch(int[] a, int key) | 二分搜索数组中的数据，存在返回索引，不存在返回-1 |
package com.app.d7_arrays;
import java.util.Arrays;
/**
目标：学会使用Arrays类的常用API，并理解其原理
*/
public class ArraysDemo1 {
public static void main(String[] args) {
int[] arr = {20, 3, 43, 34, 12, 400};
System.out.println(arr); // 数组对象的内存地址
// 1、返回数组的内容，toString(数组)
// String rs = Arrays.toString(arr);
// System.out.println(rs); // [20, 3, 43, 34, 12, 400]
System.out.println(Arrays.toString(arr)); // [20, 3, 43, 34, 12, 400]
System.out.println("---------------------------");
// 2、排序的API(默认自动对数组元素进行升序排序)
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
System.out.println("---------------------------");
// 3、二分搜索技术，binarySearch(数组, 要找的元素值)
// 前提：数组必须先排序好才支持，否则出bug
int index1 = Arrays.binarySearch(arr, 20); // 返回这个元素的位置索引
System.out.println(index1); // 2
// 返回不存在元素的规律：- (应该插入的位置索引 + 1)
int index2 = Arrays.binarySearch(arr, 18);
System.out.println(index2); // -3
System.out.println("---------------------------");
// 注意：数组如果没有排好序，进行二分搜索，可能会找不到存在的元素，从而出现bug！！
int[] arr2 = {11, 36, 34, 25, 13, 24, 233, 100};
System.out.println(Arrays.binarySearch(arr2, 36)); // -7
}
}
[I@119d7047
[20, 3, 43, 34, 12, 400]
---------------------------
[3, 12, 20, 34, 43, 400]
---------------------------
2
-3
---------------------------
-7
Process finished with exit code 0
3、Arrays类对于Comparator比较器的支持
（1）Arrays类的排序方法
| 方法 | 说明 |
|---|---|
| public static void sort(类型[] a) | 对数组进行默认升序排序 |
| public static < T> void sort(类型[] a, Comparator<? super T> c) | 使用比较器对象自定义排序 |
（2）自定义排序规则
-
设置Comparator接口对应的比较器对象，来定制比较规则。
如果认为左边数据 大于 右边数据，则返回正整数。 如果认为左边数据 小于 右边数据，则返回负整数。 如果认为左边数据 等于 右边数据，则返回0。
package com.app.d7_arrays;
import java.util.Arrays;
import java.util.Comparator;
/**
目标：学会自定义数组的排序规则：Comparator 比较器对象
*/
public class ArraysDemo2 {
public static void main(String[] args) {
// 1、Arrays的sort方法对于有值特性的数组是默认升序排序的
int[] ages1 = {36, 12, 66, 23};
System.out.println(Arrays.toString(ages1)); // 未排序
Arrays.sort(ages1); // 默认升序排序
System.out.println(Arrays.toString(ages1)); // 升序排序后
System.out.println("---------------------------");
// 2、需求：降序排序！（自定义比较器对象，只能支持引用类型的排序！！）
// 引用类型：数据类型、自定义的类的类型
Integer[] ages2 = {36, 12, 66, 23};
/*
参数一：被排序的数组，必须是引用类型的元素。
参数二：匿名内部类对象，代表一个比较器对象。
*/
Arrays.sort(ages2, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
// 自定义排序规则: 升序
/*if (o1 > o2) {
return 1; // 如果左边 大于 右边，返回一个正整数（任意）
} else if (o1 < o2) {
return -1; // 如果左边 小于 右边，返回一个负整数（任意）
}
return 0; // 如果左边 等于 右边，返回一个0*/
/*
优化以上升序排序代码：
如果左边 减 右边，得到的差是一个正整数，则返回一个正整数
如果左边 减 右边，得到的差是一个负整数，则返回一个负整数
如果左边 减 右边，得到的差是一个0，则返回0
*/
// return o1 - o2; // 升序排序
// 颠倒o1和o2的位置，就为降序排序
return o2 - o1; // 降序排序
}
});
System.out.println(Arrays.toString(ages2)); // 排序后
}
[36, 12, 66, 23]
[12, 23, 36, 66]
---------------------------
[66, 36, 23, 12]
Process finished with exit code 0
package com.app.d7_arrays;
/**
自定义类：学生类
*/
public class Student {
/**
学生属性：学号、姓名、年龄、身高
*/
private int id;
private String name;
private int age;
private double height;
/**
提供无参、有参构造器
*/
public Student() {
}
public Student(int id, String name, int age, double height) {
this.id = id;
this.name = name;
this.age = age;
this.height = height;
}
/**
提供属性对应的getter、setter方法，暴露其取值和赋值
*/
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;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
/**
重写toString方法，格式化输出
*/
@Override
public String toString() {
return "Student{" +
"学号: " + id +
", 姓名: '" + name + '\'' +
", 年龄: " + age +
", 升高: " + height +
'}'+"\n";
}
}
package com.app.d7_arrays;
import java.util.Arrays;
import java.util.Comparator;
/**
目标：学会自定义数组的排序规则：Comparator 比较器对象
*/
public class ArraysDemo2 {
public static void main(String[] args) {
System.out.println("---------------------------");
// 3、Arrays的sort方法对引用自定义类型的数组进行排序
// （自定义比较器对象，只能支持引用类型的排序！！）
Student[] students = new Student[3]; // 用于存储3个学生对象
students[0] = new Student(201903, "张飞", 34,185.6);
students[1] = new Student(201901, "刘备", 42, 175.5);
students[2] = new Student(201902, "关羽", 36, 198.3);
// Arrays.sort(students); // 会直接运行崩溃，因为不知道根据哪个属性来进行排序
// 因此，需要自定义排序规则
Arrays.sort(students, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getId() - o2.getId(); // 根据学号进行升序排序
// return o1.getAge() - o2.getAge(); // 根据年龄进行升序排序
// return o2.getId() - o1.getId(); // 根据学号进行降序排序
// return o2.getAge() - o1.getAge(); // 根据年龄进行降序排序
// 这样会导致：170.3 - 170.0 = 0，因为转为整型会直接将小数点后的数据干掉
// return (int) (o1.getHeight() - o2.getHeight()); // 根据身高进行升序排序
// 注意：浮点型排序，需要用：引用类型.compare()方法
// return Double.compare(o1.getHeight(), o2.getHeight()); // 根据身高进行升序排序
// return Double.compare(o2.getHeight(), o1.getHeight()); // 根据身高进行降序排序
}
});
System.out.println(Arrays.toString(students)); // 排序后
}
}
---------------------------
[Student{学号: 201901, 姓名: '刘备', 年龄: 42, 升高: 175.5}
, Student{学号: 201902, 姓名: '关羽', 年龄: 36, 升高: 198.3}
, Student{学号: 201903, 姓名: '张飞', 年龄: 34, 升高: 185.6}
]
Process finished with exit code 0
扫一扫
236
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
