Java 8新特性

Lambda表达式：

需要函数式接口的支持：

若接口中只有一个抽象方法时，就是函数式接口。。

@FunctionalInterface注解，可以检查是否是函数式接口

基础语法：新的操作符：： “ -> ” lambda操作符

将lambda 拆成俩部分，

左侧：Lambda参数列表

右侧：Lambda表达式中所需要实现的功能。即Lambda体

变化形势：

语法格式一：无参数，无返回值

（）-> sout

语法格式二：有一个参数，无返回值

（X）-> sout(X)

语法格式三：若只有一个参数，那么参数的小括可以不写

X -> sout(X)

语法格式四：有两个以上的参数，并且Lambda 体中有多条语句

Comparator com = (x,y) -> { System.out.println(“=========”);

return Integer.compare(x,y);

} ;

语法格式五：并且Lambda 体中有一条语句，

括号和 return语句都可以不写

Comparator com = (x,y) -> Integer.compare(x,y);

四大核心函数式接口：

1：Consumer<T> :消费形接口
       void  accept(T  t)
    
2:Supplier<T> : 供给形接口
       void  get()

3:Function<T, R > :函数型接口   R返回类型，，T参数
       R apply (T  t)
    
4:Predicate <R>  :断言型接口
       boolean test ( T  , t)

方法引用

1：对象 : : 实例方法名

2：类 : : 静态方法名

3：类 : : 实例方法名

构造器引用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PMdVBVeU-1665058647031)(C:\Users\12926\AppData\Roaming\Typora\typora-user-images\1658394373040.png)]

数组引用：

type[] :: new ;

Collectors.toList() 将流中的所有元素导出到一个列表( List )中

map 方法可以让我们进行一些流的转化，比如原来流中的元素是 A，通过 map 操作，可以使返回的流中的元素是 B

public void testMap() {
        List<String> list = new ArrayList<String>() {{
            add("1");
            add("2");
            add("3");
        }};
        //通过 map 方法list中元素转化成 小写
        List<String> strLowerList = list.stream()
                .map(str -> str.toLowerCase())
                .collect(Collectors.toList());
    }

  List<String> collect = list.stream()
                // 过滤掉我们希望留下来的值
                // 表示我们希望字符串是 1 能留下来
                // 其他的过滤掉
                .filter(str -> "1".equals(str))
                .collect(Collectors.toList());
        collect.forEach(c -> System.out.println(c));  //遍历List集合的俩种方式
        System.out.println("==========================");

        //遍历List集合的俩种方
        Iterator<String> iterator = collect.iterator();
        if (iterator.hasNext()) {
            String next = iterator.next();
            System.out.println("======"+ next);
        }

MapToInt

MapToDouble

public void testMapToInt() {
        List<String> list = new ArrayList<String>() {{
            add("1");
            add("2");
            add("3");
        }};
        list.stream()
                .mapToInt(s->Integer.valueOf(s))
                // 一定要有 mapToObj，因为 mapToInt 返回的是 IntStream，因为已经确定是 int 类型了
                // 所有没有泛型的，而 Collectors.toList() 强制要求有泛型的流，所以需要使用 mapToObj
                // 方法返回有泛型的流
                .mapToObj(s->s)
                .collect(Collectors.toList());
 
        list.stream()
                .mapToDouble(s->Double.valueOf(s))
                // DoubleStream/IntStream 有许多 sum（求和）、min（求最小值）、max（求最大值）、average（求平均值）等方法
                .sum();
    }

Distinct

distinct 方法有去重的功能：

public void testDistinct(){
        List<String> list = new ArrayList<String>() {{
            add("1");
            add("2");
            add("2");
        }};
        list.stream()
                .map(s -> Integer.valueOf(s))
                .distinct()
                .collect(Collectors.toList());
    }

Sorted

Sorted 方法提供了排序的功能，并且允许我们自定义排序。

stream流的创建

步骤：

1：首先创建stream流，

2：中间对流的操作

3：终止操作

创建流的几种方式：

1：可以通过Collection 系列的集合提供的stream （串行流）或paralleStream(并行流)

ArrayList<String> list = new ArrayList<>();

   Stream<String> stream = list.stream();

2：可以通过Arrays的静态 stream() 方法。

emp[] emp01 = new  emp[10];
Stream<emp> stream1 = Arrays.stream(emp01);

3：可以通过Stream的静态方法 —-> of()

Stream<emp> emp011 = Stream.of(emp01);

4：无限流通过Stream 的 iterate

iterate ：
Stream<Integer> stream2 = Stream.iterate(1, (x) -> x + 1);


生成： 
    Stream.generate(() -> Math.random());

Stream流的映射：

Collectors.toList() 将流中的所有元素导出到一个列表( List )中

