函数式接口

函数型接口

  1. package com.zy.function;
  3. import java.util.function.Function;
  5. /**
  6.  * Function 函数型接口, 有一个输入参数，有一个输出
  7.  * 只要是 函数型接口 可以 用 lambda表达式简化
  8.  */
  9. public class Demo01 {
  10.     public static void main(String[] args) {
  12. //        Function<String,String> function = new Function<String,String>() {
  13. //            @Override
  14. //            public String apply(String str) {
  15. //                return str;
  16. //            }
  17. //        };
  19.         Function<String,String> function = str->{return str;};
  21.         System.out.println(function.apply("asd"));
  22.     }
  23. }

断定型接口

  1. package com.zy.function;
  3. import java.util.function.Predicate;
  5. /**
  6.  * 断定型接口：有一个输入参数，返回值只能是 布尔值！
  7.  */
  8. public class Demo02 {
  9.     public static void main(String[] args) {
  10.         // 判断字符串是否为空
  11. //        Predicate<String> predicate = new Predicate<String>(){
  12. ////            @Override
  13. ////            public boolean test(String str) {
  14. ////                return str.isEmpty();
  15. ////            }
  16. ////        };
  18.         Predicate<String> predicate = (str)->{return str.isEmpty(); };
  19.         System.out.println(predicate.test(""));
  21.     }
  22. }

消费型接口

  1. package com.zy.function;
  3. import java.util.function.Consumer;
  5. /**
  6.  * Consumer 消费型接口: 只有输入，没有返回值
  7.  */
  8. public class Demo03 {
  9.     public static void main(String[] args) {
  10. //        Consumer<String> consumer = new Consumer<String>() {
  11. //            @Override
  12. //            public void accept(String str) {
  13. //                System.out.println(str);
  14. //            }
  15. //        };
  16.         Consumer<String> consumer = (str)->{System.out.println(str);};
  17.         consumer.accept("sdadasd");
  19.     }
  20. }

供给型接口

package com.zy.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 supplier = ()->{ return 1024; };
        System.out.println(supplier.get());
    }
}

Stream

package com.zy.stream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

/**
 * 题目要求：一分钟内完成此题，只能用一行代码实现！
 * 现在有5个用户！筛选：
 * 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);

        // 计算交给Stream流
        // lambda表达式、链式编程、函数式接口、Stream流式计算
//        list.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);

        Stream<Stream<User>> streamStream = list.stream()
                .map(Test::getUserAllByUpperCase);

        streamStream.forEach( sm -> {
            sm.forEach(System.out::println);
        });

        // flatMap 整合所有流 为一个流
        Stream<User> userStream = list.stream()
                .flatMap(Test::getUserAllByUpperCase);

        userStream.forEach(System.out::println);
    }

    public static Stream<User> getUserAllByUpperCase(User user){
        List<User> list = new ArrayList<>();

        user.setName(user.getName().toUpperCase());
        list.add(user);

        return list.stream();
    }

}