Day04 日期时间-Lambda表达式

Day04 日期时间-Lambda表达式

日期与时间

data类概述

Date 类的对象在归va 中代表的是当前所在系统的此刻日期时间。

Date的构造器

名称	说明
public Date()	创建一个Date 对象， 代表的是系统当前此刻日期时间。

Date的常用方法

名称	说明
public long getTime()	获取时间对象的毫秒值

Date类记录时间的2种形式

形式1：日期对象

//1.创建一个Date类的对象，代表系统此刻时间日期对象
Date d = new Date();
System.out.println(d);

形式2：时间毫秒值

指从1970年1月1日，00：00：00走到此刻的总的毫秒数，应该是很大的
    long time = d.getTime();
	System.out.println(time);

案例：

请计算出当前时间往后走1小时121秒之后的时间是多少

时间毫秒值->日期对象

构造器	说明
public Date(long time)	把时间毫秒值转换成Date日期对象
Date方法	说明
public void setTime(long time)	设置日期对象的时间为当前时间毫秒值对应的时间

public class DateDemo01 {
    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);
        System.out.println("---------------");
        long time1 = System.currentTimeMillis();
        System.out.println(time1);

        System.out.println("-----------");
        //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);

        //4.另外一种方法
        Date d3 = new Date();
        d3.setTime(time2);
        System.out.println(d3);
    }
}


SimpleDateFormat类的作用

可以对Date对象或时间毫秒值格式化成我们喜欢的时间形式

也可以把字符串的时间形式解析成日期对象


SimpleDateFormat的构造器

构造器	说明
SimpleDateFormat()	构造一个SimpleDateFormat，使用默认格式
SimpleDateFormat(String pattern)	构造一个SimpleDateFormat，使用指定的格式

SimpleDateFormat的格式化方法

格式化方法	说明
public final String format(Date date)	将日期格式化成日期/时间字符串
public final String format(Object time)	将时间毫秒值化成日期/时间字符串

格式化时间形式的常用模式对应关系如下


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 EEE HH:mm:ss a");

        //3.开始格式化日期对象成为喜欢的字符串形式
        String rs = sdf.format(d);
        System.out.println(rs);
    }
}

SimpleDateFormat解析字符串时间成为日期时间

解析方法	说明
public Date parse(String source)	从给定字符串的开始解析文本以生成时间

案例：

请计算出2021年08月06日11点11分11秒，往后走2天14小时49分06秒后的时间是多少？

public class SimpleDateFormatDemo02 {
    public static void main(String[] args) throws ParseException {
        System.out.println("----解析字符串时间----");
        //请计算出2021年08月06日11点11分11秒，往后走2天14小时49分06秒后的时间是多少？

        //1.把字符串时间拿到程序中去
        String time = "2021年08月06日 11:11:11";

        //2.把字符串时间解析成时间对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        Date d = sdf.parse(time);

        //3.往后走2天14小时49分06秒后的时间
        long time1 = d.getTime() + (2 * 24 * 60 * 60 + 14 * 60 * 60 + 49 * 60 + 6) * 1000;
        
        //4.格式化这个时间毫秒值就是结果
        System.out.println(time);
        String rs = sdf.format(time1);
        System.out.println(rs);
    }
}

