Java8 新特性

1.函数式接口

一个接口中只有一个抽象方法 （default 不算抽象方法！），那么这个接口被称为函数式接口，在JDK8中新增了@Functionalinterface注解来标注一个函数式接口。

2.新增了defualt方法，jdk8之前接口中的方法必须是抽象的，在jdk8中允许接口定义非抽象方法，在接口中的非抽象方法上使用defualt修饰即可，比如jdk8中新增了一个函数式接口：

java.util.function  java8中打破了接口中的方法必须抽象这一规范，有一个好就是可以提高程序的兼容性，在java.lang.Iterable接口中新增了forEach方法,该方法就是使用default修饰的。

在接口中定义defualt方法可以变相的让java支持"多继承"　　　　(说实话 其实没软用)

3.lambda表达式格式

可以将lambda看作是一个匿名函数，lamdba只能用于 函数式接口  ！！！(第一点就介绍了函数式接口啊！)

(类型 参数,类型1 参数1, ... ,类型 参数) -> {

　代码块;

return 结果;

}

主要还是用 ()->{} 这个格式

lambda优点：使用lambda表达式可以编写出比匿名内部类更简洁的代码

lamdba 相当于重写了 第一个抽象方法啊 (因为他只有一个抽象方法)

(没参数的话 就直接 () 即可)

在那些JDK中的 函数式接口中 你可以直接 用 lamdba表达式 重写他那 “可怜又孤独的” 抽象法.

4.forEath 方法

他接受一个Consumer类型的参数 我们进入他底层代码发现他是一个函数式接口  那么我们就可以用lamdba表达式了！

又发现了！ 他处于function包中  不用说了  function整个包下的类都是JDK8新增的

他有一个accept抽象方法

forEath 方法 + lambda表达式遍历集合：

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>(5);
        list.add(1);
        list.add(10);
        list.add(11);
        list.add(3);
        list.add(6);
        
//        for (Integer i:list){         //允许过一次发现 i 的作用于没死透？？？  下面接着用？
//            System.out.println(i);
//        }



        list.forEach((i) -> { System.out.println(i); });


    }
}

5.方法引用

当lamdba表达式只有一个参数时 ，可以省略小括号  　　❤

当lamdba表达式 重写代码体时 只有一条语句 ，可以省略花括号  和  代码题的分号 ‘;’  ❤❤

❤：list.forEach(i -> { System.out.println(i); });

❤❤：list.forEach(i ->  System.out.println(i));

  

开始介绍一下 方法应用： 

list.forEach(System.out::println);
你尝试一下  既然能打印出来 我的天？
算了 这个暂且搁置吧 真相总会迟到····


6.方法引用
comparator 这个其实是函数式接口 所以他可以用lambda表达式，但现在有方法引用 ：
一共有四种方法类型的引用：
静态方法引用：类名::方法名
某个对象的引用： 对象变量名::方法名
特定类的任意对象的方法引用： 类名::方法名
构造方法：类名::new

可以用Supplier这个接口实践下 这个接口传入后 有返回指定类型  具体看API


7.stream简介
java8新增了streaml，他和IO流没任何关系 ，这个stream主要用来处理集合数据的 ，可以将其看做一个高级迭代器。
在collection接口中新增了非抽象方法stream方法来获取集合的流，使用stream后可以写出简介的代码处理集合中的数据。
用它可以写出更简洁的代码。

先用stream把集合转换成流 然后可以用filter方法进行对每个数据处理并返回(具体API查看  类似于JS中的filter方法) ，
然后在调用里面的方法进行操作(具体自己看API)。   (排序 sorted 方法 -> 转换为list ： collect方法 )。

 　stream中有好多方法啊  感兴趣自己去看 (学过数据库的应该比较懂)  这里主要介绍两个：

　1.map-redusce

　map一般用来提取数据(每一个) redusce用来计算

　　用法： map 他在steam类中 先用它提取出你要的数据　　然后 再调用map可以在对你提取的数据在进行提取，非常方便啊(用法详细可以百度)，map方法可以用lamdba啊 你可以去看他底层代码 ，很多东西都需要看底层代码的.....

 　　　redusce方法是用三个重载  用法看API吧 感觉不怎么用到啊...反正遇到自己找 自己学！

8.数字流 Intstream 、 Longstream 、 Doublestream

Intstream ： 我们可以先把list转换成 steam

再调用其中的 mapToInt方法将他提取数据后转换成Intsteam然后就可以调用Intsteam的

函数进行计算了 如：sum就是求和.average就是平均值。

也可以直接调用Intsteam中的方法 ： range（）//计算x到y(不包含)的和 或 rangeClosed()//计算x到y(包含)的和    等····

9.创建流

stream中有个of方法 他呢 可以将你的东西转换成指定的流 比如你定义一个字符串数组str[] 那么：

