JAVA8新特性

Lambda表达式

格式:(形式参数) -> {代码块}

形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可。
->：由英文中画线和大于符号组成，固定写法。代表指向动作。
代码块：是我们具体要做的事情，也就是以前我们写的方法体内容。

组成Lambda表达式的三要素与使用要求

三要素：形式参数、箭头、代码块
使用要求：使用Lambda必须要有接口，并且要求接口中有且仅有一个抽象方法

示例：

public interface GetUser {
    void getUser();
}

public class GetUserImpl implements GetUser {
    @Override
    public void getUser() {
        System.out.println("获取到了用户");
    }
}

public class MainBoardDemo {
    public static void main(String[] args) {
        //在主方法中调用useEatable方法
        GetUser getUser = new GetUserImpl ();
        mainBoard(getUser );
        //匿名内部类
        mainBoard(new GetUser () {
            @Override
            public void getUser() {
                System.out.println("哈哈神");
            }
        });
        //Lambda表达式
        mainBoard(() -> {
            System.out.println("米老鼠");
        });
    }

    private static void mainBoard(GetUser getUser ) {
    	getUser.work();
    }
}

Lambda表达式的省略模式

参数的类型可以省略：有多个参数的情况下，不能只省略一个

如果参数有且仅有一个，那么小括号可以省略

如果代码块的语句只有一条，可以省略大括号和分号

如果代码块的语句只有一条，可以省略大括号和分号，如果有return，return也要省略掉

Lambda表达式的注意事项

使用Lambda必须要有接口，并且要求接口中有且仅有一个抽象方法;
必须有上下文环境，才能推导出Lambda对应的接口:

Lambda表达式与匿名内部类的区别

https://www.runoob.com/java/java8-lambda-expressions.html

---

接口新特性

接口组成更新概述

常量： public static final
抽象方法： public abstract
默认方法(Java 8)（作用：实现代码升级, 不会破坏现在有的代码）

静态方法(Java 8)（public static 返回值类型 方法名(参数列表) { }）
静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
私有方法(Java 9)（作用：Java 8允许在接口中定义带方法体的默认方法和静态方法，）
默认方法可以调用私有的静态方法和非静态方法；
静态方法只能调用私有的静态方法。


https://www.runoob.com/java/java8-default-methods.html

---

方法引用

方法引用通过方法的名字来指向一个方法。
方法引用可以使语言的构造更紧凑简洁，减少冗余代码。
方法引用使用一对冒号 :: 。
lambda表达式的主体仅包含一个表达式，且该表达式仅调用了一个已经存在的方法。
方法引用的通用特性：方法引用所使用方法的入参和返回值与lambda表达式实现的函数式接口的入参和返回值一致。

引用类方法

引用类方法，其实就是引用类的静态方法
格式---------类名::静态方法

引用对象方法

格式---------对象::成员方法

引用类的实例方法

引用构造器

引用构造器，其实就是引用构造方法
使用说明:Lambda表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数

https://www.runoob.com/java/java8-method-references.html

---

函数式接口：有且仅有一个抽象方法的接口，但是可以有多个非抽象方法的接口

@FunctionalInterface：

放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败;
只要保证满足函数式接口定义的条件，也照样是函数式接口。但是，建议加上该注解

https://www.runoob.com/java/java8-functional-interfaces.html

---

Stream流

https://www.runoob.com/java/java8-streams.html

---

Optional 类

https://www.runoob.com/java/java8-optional-class.html

---

日期

概述:

Java 8 在 java.time 包下提供了很多新的 API;
Local(本地) − 简化了日期时间的处理，没有时区的问题;
Zoned(时区) − 通过制定的时区处理日期时间;

LocalDate:

		// 获取当前年月日
        LocalDate localDate = LocalDate.now();
        // 构造指定的年月日
        LocalDate localDate1 = LocalDate.of(2020, 11, 28);
        // 获取年、月、日、星期几
        //获取年
        int year = localDate.getYear();
        int year1 = localDate.get(ChronoField.YEAR);
        System.out.println("year = "+year);
        //获取月
        Month month = localDate.getMonth();
        int month1 = localDate.get(ChronoField.MONTH_OF_YEAR);
        System.out.println("month="+month);

        //获取日
        int day = localDate.getDayOfMonth();
        int day1 = localDate.get(ChronoField.DAY_OF_MONTH);
        System.out.println("day="+day);
        //获取星期几
        DayOfWeek dayOfWeek = localDate.getDayOfWeek();
        int dayOfWeek1 = localDate.get(ChronoField.DAY_OF_WEEK);
        System.out.println("week="+dayOfWeek);

