Java函数式编程之Java8四大函数接口

大家好，又见面了，我是你们的朋友全栈君。

【前序】：

在Java8中，内置了四个核心函数接口，它们存在是Lamda表达式出现的前提，Lamda表达式想重写函数式接口中的唯一方法。
函数式接口与Lambda表达式之间的关系：lambda表达式相当于是一个行为，传入函数式接口中，进来实现各种操作，即行为参数化
它们的接口内只有一个抽象方法，每一个函数式接口都有@FunctionalInterface注解。

文章目录

【正文】：

四种函数式接口分别为：

Consumer< T>:消费型接口
接口方法 void accept(T t)：参数类型是T，无返回值
Supplier< T>供给型接口
接口方法 T get()：参数类型是T，返回T类型参数
Function<T,R>函数型接口</T,R>
接口方法R apply(T)：对类型T参数操作，返回R类型参数
Predicate< T>段言型接口
接口方法 boolean test（T t）：对类型T进行条件筛选操作，返回boolean

1.消费型接口

先看一下源码：

import java.util.Objects;
 
@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); };
    }

消费型接口代表了在一个输入参数上需要进行的操作。

举例1⃣️：

import java.util.function.Consumer;
 
public class Test { 
   
    public static void main(String[] args) { 
   
        Test consumertest = new Test();
        //传入字符串，然后打印
        consumertest.pass("I'm consumerFunction", (item) -> System.out.println(item));
    }
    
    //接受str字符串参数
    public void pass(String str, Consumer<String> consumer) { 
   
        consumer.accept(str);
    }
 }

函数式接口相当于把一个行为当作参数传入一个方法中，在这个例子中，System.out.println(item)是Consumer consumer的行为，即打印出所传入的参数str。

举例2⃣️：

Consumer<Integer> consumer = x -> { 
   
            int a = x + 2;
            System.out.println(a);// 12
        };
        consumer.accept(10);

2.供给型接口

源码：

@FunctionalInterface
public interface Supplier<T> { 
   
    /** * Gets a result. * * @return a result */
    T get();
}

供给型接口提供一个给定参数类型的结果

举例：产生一些整数，并放入集合中

import java.util.function.Supplier;
 
public class Test { 
   
    public static void main(String[] args) { 
   
    		Test consumertest = new Test();
    		consumertest.getNumList(10,()->(int)(Math.random()*100));


    //产生一些整数，并放入集合中. int num 为产生的个数
  public List<Integer> getNumList(int num, Supplier<Integer> supplier) { 
   

        List<Integer> list = new ArrayList<>();

        for(int i = 0;i<num;i++) { 
   
			Integer n =supplier.get()；
            list.add(n);
        }
        return list;
    }

3.函数型接口

Function接口接收一个参数，并返回单一的结果

举例：用于处理字符串


class Test{ 
   
	public static void main(String[] args){ 
   
		String newStr = strHandler("我是函数型接口"，(str)->str.subString(2,5));
		System.out.println(newStr);
		}

public String strHandler(String str, Function<String,String> fun){ 
   
		return fun.apply(str);
}

4.段言型接口

Predicate接口是一个布尔类型的函数，该函数只有一个输入参数

举例1⃣️：
筛选出长度大于4的字符串，并放入新的集合中


class Test{ 
   
	public static void main(String[] args){ 
   
		List<String> list =Arrays.asList("Hello","World","Function","Lambda","Java");
		filterStr(list,(s) -> s.length()>4);
		System.out.println(newList);
}

public List<String> filterStr(List<String> list,Predicate<String> pre){ 
   
		List<String> newList = new ArrayList<>();

		for(String str : list){ 
   
			if(pre.test(str)){ 
   
				newList.add(str);
				}
			}
			return newList;
}

举例2⃣️：
自定义类，筛选出重量大于150kg的苹果

public class Apple { 
   
        private int weight;
        private String color;

        public Apple(int weight, String color) { 
   
            this.weight = weight;
            this.color = color;
        }

        public Integer getWeight() { 
   
            return weight;
        }

        public void setWeight(Integer weight) { 
   
            this.weight = weight;
        }

        public String getColor() { 
   
            return color;
        }

        public void setColor(String color) { 
   
            this.color = color;
        }

        public String toString() { 
   
            return "Apple{" +
                    "color='" + color + '\'' +
                    ", weight=" + weight +
                    '}';
        }
    }

public class FilteringApples1 { 
   
    public static void main(String[] args) { 
   
        List<Apple> inventory = Arrays.asList(
                 new FilteringApples1.Apple(80, "green"),
                new FilteringApples1.Apple(155, "green"),
                new FilteringApples1.Apple(120, "red"));

				filterApples(inventory, (a) -> a.getWeight() > 150);
				System.out.println(result);
}


public List<Apple> filterApples(List<Apple> inventory,Predicate<Apple> pre) { 
   
        List<Apple> result = new ArrayList<>();
        for (FilteringApples1.Apple apple : inventory) { 
   
            if (p.test(apple)) { 
   
                result.add(apple);
            }
        }
        return result;
    }