Java中常用的函数式接口

Supplier接口

java.util.function.Supplier<T> 接口仅包含一个无参的方法： T get() 。用来获取一个泛型参数指定类型的对象数据。
通过求数组元素最大值演示该方法

抽象方法:get

package BoKe.javaadvance.test;

import java.util.function.Supplier;

public class Demo02Test {
    //定一个方法,方法的参数传递Supplier,泛型使用Integer
    public static int getMax(Supplier<Integer> sup) {
        return sup.get();
    }

    public static void main(String[] args) {
        int arr[] = {2, 3, 4, 52, 333, 23};
        //调用getMax方法,参数传递Lambda
        int maxNum = getMax(() -> {
            //计算数组的最大值
            int max = arr[0];
            for (int i : arr) {
                if (i > max) {
                    max = i;
                }
            }
            return max;
        });
        System.out.println(maxNum);
    }
}

通过该例子我们可以了解到Supplier接口,中我们定义了泛型Integer,在结果中我们获取了指定泛型的对象数据.

Consumer接口

java.util.function.Consumer<T> 接口则正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定。

抽象方法: accept

package BoKe.javaadvance.test;

import java.util.function.Consumer;

public class Demo10ConsumerAndThen {
    private static void consumeString(Consumer<String> one, Consumer<String> two) {
        one.andThen(two).accept("Hello");
    }

    public static void main(String[] args) {
        consumeString(
                s -> System.out.println(s.toUpperCase()),
                s ->System.out.println(s.toLowerCase()));
    }
}

可以通过链式编程实现更多功能.

package BoKe.javaadvance.test;

import java.util.function.Consumer;

public class Work1 {
    public static void printinfo(Consumer<String> one,Consumer<String> two,String[] array) {
        for (String s : array) {
            one.andThen(two).accept(s);
        }
    }
    public static void main(String[] args) {
        String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男" };
        printinfo(
                s -> System.out.print("姓名:" + s.split(",")[0]),
                s -> System.out.println(",性别:" + s.split(",")[1]),array
        );
    }
}

Predicate接口

有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。

抽象方法：test

import java.util.function.Predicate;
public class Demo15PredicateTest {
private static void method(Predicate<String> predicate) {
boolean veryLong = predicate.test("HelloWorld");
System.out.println("字符串很长吗：" + veryLong);
}
public static void main(String[] args) {
method(s ‐> s.length() > 5);
}
}

默认方法：and

package BoKe.javaadvance.test;

import java.util.function.Predicate;

public class Work2 {
    public static void test(Predicate<String> one, Predicate<String> two) {
        boolean itValue = one.and(two).test("我是哥");
        System.out.println(itValue);
    }

    public static void main(String[] args) {
        test(s -> s.contains("我"),
                s -> s.contains("哥"));
    }
}

默认方法: or

import java.util.function.Predicate;
public class Demo16PredicateAnd {
	private static void method(Predicate<String> one, Predicate<String> two) {
			boolean isValid = one.or(two).test("Helloworld");
			System.out.println("字符串符合要求吗：" + isValid);
	}
	public static void main(String[] args) {
			method(s ‐> s.contains("H"), s ‐> s.contains("W"));
	}
}

默认方法: negate

import java.util.function.Predicate;
public class Demo17PredicateNegate {
		private static void method(Predicate<String> predicate) {
				boolean veryLong = predicate.negate().test("HelloWorld");
				System.out.println("字符串很长吗：" + veryLong);
		}
		public static void main(String[] args) {
				method(s ‐> s.length() < 5);
		}
}

Function接口

抽象方法: apply

import java.util.function.Function;
public class Demo11FunctionApply {
		private static void method(Function<String, Integer> function) {
				int num = function.apply("10");
				System.out.println(num + 20);
		}
		public static void main(String[] args) {
				method(s ‐> Integer.parseInt(s));
		}
}

默认方法: andThen

import java.util.function.Function;
public class Demo12FunctionAndThen {
		private static void method(Function<String, Integer> one, Function<Integer, Integer> two) {
				int num = one.andThen(two).apply("10");
				System.out.println(num + 20);
		}
		public static void main(String[] args) {
				method(str‐>Integer.parseInt(str)+10, i ‐> i *= 10);
		}
}

综上是常见的函数式接口,感兴趣的小伙伴可以去根据这些函数式接口的特性来尝试自定义自己的函数式接口;