四大函数式接口 函数型接口 断定型接口 消费型接口 供给型接口 流式计算

函数式接口 : 有且只有一个方法的接口   比如说 Runnable  Callable  这种函数式接口在java中超级多 用来简化编程模型 在新版本的Java中大量应用

@FunctionalInterface
public interface Runnable {
    public abstract void run();
} 
foreach(消费者类型的函数式接口)'

1.Function<T,R>传入T 返回R  函数型接口

        Function<String, String> function = new Function<String, String>() {
            @Override
            public String apply(String str) {
                return str;
            }
        };
        System.out.println(function.apply("abc"));
　　　　　　--->lambda表达式写法  必须会
        Function<String, String> function = (str)->{ return str;};
　　　　 //Function<String,String> function = str ->{return str}; 更简化的写法
        System.out.println(function.apply("abc"));
2.Predicate<T t> 断定型接口  有一个输入参数 返回值只能是布尔值

Predicate<String> predicate = new Predicate<String>(){
    @Override
    public boolean test(String s) {
        return s.isEmpty();//自己定义要做的事情  我这里判断字符串是否为空
    }
};
System.out.println(predicate.test(""));

--->lambda表达式写法  必须会

Predicate<String> predicate = str->{ return str.isEmpty();};
System.out.println(predicate.test("123"));

3.Consumer 消费型接口　　 只有输入参数 没有返回值

Consumer<String> consumer = new Consumer<String>() {
    @Override
    public void accept(String str) {
        System.out.println(str);
    }
};
consumer.accept("sdhaskjfd");
Consumer<String> consumer1 = String ->{System.out.println(String);};
consumer1.accept("asdwq ioajdsasd");

4. Supplie 供给型接口  没有参数 只有返回值

Supplier supplier = new Supplier<Integer>() {
    @Override
    public Integer get() {
        return 1024;
    }
};
System.out.println(supplier.get());
Supplier<Integer> supplier1  = ()->{return 1024;};
System.out.println(supplier1.get());

只要是函数式接口就可以用lambda表达式进行简化


[流式计算]

/*
题目要求：
现在有六个用户 筛选：
1 ID必须是偶数
2 年龄大于23岁
3 用户名首字母大写
4 用户名字母倒着排序
5 只输出一个用户
 */
public class QuestionTest {

    public static void main(String[] args) {
        User u1 = new User(1,"a",21);
        User u2 = new User(2,"b",22);
        User u3 = new User(3,"c",23);
        User u4 = new User(4,"d",24);
        User u5 = new User(5,"e",25);
        User u6 = new User(6,"f",26);
        //集合用来存储数据
        List<User> users = Arrays.asList(u1, u2, u3, u4, u5,u6);
        //stream流用来计算
        //lambda表达式 链式编程 函数式接口 stream流式计算
        users.stream()
                .filter(u->{return u.getId()%2==0;})
                .filter(u->{return u.getAge()>23;})
                .map(u->{return u.getName().toUpperCase();})
                .sorted((uu1,uu2)->{return uu2.compareTo(uu1);})
                .limit(1)
                .forEach(System.out::println);
    }
}
class User{
    int id;
    String name;
    int age;

    public User(){}
    public User(int id,String name,int age){
        this.id=id;
        this.name=name;
        this.age=age;
    }

    public int getId() {
        return id;
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "user = "  + "{" + id +","+ name +"," + age + "}";
    }
}