java8 新特性

1.function interface
public class UseFoo {
    public String add(String s, Foo foo){
        return foo.method(s);
    }

    public String add(String s, Function<String,String> fn) {
        return fn.apply(s);
    }

    public static void main(String []args) {
        /**
         * Function<T,R>  输入参数为类型T， 输出为类型R， 记作 T -> R
         Consumer  输入参数为类型T， 输出为void， 记作 T -> void
         Supplier  没有输入参数， 输出为类型T， 记作 void -> T
         Predicate 输入参数为类型T， 输出为类型boolean， 记作 T -> boolean
         */
        Foo f = new Foo() {
            @Override
            public String method(String s) {
                return s + " from lambda";
            }
        };
        /**
         * -> equals new inner class
         * p parameters
         */
        Foo foo = p -> p;
        UseFoo uf = new UseFoo();
        String message = uf.add("message", foo);
        System.out.println(message);

        Function<String,String> fn = new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s + " from lambda";
            }
        };

        Function<String,String> fn1 = p -> p + " from lambda";
        String message1 = uf.add("message", fn1);
        System.out.println(message1);


        String message2 = fn1.apply("message");
        System.out.println(message2);


    }
}

2.function interface annotation

@FunctionalInterface
public interface Foo {
    String method(String s);
}

3.interface add default and static

public interface TestInterface {
    static int USER = 1;

    static String producer() {
        return  "static";
    }

    default String getOverview() {
        return "default";
    }
}

4.lambda

