Java-进阶篇【常用API、正则表达式、Arrays 数组操作类、Lambda、算法】---05
1：API
API(Application Programming interface) 应用程序编程接口 简单来说：就是Java帮我们已经写好的一些方法，我们直接拿过来用就可以了。
2：Object
Object类的作用：
一个类要么默认继承了Object类，要么间接继承了 Object 类，Object类是Java中的祖宗类。
Object作为所有类的父类，提供了很多常用的方法给每个子类对象拿来使用。
Object类里常用的几个方法：
public String toString() 默认是返回当前对象在堆内存中的地址信息:类的全限名@内存地址 public boolean equals(Object o) 默认是比较当前对象与另一个对象的地址是否相同，相同返回true，不同返回false public String toString() 默认是返回当前对象在堆内存中的地址信息:类的全限名@内存地址 问题引出： 开发中直接输出对象，默认输出对象的地址其实是毫无意义的。 开发中输出对象变量，更多的时候是希望看到对象的内容数据而不是对象的地址信息。 toString存在的意义： 父类toString()方法存在的意义就是为了被子类重写，以便返回对象的内容信息，而不是地址信息！！
package com.itheima.d9_api_object; import java.util.Objects; public class Student { //extends Object{ 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; } /** 定制相等规则。 两个对象的内容一样就认为是相等的 这个是自动生成的 s1.equals(s2) 比较者：s1 == this 被比较者： s2 ==> o */ @Override public boolean equals(Object o) { // 1、判断是否是同一个对象比较，如果是返回true。 if (this == o) return true; // 2、如果o是null返回false 如果o不是学生类型返回false ...Student != ..Pig if (o == null || this.getClass() != o.getClass()) return false; // 3、说明o一定是学生类型而且不为null Student student = (Student) o; return sex == student.sex && age == student.age && Objects.equals(name, student.name); } /** 自己重写equals，自己定制相等规则。 两个对象的内容一样就认为是相等的 s1.equals(s2) 比较者：s1 == this 被比较者： s2 ==> o */ /* @Override public boolean equals(Object o){ // 1、判断o是不是学生类型 if(o instanceof Student){ Student s2 = (Student) o; // 强转才能访问 name，age这些数据，多态的使用 // 2、判断2个对象的内容是否一样。 // if(this.name.equals(s2.name) && // this.age == s2.age && this.sex == s2.sex){ // return true; // }else { // return false; // } return this.name.equals(s2.name) && this.age == s2.age && this.sex == s2.sex ; // 简化成一行的写法【逻辑结构本身就是真或者假，三个 且 都成立相等那么就为真，否则为假的】 }else { // 学生只能和学生比较，否则结果一定是false return false; } }*/ @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", sex=" + sex + ", age=" + age + '}'; } }
3：Objects 类 【工具类】
Objects是一个工具类，提供了一些方法去完成一些功能。 官方在进行字符串比较时，没有用字符串对象的的equals方法，而是选择了Objects的equals方法来比较。 @Override
public boolean equals(Object o) { // 1、判断是否是同一个对象比较，如果是返回true。 if (this == o) return true; // 2、如果o是null返回false 如果o不是学生类型返回false ...Student != ..Pig if (o == null || this.getClass() != o.getClass()) return false; // 3、说明o一定是学生类型而且不为null Student student = (Student) o; return sex == student.sex && age == student.age && Objects.equals(name, student.name); }
使用Objects的equals方法在进行对象的比较会更安全。
name名称可能是null，null去调用 equals方法会返回空值异常 【Objects这样去毕竟不会报错，因为会进行非空判断，非空才真正调用 equals】
package com.itheima.d10_api_objects; import java.util.Objects; /** 目标：掌握objects类的常用方法:equals */ public class Test { public static void main(String[] args) { String s1 = null; String s2 = new String("itheima"); // System.out.println(s1.equals(s2)); // 留下了隐患，可能出现空指针异常。 System.out.println(Objects.equals(s1, s2)); // 更安全，结果也是对的！ /** 源码： Objects： public static boolean equals(Object a, Object b) { return (a == b) || (a != null && a.equals(b)); } */ System.out.println(Objects.isNull(s1)); // true System.out.println(s1 == null); // true System.out.println(Objects.isNull(s2)); // false System.out.println(s2 == null); // false } }
Objects的常见方法： public static boolean equals(Object a, Object b) 比较两个对象的，底层会先进行非空判断，从而可以避免空指针异常。再进行equals比较 public static boolean isNull(Object obj) 判断变量是否为null ,为null返回true ,反之 源码分析： public static boolean equals(Object a, Object b) { return (a == b) || (a != null && a.equals(b)); }
4：StringBuilder 类
StringBuilder 是一个可变的字符串的操作类，我们可以把它看成是一个对象容器。 使用 StringBuilder 的核心作用：操作字符串的性能比 String 要更高（如拼接、修改等）。 StringBuilder 构造器 public StringBuilder() 创建一个空白的可变的字符串对象，不包含任何内容 public StringBuilder(String str) 创建一个指定字符串内容的可变字符串对象 StringBuilder常用方法 public StringBuilder append(任意类型) 添加数据并返回StringBuilder对象本身 public StringBuilder reverse() 将对象的内容反转 public int length() 返回对象内容长度 public String toString() 通过toString()就可以实现把StringBuilder转换为String
string为什么拼接性能差：
string是不可变对象，每次拼接都指向新对象，原来对象作为垃圾被回收，不断产生新对象空间，性能差 【string类型底层也是基于stringBuilder的】
如下图所示，每次一个 + 号需要产生两个对象，一个string对象一个stringBuilder对象，还不断丢弃原来对象，如下图
stringBuilder 为什么性能好：
因为不管怎么做拼接，就只产生一个 stringBuilder 对象，效率高
package com.itheima.d11_api_stringbuilder; /** 目标：学会使用StringBuilder操作字符串,最终还需要知道它性能好的原因 */ public class StringBuilderDemo1 { public static void main(String[] args) { StringBuilder sb = new StringBuilder(); // "" sb.append("a"); sb.append("b"); sb.append("c"); sb.append(1); sb.append(false); sb.append(3.3); sb.append("abc"); System.out.println(sb); StringBuilder sb1 = new StringBuilder(); // 支持链式编程 sb1.append("a").append("b").append("c").append("我爱你中国"); System.out.println(sb1); // 反转 sb1.reverse().append("110"); System.out.println(sb1); System.out.println(sb1.length()); // 注意：StringBuilder只是拼接字符串的手段：效率好。 // 最终的目的还是要恢复成 String 类型。 StringBuilder sb2 = new StringBuilder(); sb2.append("123").append("456"); // 恢复成String类型 String rs = sb2.toString(); check(rs); } public static void check(String data){ System.out.println(data); } }
为什么拼接、反转字符串建议使用StringBuilder? StringBuilder：内容是可变的、拼接字符串性能好、代码优雅。 String ：内容是不可变的、拼接字符串性能差。 定义字符串使用String 拼接、修改等操作字符串使用StringBuilder
案例：
package com.itheima.d11_api_stringbuilder; public class StringBuilderTest2 { public static void main(String[] args) { int[] arr1 = null; System.out.println(toString(arr1)); int[] arr2 = {10, 88, 99}; System.out.println(toString(arr2)); int[] arr3 = {}; System.out.println(toString(arr3)); } /** 1、定义方法接收任意整型数组，返回数组内容格式 */ public static String toString(int[] arr){ if(arr != null){ // 2、开始拼接内容。 StringBuilder sb = new StringBuilder("["); for (int i = 0; i < arr.length; i++) { sb.append(arr[i] ).append(i == arr.length - 1 ? "" : ", "); // 不使用 + 号，因为使用 + 号会在内存中产生两个对象 } sb.append("]"); return sb.toString(); }else { return null; } } }
5：Math 类 数学运算的 【工具类】【没有公开的构造器，都是静态方法】
package com.itheima.d12_math; /** 目标：Math类的使用。 Math用于做数学运算。 Math类中的方法全部是静态方法，直接用类名调用即可。 方法： 方法名 说明 public static int abs(int a) 获取参数a的绝对值： public static double ceil(double a) 向上取整 public static double floor(double a) 向下取整 public static double pow(double a, double b) 获取a的b次幂 public static long round(double a) 四舍五入取整 小结： 记住。 */ public class MathDemo { public static void main(String[] args) { // 1.取绝对值:返回正数 System.out.println(Math.abs(10)); // 10 System.out.println(Math.abs(-10.3)); // 10.3 // 2.向上取整: 5 System.out.println(Math.ceil(4.00000001)); // 5.0 System.out.println(Math.ceil(4.0)); // 4.0 // 3.向下取整：4 System.out.println(Math.floor(4.99999999)); // 4.0 System.out.println(Math.floor(4.0)); // 4.0 // 4.求指数次方 System.out.println(Math.pow(2 , 3)); // 2^3 = 8.0 // 5.四舍五入 10 System.out.println(Math.round(4.49999)); // 4 System.out.println(Math.round(4.500001)); // 5 System.out.println(Math.random()); // 0.0 - 1.0 （包前不包后） // 拓展： 3 - 9 之间的随机数 （0 - 6） + 3 // [0 - 6] + 3 int data = (int)(Math.random() * 7) + 3; System.out.println(data); } }
6：System 系统类 【也是个工具类】
package com.itheima.d13_system; import java.math.BigDecimal; import java.math.RoundingMode; import java.text.SimpleDateFormat; import java.util.Arrays; /** 目标：System系统类的使用。 System代表当前系统。（虚拟机系统） 静态方法： 1.public static void exit(int status): 终止JVM虚拟机，非0是异常终止。1是正常终止【自己关闭一般填写0】 2.public static long currentTimeMillis(): 获取当前系统此刻时间毫秒值。(重点) 【时间戳】 3.可以做数组的拷贝。 arraycopy(Object var0, int var1, Object var2, int var3, int var4); * 参数一：原数组 * 参数二：从原数组的哪个位置开始赋值。 * 参数三：目标数组 * 参数四：赋值到目标数组的哪个位置 * 参数五：赋值几个。 */ public class SystemDemo { public static void main(String[] args) { System.out.println("程序开始。。。"); // System.exit(0); // JVM终止！ // 2、计算机认为时间有起源：返回1970-1-1 00：00：00 走到此刻的总的毫秒值：时间毫秒值。 long time = System.currentTimeMillis(); System.out.println(time); long startTime = System.currentTimeMillis(); // 进行时间的计算：性能分析 for (int i = 0; i < 100000; i++) { System.out.println("输出：" + i); } long endTime = System.currentTimeMillis(); System.out.println((endTime - startTime)/1000.0 + "s"); // 3、做数组拷贝（了解） /** arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 参数一：被拷贝的数组 参数二：从哪个索引位置开始拷贝 参数三：复制的目标数组 参数四：粘贴位置 参数五：拷贝元素的个数 */ int[] arr1 = {10, 20, 30, 40, 50, 60, 70}; int[] arr2 = new int[6]; // [0, 0, 0, 0, 0, 0] ==> [0, 0, 40, 50, 60, 0] System.arraycopy(arr1, 3, arr2, 2, 3); System.out.println(Arrays.toString(arr2)); System.out.println("-------------------"); double i = 10.0; double j = 3.0; // // System.out.println(k1); System.out.println("程序结束。。。。"); } }
7：BigDecimal 解决浮点型运算精度失真的问题
0.1 + 0.2 = 0.3000000004 计算机底层运算造成的 使用 BigDecimal 解决
double类型 封装成 BigDecimal 对象，然后调用对象运算方法
java开发手册：
禁止 使用double参数的构造器 方法 BigDecimal 把 double转化成 BigDecimal 对象
BigDecimal(Double) 存在精度损失风险，在精准计算或者值比较场景中可能导致业务逻辑异常
BigDecimal g = new BigDecimal(0.1F); 实际存储的值为 0.100000000149
推荐入参使用 String 的 构造方法，或者使用 BigDecimal 的 valueOf 方法：这个方法内部执行了Double的toString
double的 toString按照double的实际表达的精度对尾数精选了截断
一个是 构造器方法创建BigDecimal对象 new BigDecimal("1.1")
一个是 BigDecimal 类方法创建 BigDecimal对象 BigDecimal.valueOf(0.1F)
package com.itheima.d14_bigdecimal; import java.math.BigDecimal; import java.math.RoundingMode; import java.text.NumberFormat; /** 目标：BigDecimal大数据类。 引入： 浮点型运算的时候直接+ * / 可能会出现数据失真（精度问题）。 BigDecimal可以解决浮点型运算数据失真的问题。 BigDicimal类： 包：java.math. 创建对象的方式（最好的方式：） public static BigDecimal valueOf(double val) :包装浮点数成为大数据对象。 方法声明 public BigDecimal add(BigDecimal value) 加法运算 public BigDecimal subtract(BigDecimal value) 减法运算 public BigDecimal multiply(BigDecimal value) 乘法运算 public BigDecimal divide(BigDecimal value) 除法运算 public double doubleValue(): 把BigDecimal转换成double类型。 */ public class BigDecimalDemo { public static void main(String[] args) { // 浮点型运算的时候直接+ * / 可能会出现数据失真（精度问题）。 System.out.println(0.09 + 0.01); System.out.println(1.0 - 0.32); System.out.println(1.015 * 100); System.out.println(1.301 / 100); System.out.println("-------------------------"); double a = 0.1; double b = 0.2; double c = a + b; System.out.println(c); System.out.println("--------------------------"); // 包装浮点型数据成为大数据对象 BigDeciaml BigDecimal a1 = BigDecimal.valueOf(a); BigDecimal b1 = BigDecimal.valueOf(b); BigDecimal c1 = a1.add(b1); // BigDecimal c1 = a1.subtract(b1); // BigDecimal c1 = a1.multiply(b1); // BigDecimal c1 = a1.divide(b1); System.out.println(c1); // 目的：double double rs = c1.doubleValue(); System.out.println(rs); // 注意事项：BigDecimal是一定要精度运算的 【除不尽的这种使用 divide 除法 会报错，得不到精准值】 BigDecimal a11 = BigDecimal.valueOf(10.0); BigDecimal b11 = BigDecimal.valueOf(3.0); /** 参数一：除数 参数二：保留小数位数 参数三：舍入模式 */ BigDecimal c11 = a11.divide(b11, 2, RoundingMode.HALF_UP); // 3.3333333333 System.out.println(c11); System.out.println("-------------------"); } }
8：Date 类【日期处理专用类】
Date类代表当前所在系统的日期时间信息。 Date的构造器 public Date() 创建一个Date对象，代表的是系统当前此刻日期时间。 Date的常用方法 public long getTime() 返回从1970年1月1日 00:00:00走到此刻的总的毫秒数 public void setTime(long time) 设置日期对象的时间为当前时间毫秒值对应的时间
public Date(long time) 【时间毫秒值转换成日期对象】 new Date(1700000000000);
package com.itheima.d1_date; import java.time.Instant; import java.time.ZoneId; import java.util.Date; /** 目标：学会使用Date类处理时间，获取时间的信息 */ public class DateDemo1 { public static void main(String[] args) { // 1、创建一个Date类的对象：代表系统此刻日期时间对象 Date d = new Date(); System.out.println(d); // 2、获取时间毫秒值 long time = d.getTime(); System.out.println(time); // long time1 = System.currentTimeMillis(); // System.out.println(time1); System.out.println("------------得到当前时间往后走 1小时 121 之后的时间----------------"); // 1、得到当前时间 【毫秒值】 Date d1 = new Date(); System.out.println(d1); // 2、当前时间往后走 1小时 121s long time2 = System.currentTimeMillis(); // 得到当前时间对象的 毫秒值 Date 日期对象的getTime 方法，也可以使用 system的 currentTimeMillis time2 += (60 * 60 + 121) * 1000; // 3、把时间毫秒值转换成对应的日期对象。 Date有参构造器转换形式 // Date d2 = new Date(time2); // System.out.println(d2); Date d3 = new Date(); d3.setTime(time2); // Date使用 setTime这种形式转换 System.out.println(d3); } }
1、日期对象如何创建，如何获取时间毫秒值？ public Date(); public long getTime(); 2、时间毫秒值怎么恢复成日期对象 public Date(long time); public void setTime(long time);
9：SimpleDateFormat 时间处理类【格式化时间】
1：当前获取时间的方式： public static void main(String[] args) { // 1、创建当前日期时间对象 Date d = new Date(); System.out.println(d); // 2、得到当前时间的毫秒值 long time = d.getTime(); System.out.println(time); } 输出时间戳时间：1700xxxxx SimpleDateFormat 代表简单日期格式化，可以用来把日期时间格式化成为我们想要的形式 时间格式： xxxx-xx-xx xx:xx:xx
SimpleDateFormat： 构造器： public SimpleDateFormat(String pattern) 创建简单日期格式化对象，并封装格式化的形式信息 格式化方法： public final String format(Date date) 将日期格式化成日期/时间字符串 public final String format(Object time) 将时间毫秒值式化成日期/时间字符串
1、SimpleDateFormat代表什么，有什么作用？ 简单日期格式化对象 可以把日期对象及时间毫秒值格式化成我们想要的字符串形式。 可以把字符串的时间形式解析成Date日期对象。 2、SimpleDateFormat的对象如何创建？ public SimpleDateFormat(String pattern) 3、SimpleDateFormat格式化，以及解析时间的方法是怎么样的？ public final String format(Date d):格式化日期对象 public final String format(Object time):格式化时间毫秒值 public Date parse(String source)：解析字符串时间
EEE ：取星期几
a ：取上午还是下午
将日期格式化成日期/时间字符串
将时间毫秒值式化成日期/时间字符串 案例
package com.itheima.d2_simpledateformat; import java.text.SimpleDateFormat; import java.util.Date; /** 目标：SimpleDateFormat简单日期格式化类的使用 格式化时间 解析时间 */ public class SimpleDateFormatDemo01 { public static void main(String[] args) { // 1、日期对象 Date d = new Date(); System.out.println(d); // 2、格式化这个日期对象 (指定最终格式化的形式) SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEE a"); // 3、开始格式化日期对象成为喜欢的字符串形式 String rs = sdf.format(d); System.out.println(rs); System.out.println("----------------------------"); // 4、格式化时间毫秒值 // 需求：请问121秒后的时间是多少 long time1 = System.currentTimeMillis() + 121 * 1000; String rs2 = sdf.format(time1); System.out.println(rs2); System.out.println("------------解析字符串时间，下个代码---------------"); } }
SimpleDateFormat解析字符串时间成为日期对象： public Date parse(String source) 从给定字符串的开始解析文本以生成日期对象，返回Date类型
package com.itheima.d2_simpledateformat; import javax.xml.crypto.Data; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; public class SimpleDateFormatDemo2 { public static void main(String[] args) throws ParseException { // 目标: 学会使用SimpleDateFormat解析字符串时间成为日期对象。 // 有一个时间 2021年08月06日 11:11:11 往后 2天 14小时 49分 06秒后的时间是多少。 // 1、把字符串时间拿到程序中来 String dateStr = "2021年08月06日 11:11:11"; // 2、把字符串时间解析成日期对象（本节的重点）:形式必须与被解析时间的形式完全一样，否则运行时解析报错！ SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss"); Date d = sdf.parse(dateStr); // 解析后 返回一个 Date 日期对象 // 3、往后走2天 14小时 49分 06秒 long time = d.getTime() + (2L*24*60*60 + 14*60*60 + 49*60 + 6) * 1000; // L使用 long类型运算，int可能越界 // 4、格式化这个时间毫秒值就是结果 System.out.println(sdf.format(time)); } }
案例演示：
分析： 1：判单下单时间是否在开始到结束范围内 2：把字符串形式的时间变成毫秒值
package com.itheima.d2_simpledateformat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; public class SimpleDateFormatTest3 { public static void main(String[] args) throws ParseException { // 1、开始 和 结束时间 String startTime = "2021-11-11 00:00:00"; String endTime = "2021-11-11 00:10:00"; // 2、小贾 小皮 String xiaoJia = "2021-11-11 00:03:47"; String xiaoPi = "2021-11-11 00:10:11"; // 3、解析他们的时间 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); Date d1 = sdf.parse(startTime); Date d2 = sdf.parse(endTime); Date d3 = sdf.parse(xiaoJia); Date d4 = sdf.parse(xiaoPi); 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 static Calendar getInstance() 获取当前日历对象【调用 抽象类里某个方法创建对象，抽象类不能直接创建对象】【方法内部多态子类对象返回】 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是可变日期对象，一旦修改后其对象本身表示的时间将产生变化
package com.itheima.d3_calendar; import javax.xml.crypto.Data; import java.util.Calendar; import java.util.Date; /** 目标：日历类Calendar的使用,可以得到更加丰富的信息。 Calendar代表了系统此刻日期对应的日历对象。 Calendar是一个抽象类，不能直接创建对象。 Calendar日历类创建日历对象的语法： Calendar rightNow = Calendar.getInstance(); Calendar的方法： 1.public static Calendar getInstance(): 返回一个日历类的对象。 2.public int get(int field)：取日期中的某个字段信息。 3.public void set(int field,int value)：修改日历的某个字段信息。 4.public void add(int field,int amount)：为某个字段增加/减少指定的值 5.public final Date getTime(): 拿到此刻日期对象。 6.public long getTimeInMillis(): 拿到此刻时间毫秒值 小结： 记住。 */ public class CalendarDemo{ public static void main(String[] args) { // 1、拿到系统此刻日历对象 Calendar cal = Calendar.getInstance(); System.out.println(cal); // 2、获取日历的信息:public int get(int field)：取日期中的某个字段信息。 int year = cal.get(Calendar.YEAR); System.out.println(year); int mm = cal.get(Calendar.MONTH) + 1; System.out.println(mm); int days = cal.get(Calendar.DAY_OF_YEAR) ; System.out.println(days); // 3、public void set(int field,int value)：修改日历的某个字段信息。 // cal.set(Calendar.HOUR , 12); // System.out.println(cal); // 4.public void add(int field,int amount)：为某个字段增加/减少指定的值 // 请问64天后是什么时间 cal.add(Calendar.DAY_OF_YEAR , 64); cal.add(Calendar.MINUTE , 59); // 5.public final Date getTime(): 拿到此刻日期对象。 Date d = cal.getTime(); System.out.println(d); // 6.public long getTimeInMillis(): 拿到此刻时间毫秒值 long time = cal.getTimeInMillis(); System.out.println(time); } }
10：JDK8其他日期类 【LocalDate，LocalTime，LocalDateTime】
从Java 8开始，java.time包提供了新的日期和时间API，主要涉及的类型有：
LocalDate： 不包含具体时间的日期。【只包含年月日】
LocalTime： 不含日期的时间。【只包含时分秒】
LocalDateTime： 包含了日期及时间【年月日+时分秒】
Instant： 代表的是时间戳【毫秒值】
DateTimeFormatter 用于做时间的格式化和解析的
Duration: 用于计算两个“时间”间隔
Period: 用于计算两个“日期”间隔
新增的API严格区分了 时刻、本地日期、本地时间，并且，对日期和时间进行运算更加方便。
其次，新API的类型几乎全部是不变类型（和String的使用类似），可以放心使用不必担心被修改。
LocalDate、LocalTime、LocalDateTime 他们 分别表示日期，时间，日期时间对象，他们的类的实例是不可变的对象。 他们三者构建对象和API都是通用的 构建对象的方式如下： public static Xxxx now(); 静态方法，根据当前时间创建对象
LocaDate localDate = LocalDate.now();
/LocalTime llocalTime = LocalTime.now();
/LocalDateTime localDateTime = LocalDateTime.now(); public static Xxxx of(…); 静态方法，指定日期/时间创建对象
LocalDate localDate1 = LocalDate.of(2099 , 11,11);
/LocalTime localTime1 = LocalTime.of(11, 11, 11);
/LocalDateTime localDateTime1 = LocalDateTime.of(2020, 10, 6, 13, 23, 43); LocalDate、LocalTime、LocalDateTime获取信息的API public int geYear() 获取年 public int getMonthValue() 获取月份（1-12） Public int getDayOfMonth() 获取月中第几天乘法 Public int getDayOfYear() 获取年中第几天 Public DayOfWeek getDayOfWeek() 获取星期
LocalDateTime的转换API public LocalDate toLocalDate() 转换成一个LocalDate对象 public LocalTime toLocalTime() 转换成一个LocalTime对象
LocalDate：
package com.itheima.d4_jdk8_time; import java.time.LocalDate; import java.time.Month; public class Demo01LocalDate { public static void main(String[] args) { // 1、获取本地日期对象。 LocalDate nowDate = LocalDate.now(); System.out.println("今天的日期：" + nowDate);//今天的日期： int year = nowDate.getYear(); System.out.println("year：" + year); int month = nowDate.getMonthValue(); System.out.println("month：" + month); int day = nowDate.getDayOfMonth(); System.out.println("day：" + day); //当年的第几天 int dayOfYear = nowDate.getDayOfYear(); System.out.println("dayOfYear：" + dayOfYear); //星期 System.out.println(nowDate.getDayOfWeek()); System.out.println(nowDate.getDayOfWeek().getValue()); //月份 System.out.println(nowDate.getMonth());//AUGUST System.out.println(nowDate.getMonth().getValue());//8 System.out.println("----------指定时间创建 LocalDate--------------"); LocalDate bt = LocalDate.of(1991, 11, 11); System.out.println(bt);//直接传入对应的年月日 System.out.println(LocalDate.of(1991, Month.NOVEMBER, 11));//相对上面只是把月换成了枚举 } }
LocalTime/LocalDateTime
package com.itheima.d4_jdk8_time; import java.time.LocalDateTime; import java.time.LocalTime; import java.time.Month; public class Demo02LocalTime { public static void main(String[] args) { // 1、获取本地时间对象。 LocalTime nowTime = LocalTime.now(); System.out.println("今天的时间：" + nowTime);//今天的时间： int hour = nowTime.getHour();//时 System.out.println("hour：" + hour);//hour： int minute = nowTime.getMinute();//分 System.out.println("minute：" + minute);//minute： int second = nowTime.getSecond();//秒 System.out.println("second：" + second);//second： int nano = nowTime.getNano();//纳秒 System.out.println("nano：" + nano);//nano： System.out.println("--指定时间创建对象---"); System.out.println(LocalTime.of(8, 20));//时分 System.out.println(LocalTime.of(8, 20, 30));//时分秒 System.out.println(LocalTime.of(8, 20, 30, 150));//时分秒纳秒 LocalTime mTime = LocalTime.of(8, 20, 30, 150); System.out.println("---------------"); System.out.println(LocalDateTime.of(1991, 11, 11, 8, 20)); System.out.println(LocalDateTime.of(1991, Month.NOVEMBER, 11, 8, 20)); System.out.println(LocalDateTime.of(1991, 11, 11, 8, 20, 30)); System.out.println(LocalDateTime.of(1991, Month.NOVEMBER, 11, 8, 20, 30)); System.out.println(LocalDateTime.of(1991, 11, 11, 8, 20, 30, 150)); System.out.println(LocalDateTime.of(1991, Month.NOVEMBER, 11, 8, 20, 30, 150)); } }
LocalDateTime
package com.itheima.d4_jdk8_time; import java.time.LocalDate; import java.time.LocalDateTime; import java.time.LocalTime; public class Demo03LocalDateTime { public static void main(String[] args) { // 日期 时间 LocalDateTime nowDateTime = LocalDateTime.now(); System.out.println("今天是：" + nowDateTime);//今天是： System.out.println(nowDateTime.getYear());//年 System.out.println(nowDateTime.getMonthValue());//月 System.out.println(nowDateTime.getDayOfMonth());//日 System.out.println(nowDateTime.getHour());//时 System.out.println(nowDateTime.getMinute());//分 System.out.println(nowDateTime.getSecond());//秒 System.out.println(nowDateTime.getNano());//纳秒 //日：当年的第几天 System.out.println("dayOfYear：" + nowDateTime.getDayOfYear());//dayOfYear：249 //星期 System.out.println(nowDateTime.getDayOfWeek());//THURSDAY System.out.println(nowDateTime.getDayOfWeek().getValue());//4 //月份 System.out.println(nowDateTime.getMonth());//SEPTEMBER System.out.println(nowDateTime.getMonth().getValue());//9 LocalDate ld = nowDateTime.toLocalDate(); // LocalDateTime获取LocalDate对象 System.out.println(ld); LocalTime lt = nowDateTime.toLocalTime(); System.out.println(lt.getHour()); System.out.println(lt.getMinute()); System.out.println(lt.getSecond()); } }
修改相关的API：
LocalDateTime 综合了 LocalDate 和 LocalTime 里面的方法，所以下面只用 LocalDate 和 LocalTime 来举例。
下面这些方法返回的是一个新的实例引用，因为LocalDateTime 、LocalDate 、LocalTime 都是不可变的。
plusDays, plusWeeks, plusMonths, plusYears 向当前 LocalDate 对象添加 几天、 几周、几个月、几年
minusDays, minusWeeks, minusMonths, minusYears 从当前 LocalDate 对象减去 几天、 几周、几个月、几年
withDayOfMonth, withDayOfYear, withMonth, withYear 将月份天数、年份天数、月份、年 份 修 改 为 指 定 的 值 并 返 回 新 的 LocalDate 对象
isBefore, isAfter 比较两个 LocalDate
package com.itheima.d4_jdk8_time; import java.time.LocalDate; import java.time.LocalTime; import java.time.MonthDay; public class Demo04UpdateTime { public static void main(String[] args) { LocalTime nowTime = LocalTime.now(); System.out.println(nowTime);//当前时间 System.out.println(nowTime.minusHours(1));//一小时前 System.out.println(nowTime.minusMinutes(1));//一分钟前 System.out.println(nowTime.minusSeconds(1));//一秒前 System.out.println(nowTime.minusNanos(1));//一纳秒前 System.out.println("----------------"); System.out.println(nowTime.plusHours(1));//一小时后 System.out.println(nowTime.plusMinutes(1));//一分钟后 System.out.println(nowTime.plusSeconds(1));//一秒后 System.out.println(nowTime.plusNanos(1));//一纳秒后 System.out.println("------------------"); // 不可变对象，每次修改产生新对象！ 【原始的 nowTime不改变，每次修改都是产生心新的时间对象】 System.out.println(nowTime); System.out.println("---------------"); LocalDate myDate = LocalDate.of(2018, 9, 5); LocalDate nowDate = LocalDate.now(); System.out.println("今天是2018-09-06吗？ " + nowDate.equals(myDate));//今天是2018-09-06吗？ false System.out.println(myDate + "是否在" + nowDate + "之前？ " + myDate.isBefore(nowDate));//2018-09-05是否在2018-09-06之前？ true System.out.println(myDate + "是否在" + nowDate + "之后？ " + myDate.isAfter(nowDate));//2018-09-05是否在2018-09-06之后？ false System.out.println("---------------------------"); // 判断今天是否是你的生日 LocalDate birDate = LocalDate.of(1996, 8, 5); LocalDate nowDate1 = LocalDate.now(); MonthDay birMd = MonthDay.of(birDate.getMonthValue(), birDate.getDayOfMonth()); MonthDay nowMd = MonthDay.from(nowDate1); System.out.println("今天是你的生日吗？ " + birMd.equals(nowMd));//今天是你的生日吗？ false } }
11：JDK8其他日期类 【instant：时间戳】
Instant时间戳： JDK8获取时间戳特别简单，且功能更丰富。Instant类由一个静态的工厂方法now()可以返回当前时间戳。
Instant instant = Instant.now(); System.out.println("当前时间戳是：" + instant); Date date = Date.from(instant); System.out.println("当前时间戳是：" + date); instant = date.toInstant(); System.out.println(instant); 时间戳是包含日期和时间的，与java.util.Date很类似，事实上Instant就是类似JDK8 以前的Date。 Instant和Date这两个类可以进行转换
package com.itheima.d4_jdk8_time; import java.time.Instant; import java.time.LocalDate; import java.time.ZoneId; import java.util.Date; public class Demo05Instant { public static void main(String[] args) { // 1、得到一个Instant时间戳对象 拿到的是 0 时区的时间 Instant instant = Instant.now(); System.out.println(instant); // 2、系统此刻的时间戳怎么办？ ztZone 设置时区 systemDefault：默认时区 Instant instant1 = Instant.now(); System.out.println(instant1.atZone(ZoneId.systemDefault())); // 3、如何去返回Date对象 Date date = Date.from(instant); System.out.println(date); Instant i2 = date.toInstant(); System.out.println(i2); } }
11：JDK8其他日期类 【DateTimeFormat：日期时间格式器】
在JDK8中，引入了一个全新的日期与时间格式器DateTimeFormatter。 正反都能调用format方法。 LocalDateTime ldt = LocalDateTime.now(); System.out.println(ldt);//2021-03-01T15:09:17.444190900
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); String ldtStr = ldt.format(dtf); System.out.println(ldtStr);//2021-03-01 15:09:17
String ldtStr1 = dtf.format(ldt); System.out.println(ldtStr1);//2021-03-01 15:09:17
package com.itheima.d4_jdk8_time; import java.time.LocalDateTime; import java.time.format.DateTimeFormatter; public class Demo06DateTimeFormat { 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.format(ldt)); // 逆向格式化 System.out.println(ldt.format(dtf)); // 解析字符串时间 直接传解析器对象进行解析 灵活 DateTimeFormatter dtf1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); // 解析当前字符串时间成为本地日期时间对象 LocalDateTime ldt1 = LocalDateTime.parse("2019-11-11 11:11:11" , dtf1); System.out.println(ldt1); System.out.println(ldt1.getDayOfYear()); } }
12：JDK8其他日期类 【Duration/Period：计算日期间隔差异】
Period： 在Java8中，我们可以使用以下类来计算日期间隔差异：java.time.Period 主要是 Period 类方法 getYears()，getMonths() 和 getDays() 来计算,只能精确到年月日。 用于 LocalDate 之间的比较 LocalDate today = LocalDate.now(); System.out.println(today); // 2021-03-01 LocalDate birthDate = LocalDate.of(1995, 1, 11); System.out.println(birthDate); // 1995-01-11 Period period = Period.between(birthDate, today); System.out.printf("年龄 : %d 年 %d 月 %d 日", period.getYears(), period.getMonths(), period.getDays());
package com.itheima.d4_jdk8_time; import java.time.LocalDate; import java.time.Period; public class Demo07Period { public static void main(String[] args) { // 当前本地 年月日 LocalDate today = LocalDate.now(); System.out.println(today);// // 生日的 年月日 LocalDate birthDate = LocalDate.of(1998, 10, 13); System.out.println(birthDate); Period period = Period.between(birthDate, today);//第二个参数减第一个参数 System.out.println(period.getYears()); System.out.println(period.getMonths()); System.out.println(period.getDays()); } }
Duration： 在Java8中，我们可以使用以下类来计算时间间隔差异：java.time.Duration 提供了使用基于时间的值测量时间量的方法。 用于 LocalDateTime 之间的比较。也可用于 Instant 之间的比较。 LocalDateTime today = LocalDateTime.now(); System.out.println(today); LocalDateTime birthDate = LocalDateTime.of(1990,10,1,10,50,30); System.out.println(birthDate); Duration duration = Duration.between(birthDate, today);//第二个参数减第一个参数 System.out.println(duration.toDays());//两个时间差的天数 System.out.println(duration.toHours());//两个时间差的小时数 System.out.println(duration.toMinutes());//两个时间差的分钟数 System.out.println(duration.toMillis());//两个时间差的毫秒数 System.out.println(duration.toNanos());//两个时间差的纳秒数
package com.itheima.d4_jdk8_time; import java.time.Duration; import java.time.LocalDateTime; public class Demo08Duration { public static void main(String[] args) { // 本地日期时间对象。 LocalDateTime today = LocalDateTime.now(); System.out.println(today); // 出生的日期时间对象 LocalDateTime birthDate = LocalDateTime.of(2021,8 ,06,01,00,00); System.out.println(birthDate); Duration duration = Duration.between( today , birthDate);//第二个参数减第一个参数 System.out.println(duration.toDays());//两个时间差的天数 System.out.println(duration.toHours());//两个时间差的小时数 System.out.println(duration.toMinutes());//两个时间差的分钟数 System.out.println(duration.toMillis());//两个时间差的毫秒数 System.out.println(duration.toNanos());//两个时间差的纳秒数 } }
13：JDK8其他日期类 【ChronoUnit：测量一段时间】
ChronoUnit类可用于在单个时间单位内测量一段时间，这个工具类是最全的了，可以用于比较所有的时间单位
LocalDateTime today = LocalDateTime.now();
System.out.println(today); LocalDateTime birthDate = LocalDateTime.of(1990,10,1,10,50,30); System.out.println(birthDate);
System.out.println("相差的年数：" + ChronoUnit.YEARS.between(birthDate, today)); System.out.println("相差的月数：" + ChronoUnit.MONTHS.between(birthDate, today)); System.out.println("相差的周数：" + ChronoUnit.WEEKS.between(birthDate, today)); System.out.println("相差的天数：" + ChronoUnit.DAYS.between(birthDate, today)); System.out.println("相差的时数：" + ChronoUnit.HOURS.between(birthDate, today)); System.out.println("相差的分数：" + ChronoUnit.MINUTES.between(birthDate, today)); System.out.println("相差的秒数：" + ChronoUnit.SECONDS.between(birthDate, today)); System.out.println("相差的毫秒数：" + ChronoUnit.MILLIS.between(birthDate, today)); System.out.println("相差的微秒数：" + ChronoUnit.MICROS.between(birthDate, today)); System.out.println("相差的纳秒数：" + ChronoUnit.NANOS.between(birthDate, today)); System.out.println("相差的半天数：" + ChronoUnit.HALF_DAYS.between(birthDate, today)); System.out.println("相差的十年数：" + ChronoUnit.DECADES.between(birthDate, today)); System.out.println("相差的世纪（百年）数：" + ChronoUnit.CENTURIES.between(birthDate, today)); System.out.println("相差的千年数：" + ChronoUnit.MILLENNIA.between(birthDate, today)); System.out.println("相差的纪元数：" + ChronoUnit.ERAS.between(birthDate, today));
package com.itheima.d4_jdk8_time; import java.time.LocalDateTime; import java.time.temporal.ChronoUnit; public class Demo09ChronoUnit { public static void main(String[] args) { // 本地日期时间对象：此刻的 LocalDateTime today = LocalDateTime.now(); System.out.println(today); // 生日时间 LocalDateTime birthDate = LocalDateTime.of(1990,10,1, 10,50,59); System.out.println(birthDate); System.out.println("相差的年数：" + ChronoUnit.YEARS.between(birthDate, today)); System.out.println("相差的月数：" + ChronoUnit.MONTHS.between(birthDate, today)); System.out.println("相差的周数：" + ChronoUnit.WEEKS.between(birthDate, today)); System.out.println("相差的天数：" + ChronoUnit.DAYS.between(birthDate, today)); System.out.println("相差的时数：" + ChronoUnit.HOURS.between(birthDate, today)); System.out.println("相差的分数：" + ChronoUnit.MINUTES.between(birthDate, today)); System.out.println("相差的秒数：" + ChronoUnit.SECONDS.between(birthDate, today)); System.out.println("相差的毫秒数：" + ChronoUnit.MILLIS.between(birthDate, today)); System.out.println("相差的微秒数：" + ChronoUnit.MICROS.between(birthDate, today)); System.out.println("相差的纳秒数：" + ChronoUnit.NANOS.between(birthDate, today)); System.out.println("相差的半天数：" + ChronoUnit.HALF_DAYS.between(birthDate, today)); System.out.println("相差的十年数：" + ChronoUnit.DECADES.between(birthDate, today)); System.out.println("相差的世纪（百年）数：" + ChronoUnit.CENTURIES.between(birthDate, today)); System.out.println("相差的千年数：" + ChronoUnit.MILLENNIA.between(birthDate, today)); System.out.println("相差的纪元数：" + ChronoUnit.ERAS.between(birthDate, today)); } }
14：包装类 【其实就是8种基本数据类型对应的引用类型】【引用类型就是类的形式】
包装类：其实就是8种基本数据类型对应的引用类型 为什么提供包装类？ Java为了实现一切皆对象，为8种基本类型提供了对应的引用类型。 后面的集合和泛型其实也只能支持包装类型，不支持基本数据类型 自动装箱：基本类型的数据和变量可以直接赋值给包装类型的变量。 自动拆箱：包装类型的变量可以直接赋值给基本数据类型的变量 包装类的特有功能 包装类的变量的默认值可以是null，容错率更高。 可以把 基本类型 的数据转换成字符串类型(用处不大) 调用toString()方法得到字符串结果。 调用Integer.toString(基本类型的数据)。 可以把字符串类型的数值转换成真实的数据类型（真的很有用） Integer.parseInt(“字符串类型的整数”) Double.parseDouble(“字符串类型的小数”)。 1、包装类是什么，作用是什么？ 基本数据类型对应的引用类型，实现了一切皆对象。 后期集合和泛型不支持基本类型，只能使用包装类。 2、包装类有哪些特殊功能？ 可以把基本类型的数据转换成字符串类型(用处不大) 可以把字符串类型的数值转换成真实的数据类型（真的很有用）
package com.itheima.d5_integer; /** 目标：明白包装类的概念，并使用。 */ 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; // 自动拆箱 【引用类型变量 赋值给 基本类型 int】 System.out.println(it1); 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(number1); double score = Double.valueOf(number1); System.out.println(score + 0.1); } }
15：正则表达式 String mathes 方法匹配正则表达规则
正则表达式可以用一些规定的字符来制定规则，并用来校验数据格式的合法性
正则表达式初体验
需求：假如现在要求校验一个qq号码是否正确，6位及20位之内，必须全部是数字 。
先使用目前所学知识完成校验需求；然后体验一下正则表达式检验
package com.itheima.d6_regex; public class RegexDemo1 { public static void main(String[] args) { // 需求：校验qq号码，必须全部数字 6 - 20位 System.out.println(checkQQ("251425998")); System.out.println(checkQQ("2514259a98")); System.out.println(checkQQ(null)); System.out.println(checkQQ("2344")); System.out.println("-------------------------");
// 正则表达式的初体验： System.out.println(checkQQ2("251425998")); System.out.println(checkQQ2("2514259a98")); System.out.println(checkQQ2(null)); System.out.println(checkQQ2("2344")); } public static boolean checkQQ2(String qq){ return qq != null && qq.matches("\\d{6,20}"); } public static boolean checkQQ(String qq){ // 1、判断qq号码的长度是否满足要求 if(qq == null || qq.length() < 6 || qq.length() > 20 ) { return false; } // 2、判断qq中是否全部是数字，不是返回false // 251425a87 for (int i = 0; i < qq.length(); i++) { // 获取每位字符 char ch = qq.charAt(i); // 判断这个字符是否不是数字，不是数字直接返回false if(ch < '0' || ch > '9') { return false; } } return true; // 肯定合法了！ } }
正则表达式使用详解【匹配规则】：
package com.itheima.d6_regex; /** 目标：全面、深入学习正则表达式的规则 */ public class RegexDemo02 { public static void main(String[] args) { //public boolean matches(String regex):判断是否与正则表达式匹配，匹配返回true // 只能是 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("3".matches("\\d")); // true System.out.println("333".matches("\\d")); // false System.out.println("z".matches("\\w")); // true System.out.println("2".matches("\\w")); // true System.out.println("21".matches("\\w")); // false System.out.println("你".matches("\\w")); //false System.out.println("你".matches("\\W")); // true System.out.println("---------------------------------"); // 以上正则匹配只能校验单个字符。 // 校验密码 // 必须是数字 字母 下划线 至少 6位 System.out.println("2442fsfsf".matches("\\w{6,}")); System.out.println("244f".matches("\\w{6,}")); // 验证码 必须是数字和字符 必须是4位 System.out.println("23dF".matches("[a-zA-Z0-9]{4}")); System.out.println("23_F".matches("[a-zA-Z0-9]{4}")); System.out.println("23dF".matches("[\\w&&[^_]]{4}")); System.out.println("23_F".matches("[\\w&&[^_]]{4}")); } }
16：正则表达式产常见案例
package com.itheima.d6_regex; import java.util.Arrays; import java.util.Scanner; public class RegexTest3 { public static void main(String[] args) { // 目标：校验 手机号码 邮箱 电话号码 // checkPhone(); // checkEmail(); // checkTel(); // 校验金额是否格式金额： 99 0.5 99.5 019 | 0.3.3 int[] arr = {10, 4, 5,3, 4,6, 2}; System.out.println(Arrays.binarySearch(arr, 2)); } public static void checkTel(){ Scanner sc = new Scanner(System.in); while (true) { System.out.println("请您输入您的电话号码："); String tel = sc.next(); // 判断邮箱格式是否正确 027-3572457 0273572457 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(); // 判断邮箱格式是否正确 3268847878@qq.com // 判断邮箱格式是否正确 3268847dsda878@163.com // 判断邮箱格式是否正确 3268847dsda878@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("格式有误！"); } } } }
17：正则表达式常见的字符串方法
public String replaceAll(String regex,String newStr) 按照正则表达式匹配的内容进行替换 public String[] split(String regex)： 按照正则表达式匹配的内容进行分割字符串，反回一个字符串数组。 public Boolean match(String regex,)
package com.itheima.d6_regex; /** 目标：正则表达式在方法中的应用。 public String[] split(String regex)： -- 按照正则表达式匹配的内容进行分割字符串，反回一个字符串数组。 public String replaceAll(String regex,String newStr) -- 按照正则表达式匹配的内容进行替换 */ public class RegexDemo04 { public static void main(String[] args) { String names = "小路dhdfhdf342蓉儿43fdffdfbjdfaf小何"; String[] arrs = names.split("\\w+"); for (int i = 0; i < arrs.length; i++) { System.out.println(arrs[i]); } String names2 = names.replaceAll("\\w+", " "); System.out.println(names2); } }
18：正则表达式爬取信息【简单案例】
package com.itheima.d6_regex; import java.util.regex.Matcher; import java.util.regex.Pattern; /** 拓展：正则表达式爬取信息中的内容。(了解) */ public class RegexDemo05 { 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); } } }
19：Arrays 类 【数组 工具类】
Arrays类概述： 数组操作工具类，专门用于操作 数组元素 的。 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.itheima.d7_arrays; import java.util.Arrays; public class ArraysDemo1 { public static void main(String[] args) { // 目标：学会使用Arrays类的常用API ,并理解其原理 int[] arr = {10, 2, 55, 23, 24, 100}; System.out.println(arr); // 1、返回数组内容的 toString(数组) // String rs = Arrays.toString(arr); // System.out.println(rs); System.out.println(Arrays.toString(arr)); // 2、排序的API(默认自动对数组元素进行升序排序) Arrays.sort(arr); System.out.println(Arrays.toString(arr)); // 3、二分搜索技术（前提数组必须排好序才支持，否则出bug） int index = Arrays.binarySearch(arr, 55); System.out.println(index); // 返回不存在元素的规律： - （应该插入的位置索引 + 1） int index2 = Arrays.binarySearch(arr, 22); System.out.println(index2); // 注意：数组如果么有排好序，可能会找不到存在的元素，从而出现bug!! int[] arr2 = {12, 36, 34, 25 , 13, 24, 234, 100}; System.out.println(Arrays.binarySearch(arr2 , 36)); } }
20：Arrays 类 对于Comparator比较器的支持
Arrays类的排序方法： public static void sort(类型[] a) 对数组进行默认升序排序 public static <T> void sort(类型[] a, Comparator<? super T> c) 使用比较器对象自定义排序 自定义排序规则： 设置Comparator接口对应的比较器对象，来定制比较规则。 如果认为左边数据 大于 右边数据 返回正整数 如果认为左边数据 小于 右边数据 返回负整数 如果认为左边数据 等于 右边数据 返回0
package com.itheima.d7_arrays; 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)); } }
21：常见简单算法
冒泡排序：
选择排序：固定一个位置和后面每个位置进行比较【冒泡是两两对比大的往后移】【选择排序是定位选择，第一个位置，第二个位置】
package com.itheima.d8_sort_binarysearch; 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 - 1; 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)); } }
二分查找：
package com.itheima.d8_sort_binarysearch; /** 目标：理解二分搜索的原理并实现。 */ public class Test2 { public static void main(String[] args) { // 1、定义数组 int[] arr = {10, 14, 16, 25, 28, 30, 35, 88, 100}; // r // l // 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; // 查无此元素 } }
数组的二分查找的实现步骤是什么样的? 定义变量记录左边和右边位置。 使用while循环控制查询（条件是左边位置<=右边位置） 循环内部获取中间元素索引 判断当前要找的元素如果大于中间元素，左边位置=中间索引+1 判断当前要找的元素如果小于中间元素，右边位置=中间索引-1 判断当前要找的元素如果等于中间元素，返回当前中间元素索引
22：lambda 表达式
Lambda表达式是JDK 8开始后的一种新语法形式。 作用：简化匿名内部类的代码写法。 Lambda表达式的简化格式： (匿名内部类被重写方法的形参列表) -> { 被重写方法的方法体代码。 } 注：-> 是语法形式，无实际含义 注意：Lambda表达式只能简化函数式接口的匿名内部类的写法形式 什么是函数式接口？ 首先必须是接口、其次接口中有且仅有一个抽象方法的形式
通常可以在 接口 上加一个 @functionalInterface 注解，标记该接口必须满足函数式接口
package com.itheima.d9_lambda; public class LambdaDemo1 { public static void main(String[] args) { // 目标：学会使用Lambda的标准格式简化匿名内部类的代码形式 Animal a = new Animal() { @Override public void run() { System.out.println("乌龟跑的很慢~~~~~"); } }; a.run(); // 注意：lambda并不是可以简化所有匿名匿名内部类形式！！[1:必须是接口 2：接口中只有一个抽象方法] // Animal a1 = () -> { // System.out.println("乌龟跑的很慢~~~~~"); // }; // a1.run(); } } abstract class Animal{ public abstract void run(); }
package com.itheima.d9_lambda; 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("老师游泳贼溜~~~~~"); // }; Swimming s1 = () -> System.out.println("老师游泳贼溜~~~~~"); go(s1); System.out.println("---------------------"); // go(new Swimming() { // @Override // public void swim() { // System.out.println("学生游泳很开心~~~"); // } // }); // go(() ->{ // 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(); }
package com.itheima.d9_lambda; import javax.swing.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.util.Arrays; import java.util.Comparator; public class LambdaDemo3 { public static void main(String[] args) { Integer[] ages1 = {34, 12, 42, 23}; /** 参数一：被排序的数组 必须是引用类型的元素 参数二：匿名内部类对象，代表了一个比较器对象。 */ // 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; // 降序 // }); // Arrays.sort(ages1, ( o1, o2) -> { // return o2 - o1; // 降序 // }); Arrays.sort(ages1, ( o1, o2 ) -> o2 - o1 ); System.out.println(Arrays.toString(ages1)); System.out.println("---------------------------"); JFrame win = new JFrame("登录界面"); JButton btn = new JButton("我是一个很大的按钮"); // 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("有人点我，点我，点我！！") ); win.add(btn); win.setSize(400, 300); win.setVisible(true); } }
Lambda表达式的省略写法（进一步在Lambda表达式的基础上继续简化）：
参数类型可以省略不写。
如果只有一个参数，参数类型可以省略，同时()也可以省略。
如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写,同时要省略分号！
如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写。此时，如果这行代码是return语句，必须省略return不写，同时也必须省略";"不写
