92 java8新特性_3 _函数式接口

函数式接口

• 函数式接口：

• 如果一个接口只有一个抽象方法，则该接口称之为函数式接口，函数式接口可以使用Lambda表达式，Lambda表达式会被匹配到这个抽象方法上。
• 只有函数式接口才能使用lambda表达式

• @FunctionalInterface 注解检测接口是否符合函数式接口。

代码1：

package com.wlw.chapter13_java8.demo01;
/**
 * 函数式接口
 */
@FunctionalInterface  //检测接口是否符合函数式接口。
public interface Usb {
    void service();
}      

package com.wlw.chapter13_java8.demo01;

public class Demo {
    public static void main(String[] args) {
        //匿名内部类
        Usb mouse = new Usb() {
            @Override
            public void service() {
                System.out.println("鼠标开始工作了.....");
            }
        };
        //lambda表达式
        Usb fan = ()->{
            System.out.println("风扇开始工作了........");
        };
        //Usb fan2 = ()-> System.out.println("风扇开始工作了2........");
        run(mouse);
        run(fan);
    }
    public static void run(Usb usb){
        usb.service();
    }
}
/*执行结果:
鼠标开始工作了.....
风扇开始工作了........
*/      

常见的函数式接口

函数式接口	方法参数类型	方法返回类型	说明
Consumer< T> 消费型接口	T	void	void accept(T t); 对类型为T的对象应用操作
Supplier< T> 供给型接口	无	T	T get(); 返回类型为T的对象
Function<T,R> 函数型接口	T	R	R apply(T t); 对类型为T的对象应用操作，并返回类型为R类型的对象。
Predicate< T> 断言型接口	T	boolean	boolean test(T t); 确定类型为T的对象是否满足条件，并返回boolean类型。

代码1:

package com.wlw.chapter13_java8.demo01;

import com.wlw.chapter9_thread.casedemo04.Consume;

import java.util.Arrays;
import java.util.Random;
import java.util.function.Consumer;
import java.util.function.Supplier;

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

        //匿名内部类
        Consumer<Double> consumer = new Consumer<Double>() {
            @Override
            public void accept(Double money) {
                System.out.println("consumer唱歌消费了:"+money);
            }
        };
        //lambda表达式 ,如果形参只有1个，()可以省略，只需要参数的名称即可，
        Consumer<Double> consumer1 = t ->{
            System.out.println("consumer1唱歌消费了:"+ t);
        };

        happy(consumer,1000.0);
        happy(consumer1,1000.1);
        happy(t-> System.out.println("consumer3吃饭消费了:"+ t),2000.0);
        System.out.println("=====================================================================");

        //匿名内部类
        Supplier<Integer> supplier = new Supplier<Integer>() {
            @Override
            public Integer get() {
                return new Random().nextInt(100);
            }
        };
        //lambda表达式
        Supplier<Integer> supplier1 = ()-> {
           return new Random().nextInt(1000);
        };

        int[] nums = getNums(supplier, 5);
        System.out.println(Arrays.toString(nums));

        int[] nums1 = getNums(supplier1, 5);
        System.out.println(Arrays.toString(nums1));

        int[] nums2 = getNums(()->new Random().nextInt(10), 5);
        System.out.println(Arrays.toString(nums2));
    }

    //Consumer<T>消费型接口
    public static void happy(Consumer<Double> consumer, Double money){
        consumer.accept(money);
    }

    //Supplier<T>供给型接口
    public static int[] getNums(Supplier<Integer> supplier,int count){
        int[] arr = new int[count];
        for (int i = 0; i < count; i++) {
            arr[i] = supplier.get();
        }
        return arr;
    }
}
/* 执行结果:
consumer唱歌消费了:1000.0
consumer1唱歌消费了:1000.1
consumer3吃饭消费了:2000.0
=====================================================================
[45, 71, 69, 5, 54]
[604, 149, 414, 618, 943]
[6, 1, 8, 3, 4]
*/      

package com.wlw.chapter13_java8.demo01;


import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;

public class Demo02 {
    public static void main(String[] args) {
        //匿名内部类
        Function<String,String> function = new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s.toUpperCase();
            }
        };
        //lambda表达式
        Function<String,String> function1 = (s)-> {
            return s.trim();
        };

        String result = handlerString(function, "hello");
        System.out.println(result);

        String result1 = handlerString(function1, "    hello zhangsan    ");
        System.out.println(result1);

        String result2 = handlerString(s -> s.toLowerCase(),"HELLOWORLD");
        System.out.println(result2);
        System.out.println("===============================================================");
        //匿名内部类
        Predicate<String> predicate = new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.startsWith("zhang");
            }
        };
        List<String> list = new ArrayList<>();
        list.add("zhangwuji");
        list.add("zhangsan");
        list.add("zhangxiaofan");
        list.add("wangwu");
        list.add("lisi");

        //lambda表达式
        Predicate<String> predicate1 = (s)->{
            return s.startsWith("zhang");
        };

        List<String> resultlist = filterNames(predicate, list);
        System.out.println(resultlist);

        List<String> resultlist1 = filterNames(predicate1, list);
        System.out.println(resultlist1);

        List<String> resultlist2 = filterNames(s -> s.length()>7, list);
        System.out.println(resultlist2);
    }

    //Function<T,R>函数型接口   R apply(T t);
    public static String handlerString(Function<String,String> function,String str){
        return function.apply(str);
    }

    //Predicate<T>断言型接口
    public static List<String> filterNames(Predicate<String> predicate,List<String> list){
        List<String> list1 = new ArrayList<>();
        for (String result : list){
            if(predicate.test(result)){
                list1.add(result);
            }
        }
        return list1;
    }
}
/*执行结果:
HELLO
hello zhangsan
helloworld
===============================================================
[zhangwuji, zhangsan, zhangxiaofan]
[zhangwuji, zhangsan, zhangxiaofan]
[zhangwuji, zhangsan, zhangxiaofan]

*/