stream.of(str); 即可了  你可以调用map方法将里面的值全换成大写即：

Stream.of(arr).map(String::toUpperCase).forEach(System.out::println);

Arrays 中有一个steam方法 他可以根据你传入的数据类型返回特定数据类型的流：

例如：

String[] arr = {"a","abc"};
Stream<String> str_stream =  Arrays.stream(arr);    //类型匹配啊 成功
Stream<int> xx =  Arrays.stream(arr);           //类型不匹配啊 error

stream中有个iterate方法 它可以从seed(参1)的值 一直 用f函数(参2)   返回的数据相加。
参2 可以是 lambda表达式 或 函数体。他不会停止的啊 一直加。无线流。

但他里面又有一个limit方法 可以获取前x(参) 条数据  然后打印出来即可。

其实这玩意就是和reduce差不多的了

例：

Stream.iterate(1,x->x+3).limit(10).forEach(System.out::println);
结果：(无线流 1 + 3 一直叠加 然后选出选出前十条 然后 foreach打印出来)

1
4
7
10
13
16
19
22
25
28

流讲到这里啊  太多了 自己研究  会遇到的 相信我啦 哎 太难了 2021年5月11日 20:38:23

10.Optional类简介：

这个类的出现一个是解决空指针异常，另外更简介的代码编写啊：

上面说的redusce方法（叠加） 他就是返回的一个 Optional 类

他如果是null的话 他可以用orElse()这个方法 设置一个默认的返回值 。

他也有of方法 也可以转为指定的Optional 类啊。 

ofNullable 这个方法允许传入一个null值啊 因此可以配合实验一下啊.

具体我也不知道 打算不学那么深....累死我了。

Optional x = Optional.ofNullable(null);

 System.out.println(x.orElse("a"));

更多自己API和百度啊............

11.日期处理

LocalDate类：只能处理日期相关的数据，不包含时间

他的静态方法：now方法可以直接打印出现在的日期

例如：

LocalDate time = LocalDate.now();
System.out.println(time);

他的更方法：

getYear getMonthValue getDayOfMonth   分别是 ：

获取年、月、日 都是int 值的啊 可以尝试一下：

还有就是它的

format
方法可自定义格式输出年月日啊(日期格式化)
参数1就是

DateTimeFormatter
类的解析（字符串）

然后format最终返回的是 String类型的自定义格式年月日啊
Tips：DateTimeFormatter的解析格式是 YYYY MM dd啊！

例：

String time_1 = time.format(DateTimeFormatter.ofPattern("YYYY年MM月dd日"));
System.out.println(time_1);

是都是闰年：

isLeaapYear()方法
例：　

LocalDate time = LocalDate.now();
System.out.println(time.isLeapYear());

答案是 false  今年2021年 不是闰年啊

还有：

lengthOfMonth()　　//判断当个月的天数

lengthOfYear()　　//判断当年的天数
例：

System.out.println(time.lengthOfMonth());
System.out.println(time.lengthOfYear());

　　
　在实例化的时候 你可以自定义日期：

　方式1：用 parse 方法 可以将字符串文本转为一个日期 例：

　

LocalDate.parse()

time = LocalDate.parse("2000-10-11");

　这个是默认格式啊！他有个重载方法 可以用指定的格式，一般用默认的即可：

方式2：用 of 方法 可以将 年月日分开 转为一个日期  （你可以去看看底层代码）例：

　　

LocalDate.of()

time = LocalDate.of(2020,10,10);

可以直接用对象的equals直接判断两个日期是否相等啊：

因为它里面词重写了这个方法例：

LocalDate time1 =  LocalDate.of(2000,2,20);
LocalDate time2 =  LocalDate.of(2000,2,20);
System.out.println(time1.equals(time2));

答案是true；
或者你用 isequals 方法  也是一样的啊  这里推荐isequals

还可以对时间加减运算：

LocalDate	plus(long amountToAdd, TemporalUnit unit) 返回此日期的一个副本，添加指定的金额。
LocalDate	plus(TemporalAmount amountToAdd) 返回此日期的一个副本，添加指定的金额。
LocalDate	plusDays(long daysToAdd) 返回一份本 LocalDate与指定的天数增加。
LocalDate	plusMonths(long monthsToAdd) 返回一份本 LocalDate在月期添加指定的。
LocalDate	plusWeeks(long weeksToAdd) 返回一份本 LocalDate在周指定期间补充。
LocalDate	plusYears(long yearsToAdd) 返回一份本 LocalDate年指定期间补充。

