Java 8的中Consumer、Supplier、Predicate和Function

这几个接口都在java.util.function包下的,分别是Consumer(消费型)、supplier(供给型)、predicate(谓词型)、function(功能性)

Consumer接口

从字面上看,Consumer接口就是一个消费型的接口,通过传入参数,然后输出值,就是这么简单

Consumer实例

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
/**
* consumer接口测试
*/
@Test
public void testConsumer() {
//① 使用consumer接口实现方法
Consumer<String> consumer = new Consumer<String>() {

@Override
public void accept(String s) {
System.out.println(s);
}
};
Stream<String> stream = Stream.of("aaa", "bbb", "ccc");
stream.forEach(consumer);

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

//② 使用lambda表达式,forEach方法需要的就是一个Consumer接口
stream = Stream.of("aaa", "bbb", "ccc");
Consumer<String> consumer1 = (s) -> System.out.println(s); //lambda表达式返回的就是一个Consumer接口
stream.forEach(consumer1);
//更直接的方式
//stream.forEach((s) -> System.out.println(s));
System.out.println("********************");

//③ 使用方法引用,方法引用也是一个consumer
stream = Stream.of("aaa", "bbb", "ccc");
Consumer consumer2 = System.out::println;
stream.forEach(consumer);
//更直接的方式
//stream.forEach(System.out::println);
}

输出结果

1
2
3
4
5
6
7
8
9
10
11
aaa
bbb
ccc
********************
aaa
bbb
ccc
********************
aaa
bbb
ccc

实例分析

Consumer接口分析

在代码①中,我们直接创建Consumer接口,并且实现了一个名为accept的方法,这个方法就是这个接口的关键了。

我们看一下accept方法;这个方法传入一个参数,不返回值。当我们发现forEach需要一个Consumer类型的参数的时候,传入之后,就可以输出对应的值了。

lambda表达式作为Consumer

1
Consumer<String> consumer1 = (s) -> System.out.println(s); //lambda表达式返回的就是一个Consumer接口

在上面的代码中,我们使用下面的lambda表达式作为Consumer。仔细的看一下会发现,lambda表达式返回值就是一个Consumer;所以,也就能够理解为什么forEach方法可以使用lamdda表达式作为参数了吧。

③ 方法引用作为Consumer

1
Consumer consumer2 = System.out::println;

在上面的代码中,我们用了一个方法引用的方式作为一个Consumer,同时也可以传给forEach方法。

其他Consumer接口

除了上面使用的Consumer接口,还可以使用下面这些Consumer接口。
IntConsumerDoubleConsumerLongConsumerBiConsumer,使用方法和上面一样。

Consumer 总结

看完上面的实例我们可以总结为几点。

Consumer是一个接口,并且只要实现一个accept方法,就可以作为一个“消费者”输出信息。
② 其实,lambda表达式、方法引用的返回值都是Consumer类型,所以,他们能够作为forEach方法的参数,并且输出一个值。

Supplier 接口

Supplier接口是一个供给型的接口,其实,说白了就是一个容器,可以用来存储数据,然后可以供其他方法使用的这么一个接口。

Supplier实例

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
**
* Supplier接口测试,supplier相当一个容器或者变量,可以存储值
*/
@Test
public void testSupplier() {
//① 使用Supplier接口实现方法,只有一个get方法,无参数,返回一个值
Supplier<Integer> supplier = new Supplier<Integer>() {
@Override
public Integer get() {
//返回一个随机值
return new Random().nextInt();
}
};

System.out.println(supplier.get());
System.out.println("********************");

//② 使用lambda表达式
supplier = () -> new Random().nextInt();
System.out.println(supplier.get());
System.out.println("********************");

//③ 使用方法引用
Supplier<Double> supplier2 = Math::random;
System.out.println(supplier2.get());
}

输出结果

1
2
3
4
5
-19080692
********************
278389927
********************
0.99785060190326665

实例分析

