Java Consumer示例

Java Consumer接口来自Java 8中引入的 java.util.function包。

Consumer是一个功能接口，用来作为lambda表达式或方法引用的任务目标(传递一个参数执行指定的方法)。

Consumer的功能接口是一个接受单一参数并且不返回任何结果的操作。

Consumer的功能方法是accept(T t)。

Consumer具有以下方法。

1. accept : 这是Consumer功能接口的功能方法。accept 方法对给定的参数进行这一操作。

2. andThen : 此方法返回一个组合的Consumer，该Consumer先执行原始的Consumer操作，然后按照从左到右的顺序执行给定的andThen操作。

功能方法：accept

功能方法accept在功能接口Consumer中的定义

1
void accept(T t)

使用示例

ConsumerAccept.java

1
2
3
4
5
6
7
8
9
10
import java.util.function.Consumer;

public class ConsumerAccept {
  public static void main(String[] args) {
    Consumer<String> nameConsumer = s -> System.out.println(s); 
  
    nameConsumer.accept("Mahesh");
    nameConsumer.accept("Krishna");
  }
}

输出

1
2
Mahesh
Krishna

使用Lambda表达式创建Consumer

可以使用lambda表达式创建Consumer。

例1 基础类型操作

在我们的示例中，我们将使用lambda表达式在此处创建两个Consumer。

一个用于将数字添加到列表的方法，如果数字为奇数，则将添加到具有奇数的列表中；如果数字为偶数，则将其添加到具有偶数的另一个列表中。

ConsumerLambda1.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class ConsumerLambda1 {
  public static void main(String[] args) {
	List<Integer> oddList = new ArrayList<>();
	List<Integer> evenList = new ArrayList<>();

	Consumer<Integer> storeNumber = n -> {
	   if (n % 2 == 0) {
		 evenList.add(n);
	   } else {
		 oddList.add(n);
	   }
	};

	Consumer<List<Integer>> printList = list -> list.forEach(n -> System.out.println(n));

	storeNumber.accept(10);
	storeNumber.accept(15);
	storeNumber.accept(25);
	storeNumber.accept(30);

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

	printList.accept(oddList);

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

	printList.accept(evenList);
  }
}

输出结果

1
2
3
4
5
6
--- Odd number ---
15
25
--- Even number ---
10
30

例2 对象类型操作

我们将使用lambda表达式创建一个Consumer，它将决定并显示一个公民在选举中是否可以投票的数据。

ConsumerLambda2.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
import java.util.function.Consumer;

public class ConsumerLambda2 {
  public static void main(String[] args) {
     Consumer<Citizen> electionConsumer = c -> {
       if (c.getAge() < 18) {
    	 System.out.println(c.getName() + " is not eligible to vote.");
       } else {
    	 System.out.println(c.getName() + " can vote.");
       }
     };
   
     electionConsumer.accept(new Citizen("Ritesh", 15));
   
     electionConsumer.accept(new Citizen("Shreya", 20));
  }
}

class Citizen {
  private String name;
  private int age;

  public Citizen(String name, int age) {
	this.name = name;
	this.age = age;
  }

  public String getName() {
	return name;
  }

  public int getAge() {
	return age;
  }
}

输出结果

1
2
Ritesh is not eligible to vote.
Shreya can vote.

使用方法引用创建Consumer

Consumer可以使用方法引用来创建。

在我们的例子中，我们有一个有两个方法的实用类Utility，其中一个方法将替换Map中的值，第二个方法显示Map中的数据。我们将使用方法引用来创建Consumer。

ConsumerMethodRef.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import java.util.HashMap;
import java.util.Map;
import java.util.function.Consumer;

public class ConsumerMethodRef {
  public static void main(String[] args) {
	Map<Integer, String> persons = new HashMap<Integer, String>();
	persons.put(101, "Mahesh");
	persons.put(102, "Krishna");

	Consumer<Map<Integer, String>> updatePersons = Utility::updateData;

	Consumer<Map<Integer, String>> displayPersons = Utility::displayData;

	updatePersons.accept(persons);

	displayPersons.accept(persons);
  }
}

class Utility {
  static void updateData(Map<Integer, String> persons) {
	persons.replaceAll((k, v) -> "Shree ".concat(v));
  }

  static void displayData(Map<Integer, String> persons) {
	for (Map.Entry<Integer, String> entry : persons.entrySet()) {
	  System.out.println(entry.getKey() + " - " + entry.getValue());
	}
  }
}

输出结果

1
2
101 - Shree Mahesh
102 - Shree Krishna

使用andThen方法

在Java文档中andThen方法声明。

1
default Consumer<T> andThen(Consumer<? super T> after)
  1. 这个方法返回一个组合的Consumer，先执行当前Consumer操作，然后再执行after的Consumer操作。
  2. 如果在此操作或操作之后有异常，则将其中继到当前组合操作。
  3. 如果这个操作出现异常，那么后面的操作将不会被执行。

例1 简单拼接Consumer

我们的示例中有两个Consumer。

首先将执行squareConsumer，然后将执行printConsumer。

ConsumerAndThen1.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class ConsumerAndThen1 {
  public static void main(String[] args) {
	List<Integer> numList = Arrays.asList(3, 4, 5, 6);

	Consumer<List<Integer>> squareConsumer = list -> {
	  for (int i = 0; i < list.size(); i++) {
		list.set(i, list.get(i) * list.get(i));
	  }
	};

	Consumer<List<Integer>> printConsumer = list -> list.forEach(n -> System.out.println(n));

	squareConsumer.andThen(printConsumer).accept(numList);
  }
}

输出

1
2
3
4
9
16
25
36

例2 多个拼接Consumer

我们多次使用andThen。首先将执行oddNumConsumer，然后将执行evenNumConsumer，然后将执行taskFinishConsumer。

ConsumerAndThen2.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class ConsumerAndThen2 {
  public static void main(String[] args) {
	List<Integer> list = Arrays.asList(12, 13, 14, 15, 16, 17);

	Consumer<List<Integer>> oddNumConsumer = MyNumber::printOddNum;

	Consumer<List<Integer>> evenNumConsumer = MyNumber::printEvenNum;

	Consumer<List<Integer>> taskFinishConsumer = MyNumber::taskFinishMsg;

	oddNumConsumer.andThen(evenNumConsumer).andThen(taskFinishConsumer).accept(list);
  }
}

class MyNumber {
  static void printOddNum(List<Integer> myNumbers) {
	System.out.println("--- odd numbers ---");
	myNumbers.forEach(n -> {
	  if (n % 2 == 1) {
		System.out.print(n + " ");
	  }
	});
  }

  static void printEvenNum(List<Integer> myNumbers) {
	System.out.println("\n--- even numbers ---");
	myNumbers.forEach(n -> {
	  if (n % 2 == 0) {
		System.out.print(n + " ");
	  }
	});
  }

  static void taskFinishMsg(List<Integer> myNumbers) {
	System.out.println("\nTotal " + myNumbers.size() + " number processed.");
  }
}

输出结果

1
2
3
4
5
--- odd numbers ---
13 15 17 
--- even numbers ---
12 14 16 
Total 6 number processed.

参考文献

【1】Java doc: Consumer
【2】Java Consumer Example