函数式接口与Stream流-白红宇

函数式接口与Stream流

阅读量：481 次

发布时间：2019-03-06

本文共 3889 字，大约阅读时间需要 12 分钟。

Java 8 Lambda表达式与Stream操作详解

lambda表达式是Java语言的重要特性之一，首先亮相于Java 8。它以简洁的方式让开发者定义函数，堪称代码的诗意写作。lambda表达式的核心思想是“可推断、可省略”，这意味着编写lambda时，参数和返回值通常可以被编译器自动推断。

Lambda表达式的基本用法

lambda表达式的语法结构分为两部分：左边为参数，右边为方法体。参数可以省略类型，方法体如果只有一句，可以省略大括号和return关键字。例如：

Runnable runnable = () -> {
     System.out.println("run");
 };

这种写法比传统的匿名类更加简洁，适合于定义简短的逻辑单元。

自定义接口与Lambda表达式结合

lambda表达式的真正力量体现在接口方法的实现上。例如，定义一个简单的接口：

public interface Person {
    void show(String name);
}

使用lambda表达式实现它：

public class Main {
    public static void main(String[] args) {
        personShow((String name) -> {
            System.out.println(name);
        }, "张三");
    }
    public static void personShow(Person p, String name) {
        p.show(name);
    }
}

这里，lambda表达式作为Person接口的实现被传递给personShow方法。

Function接口与Lambda表达式结合

Function接口是处理输入和输出的常用函数式接口。它定义了一个apply方法，接收一个输入参数并返回一个结果。例如：

public class Test1 {
    public static void main(String[] args) {
        String hehe = test1.strHandler("hehe", (s) -> s.toUpperCase());
        System.out.println(hehe);
    }
    public String strHandler(String str, Function
   
     f) {
        return f.apply(str);
    }
}

这里，lambda表达式作为Function的实现，接收字符串输入并返回转换后的结果。

Stream流操作

Stream流是Java处理数据的新方式，它允许我们通过链式操作对数据进行处理，而不会改变源数据。Stream的操作分为几个主要部分：

筛选与切片

filter：接收lambda，过滤流中不符合条件的元素。

limit：限制流中元素的数量。

skip：跳过指定数量的元素，返回剩余流。

distinct：去重，基于hashCode和equals方法。

例如，过滤年龄大于18岁的员工：

public class Test2 {
    public static void main(String[] args) {
        List
   
     employees = Arrays.asList(
            new Employee("张十八", 18, 9999.99),
            new Employee("张五十八", 58, 5555.55),
            new Employee("张二十六", 26, 3333.33),
            new Employee("张三十六", 36, 6666.66),
            new Employee("张十二", 12, 8888.88)
        );
        Stream
    
      employeeStream = employees.stream()
            .filter(e -> e.getAge() > 18)
            .forEach(e -> System.out.println(e));
    }
}

映射操作

map：对流中的每个元素应用函数，返回新流。

flatMap：将流中的每个元素转换成另一个流，合并成单个流。

例如，将员工的工资转换为整数：

public class Test3 {
    public static void main(String[] args) {
        List
   
     employees = Arrays.asList(
            new Employee("张十八", 18, 9999.99),
            new Employee("张五十八", 58, 5555.55),
            new Employee("张二十六", 26, 3333.33),
            new Employee("张三十六", 36, 6666.66),
            new Employee("张十二", 12, 8888.88)
        );
        employees.stream()
            .map(e -> e.getPay().intValue())
            .forEach(e -> System.out.println(e));
    }
}

排序操作

sorted：自然排序，基于对象的compareTo方法。

sorted(Comparator com)：定制排序逻辑。

例如，按工资对员工进行排序：

public class Test4 {
    public static void main(String[] args) {
        List
   
     employees = Arrays.asList(
            new Employee("张十八", 18, 9999.99),
            new Employee("张五十八", 58, 5555.55),
            new Employee("张二十六", 26, 3333.33),
            new Employee("张三十六", 36, 6666.66),
            new Employee("张十二", 12, 8888.88)
        );
        employees.stream()
            .sorted((e1, e2) -> e1.getPay().compareTo(e2.getPay()))
            .forEach(e -> System.out.println(e));
    }
}

查找与匹配操作

allMatch：检查所有元素是否匹配。

anyMatch：检查是否存在至少一个匹配元素。

noneMatch：检查是否没有任何元素匹配。

findFirst：返回第一个元素。

findAny：返回任意元素。

count：统计元素总数。

max：返回最大值。

min：返回最小值。

例如，查找列表中是否存在大于3的数字：

public class Test5 {
    public static void main(String[] args) {
        List
   
     list = Arrays.asList(1, 2, 3);
        boolean b = list.stream()
            .allMatch(e -> e > 3);
        System.out.println(b); // false
    }
}

收集操作

将流转换为集合或其他容器：

public class Test5 {
    public static void main(String[] args) {
        List
   
     list = Arrays.asList(1, 2, 3, 4, 5, 6);
        List
    
      collect = list.stream()
            .limit(2)
            .collect(Collectors.toList());
        System.out.println(collect.size());
    }
}