Java Consumer接口

引言

在Java 8引入的函数式编程特性中，Consumer<T>接口是最常用的函数式接口之一。顾名思义，Consumer（消费者）接口表示一个操作，它接受单一输入参数但不返回任何结果。这个"消费"的概念在数据处理、迭代和流操作中非常有用。

备注

Consumer接口属于java.util.function包，是Java 8函数式编程的核心组件之一。

Consumer接口基础

接口定义

Consumer<T>接口的核心是一个名为accept的抽象方法：

java

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
    
    // 默认方法
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

其中：

• T 是泛型参数，代表输入值的类型
• accept(T t) 方法接受一个输入参数并对其执行操作
• andThen() 是一个默认方法，用于组合消费者操作

基本使用

下面是一个简单的示例，展示如何创建和使用Consumer接口：

java

import java.util.function.Consumer;

public class ConsumerDemo {
    public static void main(String[] args) {
        // 创建Consumer实例，打印输入的字符串
        Consumer<String> printConsumer = s -> System.out.println(s);
        
        // 使用accept方法
        printConsumer.accept("Hello, Consumer!");
        
        // 使用方法引用创建Consumer
        Consumer<String> printUpperCase = System.out::println;
        printUpperCase.accept("HELLO WORLD");
    }
}

输出：

Hello, Consumer!
HELLO WORLD

Consumer接口的高级用法

andThen方法

andThen方法允许我们创建一个Consumer链，按顺序执行多个Consumer操作：

java

import java.util.function.Consumer;

public class ConsumerChaining {
    public static void main(String[] args) {
        Consumer<String> printConsumer = s -> System.out.println("打印: " + s);
        Consumer<String> printLength = s -> System.out.println("长度: " + s.length());
        
        // 链式操作：先打印字符串，再打印长度
        Consumer<String> printThenLength = printConsumer.andThen(printLength);
        printThenLength.accept("Java Consumer接口");
    }
}

输出：

打印: Java Consumer接口
长度: 15

在集合中使用Consumer

Consumer接口在集合操作中特别有用，例如forEach方法：

java

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class ConsumerWithCollections {
    public static void main(String[] args) {
        List<String> languages = Arrays.asList("Java", "Python", "C++", "JavaScript");
        
        // 使用Consumer遍历列表
        Consumer<String> printWithIndex = (lang) -> {
            int index = languages.indexOf(lang);
            System.out.println(index + ": " + lang);
        };
        
        // 使用forEach方法
        languages.forEach(printWithIndex);
        
        // 简化写法，直接使用lambda
        System.out.println("\n使用简化语法：");
        languages.forEach(lang -> System.out.println(lang.toUpperCase()));
    }
}

输出：

0: Java
1: Python
2: C++
3: JavaScript

使用简化语法：
JAVA
PYTHON
C++
JAVASCRIPT

实际应用场景

1. 数据处理和转换

Consumer接口在处理数据或执行副作用操作时非常有用：

java

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class DataProcessingExample {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        
        // 创建一个处理数据的Consumer
        Consumer<List<String>> modifyList = list -> {
            for (int i = 0; i < list.size(); i++) {
                list.set(i, (i+1) + ". " + list.get(i));
            }
        };
        
        // 创建一个打印列表的Consumer
        Consumer<List<String>> printList = list -> {
            list.forEach(System.out::println);
        };
        
        // 先修改列表，然后打印
        modifyList.andThen(printList).accept(names);
    }
}

输出：

1. Alice
2. Bob
3. Charlie

2. UI事件处理

Consumer接口可以用于处理UI事件，例如在JavaFX中：

java

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;
import java.util.function.Consumer;

public class ButtonClickExample extends Application {
    @Override
    public void start(Stage primaryStage) {
        Button button = new Button("点击我");
        
        // 创建一个处理点击事件的Consumer
        Consumer<Button> handleClick = btn -> {
            btn.setText("已点击");
            System.out.println("按钮被点击了！");
        };
        
        // 设置事件处理
        button.setOnAction(event -> handleClick.accept(button));
        
        StackPane root = new StackPane();
        root.getChildren().add(button);
        primaryStage.setScene(new Scene(root, 300, 250));
        primaryStage.setTitle("Consumer事件处理示例");
        primaryStage.show();
    }
    
    public static void main(String[] args) {
        launch(args);
    }
}

警告

