java8新特性

最新推荐文章于 2024-06-24 14:24:18 发布
原创 最新推荐文章于 2024-06-24 14:24:18 发布 · 218 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

Lambda表达式

java8 内置的四大核心函数式接口
在这里插入图片描述

  • Consumer : 消费型接口

  •      void accept(T t)

  • Supplier : 供给型接口

  •      T get();

  • Function<T,R> : 函数型接口

  •  R apply(T t);

  • Predicate :断言型接口

  •  boolean test(T t);

//    Predicate<T>断言型接口
    @Test
    public void test4(){
        List<String> list = Arrays.asList("aaa","bbb","ccc");
        List<String> manzu = filterStr(list, (x) -> x.length()>2);
        System.out.println(manzu);
    }
//    需求:将满足条件的字符串放入集合中
    public List<String> filterStr(List<String> list, Predicate<String> str){
        List<String> strList = new ArrayList<>();
        for(String strs : list){
            if (str.test(strs)){
                strList.add(strs);
            }
        }
        return strList;
    }

//      Function<T,R> 函数型接口
    @Test
    public void test3(){
        String s = strHandler("\t\t\t\t    aaa", (str) -> str.trim());
        System.out.println(s);
    }
//    需求:用于处理字符串
    public String strHandler(String str, Function<String,String> fun){
        return fun.apply(str);
    }


//    Supplier<T> 供给型接口:
    @Test
    public void test2(){
        List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100));
        System.out.println(numList);
    }

    public List<Integer> getNumList(int num , Supplier<Integer> supplier){
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            Integer n = supplier.get();
            list.add(n);
        }
        return list;
    }

//    Consumer<T> 消费型接口:
    @Test
    public void test1(){
        happy(10000,con-> System.out.println(con));
    }

    public void happy(double money, Consumer<Double> con){
        con.accept(money);
    }
  • 一.方法引用:若Lambda体中的内容有方法已经实现了,我们可以使用"方法应用"
  •  (可以理解为方法引用是Lambda表达式的另外一种方式)

  • 主要语法格式有三种
  • 对象::实例方法名
  • 类::静态方法名
  • 类::实例方法名
  • 注意
    Lambda体中调用方法的参数列表与返回值类型,要与函数式接口中抽象方法的函数列表和返回值类型保持一致
  • 若Lambda参数列表中的第一参数是实例方法的调用者,而第二个参数是实例方法的参数时,可以使用Classname::method
  • 二.构造器引用
  • 格式
    ClassName::new
    注意:需要调用的构造器的参数列表要与函数式接口中抽象方法的参数列表保持一致
  • 三.数组引用
  • Type::new;
//    数组引用
    @Test
    public void test7(){
        Function<Integer,String[]> fun = (x) -> new String[x];
        String [] strs = fun.apply(1);
        System.out.println(strs.length);

        Function<Integer,String[]> fun2 = String[]::new;
        String[] apply = fun2.apply(20);
        System.out.println(apply.length);


    }

    @Test
    public void test5(){
        Supplier<Employee> sup = () -> new Employee();
//        构造器引用方式
        Supplier<Employee> sup2 = Employee::new;
        Employee employee = sup2.get();
        System.out.println(employee);
    }

//  构造器引用
    @Test
    public void test6(){
//        Function<Integer,Employee> fun = (x) -> new Employee(x);
        Function<Integer,Employee> fun2 = Employee::new;
        Employee employee = fun2.apply(11);
        System.out.println(employee);
    }

//  类::实例方法名
    @Test
    public void test4(){
        BiPredicate<String,String> bp = (x,y) -> x.equals(y);

        BiPredicate<String,String> bp2 = String::equals;
    }

//  类::静态方法名
    @Test
    public void test3 (){
        Comparator<Integer> com = (x,y) -> Integer.compare(x,y);

        Comparator<Integer> com2 = Integer::compare;

        com2.compare(1,2);
    }
