java8新特性

最新推荐文章于 2024-01-11 10:49:48 发布
最新推荐文章于 2024-01-11 10:49:48 发布
阅读量107 收藏
点赞数
分类专栏： 后端 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51620667/article/details/124904540
版权

Java8 内置的四大核心函数式接口

Consumer< T > : 消费型接口 void accept(T t);

消费，有去无回，没有返回值

/**
 * 消费型接口
 */
@Test
void test() {
    happy(10000,m -> System.out.println("Nugoah喜欢大宝剑，每次消费" + m + "元"));
}

void happy(double money, Consumer<Double> consumer) {
    consumer.accept(money);
}
Supplier< T > : 供给型接口 T ger();
/**
 * 供给型接口
 * 示例：随机产生指定随机数并放入集合
 */
@Test
void test1() {
    List<Integer> numList = getNumList(10, () -> (int) (Math.random() * 100));
    numList.forEach(System.out::println);
}
public List<Integer> getNumList(int num, Supplier<Integer> supplier) {
    ArrayList<Integer> list = new ArrayList<>();
    for (int i = 0; i < num; i++) {
        Integer n = supplier.get();
        list.add(n);
    }
    return list;
}
Function<T, R> : 函数型接口 R apply(T t);
/**
 * 函数型接口
 * 需求：处理字符串
 */
@Test
void test2() {
    String str = "\t\t\t  我大java威武   ";
    String s = strHandler(str, String::trim);//取非空字符串
    System.out.println(s);
    String s1 = strHandler(s, String::toUpperCase);//转大写
    System.out.println(s1);
    String s2 = s1.substring(2, 6);//截取字符串
    System.out.println(s2);
}
public String strHandler(String str, Function<String, String> function) {
    return function.apply(str);
}
Predicate< T > : 断言型接口 boolean test(T t);
/**
 * 断言型接口
 * 需求：过滤字符串，输出长度大于3的字符串
 */
@Test
void test3() {
    List<String> list = Arrays.asList("Hello", "world", "Lambda", "www", "ok");
    List<String> strList = filterStr(list, s -> s.length() > 3);
    strList.forEach(System.out::println);
}
public List<String> filterStr(List<String> list, Predicate<String> predicate) {
    ArrayList<String> strings = new ArrayList<>();
    for (String string : list) {
        if (predicate.test(string)){
            strings.add(string);
        }
    }
    return strings;
}

image-20220228132117950

方法引用：

若Lambda 体中的内容有方法已经实现了，我们可以使用“方法引用”（可以理解为方法引用是Lambda表达式的另外一种表现形式）

主要有三种语法格式：

  1. 对象::实例方法名
  2. 类::静态方法名
  3. 类::实例方法名

Stream的三个操作步骤：

  1. 创建Stream
  2. 中间操作
  3. 终止操作（终端操作）
创建Stream
@Test
void test4() {
    // 1.可以通过Collection 系列集合提供的 stream() 或 parallelStream()
    ArrayList<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.forEach(System.out::println);

    //生成
    Stream.generate(() -> Math.random()).forEach(System.out::println);
}
中间操作
筛选与切片
  • filter——接收 Lambda ，从流中排除某些元素
  • limit——截断流，使其元素不超过给定数量。
  • skip(n)——跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流。与limit(n) 互补
  • distinct——筛选，通过流所生成元素的hashCode() 和 equals() 去除重复元素

image-20220228220030285

filte
@Test
// 内部迭代：迭代操作由 Stream API 完成
public void test1() {
    // 中间操作：不会执行任何操作
    Stream<Employee> stream = employees.stream()
        .filter((e) -> {
            // 在执行中间操作时，不会执行任何操作(中间操作没有执行)
            System.out.println("Stream API 的中间操作")
            return e.getAge() > 35;
        });
    // 终止操作：一次性执行全部内容，即“即惰性求值”
    stream.forEach(System.out::println);
}
// 外部迭代：有我们自己完成
@Test
public void test2() {
    Iterator<Employee> it = employees.iterator();
    while(it.hasNext()) {
        System.out.println(it.next());
    }
}

image-20220228215851365

