Java - day13 - 常用API（常用API、正则表达式、Lambda、算法）
Date类概述
- Date类的对象在Java中代表的是当前所在系统的此刻日期时间。
实例：
import java.util.Date;
public class date {
public static void main(String[] args) {
Date d = new Date();
System.out.println(d); //Wed May 04 10:26:19 CST 2022
long time = d.getTime();
//形式2:时间毫秒值
//指的是从1970年1月1日00:00:00走到此刻的总的毫秒数，应该是很大的
System.out.println(time); //1651631240563
}
}
实例：
import java.util.Date;
//请计算出当前时间往后走1小时121秒之后的时间是多少。
public class date2 {
public static void main(String[] args) {
//1、得到当前时间
Date d1 = new Date();
System.out.println(d1);
//2、当前时间往后走1小时121s
long time2 = System.currentTimeMillis();
time2 += (60* 60 + 121) * 1000;
//3、把时间毫秒值转换成对应的日期对象。
// Date d2 = new Date(time2);
// System.out.println(d2); //Wed May 04 11:36:02 CST 2022
Date d3 = new Date();
d3.setTime(time2);
System.out.println(d3) ; //Wed May 04 11:36:02 CST 2022
}
}
日期对象如何创建，如何获取时间毫秒值?
* Date date = new Date();
* Long time = date.getTime();
时间毫秒值怎么恢复成日期对象
* Date d = new Date(time);
* d.setTime(time);
SimpleDateFormat类作用
- 可以对Date对象或时间毫秒值格式化成我们喜欢的时间形式。
- 也可以把字符串的时间形式解析成日期对象。
实例：
import java.text.SimpleDateFormat;
import java.util.Date;
/*
目标:SimpleDateFormat简单日期格式化类的使用格式化时间
解析时间
*/
public class SimpleDateFormat01 {
public static void main(String[] args) {
//1、日期对象
Date d = new Date();
System.out.println(d); //Wed May 04 10:44:42 CST 2022
//2、格式化这个日期对象〔指定最终格式化的形式)
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH :mm : ss EEE a");
//3、开始格式化日期对象成为喜欢的字符串形式
String rs = sdf.format(d);
System.out.println(rs); //2022年05月04日 10 :44 : 42 周三 上午
}
}
实例：
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);
// 3、往后走2天 14小时 49分 06秒
long time = d.getTime() + (2L*24*60*60 + 14*60*60 + 49*60 + 6) * 1000;
// 4、格式化这个时间毫秒值就是结果
System.out.println(sdf.format(time));
}
}
实例：
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class 秒杀 {
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("小皮秒杀失败！");
}
}
}
Calendar概述
- Calendar代表了系统此刻日期对应的日历对象。 Calendar是一个抽象类，不能直接创建对象。
实例：
import javax.xml.crypto.Data;
import java.util.Calendar;
import java.util.Date;
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);
}
}
JDK8 新增日期类
LocalDate、LocalTime、LocalDateTime
- 他们分别表示日期，时间，日期时间对象，他们的类的实例是不可变的对象。
- 他们三者构建对象和API都是通用的。
Instant（了解）
实例：
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时间戳对象
Instant instant = Instant.now();
System.out.println(instant);
// 2、系统此刻的时间戳怎么办？
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);
}
}
DateTimeFormatter
实例：
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());
}
}
Duration/Period
- Duration:用于计算两个“时间”间隔。
- Period:用于计算两个“日期”间隔。
ChronoUnit（了解）
包装类
- 自动装箱:基本类型的数据和变量可以直接赋值给包装类型的变量。
- 自动拆箱:包装类型的变量可以直接赋值给基本数据类型的变量。
包装类的特有功能
- 包装类的变量的默认值可以是null，容错率更高。
可以把基本类型的数据转换成字符串类型(用处不大)
- 调用toString()方法得到字符串结果。
- 调用Integer.toString(基本类型的数据)。
可以把字符串类型的数值转换成真实的数据类型（真的很有用)
- lnteger.parselnt(“字符串类型的整数”)
- 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);
Integer it = 100;
int it1 = it; // 自动拆箱
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);
}
}
正则表达式
- 正则表达式可以用一些规定的字符来制定规则，并用来校验数据格式的合法性。
正则表达式初体验
- 需求:假如现在要求校验一个qq号码是否正确，6位及20位之内，必须全部是数字。
实例：
public class 正则表达式 {
public static void main(String[] args) {
System.out.println(qq("456545646")); //true
System.out.println(qq("456")); //false
System.out.println(qq("aaa6")); //false
System.out.println(qq(null)); //false
}
public static boolean qq(String qq){
return qq !=null && qq.matches("\\d{6,20}");
}
}
String类的哪个方法可以与正则表达式进行匹配。
public boolean matches(String regex):
- 判断是否匹配正则表达式，匹配返回true，不匹配返回false。
案例：校验 手机号码 邮箱 电话号码
实例：
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("格式有误！");
}
}
}
}
正则表达式在字符串方法中的使用
正则表达式支持爬取信息
实例：
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);
}
}
}
Arrays类概述
- 数组操作工具类，专门用于操作数组元素的。
常见算法
选择排序
选择排序的思想
- 每轮选择当前位置，开始找出后面的较小值与该位置交换
选择排序的关键
- 确定总共需要选择几轮：数组的长度-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 - 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));
}
}
二分查找
- 基本查找在数据量特别大的时候，从前往后寻找的性能是很差的!
- 而二分查找性能好，二分查找的前提是必须是排好序的数据。
- 二分查找相当于每次去掉一半的查找范围
- 元素不存在：二分查找正常的检索条件应该是开始位置min <=结束位置max
实例：
/**
目标：理解二分搜索的原理并实现。
*/
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
- 判断当前要找的元素如果等于中间元素，返回当前中间元素索引。
Lambda表达式
Lambda概述
- Lambda表达式是JDK8开始后的一种新语法形式。
- 作用:简化匿名内部类的代码写法。
- Lambda表达式的简化格式
- 注意：Lambda表达式只能简化函数式接口的匿名内部类的写法形式
什么是函数式接口?
- 首先必须是接口、其次接口中有且仅有一个抽象方法的形式
- 通常我们会在接口上加上一个@FunctionalIlnterface注解，标记该接口必须是满足函数式接口。
实例：
public class LambdaDemo1 {
public static void main(String[] args) {
// 目标：学会使用Lambda的标准格式简化匿名内部类的代码形式
Animal a = new Animal() {
@Override
public void run() {
System.out.println("乌龟跑的很慢~~~~~");
}
};
a.run();
// 注意：lambda并不是可以简化所有匿名匿名内部类形式！！
// Animal a1 = () -> {
// System.out.println("乌龟跑的很慢~~~~~");
// };
// a1.run();
}
}
abstract class Animal{
public abstract void run();
}
Lambda实战-简化常见函数式接口
Lambda表达式简化comparator接口的匿名形式
Lambda表达式简化按钮监听器ActionListener的匿名内部类形式
实例：
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表达式的方法体代码只有一行代码。可以省略大括号不写,同时要省略分号!
- 如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写。此时，如果这行代码是return语句，必须省略return不写，同时也必须省略";"不写
- 代码实例可看上面的代码部分。
Comments | NOTHING