JavaSE-函数式接口

布响丸辣大约 9 分钟

7.1 函数式接口概述

**函数式接口:**有且仅有一个抽象方法的接口

Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导

如何检测一个接口是不是函数式接口呢?

@Functionallnterface
放在接口定义的上方:如果接口是函数式接口，编译通过，如果不是，编译失败

注意

我们自己定义函数式接口的时候，@Funtionallnterface是可选的，就算我不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。但是，建议加上该注解

7.2 函数式接口作为方法的参数

public class RunnableDemo {
    public static void main(String[] args) {
        // 匿名内部类
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程启动了");
            }
        });

        // Lambda表达式
        startThread(()-> System.out.println(Thread.currentThread().getName()+"线程启动了"));
    }

    private static void startThread(Runnable r){
        new Thread(r).start();
    }
}

7.3 函数式接口作为方法的参数

public class ComparatorDemo {
    public static void main(String[] args) {
        // 构造使用场景

        //定义集合,存储字符串
        ArrayList<String> array = new ArrayList<>();

        array.add("cccc");
        array.add("aa");
        array.add("b");
        array.add("ddd");

        System.out.println("排序前:"+array);

//        Collections.sort(array);
        Collections.sort(array,getComparator());

        System.out.println("排序后:"+array);


    }

    private static Comparator<String> getComparator(){
        // 匿名内部类
//        Comparator<String> comp = new Comparator<String>() {
//            @Override
//            public int compare(String s1, String s2) {
//                return s1.length()-s2.length();
//            }
//        };
//        return comp;

//        return new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                return o1.length()-o2.length();
//            }
//        };

        // Lambda表达式
//        return (String s1,String s2) ->{
//            return s1.length()-s2.length();
//        };
        return (s1,s2)-> s1.length()-s2.length();

        /*
         * 如果方法的返回值是一个函数式接口,我们可以使用Lambda表达式作为结果返回
         */
    }
}

7.4 常用的函数式接口

Java8后出现了大量的函数式接口,重点学4个

7.4.1 Supplier接口

Supplier< T >:包含一个无参的方法

Tget(): 获得结果
该方法不需要参数，它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据

Supplier< T >接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用

public class SupplierDemo {
    public static void main(String[] args) {
        String s = getString(()->"明明打红红");
        System.out.println(s);
        Integer i = getInteger(()->44);
        System.out.println(i);
    }

    // 定义一个方法,返回一个整数数据
    private static Integer getInteger(Supplier<Integer> sup){
        return sup.get();
    }

    // 定义一个方法,返回一个字符串数据
    private static String getString(Supplier<String> sup){
        return sup.get();
    }
}

7.4.2 Consumer接口

Consumer< T >:包含两个方法

void accept(T t):对给定的参数执行此操作
defaultConsumer< T > andThen(Consumer after): 返回一个组合的Consumer，依次执行此操作，然后执行after操作

Consumer< T >接口也被称为消费型接口，它消费的数据的数据类型由泛型指定

public class ConsumerDemo {
    public static void main(String[] args) {
        // 消费一次
        operatorString("明明打红红",s-> System.out.println(s));
        // 消费一次
        operatorString("明明打红红",s-> System.out.println(new StringBuilder(s).reverse()));
        System.out.println("+=====================+");
        // 消费两次
        operatorString("明明打红红",s -> System.out.println(s),s -> System.out.println(new StringBuilder(s).reverse()));
    }

    // 定义一个方法,消费一个字符串数据
    private static void operatorString(String name, Consumer<String> con){
        con.accept(name);
    }

    // 定义一个方法,用不同的方法消费一个字符串数据两次
    private static void operatorString(String name, Consumer<String> con1,Consumer<String> con2){
        con1.andThen(con2).accept(name);
    }
}

7.4.3 Predicate接口

Predicate< T >: 常用的四个方法

boolean test(T t): 对给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回一个布尔值
default Predicate< T >negate():返回一个逻辑的否定，对应逻辑非
defaultPredicate< T >and(Predicateother): 返回一个组合判断对应短路与default

Predicate< T >or(Predicate other): 返回一个组合判断，对应短路或