limit
@Test
public void test3() {
    employees.stream()
        .filter((e) -> {
            System.out.println("短路！");
            return e.getSalary() > 5000;
        })
        .limit(2)
        .forEach(System.out::println);
}

image-20220228223258513

skip(n)
@Test
public void test4() {
    employees.stream()
        .filter((e) -> e.getSalary() > 5000)
        // 扔掉前两个元素，跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流。与limit(n) 互补
        .skip(2)
        .forEach(System.out::println);
}
distinct
@Test
public void test4() {
    employees.stream()
        .filter((e) -> e.getSalary() > 5000)
        .skip(2)
        // 筛选，通过流所生成元素的hashCode() 和 equals() 去除重复元素
        .distinct()
        .forEach(System.out::println);
}

注意：筛选，通过流所生成元素的hashCode() 和 equals() 去除重复元素

​ 所以，必须重写hashCode() 和 equals() 方法

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

    list.stream()
        .map(String::toUpperCase)//{ {a, a, a} {b, b, b} } ,流里面放流，类似add()
        .forEach(System.out::println);
    System.out.println("----------------------");

    Stream<Stream<Character>> stream = list.stream()
        .map(TestStream01::filterCharacter);

    stream.forEach((sm) -> sm.forEach(System.out::println));

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

    Stream<Character> sm = list.stream()
        .flatMap(TestStream01::filterCharacter);//{a, a, a, b, b, b,...} 把所有的流连接成一个流,类似addAll()
    sm.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();
}
排序
  • sorted() --自然排序（Comparable）
  • sorted(Comparator com）-- 定制排序（Comparator）
@Test
public void test7() {
	List<String> list = Arrays.asList("ccc", "aaa", "bbb", "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());// 升序
                return -e1.getAge().compareTo(e2.getAge());// 降序
            }
        })
}
终止操作
  • allMatch – 检查是否匹配所有元素
  • anyMatch – 检查是否至少匹配一个元素
  • noneMatch – 检查是否没有匹配所有元素
  • findFirst – 返回第一个元素
  • findAny – 返回当前流中的任意元素
  • count – 返回流中元素的总个数
  • max – 返回流中最大值
  • min – 返回流中最小值
List<Employee> employees = Arrays.asList(
        new Employee("张三", 18, 9999.99, Employee.Status.FREE),
        new Employee("李四", 58, 5555.55, Employee.Status.BUSY),
        new Employee("王五", 26, 3333.33, Employee.Status.VOCATION),
        new Employee("赵六", 36, 6666.66, Employee.Status.FREE),
        new Employee("田七", 12, 8888.88, Employee.Status.BUSY)
);

@Test
public void test1() {
    /*
    检查是否匹配所有元素
     */
    boolean b1 = employees.stream()
            .allMatch(e -> e.getSalary().equals(Employee.Status.BUSY));
    System.out.println(b1); // 输出false
    /*
    检查是否至少匹配一个元素
     */
    boolean b2 = employees.stream()
            .anyMatch(e -> e.getSalary().equals(Employee.Status.BUSY));
    System.out.println(b2);

    /*
    检查是否没有匹配所有元素
     */
    boolean b3 = employees.stream()
            .noneMatch(e -> e.getSalary().equals(Employee.Status.BUSY));
    System.out.println(b3);
    /*
    返回第一个元素
     */
    Optional<Employee> op = employees.stream() // 如果最终的结果可能为空，则返回Optional
            .sorted((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()))
            .findFirst();
    System.out.println(op);

    /*
    返回当前流中的任意元素
     */
    Optional<Employee> op2 = employees.stream()
            .filter(e -> e.getStatus().equals(Employee.Status.FREE))
            .findAny();
    System.out.println(op2);

    /*
    返回流中元素的个数
     */
    long count = employees.stream()
            .count();
    System.out.println(count);
    /*
    返回流中元素的最大值
     */
    Optional<Employee> max = employees.stream()
            .max(Comparator.comparingDouble(Employee::getSalary));
    System.out.println(max);
    /*
    返回流中元素的最小值
     */
    Optional<Double> min = employees.stream()
            .map(Employee::getSalary) // 经过map映射，流中的数据都变成了Double类型的salary，可以直接使用方法引用
            .min(Double::compare);
    System.out.println(min.get());
}
规约

