1. 包装类
1.1 包装类概述
- 其实就是8种数据类型对应的引用类型
- Java为了实现一切皆对象,为8种基本类型提供了对应的引用类型。
- 后面的集合和泛型其实也只能支持包装类型,不支持基本数据类型。
自动装箱:基本类型的数据和变量可以直接赋值给包装类型的变量。
自动拆箱:包装类型的变量可以直接赋值给基本数据类型变量。
1.2 包装类的特有功能
- 包装类的变量默认值可以是null,容错率更高。
- 可以把基本类型的数据转换成字符串类型(用处不大)
- 可以把字符串类型的数值转换成真实的数据类型(很有用)
/**
目标:明白包装类的概念,并使用。
*/
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);
Integer it = 100;
int it1 = it; //自动拆箱
System.out.println(it);
double db = 99.5;
Double db2 = db; //自动装箱
Double db3 = db2; //自动拆箱
System.out.println(db3);
// int age = null;
Integer age1 = null;
Integer age2 = 0;
System.out.println("-------------");
// 1、包装类可以把基本类型的数据转换成字符串形式。
Integer i3 = 23;
String rs = i3.toString();
System.out.println(rs + 1);
String rs1 = Integer.toString(i3);
System.out.println(rs1 + 1);
//可以直接+字符串得到字符串类型
String rs2 = i3 +"";
System.out.println(rs2 + 1);
System.out.println("-------------");
String number = "23";
//转换成整数
//int age = Integer.parseInt(number);
int age = Integer.valueOf(number);
System.out.println(age + 1);
String number1 = "99.9";
//转换成整数
//double score = Double.parseDouble(number);
double score = Double.valueOf(number1);
System.out.println(score + 0.1);
}
}
2. 正则表达式
2.1 正则表达式概述
- 正则表达式可以用一些规定的字符来制定规则,并用来校验数据格式的合法性。
2.2 正则表达式的匹配规则
import java.util.Scanner;
public class RegexTest3 {
public static void main(String[] args) {
// 目标:校验 手机号码 邮箱 电话号码
//checkPhone();
//checkEmail();
checkTel();
}
public static void checkTel(){
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请您输入您的电话号码:");
String tel = sc.next();
// 判断电话格式是否正确 027-234823748 027-234823748
if(tel.matches("0\\d{2,6}-?\\d{5,20}")){
System.out.println("格式正确,注册完成!");
break;
}else {
System.out.println("格式有误!");
}
}
}
public static void checkEmail(){
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请您输入您的注册邮箱:");
String email = sc.next();
// 判断邮箱格式是否正确 755414220@qq.com
// 判断邮箱格式是否正确 7554142dad20@163.com
// 判断邮箱格式是否正确 7554142dad20@pci.com.cn
if(email.matches("\\w{1,30}@[a-zA-Z0-9]{2,20}(\\.[a-zA-Z0-9]{2,20}){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("格式有误!");
}
}
}
}
2.3 正则表达式在方法中的应用
2.4 正则表达式爬取信息
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
拓展:正则表达式爬取信息中的内容。(了解)
*/
public class RegexDemo5 {
public static void main(String[] args) {
String rs = "来黑马程序学习Java,电话020-43422424,或者联系邮箱" +
"itcast@itcast.cn,电话18762832633,0203232323" +
"邮箱bozai@itcast.cn,400-100-3233 ,4001003232";
// 需求:从上面的内容中爬取出 电话号码和邮箱。
// 1、定义爬取规则:字符串形式
String regex = "(\\w{1,30}@[a-zA-Z0-9]{2,20}(\\.[a-zA-Z0-9]{2,20}){1,2})|(1[3-9]\\d{9})" +
"|(0\\d{2,6}-?\\d{5,20})|(400-?\\d{3,9}-?\\d{3,9})";
// 2、把这个爬取规则编译成匹配对象。
Pattern pattern = Pattern.compile(regex);
// 3、得到一个内容匹配器对象
Matcher matcher = pattern.matcher(rs);
// 4、开始找
while(matcher.find()) {
String rs1 = matcher.group();
System.out.println(rs1);
}
}
}
3. Arrays类
3.1 Arrays类概述
- 数组操作工具类,专门用于操作数组元素的。
3.2 Arrays类的常用API
3.3 Arrays类对于Comparator比较器的支持
3.3.1 Arrays类的排序方法
3.3.2 自定义排序规则
- 设置Comparator接口对应的比较器对象,来定制比较规则。
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(Arrays.toString(ages));
// 2、需求:降序排序(自定义比较器对象,只能支持引用类型的排序!)
Integer[] ages1 = {34, 12, 42, 23};
/**
参数一:被排序的数组 必须是引用类型的元素
参数二:匿名内部类对象,代表了一个比较器对象
*/
Arrays.sort(ages1, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
// 制定比较规则。
// if(o1 > o2){
// return 1;
// }else if(o1 < o2){
// return -1;
// }
// return 0;
//return o1 - o2; // 默认升序
return o2 - o1; // 降序
}
});
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);
System.out.println(Arrays.toString(students));
// Arrays.sort(students); // 直接运行崩溃
Arrays.sort(students, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
// 自己制定比较规则
// return o1.getAge() - o2.getAge(); // 按照年龄升序排序
// return o2.getAge() - o1.getAge(); // 按照年龄降序排序
// return Double.compare(o1.getHeight(), o2.getHeight()); // 比较浮点型可以这样写 升序
return Double.compare(o2.getHeight(), o1.getHeight()); // 比较浮点型可以这样写 降序
}
});
System.out.println(Arrays.toString(students));
}
}
4. 选择排序、二分查找
4.1 选择排序
4.1.1 选择排序的思想
- 每轮选择当前位置,开始找出后面的较小值与该位置交换
4.1.2 选择排序的关键
- 确定总共需要选择几轮:数组的长度 - 1
- 控制每轮从以前位置为基准,与后面元素选择几次。
import java.util.Arrays;
/**
目标:学会使用选择排序的方法对数组进行排序。
*/
public class Test1 {
public static void main(String[] args) {
// 1、定义数组
int[] arr = {5, 1, 3, 2};
// 0 1 2 3
// 2、定义一个循环控制选择几轮: arr.length - 1
for (int i = 0; i < arr.length; i++) {
// i = 0 j = 1 2 3
// i = 1 j = 2 3
// i = 2 j = 3
// 3、定义内部循环,控制选择几次
for (int j = i + 1; j < arr.length; j++) {
// 当前位:arr[i]
// 如果有比当前位数据更小的,则交换
if(arr[i] > arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
4.2 二分查找
- 二分查找正常的检索条件应该是开始位置min <= 结束位置max
/**
目标:理解二分搜索的原理并实现。
*/
public class Test2 {
public static void main(String[] args) {
// 1、定义数组
int[] arr = {10, 14, 16, 25, 28, 30, 35, 88, 100};
System.out.println(binarySearch(arr, 35));
System.out.println(binarySearch(arr, 350));
}
/**
* 二分查找算法的实现
* @param arr 排序的数组
* @param data 要找的数据
* @return 索引,如果元素存在,直接返回-1
*/
public static int binarySearch(int[] arr, int data){
// 1、定义左边位置和右边位置
int left = 0;
int right = arr.length - 1;
// 2、开始循环,折半查询。
while (left <= right){
// 取中间索引
int middleIndex = (left + right) / 2;
// 3、判断当前中间位置的元素和要找的元素的大小情况
if(data > arr[middleIndex]) {
// 往右边找,左位置更新为 = 中间索引 + 1
left = middleIndex + 1;
}else if(data < arr[middleIndex]) {
// 往左边找,右边位置更新为 = 中间索引 - 1
right = middleIndex - 1;
}else {
return middleIndex;
}
}
return -1;//查无此元素
}
}
5. Lambda表达式
5.1 Lambda概述
- Lambda表达式是JDK 8开始后的一种新语法形式。
- 作用:简化匿名内部类的代码写法。
5.2 Lambda表达式的简化格式
什么是函数式接口?
- 首先必须是接口、其次接口中有且仅有一个抽象方法的形式
- 通常我们会在接口上加上一个@FunctionalInterface注解,标记该接口必须是满足函数式接口。
public class LambdaDemo2 {
public static void main(String[] args) {
// 目标:学会使用Lambda的标准格式简化匿名内部类的代码形式
// Lambda只能简化接口中只有一个抽象方法的匿名内部类形式
// Swimming s1 = new Swimming() {
// @Override
// public void swim() {
// System.out.println("老师游泳贼溜~~~~");
// }
// };
Swimming s1 = () -> {
System.out.println("老师游泳贼溜~~~~");
};
go(s1);
System.out.println("---------------------");
// go(new Swimming() {
// @Override
// public void swim() {
// System.out.println("学生游泳很开心");
// }
// });
go(() -> {
System.out.println("学生游泳很开心");
});
}
public static void go(Swimming s){
System.out.println("开始。。。");
s.swim();
System.out.println("结束。。。");
}
}
@FunctionalInterface // 一旦加上这个注解必须是函数式接口,里面只有一个抽象方法
interface Swimming{
void swim();
}
5.3 Lambda表达式的省略规则(进一步在Lambda表达式的基础上简化)
- 参数类型可以省略不写。
- 如果只有一个参数,参数类型可以省略,同时()也可以省略。
- 如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写,同时要省略分号!
- 如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写。此时,如果这行代码是return语句,必须省略return不写,同时也必须省略";"不写
// Arrays.sort(ages1, new Comparator<Integer>() {
// @Override
// public int compare(Integer o1, Integer o2) {
// return o2 - o1; // 降序
// }
// });
// Arrays.sort(ages1, (Integer o1, Integer o2) -> {
// return o2 - o1; // 降序
// });
// System.out.println(Arrays.toString(ages1));
// Arrays.sort(ages1, (o1, o2) -> {
// return o2 - o1; // 降序
// });
Arrays.sort(ages1, (o1, o2) -> o2 - o1 );
// btn.addActionListener(new ActionListener() {
// @Override
// public void actionPerformed(ActionEvent e) {
// System.out.println("有人点我,点我,点我!!");
// }
// });
// btn.addActionListener((ActionEvent e) -> {
// System.out.println("有人点我,点我,点我!!");
// });
// btn.addActionListener( (e) -> {
// System.out.println("有人点我,点我,点我!!");
// });
// btn.addActionListener( e -> {
// System.out.println("有人点我,点我,点我!!");
// });
btn.addActionListener( e -> System.out.println("有人点我,点我,点我!!"));