public class PredicateDemo {
    public static void main(String[] args) {
        boolean b1 = checkString("hello", s -> s.length() > 8);
        System.out.println(b1);

        boolean b2 = checkString("helloworld", s -> s.length() > 8);
        System.out.println(b2);

        boolean b3 = checkString("hello", s -> s.length() > 8, s -> s.length() < 15);
        System.out.println(b3);

        boolean b4 = checkString("helloworld", s -> s.length() > 8, s -> s.length() < 15);
        System.out.println(b4);
    }

    // 判定给定的字符串是否满足要求
    private static boolean checkString(String s, Predicate<String> pre){
        return pre.test(s);
//        return pre.negate().test(s);
    }

    // 同一个字符串给出两个不同的判断条件,最后把这两个判断的结果做与运算,结果作为最终的结果
    private static boolean checkString (String s,Predicate<String> pre1,Predicate<String> pre2){
//        return pre1.and(pre2).test(s);
        return pre1.or(pre2).test(s);
    }
}

7.4.4 Function接口

Function< TR >:常用的两个方法

Rapply(Tt):将此函数应用于给定的参数
default< V > FunctionandThen(Function after): 返回一个组合函数，首先将该函数应用于输入，然后将ater函数应用于结果

Function< T,R >接口通常用于对参数进行处理，转换处理逻辑由Lambda表达式实现)，然后返回一个新的值

public class FunctionDemo {
    public static void main(String[] args) {

        convert("100",s -> Integer.parseInt(s));

        convert(100,i -> String.valueOf(i+65));

        convert("100",s -> Integer.parseInt(s),i -> String.valueOf(i+87));
    }

    // 定义一个方法,把一个字符串转换成int类型,在控制台输出
    private static void convert(String s, Function<String,Integer> fun){
        int i = fun.apply(s);
        System.out.println(i);
    }

    // 定义一个方法,把一个int类型转加一个整数后,转为字符串在控制台输出
    private static void convert(int i, Function<Integer,String> fun){
        String s = fun.apply(i);
        System.out.println(s);
    }

    // 定义一个方法,把一个字符串转换成int类型,把int类型转加一个整数后转换成字符串在控制台输出
    private static void convert(String s, Function<String,Integer> fun1,Function<Integer,String> fun2){
        String ss = fun1.andThen(fun2).apply(s);
        System.out.println(ss);
    }
}

7.5 Stream流

7.5.1 Stream流的使用

生成流

通过数据源(集合,数组等)生成流

list.stream()

中间操作

一个流后面可以跟随零个或多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流交给下一个操作使用

filter()

终结操作

一个流只能有一个终结操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作

forEach()

7.5.2 Stream流的常见生成方式

Stream流的常见生成方式

Collection体系的集合可以使用默认方法stream0生成流
defaultStream< E > stream()
Map体系的集合间接的生成流
数组可以通过Stream接口的静态方法of(T...values)生成流

public class StreamDemo {
    public static void main(String[] args) {
        //Collection体系的集合可以使用默认方法stream )生成流
        List<String> list = new ArrayList<String>();
        Stream<String> listStream = list.stream();
        
        Set<String> set = new HashSet<String>();
        Stream<String> setStream = set .stream();
        
        //Map体系的集合间接的生成流
        Map<String,Integer> map = new HashMap<String,Integer>();
        Stream<String> keyStream = map.keySet().stream();
        Stream<Integer> valueStream = map.values().stream();
        Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();
        
        //数组可以通过stream接口的静态方法of (T... values)生成流
        String[] strArray = {"hello","world","java"};
        Stream<String> strArrayStream = Stream.of(strArray);
        Stream<String> strArrayStream2 = Stream.of("hello","world","java");
        Stream<Integer> intStream = Stream.of(10,20,30);
    }
}

7.5.3 Stream流的常见中间操作方法