map 方法可以让我们进行一些流的转化，比如原来流中的元素是 A，通过 map 操作，可以使返回的流中的元素是 B

FlatMap：方法可以让我们进行一些流的转化，，返回的结果是一个stream流

stream的排序方式：

sort ：自然排序（Comparable）

定制排序（Comparator）

  list.stream()
                .sorted((e1,e2) -> {
                    if (e1.getAge().equals(e2.getAge())) {
                        return e1.getName().compareTo(e2.getName());
                    }else {
                        return e1.getAge().compareTo(e2.getAge());
                    }
                }).collect(Collectors.toList()).forEach(System.out::println);

Stream 流的查找与匹配：

/**
* stream 流的查找与匹配
* allMatch 查找所有是否匹配的元素
* anyMatch 查找是否有任意一个元素满足当前匹配的元素
* noneMatch 没有一个匹配当前的元素
* findFirst 查找第一个元素
* fingAny 查找任意一个元素
* count 统计流中元素的总个数
* max 返回流中最大的值
* min 返回流中最小的值
*/

import org.junit.jupiter.api.Test;
import org.junit.platform.commons.util.StringUtils;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Test02 {
//    List<emp> list = Arrays.asList(
//            new emp("xiao",22, emp.Status.BUSY),
//            new emp("xia",30, emp.Status.VOCATION),
//            new emp("xialijun",99, emp.Status.BUSY),
//            new emp("xia0",30, emp.Status.FREE)
//    );
//    @Test
//    public void test(){
//        Stream<emp> stream = list.stream().filter(e -> e.getAge() > 20)
//                .limit(2)
//                .distinct().skip(1);
//        stream.forEach(System.out::println);
//    }
//    @Test
//    public void test1(){
        list.stream()
                .map(emp::getName).forEach(System.out::println);
//        list.stream()
//                .sorted((e1,e2) -> {
//                    if (e1.getAge().equals(e2.getAge())) {
//                        return e1.getName().compareTo(e2.getName());
//                    }else {
//                        return e1.getAge().compareTo(e2.getAge());
//                    }
//                }).collect(Collectors.toList()).forEach(System.out::println);
//    }

   
    @Test
    public void test2(){
        List<emp> list = Arrays.asList(
                new emp("xiao",220, emp.Status.BUSY),
                new emp("xia",30, emp.Status.VOCATION),
                new emp("xialijun",99, emp.Status.BUSY),
                new emp("xia0",30, emp.Status.FREE)
        );
        boolean match = list.stream().allMatch((e) -> e.getStatus()
                .equals(emp.Status.BUSY));
        if (StringUtils.isNotBlank(String.valueOf(match))) {
            System.out.println(match);
        }

        System.out.println("===================");
        boolean b = list.stream()
                .anyMatch((e) -> e.getStatus().equals(emp.Status.BUSY));
        System.out.println(b);
        System.out.println("====================");
        Optional<emp> first = list.stream().findFirst();
//        first.orElse(0);
        long count = list.stream().count();
        System.out.println(first);
        System.out.println(count);
        System.out.println("'======================================================");
        Optional<emp> max = list.stream().max(Comparator.comparingInt(emp::getAge));
        System.out.println(max.get());
        System.out.println("-------------------------------------------------------------------------");
        Optional<emp> min = list.stream()
                .filter(e -> e.getStatus().equals(emp.Status.BUSY))
                .min(Comparator.comparingInt(emp::getAge));
        System.out.println(min);

        Optional<Integer> min1 = list.stream().map(emp::getAge).min(Integer::compareTo);
        Optional<Integer> min2 = list.stream().map(emp::getAge).min(Integer::compare);
        System.out.println(min1);
        System.out.println(min2);
    }
}

Stream 流的约束与收集

**reduce 规约：**可以将流中的元素反复结合起来，得到一个值

reduce 的使用：

 @Test
    public void test3(){
//        Logger logger = new Logger(Test02.class);
        List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
        Integer result = list1.stream().reduce(0, (x, y) -> x + y);
        System.out.println(result);
        System.out.println("==================================");
        Optional<Integer> reduce = list.stream()
                .map(emp::getAge)
                .reduce(Integer::sum);
        System.out.println(reduce);

    }

收集：collect ===> 将流收集起来转成其他形势，.collect(Collectors.toList());

//List集合
    List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
        Integer result = list1.stream().reduce(0, (x, y) -> x + y);
        System.out.println(result);
        System.out.println("==================================");
        List<Integer> collect = list.stream()
                .map(emp::getAge)
                .collect(Collectors.toList());
        collect.forEach(System.out::println);
//        System.out.println(reduce);
        list.stream().map(emp::getName).collect(Collectors.toSet()).forEach(System.out::println);
        System.out.println("==========================lklm");