上述JavaFX示例需要JavaFX库支持，如果只是学习Consumer概念，可以忽略具体实现，只需理解Consumer在事件处理中的应用。

3. 配置对象

Consumer接口可以用于简化对象配置：

java

import java.util.function.Consumer;

class Person {
    private String name;
    private int age;
    
    public Person() {}
    
    public void setName(String name) {
        this.name = name;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
    
    // 使用Consumer简化配置
    public static Person create(Consumer<Person> builder) {
        Person person = new Person();
        builder.accept(person);
        return person;
    }
}

public class PersonBuilderExample {
    public static void main(String[] args) {
        // 使用Consumer配置Person对象
        Person person = Person.create(p -> {
            p.setName("张三");
            p.setAge(28);
        });
        
        System.out.println(person);
    }
}

输出：

Person{name='张三', age=28}

BiConsumer接口

与Consumer<T>类似，Java还提供了BiConsumer<T,U>接口，它接受两个输入参数：

java

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;

public class BiConsumerExample {
    public static void main(String[] args) {
        // 创建一个BiConsumer，接受两个参数
        BiConsumer<String, Integer> printEntry = (name, age) -> 
            System.out.println(name + " is " + age + " years old");
        
        // 使用accept方法
        printEntry.accept("Alice", 25);
        
        // 在Map上使用BiConsumer
        Map<String, Integer> ageMap = new HashMap<>();
        ageMap.put("Alice", 25);
        ageMap.put("Bob", 30);
        ageMap.put("Charlie", 35);
        
        // 使用forEach和BiConsumer遍历Map
        ageMap.forEach(printEntry);
    }
}

输出：

Alice is 25 years old
Alice is 25 years old
Bob is 30 years old
Charlie is 35 years old

IntConsumer, LongConsumer和DoubleConsumer

为了避免基本类型的自动装箱和拆箱，Java提供了专用的Consumer接口：

java

import java.util.function.DoubleConsumer;
import java.util.function.IntConsumer;
import java.util.function.LongConsumer;

public class PrimitiveConsumerExample {
    public static void main(String[] args) {
        // IntConsumer示例
        IntConsumer printInt = i -> System.out.println("Int: " + i);
        printInt.accept(10);
        
        // LongConsumer示例
        LongConsumer printLong = l -> System.out.println("Long: " + l);
        printLong.accept(100L);
        
        // DoubleConsumer示例
        DoubleConsumer printDouble = d -> System.out.println("Double: " + d);
        printDouble.accept(1.5);
    }
}

输出：

Int: 10
Long: 100
Double: 1.5

函数组合和柯里化

Consumer接口可以与其他函数式接口组合，实现更复杂的功能：

java

import java.util.function.Consumer;
import java.util.function.Function;

public class ConsumerComposition {
    public static void main(String[] args) {
        // 将Function和Consumer组合
        Function<String, String> toUpperCase = String::toUpperCase;
        Consumer<String> printer = System.out::println;
        
        // 组合：先转换，再消费
        Consumer<String> processThenPrint = s -> printer.accept(toUpperCase.apply(s));
        
        processThenPrint.accept("hello world");
    }
}

输出：

HELLO WORLD

总结

Consumer接口是Java函数式编程中的基础组件，它：

1. 接受一个输入参数但不返回任何结果
2. 可以通过andThen方法创建操作链
3. 广泛应用于集合遍历、数据处理和事件处理
4. 有针对基本类型的特殊变体（IntConsumer等）
5. 有接受两个参数的BiConsumer变体

通过掌握Consumer接口，你可以编写更简洁、更有表达力的代码，尤其在处理数据流和集合操作时。

练习

1. 创建一个Consumer，将字符串转换为小写并打印。
2. 创建两个Consumer：一个检查字符串是否为空，一个计算字符串长度，然后将它们链接起来。
3. 使用Consumer和forEach方法，过滤掉列表中长度小于5的字符串，并打印剩余的字符串。
4. 创建一个使用BiConsumer的示例，打印学生姓名和成绩。
5. 实现一个使用Consumer接口的简单日志系统，可以记录不同级别（INFO, ERROR等）的消息。

进一步阅读

• Java官方文档：Consumer接口
• Java函数式编程详解
• Stream API与Consumer接口

通过这些资源和练习，你将能够更深入地理解和应用Consumer接口，成为Java函数式编程的熟练使用者。