1

java.util.function

1
2
3
4
5
6
7
8
9

//前
Consumer c = new Consumer() {
    @Override
    public void accept(Object o) {
        System.out.println(o);
    }
};
//后
Consumer c = o -> System.out.println(o);  

1
2
3
4

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

/**
 * Predicate测试
 */
private static void predicateTest() {
        Predicate<String> p = o -> o.equals("test");
        Predicate<String> g = o -> o.startsWith("t");
        /**
         * negate: 用于对原来的Predicate做取反处理；
         * 如当调用p.test("test")为True时，调用p.negate().test("test")就会是False；
         */
        Assert.assertFalse(p.negate().test("test"));
        /**
         * and: 针对同一输入值，多个Predicate均返回True时返回True，否则返回False；
         */
        Assert.assertTrue(p.and(g).test("test"));

        /**
         * or: 针对同一输入值，多个Predicate只要有一个返回True则返回True，否则返回False
         */
        Assert.assertTrue(p.or(g).test("ta"));
        }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

/**
 * Function测试
 */
public static void functionTest() {
    Function<Integer, Integer> f = s -> ++s;
    Function<Integer, Integer> g = s -> s * 2;

    /**
     * 下面表示在执行F时，先执行G，并且执行F时使用G的输出当作输入。
     * 相当于以下代码：
     * Integer a = g.apply(1);
     * System.out.println(f.apply(a));
     * 结果为：3
     */
    System.out.println(f.compose(g).apply(1));

    /**
     * 表示执行F的Apply后使用其返回的值当作输入再执行G的Apply；
     * 相当于以下代码
     * Integer a = f.apply(1);
     * System.out.println(g.apply(a));
     * 结果为：4
     */
    System.out.println(f.andThen(g).apply(1));

    /**
     * identity方法会返回一个不进行任何处理的Function，即输出与输入值相等；
     * 结果为：a
     */
    System.out.println(Function.identity().apply("a"));
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public static void consumerTest() {
    Consumer f = System.out::println;
    Consumer f2 = n -> System.out.println(n + "-F2");

    //执行完F后再执行F2的Accept方法
    f.andThen(f2).accept("test");

    //连续执行F的Accept方法
    f.andThen(f).andThen(f).andThen(f).accept("test1");
}

1

Stream stream = Stream().Empty();

1
2
3

List<String> list = Arrays.asList("a", "b", "c", "d");
Stream listStream = list.stream();                   //获取串行的Stream对象
Stream parallelListStream = list.parallelStream();   //获取并行的Stream对象  

1
2

public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f);  
public static<T> Stream<T> iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

/**
 * 随机生成10个Double元素的Stream并将其打印
 */
Stream.generate(new Supplier<Double>() {
    @Override
    public Double get() {
        return Math.random();
    }
}).limit(10).forEach(System.out::println);

//上述写法可以简化成以下写法：
Stream.generate(() -> Math.random()).limit(10).forEach(System.out::println);

1
2
3
4
5
6

//定义
    Stream<T> filter(Predicate<? super T> predicate);
        
//查找所有包含t的元素并进行打印
    Stream<String> s = Stream.of("test", "t1", "t2", "teeeee", "aaaa");
    s.filter(n -> n.contains("t")).forEach(System.out::println);

1
2
3
4
5

//定义
    <R> Stream<R> map(Function<? super T, ? extends R> mapper);
//每个元素添加相同的后缀.txt
    Stream<String> s = Stream.of("test", "t1", "t2", "teeeee", "aaaa");
    s.map(n -> n.concat(".txt")).forEach(System.out::println);

1
2
3
4
5

//定义
    <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
//将每一个元素的拆分成单个字母，并打印
    Stream<String> s = Stream.of("test", "t1", "t2", "teeeee", "aaaa");
    s.flatMap(n -> Stream.of(n.split(""))).forEach(System.out::println);

1
2
3
4
5
6

//定义
    default Stream<T> takeWhile(Predicate<? super T> predicate)
//查找这几个元素中包含t的最长命中序列
    Stream<String> s = Stream.of("test", "t1", "t2", "teeeee", "aaaa", "taaa");
//以下结果将打印： "test", "t1", "t2", "teeeee"，最后的那个taaa不会进行打印 
    s.takeWhile(n -> n.contains("t")).forEach(System.out::println);

1
2
3
4
5
6

//定义
    default Stream<T> dropWhile(Predicate<? super T> predicate)
//删除这几个元素中包含t的最长命中序列
    Stream<String> s = Stream.of("test", "t1", "t2", "teeeee", "aaaa", "taaa");
//以下结果将打印："aaaa", "taaa" 　
    s.dropWhile(n -> n.contains("t")).forEach(System.out::println);

1

Optional o = Optional.empty();

1

o = Optional.of("test");

1
2
3
4
5
6
7
8
9

//以前的做法
String s = test();
if (null != s) {
    System.out.println(s);
}

//现在做法
Optional<String> s = Optional.ofNullable(test());
s.ifPresent(System.out::println);

1
2
3
4
5
6
7
8
9

//以前的做法
if (null == s) {
        s = "test";
        }
System.out.println(s);

//现在做法
Optional<String> o = Optional.ofNullable(s);
System.out.println(o.orElse("test"));

1
2
3
4
5
6
7
8
9

//以前的做法
if (null == s) {
        throw new Exception("test");
        }
System.out.println(s);

//现在做法
Optional<String> o = Optional.ofNullable(s);
System.out.println(o.orElseThrow(()->new Exception("test")));