一、包装类

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";                  // 合法，trueString inputQQ2 = "2234322sd34";                // 非法，falseString inputQQ3 = "345634636436436433463";      // 非法，falseString inputQQ4 = "12343";                      // 非法，falseString inputQQ5 = "342344";                     // 合法，trueString inputQQ6 = null;                         // 非法，falseSystem.out.println(checkQQ(inputQQ1));  // trueSystem.out.println(checkQQ(inputQQ2));  // falseSystem.out.println(checkQQ(inputQQ3));  // falseSystem.out.println(checkQQ(inputQQ4));  // falseSystem.out.println(checkQQ(inputQQ5));  // trueSystem.out.println(checkQQ(inputQQ6));  // falseSystem.out.println("--------------------------");// 正则表达式初体验：利用正则表达式校验QQ号是否合法String input1 = "023432234";                  // 合法，trueString input2 = "2234322sd34";                // 非法，falseString input3 = "345634636436436433463";      // 非法，falseString input4 = "12343";                      // 非法，falseString input5 = "342344";                     // 合法，trueString input6 = null;                         // 非法，falseSystem.out.println(regexCheckQQ(input1));  // trueSystem.out.println(regexCheckQQ(input2));  // falseSystem.out.println(regexCheckQQ(input3));  // falseSystem.out.println(regexCheckQQ(input4));  // falseSystem.out.println(regexCheckQQ(input5));  // trueSystem.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，否则返回falsereturn 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){// 说明符合判断条件，返回falsereturn 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的范围，不是数字，返回falsereturn false;}}// 3、遍历结束，说明全部是数字，返回truereturn true;}
}

    true
