Java8新特性:函數式編程

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

Consumer c = (o) -> {
    System.out.println(o);
}; 

Consumer c = (o) -> System.out.println(o);

Consumer c = System.out::println;

default Consumer<T> andThen(Consumer<? super T> after) {
    Objects.requireNonNull(after);
    return (T t) -> { accept(t); after.accept(t); };
}

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");
}

/**
 * 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));
     */
    System.out.println(f.compose(g).apply(1));

    /**
     * 表示執行F的Apply後使用其返回的值當作輸入再執行G的Apply；
     * 相當於以下代碼
     * Integer a = f.apply(1);
     * System.out.println(g.apply(a));
     */
    System.out.println(f.andThen(g).apply(1));

    /**
     * identity方法會返回一個不進行任何處理的Function，即輸出與輸入值相等； 
     */
    System.out.println(Function.identity().apply("a"));
}

/**
 * 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"));
}

Stream stream = Stream.empty();

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

Stream s = Stream.of("test");
Stream s1 = Stream.of("a", "b", "c", "d");

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開始組裝一個序列，第一個是1，第二個是1+1即2，第三個是2+1即3..，直接10時中止；
 * 也可簡化成以下形式：
 *        Stream.iterate(1,
 *        n -> n <= 10,
 *        n -> n+1).forEach(System.out::println);
 * 寫成以下方式是為簡化理解
 */
Stream.iterate(1,
        new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer <= 10;
            }
        },
    new UnaryOperator<Integer>() {
        @Override
        public Integer apply(Integer integer) {
            return integer+1;
        }
}).forEach(System.out::println);

/**
 * 隨機生成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);

Stream<T> filter(Predicate<? super T> predicate);

Stream<String> s = Stream.of("test", "t1", "t2", "teeeee", "aaaa");
//查找所有包含t的元素並進行打印
s.filter(n -> n.contains("t")).forEach(System.out::println);

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

Stream<String> s = Stream.of("test", "t1", "t2", "teeeee", "aaaa");
s.map(n -> n.concat(".txt")).forEach(System.out::println);

<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);

default Stream<T> takeWhile(Predicate<? super T> predicate)

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);

default Stream<T> dropWhile(Predicate<? super T> predicate)

Stream<String> s = Stream.of("test", "t1", "t2", "teeeee", "aaaa", "taaa");
//以下結果將打印："aaaa", "taaa" 　
s.dropWhile(n -> n.contains("t")).forEach(System.out::println);

Optional o = Optional.empty();

o = Optional.of("test"); 

String s = test();
if (null != s) {
    System.out.println(s);
}

Optional<String> s = Optional.ofNullable(test());
s.ifPresent(System.out::println);

if (null == s) {
    s = "test";
}
System.out.println(s);

Optional<String> o = Optional.ofNullable(s);
System.out.println(o.orElse("test"));

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")));