① Supplier接口分析

1
2
3
4
5
6
7
Supplier<Integer> supplier = new Supplier<Integer>() {
@Override
public Integer get() {
//返回一个随机值
return new Random().nextInt();
}
};

看一下这段代码,我们通过创建一个Supplier对象,实现了一个get方法,这个方法无参数,返回一个值;所以,每次使用这个接口的时候都会返回一个值,并且保存在这个接口中,所以说是一个容器。

lambda表达式作为Supplier

1
2
3
4
//② 使用lambda表达式,
supplier = () -> new Random().nextInt();
System.out.println(supplier.get());
System.out.println("********************");

上面的这段代码,我们使用lambda表达式返回一个Supplier类型的接口,然后,我们调用get方法即可获取这个值。

③ 方法引用作为 Supplier

1
2
3
//③ 使用方法引用
Supplier<Double> supplier2 = Math::random;
System.out.println(supplier2.get());

方法引用也是返回一个Supplier类型的接口。

Supplier 实例2

我们看完第一个实例之后,应该有一个了解了,下面再看一个。

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
/**
* Supplier接口测试2,使用需要Supplier的接口方法
*/
@Test
public void testSupplier2() {
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
//返回一个optional对象
Optional<Integer> first = stream.filter(i -> i > 4)
.findFirst();

//optional,对象有需要Supplier接口的方法
//orElse,如果first中存在数,就返回这个数,如果不存在,就放回传入的数
System.out.println(first.orElse(1));
System.out.println(first.orElse(7));

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

Supplier<Integer> supplier = new Supplier<Integer>() {
@Override
public Integer get() {
//返回一个随机值
return new Random().nextInt();
}
};

//orElseGet,如果first中存在数,就返回这个数,如果不存在,就返回supplier返回的值
System.out.println(first.orElseGet(supplier));
}

输出结果

1
2
3
4
5
5
********************
5

代码分析

1
2
Optional<Integer> first = stream.filter(i -> i > 4)
.findFirst();

使用这个方法获取到一个Optional对象,在Optional对象中有orElse方法 和orElseGet是需要一个Supplier接口的。

  • orElse:如果first中存在数,就返回这个数,如果不存在,就放回传入的数
  • orElseGet:如果first中存在数,就返回这个数,如果不存在,就返回supplier返回的值

其他 Supplier 接口

除了上面使用的Supplier接口,还可以使用下面这些Supplier接口。
IntSupplierDoubleSupplierLongSupplierBooleanSupplier,使用方法和上面一样。

Supplier 总结

  • Supplier接口可以理解为一个容器,用于装数据的
  • Supplier接口有一个get方法,可以返回值

Predicate 接口

Predicate接口是一个谓词型接口,其实,这就是一个类似于bool类型的判断接口。

Predicate 实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
* Predicate谓词测试,谓词其实就是一个判断的作用类似bool的作用
*/
@Test
public void testPredicate() {
//① 使用Predicate接口实现方法,只有一个test方法,传入一个参数,返回一个bool值
Predicate<Integer> predicate = new Predicate<Integer>() {
@Override
public boolean test(Integer integer) {
if (integer > 5) {
return true;
}
return false;
}
};

System.out.println(predicate.test(6));
System.out.println("********************");

//② 使用lambda表达式
predicate = (t) -> t > 5;
System.out.println(predicate.test(1));
}

输出结果

1
2
3
true
********************
false

实例分析

Predicate接口分析

1
2
3
4
5
6
7
8
9
10
//① 使用Predicate接口实现方法,只有一个test方法,传入一个参数,返回一个bool值
Predicate<Integer> predicate = new Predicate<Integer>() {
@Override
public boolean test(Integer integer) {
if (integer > 5) {
return true;
}
return false;
}
};

这段代码中,创建了一个Predicate接口对象,其中,实现类test方法,需要传入一个参数,并且返回一个bool值,所以这个接口作用就是判断!