Stream< T > filter(Predicate predicate): 用于对流中的数据进行过滤
Predicate接口中的方法 boolean test(T t): 对给定的参数进行判断，返回一个布尔值
Stream< T >limit(long maxSize): 返回此流中的素组成的流，截取前指定参数个数的数据
Stream< T >skip(long n):跳过指定参数个数的数据，返回由该流的剩余元素组成的流
static< T >Stream< T >concat(Streama, Stream b): 合并a和b两个流为一个流
Stream< T >distinct0: 返回由该流的不同元素(根据Objectequals(Object)) 组成的流
Stream< T >sorted0: 返回由此流的元素组成的流，根据自然顺序排序
Stream< T > sortedComparator comparator): 返回由该流的元素组成的流，根据提供的Comparator进行排序
< R >Stream< R >map(Function mapper): 返回由给定函数应用于此流的元素的结果组成的流
Function接口中的方法 R apply(Tt)

IntStream mapTolnt(TolntFunction mapper): 返回一ntStream其中包含将给定函数应用于此流的元素的结果

IntStream:表示原始int流

TolntFunction接口中的方法 int applyAsInt(T value)

ArrayList<String> list = new ArrayList<String>();

list.add("10");
list.add("20");
list.add("30");
list.add("40");
list.add("50");
// 将集合中的字符串数据转换成整数后在控制台输出
list.stream().map(s -> Integer.parseInt(s)).forEach(System.out::println);
list.stream().mapToInt(s -> Integer.parseInt(s)).forEach(System.out::println);
// int sum() 返回流中的元素总和
int result = list.stream().mapToInt(Integer::parseInt).sum();
System.out.println(result);

7.5.4 Stream流的终结操作

void forEach(Consumeraction): 对此流的每个元素执行操作
Consumer接口中的方法 void accept(T t):对给定的参数执行此操作

long count() 返回此流中的元素数

ArrayList<String> list = new ArrayList<String>();

list.add("林青霞");
list.add("张曼玉");
list.add("王祖贤");
list.add("柳岩");
list.add("张敏");
list.add("张无忌");

// 把集合中的元素在控制台输出
list.stream().forEach(System.out::println);

// 统计集合中有几个以张开头的元素,并把统计结果在控制台输出
long count = list.stream().filter(s -> s.startsWith("张")).count();
System.out.println(count);

7.5.5 Stream流的收集操作

对数据使用Stream流的方式操作完毕后，我想把流中的数据收集到集合中，该怎么办呢?

Stream流的收集方法

R collect(Collector controller)
但是这个收集方法的参数是一个Collector 接口

工具类Collectors提供了具体的收集方式

publicstatic < T > Collector toList(): 把元素收集到List集合中
publicstatic < T > Collector toSet(): 把元素收集到Set集合中

publicstatic CollectortoMap(FunctionkeyMapper,Function valueMapper): 把元素收集到Map集合中

List<String> list = new ArrayList<>();
list.add("林青霞");
list.add("张曼玉");
list.add("王祖贤");
list.add("柳岩");

// 得到名字为3个字的流
Stream<String> listStream = list.stream().filter(s -> s.length() == 3);

// 把处理过的流数据收集到list集合中并遍历
List<String> names = listStream.collect(Collectors.toList());
for (String name : names){
    System.out.println(name);
}

Set<Integer> set = new HashSet<>();
set.add(10);
set.add(20);
set.add(30);
set.add(33);
set.add(35);

// 得到年龄大于25的流
Stream<Integer> setStream = set.stream().filter(age -> age > 25);

// 把处理过的流数据收集到set集合中并遍历
Set<Integer> ages = setStream.collect(Collectors.toSet());
for (Integer age : ages) {
    System.out.println(age);
}

String[] strArray = {"林青霞,30","张曼玉,35","王祖贤,33","柳岩,25"};

// 得到字符串中年龄大于28的流
Stream<String> arrayStream = Stream.of(strArray).filter(s -> Integer.parseInt(s.split(",")[1]) > 28);

// 把处理过的流数据收集到set集合中并遍历,姓名做键,年龄做值
Map<String, Integer> map = arrayStream.collect(Collectors.toMap(s -> s.split(",")[0], s -> Integer.parseInt(s.split(",")[1])));

Set<String> keySet = map.keySet();
for (String key : keySet) {
    Integer value = map.get(key);
    System.out.println(key+","+value);
}