本文介绍了Java中的包装类、正则表达式的基础概念和实战应用，涉及自动装箱拆箱、正则校验QQ号码、邮箱格式验证，以及Lambda表达式在Comparator和ActionListener中的简化使用。
文章目录
包装类
其实就是8种基本数据类型对应的引用类型。
| 基本数据类型 | 引用数据类型 |
|---|---|
| byte | Byte |
| short | Short |
| int | Interger |
| long | Long |
| char | Character |
| float | Float |
| double | Double |
| boolean | Boolean |
为什么提供包装类?
Java为了实现一切皆对象，为8种基本类型提供了对应的引用类型。
后面的集合和泛型其实也只能支持包装类型，不支持基本数据类型。
自动装箱： 基本 类型的数据和变量可以直接赋值给 包装类型 的变量。
自动拆箱：包装类型 的变量可以直接赋值给 基本数据类型 的变量。
包装类的特有功能
包装类的变量的默认值可以是null，容错率更高。
可以把基本类型的数据转换成字符串类型(用处不大)
调用toString()方法得到字符串结果。
调用Integer.toString(基本类型的数据)。
可以把字符串类型的数值转换成真实的数据类型（真的很有用）
Integer.parseInt(“字符串类型的整数”)
Double.parseDouble(“字符串类型的小数”)。
测试代码：
public class Test {
public static void main(String[] args) {
int a = 10;
Integer a1 = 11;
Integer a2 = a; // 自动装箱
System.out.println(a);
System.out.println(a1);
System.out.println(a2);
System.out.println("----------------");
Integer it = 100;
int it1 = it; // 自动拆箱
System.out.println(it1);
System.out.println("----------------");
double db = 99.5;
Double db1 = db; // 自动装箱
double db2 = db1;
System.out.println(db);
System.out.println(db1);
System.out.println(db2);
System.out.println("----------------");
// int age = null; // 报错了
Integer ag1 = null; // 包装类型即引用类型可以赋值为null
Integer age2 = 0;
System.out.println("----------------");
// 1. 包装类可以把基本类型的数据转换为字符串
Integer i3 = 2345;
String rs = i3.toString();
System.out.println(rs + 1); // 23451
String rs1 = Integer.toString(i3);
System.out.println(rs1 + 1); // 23451
System.out.println("----------------");
String number = "2334";
// 转换成整数
int age = Integer.parseInt(number);
System.out.println(age);
int age4 = Integer.valueOf(number);
System.out.println(age4);
// 转换成小数
String numberDouble = "99.99";
double score = Double.parseDouble(numberDouble);
System.out.println(score);
double score1 = Double.valueOf(numberDouble);
System.out.println(score);
}
}
正则表达式
正则表达式概述、初体验
正则表示：正则表达式可以用一些规定的字符来指定规则，并用来叫i眼格式的合法性。
需求：假如现在要求校验一个qq号码是否正确，6位及20位之内，必须全部是数字 。
先使用目前所学知识完成校验需求；然后体验一下正则表达式检验。
测试代码：
public class RegexDemo1 {
public static void main(String[] args) {
// 校验qq号码，必须全部数字 6 - 20
System.out.println(checkQQ("432785734895")); // true
System.out.println(checkQQ("2342354jk")); // false
System.out.println(checkQQ(null)); // false
System.out.println(checkQQ("83745832787234809672834")); // false
System.out.println("---------------------------------");
System.out.println(checkQQ1("432785734895")); // true
System.out.println(checkQQ1("2342354jk")); // false
System.out.println(checkQQ1(null)); // false
System.out.println(checkQQ1("809672834")); // true
}
public static boolean checkQQ1(String QQ){
// return QQ != null && QQ.matches("\\d{6,21}"); // {6,21}中间没有空格的哦
return QQ != null && QQ.matches("[0-9]{6,21}"); // 官方文档里面都是没有空格的
}
public static boolean checkQQ(String QQ){
if(QQ == null || QQ.length() < 6 || QQ.length() > 20){
return false;
}
for (int i = 0; i < QQ.length(); i++) {
char ch = QQ.charAt(i);
if(ch < '0' || ch > '9'){
return false;
}
}
return true;
}
}
正则表达式的匹配规则
字符串对象提供了匹配正则表达式的方法
public boolean matches(String regex): 判断是否匹配正则表达式，匹配返回true，不匹配返回false。
字符类(默认匹配一个字符)
[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]减法）
预定义的字符类(默认匹配一个字符)
. 任何字符
\d 一个数字： [0-9]
\D 非数字： [^0-9]
\s 一个空白字符： [ \t\n\x0B\f\r]
\S 非空白字符： [^\s]
\w [a-zA-Z_0-9] 英文、数字、下划线
\W [^\w] 一个非单词字符
贪婪的量词（配合匹配多个字符）
X? X , 一次或根本不
X* X，零次或多次
X+ X，一次或多次
X {n} X，正好n次
X {n, } X, 至少n次
X {n,m} X，至少n但不超过m次
1、String类的哪个方法可以与正则表达式进行匹配。
public boolean matches(String regex):
判断是否匹配正则表达式，匹配返回true，不匹配返回false。
测试代码：
public class RegexDemo2 {
public static void main(String[] args) {
// public boolean matches(String regex):
// a, b , c
System.out.println("a".matches("[abc]")); // true
System.out.println("z".matches("[abc]")); // false
// 不能出现abc
System.out.println("a".matches("[^abc]")); // false
System.out.println("z".matches("[^abc]")); // true
// 下面都是单个字符进行匹配
System.out.println("a".matches("\\d")); // false
System.out.println("3".matches("\\d")); // ture
System.out.println("333".matches("\\d")); // false
System.out.println("z".matches("\\w")); // true "\w": [a-zA-Z_0-9] 英文、数字、下划线
System.out.println("2".matches("\\w")); // true\W
System.out.println("21".matches("\\w")); // false
System.out.println("宁".matches("\\w"));; // false
System.out.println("宁".matches("\\W")); // true "\W"或者[^\w]： 一个非单词字符
System.out.println("----------------------------");
// 密码校验，必须是数字 字母，下划线，至少六位
System.out.println("dkjfk_3489".matches("[\\w]{6,}")); // true
System.out.println("2345".matches("[\\w]{6,}")); // false
System.out.println("----------------------------");
// 验证码 必须是数字和字母 4位数 \\w: 字母，数字，下划线；
System.out.println("89er".matches("[\\w&&[^_]]{4}")); // true
System.out.println("8_er".matches("[\\w&&[^_]]{4}")); // false
System.out.println("89df".matches("[0-9a-zA-Z]{4}")); // true
System.out.println("89_f".matches("[0-9a-zA-Z]{4}")); // false
}
}
正则表达式的常见案例
请使用正则表达式完成如下需求：
需求
请编写程序模拟用户输入手机号码、验证格式正确，并给出提示，直到格式输入正确为止。
请编写程序模拟用户输入邮箱号码、验证格式正确，并给出提示，直到格式输入正确为止。
请编写程序模拟用户输入电话号码、验证格式正确，并给出提示，直到格式输入正确为止。
分析
定义方法，接收用户输入的数据，使用正则表达式完成检验，并给出提示。
实现代码：
public class RegexDemo3 {
public static void main(String[] args) {
// checkPhone();
checkMobilePhone();
// checkEmail();
}
public static void checkMobilePhone(){
Scanner sc = new Scanner(System.in);
while (true){
System.out.println("输入你的手机号: ");
String phone = sc.next();
if(phone.matches("(400-?100-?\\d{3,6})")){
System.out.println("手机号合法！！");
break;
}else {
System.out.println("手机号输入错误，请重新输入：");
}
}
}
public static void checkEmail(){
Scanner sc = new Scanner(System.in);
while (true){
System.out.println("输入你的邮箱: ");
String phone = sc.next();
/**
判断邮箱格式是否正确 3268847878@qq.com
判断邮箱格式是否正确 3268847dsda878@163.com
判断邮箱格式是否正确 3268847dsda878@pci.com.cn
*/
if(phone.matches("\\w{1,20}@[a-z0-9A-Z]{1,5}(\\.[a-z0-9A-Z]{1,3}){1,2}")){
System.out.println("邮箱合法！！");
break;
}else {
System.out.println("邮箱输入错误，请重新输入：");
}
}
}
public static void checkPhone(){
Scanner sc = new Scanner(System.in);
while (true){
System.out.println("输入你的手机号: ");
String phone = sc.next();
if(phone.matches("1[3-9]\\d{9}")){
System.out.println("手机号合法！！");
break;
}else {
System.out.println("手机号输入错误，请重新输入：");
}
}
}
}
正则表达式在方法中的应用
正则表达式在字符串方法中的使用
| 方法名 | 说明 |
|---|---|
| public String replaceAll(String regex,String newStr) | 按照正则表达式匹配的内容进行替换 |
| public String[] split(String regex) | 按照正则表达式匹配的内容进行分割字符串，反回一个字符串数组 |
测试代码：
正则表达式爬取信息
Arrays类
Arrays类概述：数组操作工具类，专门用于操作数组元素的。
Arrays类的常用API
测试类：
import java.util.Arrays;
public class ArraysDemo1 {
public static void main(String[] args) {
int[] arr = {10, 2, 44, 23, 24, 200};
System.out.println(arr); // arr默认调用toString方法，打印的是地址说明没有重写toString方法
System.out.println(arr.toString());
// 1. 返回数组内容的toString(数组)
String rs = Arrays.toString(arr); // Arrays类中重写了toString方法，且该方法是静态的
System.out.println(rs);
// 2、 排序的API(默认自动对数组元素进行升序排序)
Arrays.sort(arr); // Arrays类有静态方法sort
System.out.println(Arrays.toString(arr));
// 3、利用二分搜索技术(前提数组必须排好序才支持，否则出bug)
int index = Arrays.binarySearch(arr, 44); // Arrays类有静态方法binarySearch
System.out.println(index); // 返回的数组下标
// 返回不存在元素的规律： -(应该插入的位置索引+1)
// [2, 10, 23, 24, 44, 200]
System.out.println(Arrays.binarySearch(arr, 0)); // -1
System.out.println(Arrays.binarySearch(arr, 30)); // -5
System.out.println(Arrays.binarySearch(arr, 100)); // -6
System.out.println(Arrays.binarySearch(arr, 1000)); // -7
}
}
Arrays类的排序方法
设置Comparator接口对应的比较器对象，来定制比较规则。
如果认为左边数据 大于 右边数据 返回正整数
如果认为左边数据 小于 右边数据 返回负整数
如果认为左边数据 等于 右边数据 返回0
测试代码：
import java.util.Arrays;
import java.util.Comparator;
public class ArraysDemo2 {
public static void main(String[] args) {
// 自定义数组的排序规则：Comparator比较器对象。
// 1. Arrays的sort方法对于有值特性的数组是默认升序排序
int[] ages = {34, 12, 42, 23};
Arrays.sort(ages);
System.out.println(ages);
System.out.println(Arrays.toString(ages));
// 2. 需求，降序排序！(自定义比较器对象，只能支持引用类型的排序)
Integer[] ages1 = {12, 45, 56, 567};
/**
* 参数1：被排序的数组必须是引用类型的元素。
* 参数2：匿名内部类对象，代表了一个比较器对象。
*/
Arrays.sort(ages1, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 -o1; // 个人理解：后面减去见面是降序
// return o1 - o2; // 个人理解：前面减去后面是升序
}
});
System.out.println(Arrays.toString(ages1));
System.out.println("-----------------------");
Student[] students = new Student[3];
students[0] = new Student("吴磊",23 , 175.5);
students[1] = new Student("谢鑫",18 , 185.5);
students[2] = new Student("王亮",20 , 195.5);
// Arrays.sort(students); // 程序直接崩掉
Arrays.sort(students, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
// 返回值必须是int的
// return o2.getAge() - o1.getAge(); // 按照年龄降序
// return o1.getAge() - o2.getAge(); // 按照年龄升序
// 按照升高升序，这里要利用Double的compare方法，应为身高的差值为double类型，而返回值类型却是int类型
// return Double.compare(o1.getHeight(), o2.getHeight());
return Double.compare(o2.getHeight(), o1.getHeight()); // 按照身高降序
}
});
System.out.println(Arrays.toString(students));
}
}
Lambda表达式
Lambda概述
Lambda表达式是JDK 8开始后的一种新语法形式。
作用：简化匿名内部类的代码写法。
Lambda表达式的简化格式
(匿名内部类被重写方法的形参列表) -> { 被重写方法的方法体代码。}
注：-> 是语法形式，无实际含义
什么是函数式@@@接口？重点
首先必须是接口、其次接口中有且仅有一个抽象方法的形式
注意：Lambda表达式只能简化 函数式接口(@FunctionalInterface) 的匿名内部类的写法形式
1、Lambda表达式的基本作用？
简化函数式接口的匿名内部类的写法。
2、Lambda表达式有什么使用前提？
必须是接口的匿名内部类，接口中只能有一个抽象方法
Lambda实战-简化常见函数式接口
Lambda表达式简化Comparator接口的匿名形式
import java.util.Arrays;
import java.util.Comparator;
public class LambdaDemo03 {
public static void main(String[] args) {
Integer[] age = {34, 12, 42, 23};
/**
* 参数1：被排序的数组 必须是引用类型的元素
* 参数二：匿名内部类对象，代表一个比较器
*/
// 第一种写法
// Arrays.sort(age, new Comparator<Integer>() {
// @Override
// public int compare(Integer o1, Integer o2) {
// return o2 -o1; // 降序
// }
// });
// 第二种写法
// Arrays.sort(age, (Integer o1, Integer o2) -> {
// return o2 -o1; // 降序
// });
// 第三种写法
// Arrays.sort(age, (o1, o2) -> {
// return o2 - o1; // 降序
// });
// 第四种写法
Arrays.sort(age, (o1, o2) -> o2 - o1);
System.out.println(Arrays.toString(age));
}
}
Lambda表达式简化按钮监听器ActionListener的匿名内部类形式
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class LambdaDemo03 {
public static void main(String[] args) {
JFrame win = new JFrame("登录界面");
JButton btn = new JButton("我是一个很大的按钮");
// // 第一种写法
// btn.addActionListener(new ActionListener() {
// @Override
// public void actionPerformed(ActionEvent e) {
// System.out.println("有人点我，点我，点我~~~");
// }
// });
// // 第2种写法
// btn.addActionListener((ActionEvent e) -> {
// System.out.println("有人点我，点我，点我~~~");
// });
// // 第3种写法
// btn.addActionListener( e -> {
// System.out.println("有人点我，点我，点我~~~");
// });
// 第4种写法
btn.addActionListener( e -> System.out.println("有人点我，点我，点我~~~"));
win.add(btn);
win.setSize(400, 300);
win.setVisible(true);
}
}
注意：通常我们见到的函数式接口上都有一个@FunctionalInterface注解，标记该接口必须是满足函数式接口。
Lambda表达式的省略规则
1、参数类型可以省略不写；
2、如果只有一个参数，参数类型可以省略，同时()也可以省略；
3、如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写,同时要省略分号；
4、如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写。此时，如果这行代码是return语句，必须省略return不写，同时也必须省略";"不写。
注：省略的具体形式可以见Lambda实战-简化常见函数式接口中的3,4方法。
扫一扫
104
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