//    对象::实例方法名
    @Test
    public void test1(){
        Consumer<String> con = (x) -> System.out.println(x);

        PrintStream printStream = System.out;
        Consumer<String> con1 = printStream::println;

        Consumer<String> con2 = System.out::println;
        con2.accept("aaa");
    }

    @Test
    public void test2(){
        Employee employee = new Employee("张三",1,1);
        Supplier<String> sup = () -> employee.getName();
        String s = sup.get();
        System.out.println(s);


        Supplier<String> sup1 = employee::getName;
        String s1 = sup1.get();
        System.out.println(s1);
    }

Stream

1.创建stream

//  创建stream
    @Test
    public void test1(){
//        1.可以通过Collection系列集合提供的stream()或parallelStream()
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();

//        2.通过Arrays中的静态方法stream()获取数组流
        Employee[] emps = new Employee[10];
        Stream<Employee> stream2 = Arrays.stream(emps);

//        3.通过Stream类中的静态方法of()
        Stream<String> stream3 = Stream.of("aa", "bb", "cc");

//        4.创建无线流
//        迭代
        Stream<Integer> stream4 = Stream.iterate(0, (x) -> x + 2);
        stream4.limit(10).forEach(System.out::println);
//        生成
        Stream.generate(() -> Math.random()).limit(5).forEach(System.out::println);
    }

2.中间操作

1.filter,distinct,limit,skip

在这里插入图片描述

    List<Employee> employees = Arrays.asList(
            new Employee("张三",18,99.999),
            new Employee("李四",38,9999.9999),
            new Employee("王五",50,99.999),
            new Employee("赵六",55,99.999),
            new Employee("田七",18,99.999),
            new Employee("田七",18,99.999),
            new Employee("田七",18,99.999)
    );
    /*
    *  筛选与切片
    * filter ---接收Lambda
    * limit ---截断流
    * skip ---跳过
    * distinct----筛选,通过hashcode() 和 equals去重
    * */
//    内部迭代:迭代操作有Stream API完成
    @Test
    public void test1(){
//        中间操作,不会执行任何操作
        Stream<Employee> stream_api = employees.stream().filter((e) -> {
            System.out.println("Stream API 的中间操作");
            return e.getAge() > 18;
        });

//        终止操作:一次性执行全部内容,即"惰性求值"
        stream_api.forEach(System.out::println);
    }
