Java 8 之函数式接口史上最全详解

函数式接口简介

  函数式接口:指只有一个抽象方法的接口
  函数式接口:可以被隐式转换为Lambda表达式。
  函数式接口：可以用@FunctionalInterface注解标识(此注解非必须使用)

常用函数式接口

消费式接口

    方法是定义一个泛型参数,无返回值
    interface Consumer<T> {
        void accept(T t);
    }

生产者接口

    方法无参数，存在返回值数据
    Interface Supplier<T> {
        T get();
    }

转换数据类型接口

    指定参数类型，指定返回值类型，将参数转换成对应指定数据类型
    Interface Function<T,R>  {
        R apply(T t);
    }

判断接口

判断接口
当数据类型符合test方法验证时，则返回true,否则返回false

    Interface Predicate<T> {
        boolean test(T t);
    }

比较器接口

比较器接口

    interface Comparator<T> {
        int compare(T o1, T o2);
    }

以上接口都只存在一个抽象方法，我们称之为”函数式接口“

比较器函数式接口

package com.java265;

import java.util.Arrays;
import java.util.Comparator;

public class Demo1 {
    public static void main(String[] args) {
        Person sp1 = new Person("小李", 12, '男');
        Person sp2 = new Person("小王", 22, '女');
        Person sp3 = new Person("校长", 45, '男');
        Person sp4 = new Person("阿里", 53, '男'); 
        
        Person[] arr = {
            sp1, sp2, sp3, sp4  
        };
        
        Arrays.sort(arr, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o2.getAge() - o1.getAge();
            }
        });
        
        
        Arrays.sort(arr, (p1, p2) -> p2.getAge() - p1.getAge());
        
        for (Person Person : arr) {
            System.out.println(Person);
        }
    }
}

消费函数式接口 Consumer

消费式接口
    方法是消耗一个参数，但是没有返回值
    interface Consumer<T> {
        void accept(T t);
    }

package com.java265;

import java.util.function.Consumer;

/**
 * 消费函数式接口
 *      Consumer接口是封装了一个无返回值有一个参数的方法。
 * @author Anonymous
 *
 */
public class Demo2 {
    public static void main(String[] args) {
        
        String str = "消费接口的调用";
        
        test(str, new Consumer<String>() {

            @Override
            public void accept(String t) {
                System.out.println(t);
            }
        });
        
        test(str, (s) -> {
            System.out.println("字符串长度:" + s.length());
        });
    }
    
    /**
     * 当前方法带有一个消费接口，需要完成一个有参数无返回值方法，当前接口泛型要求String类型
     * 
     * @param str String类型
     * @param c Consumer消费接口
     */
    public static void test(String str, Consumer<String> c) {
        c.accept(str);
    }
} 

生产者接口 Supplier

生产者接口
    方法不需要参数，但是存在返回值数据
    Interface Supplier<T> {
        T get();
    }

package com.java265;

/*
生产者接口
    方法不需要参数，但是存在返回值数据
    Interface Supplier<T> {
        T get();
    }
 */

import java.util.function.Supplier;

public class Demo3 {
    public static void main(String[] args) {
        Integer[] arr = {1, 3, 5, 17, 9, 2, 4, 6, 8, 10};
        
        Integer max = getMax(arr, new Supplier<Integer>() {

            @Override
            public Integer get() {
                int max = arr[0];
                for (int i = 1; i < arr.length; i++) {
                    if (max < arr[i]) {
                        max = arr[i];
                    }
                }
                
                return max;
            }
        });
        
        Integer max2 = getMax(arr, () -> {
            int max1 = arr[0];
            for (int i = 1; i < arr.length; i++) {
                if (max1 < arr[i]) {
                    max1 = arr[i];
                }
            }
            
            return max1;
        });
        
        Person sp1 = new Person("小李", 12, '男');
        Person sp2 = new Person("小王", 22, '女');
        Person sp3 = new Person("校长", 45, '男');
        Person sp4 = new Person("阿里", 53, '男'); 
        
        Person[] arr = {
            sp1, sp2, sp3, sp4  
        };
        
        Person max3 = getMax(spArr, () -> {
            Person sp = spArr[0];
            
            for (int i = 1; i < spArr.length; i++) {
                if (sp.getAge() < spArr[i].getAge()) {
                    sp = spArr[i];
                }
            } 
            return sp;
        });
        
        System.out.println(max3);
    }
    
    /**
     * 找出指定数据类型数组中的最大值
     * 
     * @param <T> 反正占位符
     * @param t 指定数据类型数组
     * @param s 生产者接口
     * @return 对应数据类型的最大值
     */
    public static <T> T getMax(T[] t, Supplier<T> s) {
        return s.get();
    }
}

转换数据类型接口 Function

转换数据类型接口
    指定参数类型，指定返回值类型，将参数转换成对应指定数据类型
    Interface Function<T,R>  {
        R apply(T t);
    }

package com.java265;

import java.util.function.Function;

/**
 * 转换接口
 * @author Anonymous
 *
 */
public class Demo4 {
    public static void main(String[] args) {
        String str = "骚磊,106,男";
        
        Person person = change(str, new Function<String, Person>() {

            @Override
            public Person apply(String t) {
                String[] split = t.split(",");
            
                String name = split[0];
                int age = Integer.parseInt(split[1]);
                char gender = split[2].charAt(0);
                
                return new Person(name, age, gender);
            }
        });
        
        Person person2 = change(str, (s) -> {
            String[] split = s.split(",");
            
            String name = split[0];
            int age = Integer.parseInt(split[1]);
            char gender = split[2].charAt(0);
            
            return new Person(name, age, gender);
        });
        
        System.out.println(person2);
    }
    
    /**
     * 讲字符串内容转换成Person类型
     * 
     * @param str 数据字符串
     * @param fun 转换接口
     * @return Person类型
     */
    public static Person change(String str, Function<String, Person> fun) {
        return fun.apply(str);
    }
}

判断接口 Predicate

判断接口，指定数据类型通过当前test方法判断，满足要求返回true，不满足返回false 类似于filter
    Interface Predicate<T> {
        boolean test(T t);
    }

package com.java265;

import java.security.Permissions;
import java.util.Arraylist;
import java.util.function.Predicate;

public class Demo5 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        
        list.add("java265.com");
        list.add("Java265.com");
        list.add("java教程"); 
        list.add("世界上最全的教程网"); 
        
        /*
        list.removeIf(new Predicate<String>() {

            @Override
            public boolean test(String t) {
                return t.contains("Java");
            }
        });
        
        list.removeIf(s -> s.length() > 4);
        */
        list.stream().skip(3).forEach(System.out::println);
    }
}