2022.8.21 四大函数式接口与Stream流式计算

12、四大函数式接口（重点）

函数接口：只有一个方法的接口

 @FunctionalInterface
 public interface Runnable {
   
     public abstract void run();
 }
 //超级多@FunctionalInterface
 //减缓编程模型，在新版本中的框架底层大量应用
 //foreach(消费者类型的函数式接口)

1、Function函数式接口

 package com.xing.function;
 ​
 import java.util.function.Function;
 ​
 /**
  * Function 函数型接口  有一个输入参数 一个输出参数
  * 只要是函数结构就可以用lambda简化
  */
 public class demo01 {
     public static void main(String[] args) {
         //工具类：输出输入的值          参数的类型   返回值类型   
         /*Function function = new Function<String,String>() {
             @Override
             public String apply(String str) {
                 return str;
             }
         };*/
 ​
         // Function<String,String> function = (参数) ->{代码;};
 ​
         Function<String,String> function = (str) ->{return str;};
         System.out.println(function.apply("ads"));
     }
 }

 

2、Predicate 断定型接口

有一个输入参数，返回值只能是 布尔值！

 package com.xing.function;
 ​
 import java.util.function.Predicate;
 /*
 断定型接口：有一个输入参数，返回值只能是boolean值
  */
 public class demo02 {
     public static void main(String[] args) {
         //判断字符串是否为空                         参数的类型
        /* Predicate<String> predicate = new Predicate<String>(){
             @Override
             public boolean test(String str) {
                return str.isEmpty();
             }
         };*/
         
         Predicate<String> predicate = (str) -> {return str.isEmpty();};
         
         System.out.println(predicate.test(""));//true
         System.out.println(predicate.test("1"));//false
     }
 }

3、Consumer 消费型接口

 package com.xing.function;
 ​
 import java.util.function.Consumer;
 /*
 Consumer 消费型接口：只有输入，没有返回值
  */
 public class demo03 {
     public static void main(String[] args) {
         //                                        参数类型
         /*Consumer<String>  consumer = new Consumer<String>() {
             @Override
             public void accept(String str) {
                 System.out.println(str);
             }
         };*/
         Consumer<String> consumer = (str) -> {
             System.out.println(str);
         };
         consumer.accept("asb");//asb
     }
 }
 ​

4、Supplier 供给型接口

 package com.xing.function;
 ​
 import java.util.function.Supplier;
 /*
 supplier 供给型接口，不需要输入只有返回值
  */
 public class demo04 {
     public static void main(String[] args) {
        //                                返回值类型
        /* Supplier supplier = new Supplier<Integer>(){
             @Override
             public Integer get() {
                 System.out.println("get()");
                 return 1024;
             }
         };*/
         Supplier<Integer> supplier = () -> {return 1024;};
         System.out.println(supplier.get());//1024
     }
 }

13、Stream流式计算（重点）

大数据：存储+计算

集合、MySQL本质就是存储东西的；计算都应该交给流！

常见使用方法：map（对对象进行操作）filter（对对象进行过滤）sorted（排序）limit（限制输出数量）

 package com.xing.stream;
 ​
 import java.util.Arrays;
 import java.util.List;
 import java.util.Locale;
 ​
 /**
  * 题目要求：一分钟完成此题，只能用一行代码解决
  * 现在有五个用户！筛选：
  * 1.ID必须是偶数
  * 2.年龄必须大于23岁
  * 3.用户名转为大写
  * 4.用户名字母顺序倒序
  * 5.只输出一个用户
  */
 public class Test {
     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(6,"e",25);
 ​
         //集合就是存储
         List<User> list = Arrays.asList(u1, u2, u3, u4, u5);
 ​
         //计算交给流,链式编程
        /*
        * list.stream()：将list转换为流
        * filter(Predicate<? super T> predicate):过滤 参数为断定型接口  看看断定型接口的简写方式
        * map(Function<? super T, ? extends R> mapper): 映射 参数为函数式接口
        * sorted(Comparator<? super T> comparator)：排序(默认正序)  参数为消费型接口
        * limit(long maxSize)：输出的数据数
        */
         list.stream()
                 .filter(u->{return u.getId()%2==0;})//判断偶数
                 .filter(u ->{return u.getAge() >23;})//判断大于23岁
                 .map(u -> {return u.getName().toUpperCase(Locale.ROOT);})//名字大写
                 //.sorted((uu1,uu2)->{return uu1.compareTo(uu2);})//正序
                 .sorted((uu1,uu2)->{return uu2.compareTo(uu1);})//倒序
                 .limit(1)
                 .forEach(System.out::println);//输出 E
 ​
 ​
     }
 }
 class User{
     private int id;
     private String name;
     private  int age;
 ​
     public User(int id, String name, int age) {
         this.id = id;
         this.name = name;
         this.age = age;
     }
 ​
     public int getId() {
         return id;
     }
 ​
     public String getName() {
         return name;
     }
 ​
     public int getAge() {
         return age;
     }
 ​
     public void setId(int id) {
         this.id = id;
     }
 ​
     public void setName(String name) {
         this.name = name;
     }
 ​
     public void setAge(int age) {
         this.age = age;
     }
 ​
     @Override
     public String toString() {
         return "User{" +
                 "id=" + id +
                 ", name='" + name + '\'' +
                 ", age=" + age +
                 '}';
     }
 }