false
false
false
true
false
--------------------------
true
false
false
false
true
falseProcess 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、cSystem.out.println("a".matches("[abc]"));   // trueSystem.out.println("z".matches("[abc]"));   // false// 不能出现 a、b、cSystem.out.println("a".matches("[^abc]"));  // falseSystem.out.println("z".matches("[^abc]"));  // true// 只能是一个数字System.out.println("a".matches("\\d"));     // falseSystem.out.println("12".matches("\\d"));    // falseSystem.out.println("1".matches("\\d"));     // true// 只能是一个大小写英文字母、数字、下划线System.out.println("a".matches("\\w"));     // trueSystem.out.println("A".matches("\\w"));     // trueSystem.out.println("z".matches("\\w"));     // trueSystem.out.println("Z".matches("\\w"));     // trueSystem.out.println("_".matches("\\w"));     // trueSystem.out.println("3".matches("\\w"));     // trueSystem.out.println("abc".matches("\\w"));   // falseSystem.out.println("ABC".matches("\\w"));   // falseSystem.out.println("32".matches("\\w"));    // falseSystem.out.println("你".matches("\\w"));    // falseSystem.out.println("--------------------------------------");// 校验密码// 必须是数字、字母、下划线 至少 6位String regex1 = "\\w{6,}";  // \\w：代表字母、数字、下划线System.out.println("123Abc_D".matches(regex1));  // trueSystem.out.println("你真6_Abb".matches(regex1));  // falseSystem.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));     // trueSystem.out.println("@_2f".matches(regex2));   // false/*方式2：[\\w&&[^_]] ——>代表从字符、数字、下划线中去掉下划线{4} ——>代表只要4次*/String regex3 = "[\\w&&[^_]]{4}";   // 字符、数字，除了下划线，正好4次，其他都不要System.out.println("5T7c".matches(regex2));    // trueSystem.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
falseProcess 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
4001004534Process 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(数组, 要找的元素值)// 前提：数组必须先排序好才支持，否则出bugint index1 = Arrays.binarySearch(arr, 20);  // 返回这个元素的位置索引System.out.println(index1);     // 2// 返回不存在元素的规律：- (应该插入的位置索引 + 1)int index2 = Arrays.binarySearch(arr, 18);System.out.println(index2);     // -3System.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
---------------------------
-7Process 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>() {@Overridepublic 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方法，格式化输出*/@Overridepublic 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>() {@Overridepublic 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

71-Java的包装类、正则表达式、Arrays相关推荐

  1. 【Java】包装类 正则表达式 Arrays类 常见算法 泛型

    包装类         其实就是8种基本数据类型对应的引用类型 Java为了实现一切皆对象,为了8种基本类型提供了对应的引用类型 后面的集合和泛型其实也只是支持包装类型,不支持基本数据类型 自动装箱: ...

  2. java学习--基础知识进阶第五天--API、 Object类 System类、日期相关类、包装类正则表达式...

    今日内容介绍 u  Object类 & System类 u  日期相关类 u  包装类&正则表达式 第1章 Object类 & System类 1.1 Object类 1.1. ...

  3. Java基础：正则表达式

    相关阅读 Java基础:String类 Java字符串格式化 Java基础:正则表达式 1. 正则表达式概述 正则表达式,又称正规表示法.常规表示法(英语:Regular Expression,在代码 ...

  4. java中，正则表达式的使用 （最普通使用，Group，贪婪模式）

    目录 0.最普通的使用 1.正则表达式有Group功能. 2.正则表达式中的贪婪模式, 非贪婪模式(*?) 3.find() 与 matches() 之间的区别 ↓循环获取所有文件 ↓文件内部内容读取 ...

  5. Java中的正则表达式 regex

    常用类解析:正则表达式 regex 前言 一.正则表达式 二.匹配规则 三.匹配任意字符 四.匹配数字 五.匹配常用字符 六.匹配空格字符 七.匹配非数字 八.重复匹配 九.正则表达式小总结 十.匹配 ...

  6. java的数组与Arrays类源码详解

    java的数组与Arrays类源码详解 java.util.Arrays 类是 JDK 提供的一个工具类,用来处理数组的各种方法,而且每个方法基本上都是静态方法,能直接通过类名Arrays调用. 类的 ...

  7. java 风格的正则表达式 vs Perl风格的正则表达式

    java风格的正则表达式 1.^\d+$ //匹配非负整数(正整数 + 0) 2.^[0-9]*[1-9][0-9]*$ //匹配正整数 3.^((-\d+)|(0+))$ //匹配非正整数(负整数 ...

  8. java一年包装_浅谈Java的包装类

    一.什么是Java包装类 所谓Java包装类,就是将Java中的8种基本数据类型分别包装成为类的形式.包装类与基本数据类型的对应关系如下表所示. 基本数据类型 包装类 byte Byte short ...

  9. java js 正则表达式_如何在JavaScript与Java中使用正则表达式

    如何在JavaScript与Java中使用正则表达式 发布时间:2021-02-11 13:16:01 来源:亿速云 阅读:69 作者:Leah 如何在JavaScript与Java中使用正则表达式? ...

  10. 关于包装java_[java初探09]__关于java的包装类

    前言 在Java语言的学习过程中,我们逐渐的理解了Java面向对象的思想,与类和对象的应用.但是在基本数据类型的使用上,我们无法将其定义为一个对象,通过使用对象的方法来使用它们,但是Java语言的思想 ...

最新文章

  1. zabbix菜单出现问号乱码问题
  2. 【Azure Services Platform Step by Step-第1篇】INTRODUCING THE AZURE SERVICES PLATFORM
  3. C++拷贝构造函数(深拷贝与浅拷贝)
  4. QT [005] 数据库设计 - 一个被忽略的数据库show类 - ConnectionWidget Class
  5. 正确地组织python项目的结构
  6. 编历修改工作表中的控件属性(更新条形码)
  7. titanium开发教程-04-05从rows打开window
  8. 计算机加域后数据库无法登录,客户端多台计算机登录域失败，显示如下
  9. HTML5-单、多选框，按钮
  10. Linux的nc,局域网文件互传
  11. vue 自动播放视频
  12. Flutter Ticker类的用法
  13. 4、cas Server连接mysql
  14. 解决 org.gjt.mm.mysql.Driver 报错问题（目前有效，看后续会不会出什么问题）
  15. LaTeX中的宽度单位em,ex,px,pt
  16. 振动力学--vibration
  17. [MemTest太慢? 来试试这个压力更大吧!]分享一个快速测试内存超频出错的软件-TM5(和国外大佬的极限自定义配置)
  18. Spring Boot整合Nacos时遇到 java.lang.IllegalStateException: Context has been already given a name 的解决办法
  19. Unity 小游戏：3D射箭
  20. 【产品】支付宝蚂蚁森林产品体验报告

热门文章

  1. 中国少儿编程教育行业投资趋势与前景规划建议报告2022年版
  2. 阿里云轻量应用服务器最新价格表2023版（2核8G/4核8G/4核16G/8核16G/8核32G）
  3. javascript常见方法汇总之一——数组字符串相关
  4. 运行时常量池，字符串常量池
  5. Java面向对象(OOP)--内部类（匿名内部类）
  6. android仿抖音上下切换视频,微信小程序仿抖音视频之整屏上下切换功能的实现代码...
  7. 基于机器学习的webshell检测（一）
  8. c语言软件设计整体规划及方案,《C语言程序设计》网络课程建设方案.doc
  9. Android 圆角闪光遮照效果
  10. 练习3: 基本数据类型 (第3周)