函数式接口Consumer、BiConsumer、Supplier、Predicate、Function、BiFunction
1.Consumer
Java Consumer接口来自Java 8中引入的 java.util.function包。
Consumer是一个功能接口，用来作为lambda表达式或方法引用的任务目标(传递一个参数执行指定的方法)。
Consumer的功能接口是一个接受单一参数并且不返回任何结果的操作。必要时，"结果"可以存在在集合里面
Consumer的功能方法是accept(T t)。
Consumer具有以下方法。
- accept : 这是Consumer功能接口的功能方法。accept 方法对给定的参数进行这一操作。
- andThen : 此方法返回一个组合的Consumer，该Consumer先执行原始的Consumer操作，然后按照从左到右的顺序执行给定的andThen操作
示例
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;public class Test0807 {public static void main(String[] args) {Consumer<Integer> print = i -> System.out.print(i);//1print.accept(1);System.out.println("----------------->");List<Integer> list = Arrays.asList(1, 2, 3, 4);//集合的每个元素乘以5Consumer<List<Integer>> change=i->{for (int j = 0; j < i.size(); j++) {i.set(j,i.get(j)*5);}};//打印每个元素Consumer<List<Integer>> print1=i->{for (int j = 0; j < i.size(); j++) {System.out.print(i.get(j)+" ");}};//每个先乘以5之后再打印//5 10 15 20 change.andThen(print1).accept(list);}
}
实例使用
public class Test0807 {public static void main(String[] args) {List<Integer> list = Stream.of(1, 2, 3, 4).collect(Collectors.toList());list.forEach(i-> System.out.println(i));}
2.BiConsumer
Java BiConsumer接口来自Java 8中引入的 java.util.function包。
BiConsumer是一个功能接口，用来作为lambda表达式或方法引用的任务目标(传递两个参数执行指定的方法)。
BiConsumer的功能接口是一个接受两个参数并且不返回任何结果的操作。
BiConsumer的功能方法是accept(T t, U u)。
BiConsumer具有以下方法。
- accept : 这是Consumer功能接口的功能方法。accept 方法对给定的参数进行这一操作。
- andThen : 此方法返回一个组合的BiConsumer，该BiConsumer先执行原始的BiConsumer操作，然后按照从左到右的顺序执行给定的andThen操作
示例
import com.google.common.collect.Maps;import java.util.Map;
import java.util.function.BiConsumer;public class Test0807 {public static void main(String[] args) {BiConsumer<String,Integer> print = (K,V) -> System.out.println(K+":"+V);print.accept("1",2);System.out.println("----------------->");Map<String,Integer> map = Maps.newLinkedHashMap();for (int i = 0; i < 10; i++) {map.put(i+"",i);}//打印key拼接aBiConsumer<String,Integer> print1=(K,V)->{System.out.println("keyChange--->"+K.concat("a")+":"+V);};//打印value乘以2BiConsumer<String,Integer> print2=(K,V)->{System.out.println("valueChange--->"+K+":"+V*2);};//打印key拼接a后打印value乘以2for (Map.Entry<String, Integer> entry : map.entrySet()) {print1.andThen(print2).accept(entry.getKey(), entry.getValue());}}
}
实际使用
import java.util.HashMap;
import java.util.Map;public class Test0807 {public static void main(String[] args) {Map<Integer,String> map=new HashMap<>();map.put(1,"a");map.put(2,"b");map.put(3,"c");map.put(4,"d");map.forEach((k,v)->{System.out.println(k+":"+v);});}
}
3.Supplier
Java Supplier接口来自Java 8中引入的 java.util.function包。
Supplier是一个功能接口，代表结果的提供者。
Supplier的功能接口是不需要接受参数并且获取结果的操作。
Supplier的功能方法是get()
示例
import com.google.common.collect.Lists;import java.util.List;
import java.util.Random;
import java.util.function.Supplier;public class Test0807 {public static void main(String[] args) {Supplier<Integer> supplier=()->new Random().nextInt(10)+1;List<Integer> list = Lists.newArrayList();for (int i = 0; i < 10; i++) {list.add(supplier.get());}list.forEach(i-> System.out.println(i));}
}
实际使用
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;public class Test0807 {public static void main(String[] args) {Map<Integer,String> map=new HashMap<>();map.put(1,"a");map.put(2,"b");map.put(3,"c");map.put(4,"d");ArrayList<Map.Entry<Integer, String>> collect = map.entrySet().stream().collect(Collectors.toCollection(() -> new ArrayList<>()));//等价于//ArrayList<Map.Entry<Integer, String>> collect = map.entrySet().stream().collect(Collectors.toCollection(ArrayList::new));System.out.println("collect = " + collect);}
}
4.Predicate
Java Predicate接口来自Java 8中引入的 java.util.function包。
Predicate是一个返回值布尔值的函数。
| 方法名 | 作用 |
|---|---|
| test(T t) | 判断对象t是否满足条件，满足返回true，不满足返回false |
| and(Predicate<? super T> other) | 判断对象t是否同时满足当前条件以及other条件，满足返回true，不满足返回false，相当于短路与&& |
| negate() | 对test(T t)的结果取反 |
| or(Predicate<? super T> other) | 判断对象t是否满足当前条件或者满足other条件，满足返回true，不满足返回false，相当于短路或|| |
| isEqual(Object targetRef) | 判断当前对象是否与对象targetRef属性值相等，相当于 Objects.equals(Object a, Object b) |
示例：
import lombok.Data;
import lombok.experimental.Accessors;
import org.apache.commons.lang3.StringUtils;import java.util.function.Predicate;public class Test0807 {public static void main(String[] args) {Stu stu1 = new Stu().setAge(20).setName("张三").setSex("男");//年龄是否大于20Predicate<Stu> condition1=i->i.getAge()>20;//是否性别是女Predicate<Stu> condition2=i-> StringUtils.equals("女",i.getSex());//判断stu1的年龄是否大于20boolean test1 = condition1.test(stu1);System.out.println("test1 = " + test1);//false//negate对结果取反boolean test11 = condition1.negate().test(stu1);System.out.println("test11 = " + test11);//false//判断stu1是否性别是女boolean test2 = condition2.test(stu1);System.out.println("test2 = " + test2);//false//判断stu1是否同时年龄大于20与性别是女stu1.setAge(25);boolean test3 = condition1.and(condition2).test(stu1);System.out.println("test3 = " + test3);//false//判断stu1是否年龄大于20或者性别是女boolean test4 = condition1.or(condition2).test(stu1);System.out.println("test4 = " + test4);//true//判断stu与stu1是否equalsStu stu = new Stu().setSex("男").setAge(25).setName("张三");boolean test5 = Predicate.isEqual(stu).test(stu1);System.out.println("test5 = " + test5);//true}
}@Data
@Accessors(chain = true)
class Stu{private String name;private Integer age;private String sex;
}
实际使用
import com.google.common.collect.Lists;import java.util.List;public class Test0807 {public static void main(String[] args) {List<Integer> list = Lists.newArrayList();for (int i = 0; i < 10; i++) {list.add(i);}//输出偶数list.stream().filter(i -> i % 2 == 0).forEach(i-> System.out.println(i));}
}
5.Function
Java Function接口来自Java 8中引入的 java.util.function包。
Function是一个功能接口，用来作为lambda表达式或方法引用的任务目标(传递一个参数执行指定的方法)。
Function的功能接口是一个接受单一参数并且返回单一结果的操作。
Function的功能方法是R apply(T t);
Function具有以下方法
| 方法名 | 作用 |
|---|---|
| R apply(T t); | 对传入的参数t进行函数运算后返回R |
| compose(Function<? super V, ? extends T> before) | 先对传入的参数进行before函数运算，然后在before函数运算基础上面再进行当前函数运算 |
| andThen(Function<? super R, ? extends V> after) | 先对传入的参数进行当前函数运算，然后在当前函数运算基础上面再进行after函数运算 |
| identity() | 输入什么就返回什么 |
示例：
public class Test0807 {public static void main(String[] args) {Function<Integer,Integer> multi=i-> i*10;Integer result = multi.apply(10);System.out.println("result = " + result);Function<Integer,Integer> add=i -> i + 10;//先加10再乘以10result= multi.compose(add).apply(10);//(10+10)*10System.out.println("result = " + result);//先乘以10再加10result= multi.andThen(add).apply(10);//10*20+10System.out.println("result = " + result);}
}
实际使用
import com.google.common.collect.Lists;import java.util.List;public class Test0807 {public static void main(String[] args) {List<Integer> list = Lists.newArrayList();for (int i = 0; i < 10; i++) {list.add(i);}list.stream().map(i -> i * 2).forEach(i-> System.out.println(i));}
}
6.BiFunction
Java BiFunction接口来自Java 8中引入的 java.util.function包。
BiFunction是一个功能接口，用来作为lambda表达式或方法引用的任务目标(传递两个个参数执行指定的方法)。
BiFunction的功能接口是一个接受两个参数并且返回单一结果的操作。
BiFunction的功能方法是R apply(T t, U u);
BiFunction具有以下方法
- apply: 这是BiFunction功能接口的功能方法。apply方法对给定的参数进行这一操作。
- andThen : 此方法返回一个组合的BiFunction，该BiFunction先执行原始的BiFunctionr操作，然后按照从左到右的顺序执行给定的andThen操作
示例：
import java.util.function.BiFunction;public class Test0807 {public static void main(String[] args) {//value*10BiFunction<String,Integer,Integer> biFunction1=(K,V)->{V=V*10;return V;};Integer a = biFunction1.apply("a", 10);System.out.println("a = " + a);//10//value+10Integer a1 = biFunction1.andThen(i -> i + 10).apply("a", 10);//10*10+10System.out.println("a1 = " + a1);//key大写BiFunction<String,Integer,String> biFunction2=(K,V)->{K=K.toUpperCase();return K;};String a2 = biFunction2.apply("a", 10);System.out.println("a2 = " + a2);//A//拼接本身String a3 = biFunction2.andThen(i -> i.concat(i)).apply("a", 10);System.out.println("a3 = " + a3);//AA}
}
实际使用
import java.util.HashMap;
import java.util.Map;public class Test0807 {public static void main(String[] args) {Map<Integer,String> map=new HashMap<>();map.put(1,"a");map.put(2,"b");map.put(3,"c");map.put(4,"d");//value大写map.keySet().forEach(i->{map.computeIfPresent(i, (K, V) -> V.toUpperCase());});map.forEach((K,V)-> System.out.println(K+":"+V));}
}
)
)