1
System.out.println(predicate.test(6));

再看,调用test方法,传入一个值,就会返回一个bool值。

② 使用lambda表达式作为predicate

1
2
3
//② 使用lambda表达式,
predicate = (t) -> t > 5;
System.out.println(predicate.test(1));

lambda表达式返回一个Predicate接口,然后调用test方法!

Predicate 接口实例2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
* Predicate谓词测试,Predicate作为接口使用
*/
@Test
public void testPredicate2() {
//① 将Predicate作为filter接口,Predicate起到一个判断的作用
Predicate<Integer> predicate = new Predicate<Integer>() {
@Override
public boolean test(Integer integer) {
if (integer > 5) {
return true;
}
return false;
}
};

Stream<Integer> stream = Stream.of(1, 23, 3, 4, 5, 56, 6, 6);
List<Integer> list = stream.filter(predicate).collect(Collectors.toList());
list.forEach(System.out::println);
}

输出结果

23
56
6
6

1
2
3
4
5
6
7

这段代码,首先创建一个`Predicate`对象,然后实现`test`方法,在`test`方法中做一个判断:如果传入的参数大于 5 ,就返回`true`,否则返回`false`;

```java
Stream<Integer> stream = Stream.of(1, 23, 3, 4, 5, 56, 6, 6);
List<Integer> list = stream.filter(predicate).collect(Collectors.toList());
list.forEach(System.out::println);

这段代码调用Streamfilter方法,filter方法需要的参数就是Predicate接口,所以在这里只要大于 5 的数据就会输出。

Predicate 接口总结

  • Predicate是一个谓词型接口,其实只是起到一个判断作用
  • Predicate通过实现一个test方法做判断

Function 接口

Function接口是一个功能型接口,它的一个作用就是转换作用,将输入数据转换成另一种形式的输出数据。

Function 接口实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
* Function测试,function的作用是转换,将一个值转为另外一个值
*/
@Test
public void testFunction() {
//① 使用map方法,泛型的第一个参数是转换前的类型,第二个是转化后的类型
Function<String, Integer> function = new Function<String, Integer>() {
@Override
public Integer apply(String s) {
return s.length();//获取每个字符串的长度,并且返回
}
};

Stream<String> stream = Stream.of("aaa", "bbbbb", "ccccccc");
Stream<Integer> stream1 = stream.map(function);
stream1.forEach(System.out::println);
}

输出结果

1
2
3
3
5
7

代码分析

Function接口分析

1
2
3
4
5
6
7
//① 使用map方法,泛型的第一个参数是转换前的类型,第二个是转化后的类型
Function<String, Integer> function = new Function<String, Integer>() {
@Override
public Integer apply(String s) {
return s.length(); //获取每个字符串的长度,并且返回
}
};

这段代码创建了一个Function接口对象,实现了一个apply方法,这个方法有一个输入参数和一个输出参数。其中,泛型的第一个参数是转换前的类型,第二个是转化后的类型。

在上面的代码中,就是获取字符串的长度,然后将每个字符串的长度作为返回值返回。

② 重要应用 map 方法

1
2
3
Stream<String> stream = Stream.of("aaa", "bbbbb", "ccccccc");
Stream<Integer> stream1 = stream.map(function);
stream1.forEach(System.out::println);

Function接口的重要应用不得不说Stream类的map方法,map方法传入一个Function接口,返回一个转换后的Stream类。

其他 Function 接口

除了上面使用的Function接口,还可以使用下面这些Function接口。
IntFunctionDoubleFunctionLongFunctionToIntFunctionToDoubleFunctionDoubleToIntFunction等等,使用方法和上面一样。

Function 接口总结

  • Function接口是一个功能型接口,是一个转换数据的作用
  • Function接口实现apply方法来做转换

Powered by AppBlog.CN     浙ICP备14037229号

Copyright © 2012 - 2020 APP开发技术博客 All Rights Reserved.

访客数 : | 访问量 :