LocalDate	minus(long amountToSubtract, TemporalUnit unit) 返回此日期的一个副本，用指定的金额减去。
LocalDate	minus(TemporalAmount amountToSubtract) 返回此日期的一个副本，用指定的金额减去。
LocalDate	minusDays(long daysToSubtract) 返回一份本 LocalDate与指定的天数减去。
LocalDate	minusMonths(long monthsToSubtract) 返回一份本 LocalDate与指定期个月减去。
LocalDate	minusWeeks(long weeksToSubtract) 返回一份本 LocalDate在周中减去指定的时间。
LocalDate	minusYears(long yearsToSubtract) 返回一份本 LocalDate与指定期在年中减去。

自己动手啦    还有就是 plus 的amountToAdd 和  minus 的 amountToSubtract  是自己指定的年月日 （ChronoUnit 已经定义好的枚举常量）自己用：

CENTURIES

单位，代表了一个世纪的概念。

DAYS

代表一天的概念的单位。

DECADES

单位，代表了十年的概念。

ERAS

代表一个时代概念的单位。

FOREVER

代表永远的概念的人工单位。

HALF_DAYS

单位，代表了半天的概念，在上午/下午使用。

HOURS

表示一个小时的概念的单位。

MICROS

一个表示一个微秒的概念。

MILLENNIA

代表千年概念的单位。

MILLIS

表示毫秒的概念的单位。

MINUTES

表示一分钟的概念的单位。

MONTHS

表示一个月的概念的单位。

NANOS

单位，代表一个纳秒的概念，最小的支持单位的时间。

SECONDS

表示第二个概念的单位。

WEEKS

表示一周的概念的单位。

YEARS

代表一年的概念的单位。 

差不多懂得 年月日就好啦... 例子： 算出一个礼拜后的今天:

LocalDate time = LocalDate.now();   //2021年5月12日
System.out.println(time.plus(1, ChronoUnit.WEEKS)); //2021-05-19

日期就差不多讲到这里啊  主要还得看API 遇到要用的 还得看API啊

下面将时间 因为上面只针对日期 这里将只针对时间：

LocalTime 类 他可以用 now 获取当前时间：

LocalTime time = LocalTime.now();       //获取现在指定时间（包含毫秒）
LocalTime time1 = LocalTime.now().withNano(0);//获取现在指定时间(吧毫秒设为0 不包换毫秒)
System.out.println(time);   //08:26:10.006
System.out.println(time1);  //08:26:10

对时间加减：

LocalTime	plus(long amountToAdd, TemporalUnit unit) 返回此时间的副本，添加指定的金额。
LocalTime	plus(TemporalAmount amountToAdd) 返回此时间的副本，添加指定的金额。
LocalTime	plusHours(long hoursToAdd) 返回一份本 LocalTime在指定时间内添加时间。
LocalTime	plusMinutes(long minutesToAdd) 返回一份本 LocalTime在几分钟之内指定期间补充。
LocalTime	plusNanos(long nanosToAdd) 返回一份本 LocalTime在纳秒指定期间补充。
LocalTime	plusSeconds(long secondstoAdd) 返回一份本 LocalTime在指定时间内增加秒。

LocalTime	minus(long amountToSubtract, TemporalUnit unit) 返回此时间的副本与指定的金额减去。
LocalTime	minus(TemporalAmount amountToSubtract) 返回此时间的副本与指定的金额减去。
LocalTime	minusHours(long hoursToSubtract) 返回一份本 LocalTime减去指定的时间在小时。
LocalTime	minusMinutes(long minutesToSubtract) 返回一份本 LocalTime在几分钟之内减去指定的时间。
LocalTime	minusNanos(long nanosToSubtract) 返回一份本 LocalTime减去指定的时间在纳秒。
LocalTime	minusSeconds(long secondsToSubtract) 返回一份本 LocalTime与指定期秒减去。

有了上面的基础 这里自己动手吧！

你还可以用 LocalTime.parse() 方法给它赋值指定时间： 例：

LocalTime time = LocalTime.now();
System.out.println(time);   //08:30:52.207
time = LocalTime.parse("13:13:13");
System.out.println(time);   //13:13:13

非常的方便 格式注意要 ：： 即可  还有of 呢 其实跟上面介绍的日期一样的...

不多说啊 主要看API 啊！ 

再来介绍一个  时间处理通吃的 LocalDateTime 它的使用也是 now  啊  of  啊  什么什么的啊

我们点进去看他的底层代码会发现啊  他们实现了共同的接口和类啥的  用法自己API吧·····



除了这三个 在介绍两个类：

Duration 和 Period

Duration 专门处理 时间的啊  API有很多他详细代码 可以自己百度去找用法！ 这里不多说！
Period 专门处理 日期的啊  API有很多他详细代码 可以自己百度去找用法！ 这里不多说！

他有很多方法很方便啊   详看API！！

 时间日期这一块 就差不多了啊 你又不是要做时间专家.......