//迭代器
        HashSet<Integer> collect1 = list.stream().map(emp::getAge).collect(Collectors.toCollection(HashSet::new));
        Iterator<Integer> iterator = collect1.iterator();
        while (iterator.hasNext()) {
            Integer next = iterator.next();
            System.out.println("======" +  next);
        }

        System.out.println("===============================");
//增强for 循环
        for (Integer next : collect1) {
            System.out.println(next);
        }
        System.out.println("===============================");
//foreach 遍历
        collect1.forEach(System.out::println);
    }

 Map<emp.Status, List<emp>> map = list.stream().collect(Collectors.groupingBy(emp::getStatus));
        /**
         * map的遍历方法
         */
        //1 :迭代器
        Iterator<Map.Entry<emp.Status, List<emp>>> iterator1 = map.entrySet().iterator();
        while (iterator1.hasNext()) {
            Map.Entry<emp.Status, List<emp>> nextMap = iterator1.next();
            //emp.Status key = nextMap.getKey();
            System.out.println(nextMap);
        }
        System.out.println("???????????????????????????????????????????????????????????");
        //for 循环
        for (Map.Entry< emp.Status, List<emp>> entry : map.entrySet() ) {
            emp.Status key = entry.getKey();
            List<emp> value = entry.getValue();
            System.out.println(key+":"+value);
        }
    }

时间：

Instant start = Instant.now();

Instant end = Instant.now();

System.out.println("一共花费了:" + Duration.between(start,end).getUnits());

Optional类：

避免空指针异常：

/**
     * OPtional容器类的常用方法：
     *           Optional.of(T, t) :创建一个Optional 类的实例
     *           Optional.empty()  :创建一个空的Optional类的实例
     *           Optional.ofNullable(T ,t) :若t不为空 ， 则创建Optional实例 ，否则则创建空实例
     *
     *           isPresent()  : 判断是否包含值
     *           orElse(T t)  : 如果调用对象 包含值 ，则返回该值，否则返回  t
     *           orElseGet (Suppliser s)  :如果 如果调用对象 包含值 ，则返回该值，否则返回 s 获取的值
     *           map (Function  f) 如果有值对其进行处理，并返回先处理后的Optional  ,否则返回 Optional.empty()
     *           flapMap(Function mapper ) :与map相似 , 要求返回值必须是Optional
     */

接口中的默认方法和静态方法：

默认方法：default

类优先的原则：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IFbDSIu0-1665058647033)(C:\Users\12926\AppData\Roaming\Typora\typora-user-images\1658625445426.png)]

时间日期API

datetimeFormatter.ofpattern()

 @Test
    public void test1() {
        // LocalDate   LocalTime   LocalDateTime
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);
        int year = now.getYear();
        System.out.println(year);
        System.out.println("================");
        LocalDateTime of = LocalDateTime.of(2022, 10, 8, 13, 33, 44);
        System.out.println(of);
        LocalDateTime localDateTime = of.plusYears(2);
        System.out.println(localDateTime);
    }
}

时间戳：(Unix 元年：1970年1月1日 00：00 ：00 到现在某个时间段之前的毫秒值)

Instant

@Test
    public void test2() {
        Instant now = Instant.now();
        System.out.println(now);
        System.out.println("=================");
        OffsetDateTime offsetDateTime = now.atOffset(ZoneOffset.ofHours(8));
        System.out.println(offsetDateTime);
    }
    @Test
    public void test3() throws InterruptedException {
        LocalDate now = LocalDate.now();
        Thread.sleep(1000000000L);
        LocalDate now1 = LocalDate.now();
        Period between = Period.between(now, now1);
        System.out.println(between.getDays());
    }

时间矫正器： TemporalAdjuster

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c2V1Kab7-1665058647034)(C:\Users\12926\AppData\Roaming\Typora\typora-user-images\1658629734818.png)]

DateTimeFotmatter :格式化时间日期

 @Test
    public void test5() {
        DateTimeFormatter isoDateTime = DateTimeFormatter.ISO_DATE_TIME;
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd  HH:mm:ss");

        LocalDateTime now = LocalDateTime.now();
        String format = now.format(dateTimeFormatter);
        System.out.println(format);
    }
}

重复注解，类型注解

));
}


### 时间矫正器： TemporalAdjuster

[外链图片转存中...(img-c2V1Kab7-1665058647034)]

DateTimeFotmatter   :格式化时间日期

```java
 @Test
    public void test5() {
        DateTimeFormatter isoDateTime = DateTimeFormatter.ISO_DATE_TIME;
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd  HH:mm:ss");

        LocalDateTime now = LocalDateTime.now();
        String format = now.format(dateTimeFormatter);
        System.out.println(format);
    }
}