Java的函数式接口及使用示例

Java 1.8加入了lambda表达式，可以进行函数式编程了，这几天也一直在研究这个东西，从Java核心技术中得知java.util.function包中已经定义了许多常用的函数式接口。

书中也列举了这个包下所有的接口，一共43个，有9个是通用接口，其余34个均为有关boolean、断言、提供int、long、double三者的值以及处理int、long、double三者之间值相互转换的一些接口。最后一个Runnable接口虽然没有在java.util.function包下，但是符合函数式接口的定义。

下面是博主我根据这几天理解写的关于每个接口的理解以及接口内有些默认已经实现的方法的理解。最后精心设计了一个使用示例。

我们知道函数式接口就是仅仅只含有一个抽象方法的接口，可为什么还是要研究类库中已经封装好的接口呢？答案就是为了提高编程统一率和效率。首先，如果是我们自己写，这些接口对于我们来说是一种额外的工作，因此使用官方提供好的接口会提高开发效率；另外，官方提供的接口用的人比较多，这样容易提高代码转手的难度，如果两个人同时都学习了这一组接口，那么当他们进行代码交接的时候将会变得简单许多。试想一下，如果我们自己写这些通用接口，不同的人有不同的想法，他们起的名字就有可能不一样，结果极有可能是不同的人开发出了不同的接口，却实现了同样的功能，当两个人再次交接代码时，无形增加了交接成本。

通用函数式接口有：

其他关于boolean、int、long、double类型的专用接口：

下面是所有的这43个接口的总览：(java.util.function包中)

细心的童鞋们可能会注意到了在第一个列表最后一列还标注了一个其他方法。这些是在接口中就已经实现的方法，用于增强接口的功能，下面介绍几个重要的方法。

1、andThen和compose

这两个方法详细请参考博主Lelontar的文章，他详细讲述了这两个方法的理解以及用法。

2、and、or、negate、isEqual方法

这几个方法是出现在和断言相关的接口中，用于表示断言的与、或、非以及元素与某值是否相等的关系。引用核心技术原文中的话，就是：

写了一个示例如下：

public class Test2 {
	public static void main(String[] args) {
/*		// 提供100以内的整数供打印
		printRandom(5, () -> (int)(Math.random()*100));*/
		
/*		// 打印数组中每个元素的值，先用标准输出打印，然后加上'@'符号后再次打印
		OperateEachNumberButNotReturn(new Integer[]{1,2,3,4,5},System.out::print,x -> System.out.println("@"+x));*/
		
/*		// 打印每相邻两元素的和
		OperateNearNumberButNotReturn(new Integer[]{1,2,3,4,5,6}, (x,y) -> System.out.print((x+y)+" "));*/
		
/*		Integer[] numbers = new Integer[]{1,2,3,4,5};
		// 给数组中的每一个元素加3后然后拼接@符号
		String[] result = OperateEachNumberAndReturn(numbers, (x) -> x+3+"@");
		System.out.println(Arrays.toString(result));*/
		
/*		// 每相邻两元素相加求和并返回详细信息
		String[] result = OperateNearNumberAndReturn(new Integer[]{1,2,3,4,5,6}, (x,y) -> x+"+"+y+"="+(x+y));
		System.out.println(Arrays.toString(result));*/

/*		// 返回数组中每一个数字的相反数
		Integer[] result = CalculateEachNumberAndReturnUnary(new Integer[]{1,2,3,4,5,6}, x -> -x);
		System.out.println(Arrays.toString(result));*/
		
/*		// 每相邻两元素相加求和
		Integer[] result = CalculateNearNumberAndReturnBinary(new Integer[]{1,2,3,4,5,6}, (x,y) -> x+y);
		System.out.println(Arrays.toString(result));*/
		
/*		// 判断数组中的每一个元素是否为正数
		String[] result = predicateEachNumberArray(new Integer[]{1,2,3,4,5,6},"是个正数","不是个正数",x -> x>0 ? true : false);
		System.out.println(Arrays.toString(result));*/
		
/*		// 判断数组中没连续相邻的两个元素是否相等
		String[] result = predicateNearNumberArray(new Integer[]{1,2,4,4,5,6},"相等","不相等", (x,y) -> x == y);
		System.out.println(Arrays.toString(result));*/
	}
	
	/**
	 * 打印count个随机整数，需要提供一个Supplier实现类
	 * @param count
	 * @param supplier
	 */
	public static void printRandom(int count,Supplier<Integer> supplier){
		for(int i=0;i<count;i++){
			System.out.println(supplier.get());
		}
	}
	
