JUC并发学习（六）

JUC并发学（六）

一、四大函数式接口（只有一个方法的接口）

Lambda表达式，链式编程，函数式接口，stream流式计算。

函数式接口

1.Function接口

  public static void main(String[] args) {
        Function function = new Function<String,String>() {
            @Override
            public String apply(String Str) {
                return Str;
            }
        };
        System.out.println(function.apply("AAAA"));
    }

变成Lambda表达式

public static void main(String[] args) {
       
        Function<String,String> function1 = (str)->{return str;};
        System.out.println(function1.apply("AAAA"));
    }

2.断定式函数：输入一个参数，返回boolean值

public static void main(String[] args) {
        Predicate<String> predicate = new Predicate<String>() {
            @Override
            public boolean test(String str) {
              if (str==null){
                  return false;
              }
                return true;
            }
        };
        System.out.println(predicate.test("aaaaaaaa"));
    }

变成Lambda表达式

public static void main(String[] args) {
      

       Predicate<String> predicate1=(str)->{
            if (str==null){
                return false;
            }
            return true;
        };

        System.out.println( predicate1.test("aaaaaaaaaaa"));
    }

3.Cunsumer接口：消费者接口   只有输入，没有返回值。

 public static void main(String[] args) {
        Consumer<String> consumer = new Consumer<String>() {

            @Override
            public void accept(String str) {
                System.out.println(str);
            }
        };
        consumer.accept("aaaaaaaaa");
     
    }

变成Lambda表达式

 public static void main(String[] args) {
      
        Consumer<String> consumer1=(str)->{
            System.out.println(str);
        };
        consumer1.accept("aaaaaaaa");
    }

4.Supplier供给者   没有参数，只有返回值。

public static void main(String[] args) {
        Supplier<String> supplier = new Supplier<String>() {
            @Override
            public String get() {
                return "aaaa";
            }
        };
        supplier.get();
        
    }

 变成Lambda表达式

public static void main(String[] args) {
        Supplier<String> supplier1=()->{
            return "aaaa";
        };
        supplier1.get();
    }

stream流式计算+链式编程

例子

//1.任务
//id为偶数
//age>23
//用户名转大写
//用户名字母倒叙排列
//只输出一个用户
public class test1 {
    public static void main(String[] args) {
        User a = new User(1, "a", 21);
        User b = new User(2, "b", 25);
        User c = new User(3, "c", 23);
        User d = new User(4, "d", 19);
        User e = new User(5, "e", 27);
        User f = new User(6, "f", 20);
        //集合存储
        List<User> users = Arrays.asList(a, b, c, d, e, f);
        //计算用流
        users.stream().filter((user)->{return user.getId()%2==0;}). //过滤偶数
                filter((user -> {return user.getAge()>23;})). //过滤age>23
                map(user -> {return user.getName().toUpperCase();}). //转大写
                sorted((user1,user2)->{return user2.compareTo(user1);}). //倒叙排序
                limit(1). //分页
                forEach((user)->{ System.out.println(user.toString()); }); //输出

    }
}