【java8的特性-2】函数式接口！

一、什么是函数式接口 

函数式接口是一种只包含一个抽象方法的接口，用于支持函数式编程。在Java 8中，引入了一个新的注解@FunctionalInterface，用来标记一个接口是函数式接口。这样做的目的是为了让编译器在编译时对函数式接口进行检查，确保该接口只包含一个抽象方法。

函数式接口可以使用Lambda表达式或方法引用来简化代码。Java 8中提供了许多内置的函数式接口，如Consumer、Supplier、Function、Predicate等。这些接口都包含了一些通用的方法，可以用来支持函数式编程。

函数式接口使得Java程序员可以更加轻松地编写函数式代码，从而提高了代码的可读性和可维护性。

二、内置函数式接口

 在Java8中专门有一个包（java.util.function）用来存放函数式接口,该包下的所有接口都有@FunctionalInterface注解，提供函数式编程方式。

（一）、Predicate接口

Predicate接口是只有一个参数的返回布尔类型值的断言型接口。该接口中包含多种默认方法来讲Predicate组合成其他其他复杂的逻辑。

Predicate接口的源代码： 

@FunctionalInterface
public interface Predicate<T> {

    //该方法是接收一个传入参数的类型，返回一个布尔值
    boolean test(T t);

    //and方法，两边均成立时返回true
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }
   
    //对判断取反
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

   //只要有一个为true,就返回true
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    //该方法接收一个Object类型的对象，判断两个test方法是否相同
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

使用

List<String> list=Arrays.asList("孙悟空","猪#八戒","牛魔王","铁扇公主","玉兔");
		
		//test方法一：判断字符长度是否为4的
		Predicate<String> predicate1=(role)->{
			return role.length() !=4;
		};
		
		//test方法二：判断是否含有非字符类型的
		Predicate<String> predicate2=(role)->{
			for(int i=0;i<role.length();i++) {
				if(!Character.isLetter(role.charAt(i))) {
					return false;
				}
			}
			return true;
		};
		
		//and方法
		Predicate<String> predicate3=predicate1.and(predicate2);
		
		//取反
		Predicate<String> predicate4=predicate3.negate();
        
         //OR方法
		Predicate<String> predicate5=predicate1.or(predicate2);

（二）、Funcation接口 

T是函数的输入类型，R是函数的输出类型。Function接口还有一些默认方法，例如andThen()和compose()，用于组合函数。 

@FunctionalInterface
public interface Function<T, R> {

    R apply(T t);

   
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

   
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

   
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

实现

	List<String> list=Arrays.asList("sunWuKong","GGBond","eat","Sleep");
		
		//功能一将字母都转换成大写
		Function<String, String> fun1=(role)->{  //映射操作
//			System.out.println("fun1==>");
			return role.toUpperCase(); 
		};
		
		//功能二添加括号
		Function<String, String> fun2=(role)->{  //映射操作
//			System.out.println("fun2==>");
			return String.format("<%s>", role);
		};
		
		//功能一和功能二合并形成功能三(谁调用谁先执行)
		Function<String, String> fun3=fun1.andThen(fun2);
		
		//功能一和功能二合并形成功能四(被调用谁先执行)
		Function<String, String> fun4=fun1.compose(fun2);
		
		
		list.stream()  //换成 Stream 流
		.map(fun4)
		.forEach((role)->{  
			System.out.println(role);
		});

（三）、Comparator接口

比较指定元素的大小 

List<String> list=Arrays.asList("sunWuKong","GGBond","eat","Sleep");
		
		//比较规则一按照内容ASCII比较
		Comparator<String> comp1=(x,y)->{
			return x.compareTo(y);
		};
		
		//比较规则二按照长度
		Comparator<String> comp2=(x,y)->{
			return x.length()-y.length();
		};
		
		//比较规则三效比较内容再比较长度
		Comparator<String> comp3=comp1.thenComparing(comp2);
		
		//比较规则四按照内容降序
		Comparator<String> comp4=comp1.reversed();
		
		//排序
		list.sort(comp2);
		System.out.println(list);