java8三种函数式接口的说明

直接贴代码，注释非常清楚
Predicated

package test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

/**
 * @Author khe
 * @Date 2018/12/5
 */

/****
 * 说明 ：Predicated定义了一个接口，要求传入一个泛型为T的参数，然后对参数进行test方法判断
 * 返回一个boolean
 *
 */

public class PredicatedTest {

	/***
	 * 定义一个方法，实现：传入一个list，通过断言过滤后返回你需要的list
	 * 这就非常方便了，你想要什么过滤条件就通过lambda表达式传递进来
	 * @param list
	 * @param predicate
	 * @return
	 */
	public static List<Integer> getListByFilter(List<Integer> list, Predicate<Integer> predicate) {
		List<Integer> result = new ArrayList<>();
		for (Integer i : list) {
			if (predicate.test(i)) {
				result.add(i);
			}
		}
		return result;
	}

	public static void main(String[] args) {
		//数字大于5的集合
		List<Integer> originList = Arrays.asList(1, 23, 45, 45, -56, 67, -4, 534, 4, 6);
		List<Integer> list1 = getListByFilter(originList, (Integer i) -> i > 5);
		System.out.print("大于5的数 ：");
		for (int i : list1) {
			System.out.print(i + " ");
		}
		System.out.println();

		//偶数集合
		List<Integer> list2 = getListByFilter(originList, (Integer i) -> i % 2 == 0);
		System.out.print("偶数 ：");
		for (int i : list2) {
			System.out.print(i + " ");
		}
		System.out.println();

		//负数集合
		List<Integer> list3 = getListByFilter(originList, (Integer i) -> i < 0);
		System.out.print("负数 ：");
		for (int i : list3) {
			System.out.print(i + " ");
		}
		System.out.println();

		//素数集合
		List<Integer> list4 = getListByFilter(originList, (Integer i) -> {
			//有点小长的代码可以通过{}括起来
			//2特殊处理，2是最小的素数，凡是2的倍数都不是素数,还有负数的考虑
			if (i == 2) {
				return true;
			}
			if (i < 2 || i % 2 == 0) {
				return false;
			}
			//这里有个点需要提一个，为什么需要把平方根单独算出来，
			//理由是这会减少代码的执行次数，因为大部分人都会选择将计算平方根
			//的计算直接写在for循环上，这样每次执行都会重新计算平方根，
			// 代码执行效率可想而知，因此需要单独拿出来
			int end = (int) Math.sqrt(i);
			//2的倍数已经排除掉了
			for (int temp = 3; temp <= end; temp += 2) {
				if (i % temp == 0) {
					return false;
				}
			}
			return true;
		});
		System.out.print("素数 ：");
		for (int i : list4) {
			System.out.print(i + " ");
		}
		System.out.println();

	}

}

Consumer

package test;

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

/**
 * @Author khe
 * @Date 2018/12/5
 */

/***
 * 说明：Consumer定义了一个accecp方法，要求传入一个泛型为T的参数，返回值为void
 * 然后由调用者对传入的参数进行一系列的操作
 */
public class ConsumerTest {

	/***
	 * 说明：这是一个修改值的方法，通过consumer对需要修改的值进行accept操作存起来
	 * 然后具体实现由调用者提供
	 * @param list
	 * @param consumer
	 */
	private static void consumerList(List<Integer> list,Consumer<List<Integer>> consumer){
		//将集合加入处理
		consumer.accept(list);
	}

	public static void main(String[] args) {
		List<Integer> originList = Arrays.asList(1, 23, 45, 45, -56, 67, -4, 534, 4, 6);
		//将大于5的数打印
		consumerList(originList,(List<Integer> list)-> {
			for(int i=0;i<list.size();i++)
			if(list.get(i)>5)
			System.out.print(list.get(i)+ " ");
		});
		System.out.println();
		//将所有数修改为0
		consumerList(originList,(List<Integer> list)->{
			for(int i=0;i<list.size();i++) list.set(i,0);
		});
		//值已经修改
		for (int i : originList) {
			System.out.print(i+" ");
		}
	}

}

Function

package test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Function;

/**
 * @Author khe
 * @Date 2018/12/5
 */

/***
 * 说明Function接口提供了apply方法，实现一个传入泛型为T的对象返回一个泛型为R的对象
 */
public class FunctionTest {
	/***
	 * 这里使用官方的例子,实现的功能是传入个T泛型的List,返回一个R泛型的List
	 * @param list
	 * @param function
	 * @param <T>
	 * @param <R>
	 * @return
	 */
	public static <T, R> List<R> map(List<T> list, Function<T, R> function) {
		List<R> result = new ArrayList<>();
		for (T t : list) {
			result.add(function.apply(t));
		}
		return result;
	}

	public static void main(String[] args) {
		//将String类型的list转换为字符串长度的List
		List<String> stringList = Arrays.asList("lambda", "in", "action");
		List<Integer> list = map(stringList, (String s) -> s.length());
		for (int i : list) {
			System.out.println(i);
		}
	}


}