image-20220301151135503

List<Employee> employees = Arrays.asList(
        new Employee("张三", 18, 9999.99, Employee.Status.FREE),
        new Employee("李四", 58, 5555.55, Employee.Status.BUSY),
        new Employee("王五", 26, 3333.33, Employee.Status.VOCATION),
        new Employee("赵六", 36, 6666.66, Employee.Status.FREE),
        new Employee("田七", 12, 8888.88, Employee.Status.BUSY)
);
/**
     * 规约
     * reduce(T identity, BinaryOperator) / reduce(BinaryOperator) -- 可以将流中元素反复结合起来，得到一个值
     *           起始值      二元运算
     */
    @Test
    public void test2() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
        Integer num = list.stream()
                .reduce(0, (x, y) -> x + y);
//                .reduce(0, Integer::sum)
        System.out.println(num);

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

image-20220301151106774

image-20220301151118546

收集

image-20220301151700101

/**
 * 收集
 * collect -- 将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
 */
@Test
public void test3() {
    List<String> list = employees.stream()
            .map(Employee::getName)
            .collect(Collectors.toList());
    list.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);
}

@Test
public void test4() {
    // 总数
    Long count = employees.stream()
            .collect(Collectors.counting());
    System.out.println(count);

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

    // 平均值
    Double avg = employees.stream()
            .collect(Collectors.averagingDouble(Employee::getSalary));
    System.out.println(avg);

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

    // 总和
    Double sum = employees.stream()
            .collect(Collectors.summingDouble(Employee::getSalary));
    System.out.println(sum);

    //工资最大的成员
    Optional<Employee> max = employees.stream()
            .collect(Collectors.maxBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
    System.out.println(max.get());
    //最小工资
    Optional<Double> min = employees.stream()
            .map(Employee::getSalary)
            .collect(Collectors.minBy(Double::compare));
    System.out.println(min.get());
}
// 多级分组
    @Test
    public void test5() {
        Map<Employee.Status, Map<String, List<Employee>>> map = employees.stream()
                .collect(Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy((e) -> {
                    if (e.getAge() <= 35) {
                        return "青年";
                    } else if (e.getAge() <= 50) {
                        return "中年";
                    } else {
                        return "老年";
                    }
                })));
        map.forEach((key, value) -> System.out.println(key + ":" + value));
    }

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

    @Test
    public void test7() {
        DoubleSummaryStatistics dds = employees.stream()
                .collect(Collectors.summarizingDouble(Employee::getSalary));
        System.out.println(dds.getSum());
        System.out.println(dds.getAverage()); // 平均值
        System.out.println(dds.getMax());
    }

    @Test
    public void test8() {
        String str = employees.stream()
                .map(Employee::getName)
                .collect(Collectors.joining(",", "===", "==="));
        System.out.println(str);
    }

image-20220301220031221