LocalDate:

		// 创建 LocalTime
        LocalTime localTime = LocalTime.of(14, 14, 14);
        LocalTime localTime1 = LocalTime.now();

        // 获取小时
        int hour = localTime1.getHour();
        int hour1 = localTime1.get(ChronoField.HOUR_OF_DAY);
        System.out.println("hour1="+hour1);
        // 获取分
        int minute = localTime1.getMinute();
        int minute1 = localTime1.get(ChronoField.MINUTE_OF_HOUR);
        System.out.println("minute1="+minute1);
        // 获取秒
        int second = localTime1.getMinute();
        int second1 = localTime1.get(ChronoField.SECOND_OF_MINUTE);
        System.out.println("second1="+second1);

LocalDateTime :

		// 创建 LocalDateTime
        LocalDateTime localDateTime = LocalDateTime.now();
        LocalDateTime localDateTime1 = LocalDateTime.of(2019,Month.SEPTEMBER, 10, 14, 46, 56);

        LocalDate localDate = LocalDate.now();
        LocalTime localTime = LocalTime.now();
        LocalDateTime localDateTime2 = LocalDateTime.of(localDate, localTime);

        LocalDateTime localDateTime3 = localDate.atTime(localTime);
        LocalDateTime localDateTime4 = localTime.atDate(localDate);
        // 获取LocalDate
        LocalDate localDate2 = localDateTime.toLocalDate();
        // 获取LocalTime
        LocalTime localTime2 = localDateTime.toLocalTime();

Instant 获取秒数 :

		// 创建Instant对象
        Instant instant = Instant.now();
        // 获取秒数
        long currentSecond = instant.getEpochSecond();
        System.out.println(currentSecond);
        // 获取毫秒数
        long currentMilli = instant.toEpochMilli();
        System.out.println(currentMilli);
        //如果只是为了获取秒数或者毫秒数，可以使用
        long l = System.currentTimeMillis();
        System.out.println(l);

Duration 表示一个时间段 :

		LocalDateTime from = LocalDateTime.of(2017,Month.JANUARY, 1, 00, 0, 0);  // 2017-01-01 00:00:00
        LocalDateTime to = LocalDateTime.of(2020, Month.SEPTEMBER, 12, 14, 28, 0);  // 2020-09-15 14:28:00
        Duration duration = Duration.between(from, to);     // 表示从 from 到 to 这段时间
        long days = duration.toDays();              // 这段时间的总天数
        long hours = duration.toHours();            // 这段时间的小时数
        long minutes = duration.toMinutes();        // 这段时间的分钟数
        long seconds = duration.getSeconds();       // 这段时间的秒数
        long milliSeconds = duration.toMillis();    // 这段时间的毫秒数
        long nanoSeconds = duration.toNanos();      // 这段时间的纳秒数

日期操作:

 		LocalDateTime localDateTime = LocalDateTime.of(2020,Month.SEPTEMBER, 12, 14, 32, 0);
        // 增加一年
        localDateTime = localDateTime.plusYears(1);
        localDateTime = localDateTime.plus(1, ChronoUnit.YEARS);
        System.out.println(localDateTime.toLocalDate());
        System.out.println(localDateTime.toLocalTime());
        // 减少一个月
        localDateTime = localDateTime.minusMonths(1);
        localDateTime = localDateTime.minus(1, ChronoUnit.MONTHS);
        // 通过with修改某些值
        // 修改年为2020
        localDateTime = localDateTime.withYear(2021);
        localDateTime = localDateTime.with(ChronoField.YEAR, 2020);
        // 时间计算
        // 获取该年的第一天
        LocalDate localDate = LocalDate.now();
        LocalDate localDate1 = localDate.with(TemporalAdjusters.firstDayOfYear());

格式化时间:

		LocalDate localDate = LocalDate.of(2020, 11, 28);
        String s1 = localDate.format(DateTimeFormatter.BASIC_ISO_DATE);
        String s2 = localDate.format(DateTimeFormatter.ISO_LOCAL_DATE);
        System.out.println("s1："+ s1);
        System.out.println("s2："+ s2);

        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println("获取当前时间："+localDateTime);

        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:MM:SS");
        String s = localDateTime.format(formatter);
        System.out.println("格式化当前时间："+ s);

https://www.runoob.com/java/java8-datetime-api.html