内置核心四大函数式接口

    /**
     * 函数型接口，接受一个参数，返回一个参数，泛型中前面的是参数类型，后面的是返回值类型。
     */
    @Test
    public void testFunction() {
        Function<String, Integer> f = new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return s.hashCode();
            }
        };

        Function<String, Integer> f1 = s -> {
            return s.hashCode();
        };

        System.out.println(f.apply("wqe"));
    }

    /**
     * 判断型接口，根据参数，返回一个boolean值
     */
    @Test
    public void testPredicate() {
        Predicate<Integer> p = new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer > 0;
            }
        };

        Predicate<Integer> p1 = s -> {
            return 1 > s;
        };

        System.out.println(p.test(1));
        testConsumer();
    }

    /**
     * 消费型接口，只有参数，没有返回值
     */
    @Test
    public void testConsumer() {
        Consumer<String> c = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println("消费" + s);
            }
        };

        Consumer<String> c1 = s -> {
            System.out.println("消费" + s);
        };
        c.accept("new");
    }

    /**
     * 供给型接口，没有参数，只有返回值
     */
    @Test
    public void testSupplier() {
        Supplier<String> s = new Supplier() {
            @Override
            public String get() {
                return "qwe";
            }
        };

        Supplier<String> s1 = () -> {
            return "qwe";
        };
        System.out.println(s.get());
    }

Stream流

/**
 * 偶数ID
 * 年龄大于24
 * 用户名转换为大写
 * 用户名字母倒排序
 * 的一个用户
 */
public class StreamDemo {
	public static void main(String[] args){
		User u1 = new User(11, "a", 23);
        User u2 = new User(12, "b", 24);
        User u3 = new User(13, "c", 22);
        User u4 = new User(14, "d", 28);
        User u5 = new User(16, "e", 26);
        
        List<User> list = Arrays.asList(u1, u2, u3, u4, u5);
		list.stream().filter(user -> {
			return user.getId() % 2 == 0;
		}).filter(user -> {
			return user.getAge() > 24;
		}).map(user -> {
			return user.getName().toUpperCase();
		}).sorted((o1, o2) -> {
			return o2.compareTo(o1);
		}).limit(1).forEach(System.out::println);
	}
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private int id;
    private String name;
    private int age;
}