oah1021
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java8 新特性
06-17
java8的新特性，包含lambda表达式，stream流以及Optional和日期
Java 常用函数式接口之Consumer接口
u013950690的博客
04-04 540
*** 对给定参数执行消费操作。* @param t 输入参数*/java.util.function.Consumer 接口则正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据， 其数据类型由泛型决定。
Java 8之Consumer接口方法应用
sinat_31583645的博客
12-14 4740
Java 8新特性之lambda中Consumer接口中accept()与andThen()方法应用
Java的Consumer
weixin_63490470的博客
12-29 1984
Java中的Consumer接口是Java 8引入的一部分，属于包。它代表了一个接受单个输入参数但不返回任何结果的操作，可以看作是一个具有单个参数的函数，这个函数执行某种操作但不返回任何值。由于它是一个函数式接口，可以配合lambda表达式或方法引用使用。Consumer接口主要用于实现在对某些对象执行操作时不需要返回结果的场景。例如，它经常用于从集合中处理信息、打印值、写入日志等。
java Consumer接口与示例
热门推荐
西凉的悲伤博客
04-21 1万+
目录一、consumer使用示例代码1：示例代码2：示例代码3：示例代码4：二、Consumer相关的接口 Java 8 中的 Consumer 是一个函数接口，它可以接受一个泛型 <T> 类型参数，进行处理后无任何返回值。 accept(T) 方法是 Consumer 函数式接口的函数方法，传入一个任意类型，无返回值，可以用于 Lambda 表达式和方法引用。 andThen(Consumer) 方法可以传入一个 Consumer，返回组合了两个 Consumer 后的 Consumer ，
【Java 基础篇】Java Consumer 接口详解
繁依Fanyi的博客
09-23 7305
Consumer是Java 8中的一个函数式接口，它位于包中。它定义了一个名为accept的抽象方法，该方法接受一个参数并且不返回任何结果。换句话说，Consumer接口表示一个消费者，它可以对给定的对象执行某些操作，但不产生任何结果。ConsumerT是Consumer接口的泛型类型参数，表示输入类型。Consumer接口是Java 8中引入的一个函数式接口，用于表示一个消费者，它接受一个输入并执行某些操作。它在集合操作、数据处理、对象配置和异常处理等场景中非常有用。通过学习Consumer。
Java8新特性
06-15
Java8发布到现在至少3年了，但是对Lambda表达式不熟悉、看不懂、不会用的现象非常常见。 即使是升级到JDK1.8了，但是很多开发者依然是停留在1.8之前的开发方式，使用的也是非常老旧和过时的API，遇到函数式接口也是...
java8 新特性
02-28
介绍了Java 8 这个里程碑版本的新特性，包括Lambdas、流和函数式编程。有了函数式的编程 特性，可以让代码更简洁，同时也能自动化地利用多核硬件。全书分四个部分：基础知识、函数式数据处理、 高效Java 8 编程和...
JAVA8新特性讲解
12-15
Java 8是Java语言发展的一个重要里程碑，引入了许多创新特性，极大地提升了开发效率和代码质量。以下是关于Java 8新特性的详细讲解： ...通过观看“Java8 新特性视频教程”，你可以深入理解并熟练运用这些特性。
Java8新特性共76页
11-18
Java8新特性共76页
java8新特性-最新
12-18
在Java 8中，最重要的两个新特性无疑是Lambda表达式和Stream API。这两个特性都与函数式编程思想密切相关，让Java开发者能够更加灵活地处理数据。 ### Lambda表达式 Lambda表达式是Java 8中最显著的新特性之一，它...
全网详解(波哥)Java8新特性(Lambda、Stream、LocalDate等)新特性
09-02
全网详解(波哥)Java8新特性(Lambda、Stream、LocalDate等)新特性 自学java的同行们应该都要学习java8的新特性，譬如：（Lambda、Stream、LocalDate等）！本人在学习java的时候看的是波哥的视频，确实讲的不错，很...
尚硅谷Java8新特性视频教程
01-21
尚硅谷Java视频Java8新特性视频教程尚硅谷Java视频Java8新特性视频教程尚硅谷Java视频Java8新特性视频教程
Consumer＜T＞接口的使用
o676448的博客
07-08 1225
Consumer:包含两个方法 void accept(T t):对给定参数执行此操作 default Consumer andThen(Consumer after):返回一个组合的Consumer,依次执行次操作,然后执行after操作
逐步走向响应式编程（二）-常见函数式接口- Consumer＜T＞
浦江之猿的博客
05-14 539
java8提供的Consumer<T>也是一大常用接口，其功能正如其名，用于“消费”操作。此接口提供了两个方法，其中一个是待实现的方法accept，另一个是默认方法andThen。此接口主要用于对某数据进行处理，无需返回值的情景。
Java8新特性-函数式接口
最新发布
射手座的程序媛的专栏
01-11 1181
函数式接口
消费型接口和供给型接口
LIAO_YUANLONG的博客
12-20 622
深入解析Java8新特性
" Beginning Java 8 Language Features 是一本关于了解Java 8新特性的书籍，涵盖了从注解、内部类到流等广泛的主题，旨在帮助读者深入理解Java 8的重要更新。" Java 8作为Java语言的一个重大版本更新，引入了许多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

oah1021

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值