//    外部迭代:
    @Test
    public void test2(){
        Iterator<Employee> iterator = employees.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    @Test
    public void test3(){
        employees.stream().filter((e)->e.getSalary()>99).limit(2).forEach(System.out::println);
    }

    @Test
    public void test4(){
        employees.stream().filter((e)->e.getSalary()>99).distinct().forEach(System.out::println);
    }

2.map,flatMap

   /*
    * 映射
    * map ---接收Lambda,将元素转换成其他形式或提取信息,接收一个函数作为参数,该函数会被应用到每个元素上,并将其映射成一个新的元素
    * flatMap --- 接收一个函数作为参数,将流中的每个值都换成另一个流,然后把所有流连城一个流
    *
    * */
    @Test
    public void test5(){
            List<String> list = Arrays.asList("aaa","bbb","ccc","ddd");
            list.stream().map((e)-> {return e.toUpperCase();}).forEach(System.out::println);

        System.out.println("--------------------");

        employees.stream().map(Employee::getName).forEach(System.out::println);

        System.out.println("--------------------");
        Stream<Stream<Character>> streamStream = list.stream().map(TestStreamAPI2::filterCharacter);
        streamStream.forEach((e) -> e.forEach(System.out::println));

        System.out.println("--------------------");
        Stream<Character> characterStream = list.stream().flatMap(TestStreamAPI2::filterCharacter);
        characterStream.forEach(System.out::println);
    }

    public static Stream<Character> filterCharacter (String str){
        List<Character> list = new ArrayList<>();
        for (Character ch:str.toCharArray()){
            list.add(ch);
        }
        return list.stream();
    }

3.sorted排序

    /*
    * 排序
    * sorted() ---自然排序
    * sorted(Comparator com) ---定制排序
    * */
    @Test
    public void test7(){
        List<String> list = Arrays.asList("ccc","bbb","aaa","ddd");
        list.stream().sorted().forEach(System.out::println);
        System.out.println("-------------------------");
        employees.stream().sorted((e1,e2)->{
            if (e1.getAge().equals(e2.getAge())){
                return e1.getName().compareTo(e2.getName());
            }else {
                return e1.getAge().compareTo(e2.getAge());
            }
        }).forEach(System.out::println);
    }

终止操作

1.allMatch,anyMatch,noneMatch,FindFirst,findAny,count,max,min

    /*
    * allMatch ---检查是否匹配所有元素
    * anyMatch ---检查是否至少匹配一个元素
    * noneMatch ---检查是否没有匹配所有元素
    * FindFirst ----返回第一个元素
    * findAny ---返回当前流中任意元素
    * count ---返回流中元素个数
    * max ---返回流中最大值
    * min ---返回流中最小值
    *
    * */
@Test
public void test(){
    boolean b = employees.stream().allMatch((e)->e.getStatus().equals(Employee.Status.FREE));
    System.out.println(b);

    boolean b1 = employees.stream().anyMatch((e) -> e.getStatus().equals(Employee.Status.FREE));
    System.out.println(b1);

    boolean b2 = employees.stream().noneMatch((e) -> e.getStatus().equals(Employee.Status.FREE));
    System.out.println(b2);

    Optional<Employee> op = employees.stream().sorted((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())).findFirst();

    System.out.println(op.get());

    Optional<Employee> any = employees.stream().filter((e) -> e.getStatus().equals(Employee.Status.FREE)).findAny();

    System.out.println(any.get());
}
    @Test
public void test2(){
    long count = employees.stream().count();
    System.out.println(count);

    Optional<Employee> max = employees.stream().max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
    System.out.println(max.get());

    Optional<Double> min = employees.stream().map(Employee::getSalary).min(Double::compare);
    System.out.println(min.get());
}

2.reduce

    /*
    * 归约
      reduce(T identity,BinaryOperator) 可以将流中元素反复结合起来,得到一个值
     */
    @Test
    public void test3(){
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Integer sum = list.stream().reduce(0, (x, y) -> x + y);
        System.out.println(sum);

        System.out.println("-----------------------------------");
        Optional<Double> op = employees.stream().map(Employee::getSalary).reduce(Double::sum);
        System.out.println(op.get());
    }

3.collect

    /*
    * 收集
    * Collect ---将流转换为其他形式,接收一个Collector接口的实现,用于给Stream中元素
    * */
    @Test
    public void test4(){
        List<String> collect = employees.stream().map(Employee::getName).collect(Collectors.toList());
        collect.forEach(System.out::println);
        System.out.println("--------------------------");
        Set<String> set = employees.stream().map(Employee::getName).collect(Collectors.toSet());
        set.forEach(System.out::println);
        System.out.println("---------------------");
        HashSet<String> hs = employees.stream().map(Employee::getName).collect(Collectors.toCollection(HashSet::new));
        hs.forEach(System.out::println);
    }

4.总数,平均值,总和,最大值,最小值

    @Test
    public void test5(){
//        总数
        Long collect = employees.stream().collect(Collectors.counting());
        System.out.println(collect);
//        平均值
        Double avg = employees.stream().collect(Collectors.averagingDouble(Employee::getSalary));
        System.out.println(avg);
//        总和
        Double sum = employees.stream().collect(Collectors.summingDouble(Employee::getAge));
        System.out.println(sum);
//        最大值
        Optional<Employee> opt = employees.stream().collect(Collectors.maxBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
        System.out.println(opt.get());
//        最小值
        Optional<Double> opt1 = employees.stream().map(Employee::getSalary).collect(Collectors.minBy(Double::compare));
        System.out.println(opt1.get());
    }

5.分组

    @Test
    public void test6(){
        Map<Employee.Status, List<Employee>> collect = employees.stream().collect(Collectors.groupingBy(Employee::getStatus));
        System.out.println(collect);
    }

6.多级分组

//多级分组
    @Test
    public void test7(){
        Map<Employee.Status, Map<String, List<Employee>>> collect = employees.stream().collect(Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy((e) -> {
                    if (e.getAge() <= 35) {
                        return "青年";
                    } else if (e.getAge() <= 50) {
                        return "中年";
                    } else {
                        return "老年";
                    }
                }
        )));
        System.out.println(collect);
    }

7.分区

//    分区
    @Test
    public void test8(){
        Map<Boolean, List<Employee>> map = employees.stream().collect(Collectors.partitioningBy((e) -> e.getSalary() > 8000));
        System.out.println(map);
    }

收集

//      收集
//    collect---将流转换为其他形式,接收一个collector接口的实现,用于给Stream中元素做汇总的方法
    @Test
    public void test9(){
        DoubleSummaryStatistics collect = employees.stream().collect(Collectors.summarizingDouble(Employee::getSalary));
        System.out.println(collect.getSum());
        System.out.println(collect.getAverage());
        System.out.println(collect.getMax());
    }
    @Test
    public void test10(){
        employees.stream().map(Employee::getName).collect(Collectors.joining(","));
    }

并行流和串行流

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

//    java8并行流
    @Test
    public void test(){
        Instant start = Instant.now();
        LongStream.rangeClosed(0,1000000000000L).parallel().reduce(0,Long::sum);
        Instant end = Instant.now();
        System.out.println("消耗时间为:"+ Duration.between(start,end).toMillis());
    }

Option容器类

在这里插入图片描述

java8 新特性
二进制杯莫停的博客
05-23 1760
行为参数化lambda表达式Stream Api。
java8 persistence_JPA(Java Persistence API)学习八（集合映射Map）
weixin_39983384的博客
02-25 136
import javax.persistence.*;@Embeddablepublic class Address {private int e_pincode;private String e_city;private String e_state;}第三步：将实体类和数据库配置映射到persistence.xml文件中xmlns="http://xmlns.jcp.org/xml/ns/pe...
JAVA中apply方法的原理_关于学习java函数式接口Function中的apply方法的一些感悟
weixin_33196106的博客
03-02 3834
起因是这样的,学习函数式编程的时候学到了Function接口,对于其中的apply方法感到不解,下面贴上我的不解代码在这里插public class Function接口 {public static void main(String[] args) {String s="1234";method(s,(String a)->{**return Integer.parseInt(a);**}...
java中各种类型用Stream流求最大值最小值
热门推荐
拒绝熬夜啊的博客
01-20 3万+
java中Bigdecimal、Integer、Long、Double类型用流的方式求最大值和最小值
java中函数式编程apply的用法实例？
gb4215287的博客
06-20 1514
java中函数式编程apply的用法实例？
Java8中Stream流求最大值最小值
qq_43842093的博客
02-18 2万+
【代码】Java8中Stream流求最大值最小值。
Java8 新特性
04-27
Java8是Java编程语言的一次重大更新，引入了许多新的特性和功能，极大地提升了开发效率和代码的可读性。以下是一些主要的Java8新特性详解： 1. **Lambda表达式**：Lambda表达式是Java8中最显著的新特性，它为Java...
Java8新特性
06-15
Java8发布到现在至少3年了，但是对Lambda表达式不熟悉、看不懂、不会用的现象非常常见。 即使是升级到JDK1.8了，但是很多开发者依然是停留在1.8之前的开发方式，使用的也是非常老旧和过时的API，遇到函数式接口也是...
JAVA Stream 中 Function＜T, R＞ 中 apply，compose， andThen 方法学习总结
weixin_44131922的博客
06-06 2906
Stream 中的 Function 实际上解决了一个简单的问题，那就是我们在实际书写代码的时候，一个方法一般只能作为代码中的某一行函数，用于处理里面的数值，但是并不能将一个方法作为一个参数，将方法以参数的形式将方法传递到下一个方法中继续使用。compose 看内部实现，这个方法的入参也为 Function 类型，当调用时会先执行 作为入参的 Function 中的apply 方法，再将计算的结果作为原有方法的 apply 入参。apply 的作用为执行当前方法函数，t 为入参，R 为返回值类型。
Java Stream的简单应用
砖业手艺混子的博客
11-23 3646
代码实现:根据外部传入的userids集合(是userid的源集合),temps是根据结果得到哪些是有用的userid(有一些不符合条件的过滤了,代码实现也是为了得到被过滤的userid),目标集合cache(是为了存入redis才取此名,把不合法的userid存入redis,), 总之就想试试Stream,其实在工作中真的很多CV,看看同事写的,复制,粘贴,改参数,改返回值,一条龙,完成。至于我为什么不复制粘贴,一把梭?这也是我在工作中第一次使用Stream,时隔多日,也顺便复习一下,总结一下。
java中call和apply_JavaScript中call()和apply()使用方法详解
weixin_39932479的博客
02-25 413
概要一.官方定义在JavaScript中对于call()以及apply()的定义为：调用一个对象的一个方法，以另一个对象替换当前对象。二.个人理解(配合demo)从官方定义中我们可以看到什么(以apply()为例)：1.用来调用一个对象2.用调用的对象来替换当前对象熟悉面向对象编程的同学应该对this关键字特别熟悉，对于Java来说，this就是指当前对象。在JavaScript中，默认情况下(没...
java中apply方法的使用
最新发布
gb4215287的博客
06-24 791
java中apply方法的使用
java apply_apply()与call()的区别
weixin_39834678的博客
02-12 3268
一直都没太明白apply()与call()的具体使用原理，今日闲来无事，决定好好研究一番。JavaScript中的每一个Function对象都有一个apply()方法和一个call()方法，它们的语法分别为：/*apply()方法*/function.apply(thisObj[, argArray])/*call()方法*/function.call(thisObj[, arg1[, arg2[...
Java8新特性 - Stream - 13 - Stream的max()、min()方法详解
northcastle的博客
03-14 2万+
java8新特性 Stream操作 集合数据 求max()、min() 取集合中的最大值最小值
Java8 Stream流
雨后是冰雹
03-30 1112
文章目录stream操作方法分类1. concat方法2. distinct3. filter4. map5. flatMap6. peek7. skip8. sorted9. limit10. collect11. count12. forEach13. forEachOrder14. max15. min16. reduce17. allMatch18. anyMatch19. findAny...
Java8中四种基础函数式接口
一路向前
11-27 2966
Java8中四种基础函数式接口 函数式接口 参数类型 返回类型 用途 举例 Function<T, R>{R apply(T t);} T，R R 给定指定类型T的参数，返回R类型的结果，将函数限定。 对内容进行处理。比如给一张白纸，返回一张好看的画 P...
浅聊一下Stream流
渴望飞翔的小白
10-13 2957
下面的内容写的可能比较混乱stream流中的filter方法：//过滤stream流中的limit方法：//限制输出数据数量从下面可以看到skip指定类型是long，所以不能指定跳过某一个String。
Java8 Stream详解~聚合（max/min/count)
小强快跑~~
02-25 2512
max、min、count这些字眼你一定不陌生，没错，在mysql中我们常用它们进行数据统计。Java stream中也引入了这些概念和用法，极大地方便了我们对集合、数组的数据统计工作。 「案例一：获取String集合中最长的元素。」 public class StreamTest { public static void main(String[] args) { List<String> list = Arrays.asList("adnm", "admmt", "pot",
Java8新特性深度解析与源码示例
以上所述知识点均可以在“黑马程序员_java8新特性详解笔记和源码”提供的资源中找到。文件名称列表中的“源码.rar”应包含了详细的示例代码，展示如何在实际项目中应用Java 8的新特性。而“JDK8笔记.txt”则应是对于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值