总结
//1 、SimleDateFormat 可以格式化哪些时间形式？
SimpIeDateFormat sdf = new Simp1eDateFormat("yyyy-MM-dd HH：mm：ss)；
String rsl = sdf.format(date);
String rs2 = sdf.format(time);

//2 、SimpleDateFormat 如何进行字符串时间的解析的？
Simp1eDateFormat sdf = new SimpIeDateFormat"yyyy-MM-dd HH：mm：ss)；
Date d = sdf.parse(("2021-08-04 11:11:11） ；

Calendar概述（日历）

• Calendar代表了系统此刻日期对应的日历对象

• Calendar是一个抽象类，不能直接创建对象

Calendar日历类创建日历对象的方法：（掉方法）

public static Calendar getInstance()  ->获取当前日历对象
    Calendar cal = 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是可变日期对象，一旦修改后其对象本身表示的时间将产生变化。

JDK8新增日期类

概述：LocalTime、LocalDate、LocalDateTime




Instant时间戳


DateTimeFormatter：


Duration/Period

Period:


Duration:


ChronoUnit:用于在单个时间单位内测量一段时间

//本地日期时间对象
LocalDateTime today = LocalDateTime.now();
System.out.println(today);

//出生的日期对象
LocalDateTime birTime = LocalDateTime.of(1999, 11, 13, 05, 22,50);
System.out.println(birTime);

System.out.println("相差的年数：" + ChronoUnit.YEARS.between(birTime,today));
System.out.println("相差的月数：" + ChronoUnit.MONTHS.between(birTime,today));
System.out.println("相差的周数：" + ChronoUnit.WEEKS.between(birTime,today));
System.out.println("相差的天数：" + ChronoUnit.DAYS.between(birTime,today));
System.out.println("相差的时数：" + ChronoUnit.HOURS.between(birTime,today));
System.out.println("相差的分数：" + ChronoUnit.MINUTES.between(birTime,today));
System.out.println("相差的秒数：" + ChronoUnit.SECONDS.between(birTime,today));
System.out.println("相差的毫秒数：" + ChronoUnit.MILLIS.between(birTime,today));
System.out.println("相差的微秒数：" + ChronoUnit.MICROS.between(birTime,today));
System.out.println("相差的纳秒数：" + ChronoUnit.NANOS.between(birTime,today));
System.out.println("相差的半天数：" + ChronoUnit.HALF_DAYS.between(birTime,today));
System.out.println("相差的半天十年数：" + ChronoUnit.DECADES.between(birTime,today));
System.out.println("相差的半天世纪（百年）数：" + ChronoUnit.CENTURIES.between(birTime,today));

包装类：

其实就是8中基本数据类型对应的引用数据类型

基本数据类型	引用数据类型
byte	Byte
short	Short
int	Integer
long	Long
char	Character
float	Float
double	Double
boolean	Boolean

为什么提供包装类：

• java为了实现一切皆对象，为8种基本类型提供了对应的引用类型

• 后面的集合和泛型其实也只能支持包装类型

自动装箱： 基本类型的数据和变量可以直接赋值给包装类型的变量。

int a = 10;
Integer a2 = a;//自动装箱

自动拆箱： 包装类型的变量可以直接赋值给基本数据类型的变量。

Integer it = 100;
int it1 = it;//自动拆箱

包装类的特有功能

• 包装类的变量的默认值可以是null ，容错率更高

int age = null;//会报错
Integer age1 = null;//是可以的

• 可以把基本类型的数据转换成字符串类型（ 用处不大）

• 调用tostring() 方法得到字符串结果。

• 调用lnteger.toString( 基本类型的数据）。

可以把字符串类型的数值转换成真实的数据类型（ 真的很有用）

• lnteger.parselnt( " 字符串类型的整数" ）

• Double.parseDouble( " 字符串类型的小数” ） 。

• 用Double/Integer.valueof(String s)可以实现一样的效果


正则表达式：

正则表示：

正则表达式可以用一些规定的字符来制定规则，并用来校验数据格式的合法性


String类的哪个方法可以与正则表达式进行匹配

public boolean matches(String regex);
//判断是否匹配正则表达式，匹配返回true，不匹配返回false

正则表达式在字符串方法中的应用

方法名	说明
public String replaceAll(String regex,String newStr)	按正则表达式匹配的内容进行替换
public String[] split(String regex)	按照正则表达式匹配的内容进行分割字符串，返回一个字符串数组

正则表达式爬取信息

public class RegexDemo05 {
    public static void main(String[] args) {
        String rs = "来地大学习地质工程，电话100-120119，或者联系邮箱" +
                "1202120421@cug.com,电话15072179532，027-5715330" +
                "邮箱21312321213@qq.com,电话15827290767";

        //需求，从上面的内容中爬取去 电话号码和邮箱
        //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);
        }
    }
}
1202120421@cug.com
15072179532
027-5715330
21312321213@qq.com
15827290767

Arrays类

Arrays类概述

数组操作工具类，专门用于操作数组元素的

Arrays类的常用API

方法名	说明
public static String toString(类型[] a)	对数组进行排序
public static void sort(类型[] a)	对数组进行默认升序排序
public static void sort(类型[] a,Comparator <? super T>c)	使用比较器对象自定义排序
public static int bbinarySearch(int[] a,int key)	二分搜索数组中的数据，存在返回索引，不存在返回-1

自定义排序规则

设置Comparator接口对应的比较器对象，来定制比较规则


常见算法

选择排序的思想

每轮选择当前位置，开始找出后面的较小值与该位置交换

选择排序的关键

确定总共需要选择几轮：数组的长度-1；

控制每轮从以前位置为基准，与后面元素选择几次

二分查找

二分查找性能好，二分查找的前提是必须排好序的数据

二分查找相当于每次去掉一半的数据

二分查找--元素不存在：

• 结论：二分查找正常的检索条件应该是开始位置min<=结束位置max

实现步骤：

Lambda表达式

Lambad概述：

． Lambda 表达式EJDK 8 开始后的一种新语法形式。

． 作用： 简化匿名内部类的代码写法。

Lambda 表达式的简化格式

（匿名内部类被重写方法的形参列表）-> {
被重写方法的方法体代码。
}
注： -> 是语法形式/ 无实际含义

Lambda表达式只能简化函数式接口的匿名内部类的写法形式。

什么是函数式接口

• 首先必须是接口，其次接口中有且仅有一个抽象方法的形式

• 通常我们会在接口上加上一个@FunctionalInterface注解，标记该接口必须是满足函数时接口

总结~
//1 、Lambda 表达式的基本作用？
． 简化函数式接囗的匿名内部类的写法。
//2 、Lambda 表达式有什么使用前提？
． 必须是接囗的匿名内部类， 接囗中只能有一个抽象方法
//3 、Lambda 的好处？
． Lambda是一个匿名函数，我们可以把Lambda表达式理解为
是一段可以传递的代码，它可以写出更简洁、更灵活的代码，
作为一种更紧凑的代码风格，java语言表达能力得到了提升。

Lambda 表达式的省略写法（进一步在Lambda 表达式的基础上继续简化）

． 数类型可以省略不写。

． 如果只有一个参数， 参数类型可以省略， 同时0 也可以省略。

． 如果Lambda 表达式的方法体代码只有一行代码。可以省略大括号不写， 同时要省略分号！

． 如果Lambda 表达式的方法体代码只有一行代码。可以省略大括号不写。此时， 如果这行代码是return语句， 必须省略return 不写， 同时也必须省略； 不写

public class LambdaDemo02 {
    //Lambda表达式只能简化函数式接口的匿名内部类的写法形式。
    public static void main(String[] args) {
        /*Swimming s1 = new Swimming(){
            @Override
            public void Swim() {
                System.out.println("老师游得快！");
            }
        };
        go(s1);*/
        Swimming s1 = () ->{
            System.out.println("老师游得慢~");
        };
        Swimming s2 = () -> 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();