public class Test {
    public static void main(String []args) {
        /**
         * 1	BiConsumer<T,U>
         代表了一个接受两个输入参数的操作，并且不返回任何结果

         2	BiFunction<T,U,R>
         代表了一个接受两个输入参数的方法，并且返回一个结果

         3	BinaryOperator<T>
         代表了一个作用于于两个同类型操作符的操作，并且返回了操作符同类型的结果

         4	BiPredicate<T,U>
         代表了一个两个参数的boolean值方法

         5	BooleanSupplier
         代表了boolean值结果的提供方

         6	Consumer<T>
         代表了接受一个输入参数并且无返回的操作

         7	DoubleBinaryOperator
         代表了作用于两个double值操作符的操作，并且返回了一个double值的结果。

         8	DoubleConsumer
         代表一个接受double值参数的操作，并且不返回结果。

         9	DoubleFunction<R>
         代表接受一个double值参数的方法，并且返回结果

         10	DoublePredicate
         代表一个拥有double值参数的boolean值方法

         11	DoubleSupplier
         代表一个double值结构的提供方

         12	DoubleToIntFunction
         接受一个double类型输入，返回一个int类型结果。

         13	DoubleToLongFunction
         接受一个double类型输入，返回一个long类型结果

         14	DoubleUnaryOperator
         接受一个参数同为类型double,返回值类型也为double 。

         15	Function<T,R>
         接受一个输入参数，返回一个结果。

         16	IntBinaryOperator
         接受两个参数同为类型int,返回值类型也为int 。

         17	IntConsumer
         接受一个int类型的输入参数，无返回值 。

         18	IntFunction<R>
         接受一个int类型输入参数，返回一个结果 。

         19	IntPredicate
         ：接受一个int输入参数，返回一个布尔值的结果。

         20	IntSupplier
         无参数，返回一个int类型结果。

         21	IntToDoubleFunction
         接受一个int类型输入，返回一个double类型结果 。

         22	IntToLongFunction
         接受一个int类型输入，返回一个long类型结果。

         23	IntUnaryOperator
         接受一个参数同为类型int,返回值类型也为int 。

         24	LongBinaryOperator
         接受两个参数同为类型long,返回值类型也为long。

         25	LongConsumer
         接受一个long类型的输入参数，无返回值。

         26	LongFunction<R>
         接受一个long类型输入参数，返回一个结果。

         27	LongPredicate
         R接受一个long输入参数，返回一个布尔值类型结果。

         28	LongSupplier
         无参数，返回一个结果long类型的值。

         29	LongToDoubleFunction
         接受一个long类型输入，返回一个double类型结果。

         30	LongToIntFunction
         接受一个long类型输入，返回一个int类型结果。

         31	LongUnaryOperator
         接受一个参数同为类型long,返回值类型也为long。

         32	ObjDoubleConsumer<T>
         接受一个object类型和一个double类型的输入参数，无返回值。

         33	ObjIntConsumer<T>
         接受一个object类型和一个int类型的输入参数，无返回值。

         34	ObjLongConsumer<T>
         接受一个object类型和一个long类型的输入参数，无返回值。

         35	Predicate<T>
         接受一个输入参数，返回一个布尔值结果。

         36	Supplier<T>
         无参数，返回一个结果。

         37	ToDoubleBiFunction<T,U>
         接受两个输入参数，返回一个double类型结果

         38	ToDoubleFunction<T>
         接受一个输入参数，返回一个double类型结果

         39	ToIntBiFunction<T,U>
         接受两个输入参数，返回一个int类型结果。

         40	ToIntFunction<T>
         接受一个输入参数，返回一个int类型结果。

         41	ToLongBiFunction<T,U>
         接受两个输入参数，返回一个long类型结果。

         42	ToLongFunction<T>
         接受一个输入参数，返回一个long类型结果。

         43	UnaryOperator<T>
         接受一个参数为类型T,返回值类型也为T。
         */

        /**
         * Intermediate：
         map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered

         Terminal：
         forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator

         Short-circuiting：
         anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit
         */
        /**
         * 1.interface add static method(only apply in interface,implementing can not be overriden,only use example:"TestInterface.producer()")
         */
        System.out.println(TestInterface.producer());
        System.out.println(TestInterface.USER);
        /**
         * 2.interface add default method(cat be overrided)
         */
        TestInterface tf = new TestImpl();
        System.out.println(tf.getOverview());
        /**
         * 3.lambda
         */
        String[] arr = new String[]{"1","2"};
        Stream<String> stream = Arrays.stream(arr);
        stream.forEach(p -> System.out.println(p));
        Stream<String> stringStream = Stream.of("3", "4");

        /**
         * create infinite stream
         */
        Stream.generate(() -> "1").limit(10).forEach(p -> System.out.println(p));
        Stream.iterate(10, n -> n + 2).limit(10).forEach(p -> System.out.println(p));

        System.out.println("==========================================");
        ArrayList<String> arrayList = Lists.newArrayList("5", "6", "5");
        Stream<String> stream1 = arrayList.stream();
        /**
         * multi thread
         */
        arrayList.parallelStream().forEach(p -> System.out.println(p));
        /**
         * create random number
         */
        IntStream.range(1,3).forEach(p -> System.out.println(p));
        /**
         * count
         */
        System.out.println(arrayList.stream().count());
        /**
         * distinct count
         */
        System.out.println(arrayList.stream().distinct().count());
        /**
         * match only on in stream
         */
        System.out.println(arrayList.stream().anyMatch(p -> p.equals("5")));
        /**
         * match all in stream
         */
        System.out.println(arrayList.stream().allMatch(p -> p.equals("6")));
        /**
         * match no one in stream
         */
        System.out.println(arrayList.stream().noneMatch(p -> p.equals("1")));
        /**
         * validate stream contains element
         */
        Optional<String> first = arrayList.stream().findFirst();
        System.out.println(first.isPresent());
        System.out.println(arrayList.stream().findAny().isPresent());

        /**
         * filter
         */

        List<User> list = Lists.newArrayList();
        list.add(new User(1,"1", 1));
        list.add(new User(2,"2", 1));
        list.add(new User(3,"3", 1));

        /**
         * stream group by
         */
        Map<Integer, List<User>> collect = list.stream().collect(Collectors.groupingBy(User::getType));
        /**
         * stream partition
         * ...  equals filter
         */
        Map<Boolean, List<User>> listMap = list.stream().collect(Collectors.partitioningBy(p -> p.getAge() > 1));
        list.stream().map(p -> p.getAge()).collect(Collectors.toList()).forEach(p -> System.out.println(p));

        List<Integer> collect1 = list.stream().map(User::getAge).collect(Collectors.toList());
        System.out.println();

        /**
         * Map<Employee.Gender, Employee>  highestEarnerByGender = Employee.persons()
         .stream()
         .collect(Collectors.toMap(Employee::getGender, Function.identity(),
         (oldPerson, newPerson)  -> newPerson.getIncome() > oldPerson.getIncome() ? newPerson : oldPerson));
         System.out.println(highestEarnerByGender);
         */
        /**
         * 1.key
         * 2.value
         * 3.same type key, return one
         */
        Map<Integer, User> collect2 = list.stream().collect(Collectors.toMap(p -> p.getType(), Function.identity(), (k1, k2) -> k1));

        list.stream().mapToInt(p -> p.getAge()).forEach(p -> System.out.println(p));

        Double collect3 = list.stream().collect(Collectors.averagingInt(User::getAge));
        System.out.println(collect3);

        Optional<User> collect4 = list.stream().collect(Collectors.minBy(Comparator.comparingInt(User::getAge)));
        System.out.println(collect4.get().getAge());

        String collect5 = list.stream().map(User::getName).collect(Collectors.joining(","));
        System.out.println(collect5);

        System.out.println();

        /**
         * 4.optional
         */
    }

    static class User {
        private Integer age;
        private String name;
        private Integer type;

        public User(Integer age, String name, Integer type) {
            this.age = age;
            this.name = name;
            this.type = type;
        }

        public Integer getAge() {
            return age;
        }

        public void setAge(Integer age) {
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public Integer getType() {
            return type;
        }

        public void setType(Integer type) {
            this.type = type;
        }
    }
}