1.Object
作用
一个类要么默认继承了Object类，要么间接继承了Object类，Object类是Java中的祖宗类
Object类的方法是一切子类都可以直接使用的
Object类的常用方法
方法名 | 说明 |
public String toString() | 默认是返回当前对象在堆内存中的地址信息：类的全限名@内存地址 |
public Boolean equas(Object o) | 默认是比较当前对象与另一个对象的地址是否相同，相同返回true |
toString存在意义
父类toString()方法存在的意义就是为了被子类重写，以便返回对象的内容信息，而不是地址信息
public class Student {
private String name;
private char sex;
private int age;
public Student() {
}
public Student(String name, char sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", sex=" + sex +
", age=" + age +
'}';
}
}equals存在的意义
父类equals方法存在的意义就是为了被子类重写，以便子类自己来定制比较规则
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return sex == student.sex && age == student.age && Objects.equals(name, student.name);
}2.Objects
Object类与Object还是继承关系，Objects类是从JDK1.7之后才有的
官方在进行字符串比较时，没有对象自己的equals方法，而是选择了Objects的equals方法来比较两个对象
Objects的equals方法比较的结果是一样的，但是更安全
Objects的常见方法
方法名 | 说明 |
public static boolean equals(Object a, Object b) | 比较两个对象的，底层会先进行非空判断，从而可以避免空指针异常，再进行equals比较 |
public static boolean isNull(Object obj) | 判断变量是否为null，为null返回true，反之 |
public class Test {
public static void main(String[] args) {
String s1 = null;
String s2 = new String("张三");
// System.out.println(s1.equals(s2));
System.out.println( Objects.equals(s1, s2)); // 更安全，更准确
System.out.println(Objects.equals(s, s1));
}
}3.StringBuilder
StringBuilder是一个可变的字符串类，可以把它堪称是一个对象容器
作用：提高字符串的操作效率，如拼接，修改等
StringBuilder构造器
名称 | 说明 |
public StringBuilder | 创建一个空白的可变的字符串对象，不包含任何内容 |
public StringBuilder(String str) | 创建一个指定字符串内容的可变字符串对象 |
StringBuilder常用方法
方法 | 说明 |
public StringBuilder append（任意类型） | 添加数据并返回StringBuilder对象本身 |
public StringBuilder reverse() | 将对象的内容反转 |
public int length() | 返回对象内容长度 |
public String toString() | 通过toString()就可以实现把StringBuilder转换为String |
public class Test {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
sb.append("a");
sb.append("2");
sb.append(222);
System.out.println(sb);
StringBuilder sb1 = new StringBuilder();
sb1.append("a").append(2).append(3);
System.out.println(sb1);
System.out.println(sb1.length());
}
}案例：打印整型数组的内容
public class Test2 {
public static void main(String[] args) {
int[] arr1 = {2,3,5,5,6};
System.out.println(arrToString(arr1));
}
public static String arrToString(int[] arr) {
if(arr != null) {
StringBuilder s = new StringBuilder("[");
for (int i = 0; i < arr.length; i++) {
s.append(arr[i]).append(i == arr.length - 1 ? "" : ", ");
}
s.append("]");
return s.toString();
}else {
return null;
}
}
}4.Math类
包含执行基本数字运算的方法，Math类没有提供公开的构造器
Math类的常用方法
方法 | 说明 |
public static int abs(int a) | 获取参数绝对值 |
public static idouble ceil(doublle a) | 向上取整 |
public static double floor(double a) | 向下取整 |
public static int round(float a) | 四舍五入 |
public static int max(int a) | 获取两个int值中的较大值 |
publlic static double pow(double a, double b) | 返回a的b次幂的值 |
public static double random() | 返回值为doublle的随机值，范围[0.0,1.0] |
5.System类
System的功能是通用的，都是直接用类名调用即可，所以System不能被实例化
System类的常用方法
方法 | 说明 |
public static void exit(int status) | 终止当前运行的Java虚拟机，非零表示异常终止 |
public static long currentTimeMills() | 返回当前系统的时间毫秒值形式 |
public static void arraycope（数据源数组，起始索引，目的地数组，起始拷贝，拷贝个数） | 数组拷贝 |
public class Test {
public static void main(String[] args) {
System.out.println("程序中断");
long time = System.currentTimeMillis();
System.out.println(time);
int[] arr1 = {10,20,30,40,50, 60, 70};
int[] arr2 = new int[6];
System.arraycopy(arr1, 2, arr2, 2, 3);
System.out.println(Arrays.toString(arr2));
System.exit(0); // JVM终止
System.out.println("00");
}
}6.BigDecimal
用于解决浮点型运算精度失真问题
使用步骤
创建对象BigDecimal
public static BigDecimal valueOf(double val); // 包装浮点数成为BigDecimal对象BigDecima常用API
方法名 | 说明 |
public BigDecimall add(BigDecimal b) | 加法 |
public BigDecimall subtract(BigDecimal b) | 减法 |
public BigDecimall multiply(BigDecimal b) | 乘法 |
public BigDecimall divide(BigDecimal b) | 除法 |
public BigDecimall divide(另一个BigDecimall对象，精确几位，舍入模式) | 除法 |
public class Test {
public static void main(String[] args) {
double a = 0.1;
double b = 0.2;
double c = a + b;
System.out.println(c);
BigDecimal a1 = BigDecimal.valueOf(a);
BigDecimal a2 = BigDecimal.valueOf(b);
BigDecimal c1 = a1.add(a2);
System.out.println(c1);
BigDecimal c2 = a1.multiply(a2);
System.out.println(c2);
double e = 10;
double f = 3;
BigDecimal a11 = BigDecimal.valueOf(e);
BigDecimal a22 = BigDecimal.valueOf(f);
BigDecimal c3 = a11.divide(a22, 2, RoundingMode.HALF_UP);
System.out.println(c3);
}
}7.Date类
Date类的对象在Java中代表的是当前所在系统的此刻日期时间
Date的构造器
public Date() 创建一个Date对象，代表的是系统当前此刻日期时间Date的常用方法
public long getTime() 获取时间对象的毫秒值public static void main(String[] args) {
// 1. 创建一个Date类的兑现，代表系统此刻日期时间对象
Date d = new Date();
long time = d.getTime();
System.out.println(d);
System.out.println(time);
}时间毫秒值->日期对象
public Date(long time) 把时间毫秒值转换成Date日期对象public void setTime(long time) 设置日期对象的时间为当前时间毫秒值对应的时间SimpleDateFormat类作用
可以把对象或时间毫秒值格式化成常用的时间格式
也可以把字符串时间形式解析成日期对象
SimpleDateFormat的构造器
public SimpleDateFormat() 构造一个SimpleDateFormat，使用默认格式
public SimpleDateFormat(String pattern) 构造一个SimpleDateFormat，使用指定的格式SimpleDateFormat的格式化方法
public final String format(Date date) 将日期格式化成日期/时间字符串
public final String format(Object time) 将时间毫秒值格式化成日期/时间字符串public static void main(String[] args) {
Date d = new Date();
System.out.println(d);
// 格式化日期
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEE a");
String rs = sdf.format(d);
System.out.println(rs);
}SimpleDateFormat解析字符串时间成为日期对象
public Date parse(String source) 从给定字符串的开始解析文本以生成日期public static void main(String[] args) throws ParseException {
// 使用SimpleDateFormat解析字符串时间为日期对象
// 有一个时间2022年07月05日 13：30：30往后2天20小时20分09秒后的时间是多少
String dateStr = "2022年07月05日 13:30:30";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
Date d = sdf.parse(dateStr);
long time = d.getTime() + (2L*24*60*60 + 20*60*60+20*60+9)*1000;
System.out.println(sdf.format(time));
}8.案例：秒杀活动
需求：秒杀开始时间为 2022年 6月18日 00：00：00 - 2022年6月18日 00：10：00
小明下单并付款的时间为 2022年6月18日 00：03：58
小张下单并付款的时间为 2022年6月18日 00：10：38
判断他们是否秒杀成功
public static void main(String[] args) throws ParseException {
// 1.开始和结束时间
String startTime = "2022-06-18 00:00:00";
String endTime = "2022-06-18 00:10:00";
// 2.小明小张时间
String xiaoming = "2022-06-18 00:03:58";
String xiaozhang = "2022-06-18 00:10:38";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d1 = sdf.parse(startTime);
Date d2 = sdf.parse(endTime);
Date d3 = sdf.parse(xiaoming);
Date d4 = sdf.parse(xiaozhang);
if(d3.after(d1) && d3.before(d2)) {
System.out.println("小明秒杀成功");
} else {
System.out.println("小明秒杀失败");
}
if(d4.after(d1) && d4.before(d2)) {
System.out.println("小张秒杀成功");
} else {
System.out.println("小张秒杀失败");
}
}9.Calendar
Calendar代表了系统此刻日期对应的日历对象
Calendar是一个抽象类，不能直接创建对象
Calendar常用方法
public int get(int field) 取日期中的某个字段信息
public void set(int field, int value) 修改日历的某个字段信息
public void add(int field, int amount) 为某个字段增加/减少指定的值
public final Date getTime() 拿到此刻日期对象
public long getTimeInMillis() 拿到此刻时间毫秒值注意：calendar是可变日期对象，一旦修改后其对象本身表示的时间将产生变化
10.JDK8新增日期类
从Java8开始，Java.time包提供了新的日期和时间API，主要涉及的类类型有
LocalDate: 不包含jurisdiction时间的日期
LocallTime: 不含日期的时间
LocalDateTime： 包含了日期及时间
Instant： 代表的是时间戳
DateTimeFormatter 用于做时间的格式化和解析的
Duration： 用于计算两个“时间”间隔
Period：用于计算两个“日期”间隔
新增的API严格区分了时刻、本地日期、本地时间，并且，对日期和时间进行运算更加方便
其次，新API的类类型几乎全部是不变类型（和String的使用类似），可以放心使用不必担心被修改
LocalDate、LocalTime、LocalDateTime
分别表示日期、时间、日期时间对象，它们的类的实例是不可变的对象
它们构建对象和API都是通用的
LocalDateTime综合了LocalDate和LocalTime里面的方法
这些方法返回的是一个新的实例的引用
plusDays, plusWeeks, plusMonths, plusYears 向当前LocalDate对象添加几天、几周、几个月，几年
minusDays, minusWeeks, minusMonths, minusYears 从当前LocalDate对象减去几天、几周、几个月、几年
withDayOfMonth, withDayOfYear, withMonth, withYear 将月份天数、年份天数、月份、年份修改为指定的值并返回新的LocalDate对象
isBefore，isAfter 比较两个LocalDateInstant时间戳
时间戳是包含日期和时间的，与java.util.Date很类似，事实上Instant就是类似JDK8之前的Date
Instant和Date这两个类可以进行转换
public static void main(String[] args) {
// 得到一个Instant时间戳对象
Instant instant = Instant.now();
System.out.println(instant);
// 系统此刻时间戳
Instant instant1 = Instant.now();
System.out.println(instant1.atZone(ZoneId.systemDefault()));
// 如何返回Date对象
Date date = Date.from(instant);
System.out.println(date);
}DateTimeFormatter
在JDK8中，引入了一个全新的日期与格式器DateTimeFormatter
正反都能调用format方法
public static void main(String[] args) {
LocalDateTime ldt = LocalDateTime.now();
System.out.println(ldt);
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss EEE a");
System.out.println(dtf);
DateTimeFormatter dtf1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDateTime ldt1 = LocalDateTime.parse("2022-11-11 11:11:11", dtf1);
System.out.println(ldt1);
}Period
在Java8中。可以使用java.time.Period
主要是Period类方法getYear(), getMonths() 和getDays() 来计算，只能精确到年月日
用于LocalDate之间的比较
public static void main(String[] args) {
LocalDate today = LocalDate.now();
System.out.println(today);
LocalDate b = LocalDate.of(2010,10,11);
System.out.println(b);
Period period = Period.between(b, today);
System.out.println(period.getYears());
}Duration
public static void main(String[] args) {
LocalDateTime today = LocalDateTime.now();
System.out.println(today);
LocalDateTime b = LocalDateTime.of(2010,10,11, 20: 20: 01);
System.out.println(b);
Duration d = Duration.between(b, today);
System.out.println(d.getYears());
}11.包装类
包装类就是8种基本数据类型对应的引用类型
基本数据类型 | 引用数据类型 |
byte | Byte |
short | Short |
int | Integer |
long | Long |
char | Character |
float | Float |
double | Double |
boolean | Boolean |
为什么提供包装类
Java为了实现一切皆对象，为8种基本类型提供来了对应的引用类型
集合和泛型其实也只能支持包装类型，不支持基本数据类型
自动装箱：基本类型的数据和变量可以直接赋值给包装类型的变量
自动拆箱：包装类型的变量可以直接赋值给基本数据类类型的变量
包装类的特有功能
包装类的变量的默认值可以是null，容错率更高
可以把基本类型的数据转换成字符串类型
调用toString() 方法得到字符串结果
调用Integer.toString(基本类型的数据)
可以把字符串类型的数值转换成真是的数据类型
Integer.parseInt(“字符串类型的整数”)
Double.parseDouble(“字符串类型的小数”)
valueOf() 效果一样
public static void main(String[] args) {
int a = 10;
Integer a1 = 11;
Integer a2 = a; // 自动装箱
System.out.println(a);
System.out.println(a);
Integer i = 100;
int i2 = i; // 自动拆箱
System.out.println(i2);
// int age = null;
Integer age2 = null;
}12.正则表达式
正则表达式可以用一些规定的字符来指定规则，并用来校验数据格式的合法性
字符串对象提供了匹配正则表达式规则的API
public boolean matched(String regex);// 验证码 必须是数字和字符 且为4位
System.out.println("12cd".matches("[a-zA-Z0-9]{4}"));
System.out.println("12cd".matches("[\\w&&[^_]]{4}"));案例：使用正则表达式完成如下需求
1.便且程序模拟用户输入手机号码，验证格式是否正确，并给出提示，直到格式输入正确为止
2.便且程序模拟用户输入邮箱号码，验证格式是否正确，并给出提示，直到格式输入正确为止
3.便且程序模拟用户输入电话号码，验证格式是否正确，并给出提示，直到格式输入正确为止
public static void checkTel() {
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请您输入需要验证的电话号码");
String tel = sc.next();
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();
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("格式有误");
}
}
}正则表达式在字符串方法中的使用
public String replaceAll(String regex, String newStr) 按照正则表达式匹配的内容进行替换
public String[] split(String regex) 按照正则表达式匹配的内容进行分割字符串，返回一个字符串数组public static void main(String[] args) {
String name = "张三123456李四123456王五123456赵六";
String[] arr = name.split("\\w+");
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}正则表达式爬取信息
public static void main(String[] args) {
String rs = "张三电话010-231399,邮箱2345678@qq.com,手机13452337895";
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}";
// 把这个爬取规则编译成匹配对象
Pattern pattern = Pattern.compile(regex);
// 得到一个内容匹配器对象
Matcher matcher = pattern.matcher(rs);
// 寻找
while (matcher.find()) {
String rs1 = matcher.group();
System.out.println(rs1);
}
}13.Arrays类
数组操作工具类，专门用于处理数组元素
Array类的常用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) 二分搜索数组中的数据，存在返回索引，不存在返回-1public static void main(String[] args) {
int[] arr = {20, 21, 15, 40, 34};
System.out.println(arr);
// 返回数组内容
String rs = Arrays.toString(arr);
System.out.println(rs);
// 排序（自动对数组元素进行升序排序）
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
// 二分搜索技术(前提数组必须排好序才支持，否则出bug)
// 返回不存在元素的规律 -（应该插入位置的索引+1）
int index = Arrays.binarySearch(arr, 40);
System.out.println(index);
}自定义排序规则
设置Comparator接口对比的比较器对象，来定制比较规则
如果认为左边数据大于右边数据返回正整数
如果认为左边数据小于右边数据返回负整数
如果认为左边数据等于右边数据返回0
// 定义Student类public static void main(String[] args) {
// Comparator比较器对象
Integer[] arr = {10, 22, 45,3,12,34};
// 降序排序（自定义比较器对象，只能支持引用类型的排序）
Arrays.sort(arr, new Comparator<>(){
@Override
public int compare(Integer o1, Integer o2) {
// 指定比较规则
return o1-o2;
}
});
System.out.println(Arrays.toString(arr));
Student[] students = new Student[3];
students[0] = new Student("张三", 23, 178.5);
students[1] = new Student("李四", 22, 167.5);
students[2] = new Student("王五", 25, 165.5);
System.out.println(Arrays.toString(students));
Arrays.sort(students, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
// return o1.getAge() - o2.getAge();
return Double.compare(o1.getHeight(),o2.getHeight()); // 比较浮点型
}
});
System.out.println(Arrays.toString(students));
}
}14.排序方法
选择排序
每轮选择当前位置，开始找出后面的较小值与该位置交换
public static void main(String[] args) {
int[] arr = {2,3,5,1,7,9};
for (int i = 0; i < arr.length-1; i++) {
for (int j=i; j< arr.length-1;j++) {
if(arr[i]>arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
}二分查找
在数据量特别大的时候，基本查找从前往后寻找的性能是很差的
二分查询性能好，二分查找的前提是必须是排序好的数据
二分查找正常的检索条件应该是开始位置min<= 结束位置max
public static int binarySearch(int[] arr, int data) {
int left = 0;
int right = arr.length -1;
// 开始循环，这般查询
while (left <= right) {
// 取中间索引
int middleIndex = (left + right) / 2;
// 判断当前中间位置元素和要找的元素的大小情况
if(data> arr[middleIndex]) {
left = middleIndex + 1;
}else if(data< arr[middleIndex]) {
right = middleIndex-1;
} else {
return middleIndex;
}
}
return -1;
}步骤
定义变量记录左边和右边位置
使用while循环控制查询（条件是左边位置<=右边位置）
循环内部获取中间元素索引
判断当前要找的元素如果大于中间元素，左边位置=中间索引+1
判断当前要找的元素如果等于中间元素，右边位置=中间索引-1
判断当前要找的元素如果等于中间元素，返回当前中间元素索引
15.Lambda表达式
Lambda表达式是JDK 8开始后的一种新语法形式
作用：简化匿名内部类的代码写法
Lambda表达式的简化形式
(匿名内部类被重写方法的形参列表) -> {
被重写方法的方法体代码
}注意：Lambda表达式只能简化函数时接口的匿名内部类的写法形式
首先必须是接口、其次接口中有且仅有一个抽象方法的形式
通常会在接口上加上一个@FunctionalInterface注解，标记该接口满足函数式接口
public class Test {
public static void main(String[] args) {
Run r1 = new Run() {
@Override
public void run() {
System.out.println("人在跑");
}
};
go(r1);
Run r2 = () -> {
System.out.println("狗在跑");
};
go(r2);
}
public static void go(Run r) {
System.out.println("开始");
r.run();
System.out.println("结束");
}
}
@FunctionalInterface // 一旦加上这个注释必须是函数时接口，里面只能有一个抽象方法
interface Run {
void run();
}好处：Lambda是一个匿名函数，可以把Lambda表达式理解为是一段可以传递的代码，它可以写出更简洁、更灵活的代码，作为一种更紧凑的代码风格，使Java语言表达能力得到了提升
Lambda表达式的省略规则
参数类型可以不写
如果只有一个参数，参数类型可以省略，同时（）也可以省略
如果Lambda表达式的方法体代码只有一行，可以省略大括号不写，同时要省略分号
如果Lambda表达式的方法体代码只有一行代码，可以生路大括号不写，此时，如果这行代码是return语句，必须省略return不屑，同时也必须省略分号不写