	/**
	 * 操作数组中每个元素的值，不会返回结果，需提供一个Consumer实现类
	 * @param numbers
	 * @param operator
	 */
	public static void OperateEachNumberButNotReturn(Integer[] numbers,Consumer<Integer> operator1,Consumer<Integer> operator2){
		for(int i=0;i<numbers.length;i++){
			operator1.andThen(operator2).accept(numbers[i]);
		}
	}
	
	/**
	 * 操作数组中每相邻两元素的值。不会返回结果，数组的索引必须大于等于2且为偶数，需提供一个BiConsumer实现类
	 * @param numbers
	 * @param operator
	 */ 
	public static void OperateNearNumberButNotReturn(Integer[] numbers,BiConsumer<Integer, Integer> operator){
		for(int i=0;i<numbers.length/2;i++){
			operator.accept(numbers[i*2], numbers[i*2+1]);
		}
	}
	
	/**
	 * 操作数组中的每一个值，并返回String[]类型的结果，需提供一个Function实现类
	 * @param numbers
	 * @param operator
	 * @return
	 */
	public static String[] OperateEachNumberAndReturn(Integer[] numbers,Function<Integer, String> operator){
		String[] numbersString = new String[numbers.length];
		for(int i=0;i<numbers.length;i++){
			numbersString[i] = operator.apply(numbers[i]);
		}
		return numbersString;
	}
	
	/**
	 * 操作数组中每相邻两元素的值。并返回String[]类型的结果，数组的索引必须大于等于2且为偶数，需提供一个BiFunction实现类
	 * @param numbers
	 * @param operator
	 * @return
	 */
	public static String[] OperateNearNumberAndReturn(Integer[] numbers,BiFunction<Integer, Integer, String> operator){
		String[] result = new String[numbers.length/2];
		for(int i=0;i<numbers.length/2;i++){
			result[i] = operator.apply(numbers[i*2], numbers[i*2+1]);
		}
		return result;
	}
	
	/**
	 * 操作数组中的每一个值，且返回相同类型的结果，需提供一个UnaryOperator实现类
	 * @param numbers
	 * @param operator
	 * @return
	 */
	public static Integer[] CalculateEachNumberAndReturnUnary(Integer[] numbers,UnaryOperator<Integer> operator){
		Integer[] result = new Integer[numbers.length];
		for(int i=0;i<numbers.length;i++){
			result[i] = operator.apply(numbers[i]);
		}
		return result;
	}
	
	/**
	 * 操作数组中每相邻两元素的值。且返回相同类型的结果，数组的索引必须大于等于2且为偶数，需提供一个BinaryOperator实现类
	 * @param numbers
	 * @param operator
	 * @return
	 */
	public static Integer[] CalculateNearNumberAndReturnBinary(Integer[] numbers,BinaryOperator<Integer> operator){
		Integer[] result = new Integer[numbers.length/2];
		for(int i=0;i<numbers.length/2;i++){
			result[i] = operator.apply(numbers[2*i], numbers[2*i+1]);
		}
		return result;
	}
	
	/**
	 * 操作数组中的每一个元素，断言它们
	 * @param numbers
	 * @param success 断言成功后打印的字符串
	 * @param error 断言失败后打印的字符串
	 * @param predicate
	 * @return
	 */
	public static String[] predicateEachNumberArray(Integer[] numbers,String success,String error,Predicate<Integer> predicate){
		String[] result = new String[numbers.length];
		for(int i=0;i<numbers.length;i++){
			result[i] = predicate.test(numbers[i]) ? numbers[i]+success : numbers[i]+error;
		}
		return result;
	}
	
	/**
	 * 操作数组中的每连续的两个相邻元素，断言它们
	 * @param numbers
	 * @param success 断言成功后打印的字符串
	 * @param error 断言失败后打印的字符串
	 * @param predicate
	 * @return
	 */
	public static String[] predicateNearNumberArray(Integer[] numbers,String success,String error,BiPredicate<Integer, Integer> predicate){
		String[] result = new String[numbers.length/2];
		for(int i=0;i<numbers.length/2;i++){
			result[i] = predicate.test(numbers[2*i], numbers[2*i+1]) ? numbers[2*i]+"和"+numbers[2*i+1]+success : numbers[2*i]+"和"+numbers[2*i+1]+error;
		}
		return result;
	}
}

参考资料：Java核心技术第10版