Java 8新特性-阿里云开发者社区

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);
    }
}

Java 8新特性

Java 8新特性

Lambda表达式：

需要函数式接口的支持：

变化形势：

四大核心函数式接口：

方法引用

构造器引用

stream流的创建

创建流的几种方式：

Stream流的映射：

stream的排序方式：

Stream 流的查找与匹配：

Stream 流的约束与收集

Optional类：

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

时间日期API

时间矫正器： TemporalAdjuster

重复注解，类型注解

重复注解，类型注解

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Java 8新特性

Java 8新特性

Lambda表达式：

需要函数式接口的支持：

变化形势：

四大核心函数式接口：

方法引用

构造器引用

stream流的创建

创建流的几种方式：

Stream流的映射：

stream的排序方式：

Stream 流的查找与匹配：

Stream 流的 约束与收集

Optional类：

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

时间日期API

时间矫正器： TemporalAdjuster

重复注解，类型注解

重复注解，类型注解

热门文章

最新文章

相关课程

相关电子书

相关实验场景

Stream 流的约束与收集