JUC-四大函数式接口&流式计算

函数式接口

定义

只有一个方法的接口

@FunctionalInterface
public interface Runnable {
  public abstract void run();
}

都可以用lambda表达式来简化

四大函数式接口

Function

/**
 * Function 函数型接口（可用lambda）
 *  有一个输入参数，有一个输出参数
 *
 */
public class Demo01 {
    public static void main(String[] args) {
        Function stringStringFunction = new Function<String, Integer>(){
            @Override
            public Integer apply(String s) {
                return s.length();
            }
        };

        Function<String,String> function = (str) -> {return str;};
        System.out.println(function.apply("aa"));
    }
}

Predicate

/**
 * 断定型接口：输入一个参数，返回值只能是布尔值
 */
public class PredicateDemo {
    public static void main(String[] args) {
        Predicate<String> objectPredicate = new Predicate<String>(){
            @Override
            public boolean test(String o) {
                return o.isEmpty();
            }
        };

        Predicate<String> predicate = (str) ->{
          return str.isEmpty();
        };

        System.out.println(predicate.test("a"));
    }
}

Consumer

/**
 *  Consumer：消费型接口：只有输入，没有返回值
 */
public class ConsumerDemo {
    public static void main(String[] args) {
        Consumer<String> objectConsumer = new Consumer<String>(){
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };

        Consumer<String> consumer = (str) ->{
            System.out.println(str);
        };

        consumer.accept("输出");
    }
}

Supplier

/**
 * Supplier 供给型接口，没有参数，没有返回值
 */
public class SupplierDemo {
    public static void main(String[] args) {
        Supplier supplier = new Supplier<String>() {
            @Override
            public String get() {
                return new Date().toString();
            }
        };

        Supplier<String> stringSupplier = () ->{
            return new Date().toString();
        };
        System.out.println(stringSupplier.get());
    }
}

Stream流式计算

定义

1. 大数据：存储+计算
2. 集合、MySQL本质就是存储东西
3. 计算都应该交给流来操作

代码展示

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);
// 集合就是存储
List<User> list = Arrays.asList(u1,u2,u3,u4,u5);
// 计算交给Stream流
list.stream()
        //取id为偶数的
        .filter(user -> {return user.getId()%2==0 ;})
        //年龄必须大于23
        .filter(user -> {return user.getAge()>23;})
        //用户名转为大写,map可进行类型转换
        .map(user -> {return user.getName().toUpperCase();})
        //用户名字母倒叙排序
        .sorted((o1, o2) -> {return o2.compareTo(o1);})
        //只输出一个用户
        .limit(1)
        .forEach(System.out::println);

常见API

参考