java 8 大致归纳

 

java8的总体思想就是局部逻辑功能包，这个功能包可以直接使用或者代表一个有此功能包的对象，1可以简化书写，2重用性，组合性灵活性高

 

 lamd表达式和::都是返回一个方法过程对象，不是运算结果，类似回调的思想

可重复注解（一个类用多个类似注解组合）

 

 

1，lambda表达式定义的是一个接口（根据上下文可知）中的一个函数具体逻辑，整个表达式当接口的对象用（new），这是lambda方式之一

第二种用于功能打包的工具（Predicate，Functions，Suppliers，Consumers），工具中不再是事先像常规接口定义好的一个形式的方法，这种工具中的接口方法可以是任意形式，具体根据是定义工具时的lambda表达式定

 

 

List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");  

   

Collections.sort(names, new Comparator<String>() {  

    @Override  

    public int compare(String a, String b) {  

        return b.compareTo(a);  

    }  

});  

 

 

Collections.sort(names, (String a, String b) -> {  

    return b.compareTo(a);  

});  

 

 

 

@FunctionalInterface  

interface Converter<F, T> {  

    T convert(F from);  

}  

   

Converter<String, Integer> converter = (from) -> Integer.valueOf(from);  

Integer converted = converter.convert("123");  

System.out.println(converted);    // 123  

 

注意，如果你不写@FunctionalInterface 标注，程序也是正确的。

 

 

2，用::引用内部构造方法或返回者内部方法的引用（不是结果）（引用是传递的是这个函数逻辑用的是这个函数，调用是调用这个方法直接用结果）

引用构造方法的时候根据后面这个对象调用方法是传递的参数形式同时决定调用什么形式的构造方法

 

 

class Something {  

    String startsWith(String s) {  

        return String.valueOf(s.charAt(0));  

    }  

}  

   

Something something = new Something();  

Converter<String, String> converter = something::startsWith;  

String converted = converter.convert("Java");  

System.out.println(converted);    // "J"  

 

 

 

 

PersonFactory<Person> personFactory = Person::new;  

Person person = personFactory.create("Peter", "Parker");  ----引用构造方法的时候根据后面这个对象调用方法是传递的参数形式同时决定调用什么形式的构造方法

 

 

 

3，lambda表达式可以访问外部的局部变量，不管是否final都会编译的时候当做final处理，但是不可以改变局部变量的值，但是

对于类级别的成员变量可以改变值，lambda不可以访问默认接口方法 ，方式的任何实例是可以的

 

 

 

4，Predicate 可自定义判断逻辑的判断工具类，程序中直接用其判断

and表示系列条件组合，test表示直接返回这个条件返回的结果

 

int[] numbers= {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};

        List<Integer> list=new ArrayList<>();

        for(int i:numbers) {

            list.add(i);

        }

        Predicate<Integer> p1=i->i>5;

        Predicate<Integer> p2=i->i<20;

        Predicate<Integer> p3=i->i%2==0;

        List test=list.stream().filter(p1.and(p2).and(p3)).collect(Collectors.toList());

        System.out.println(test.toString());

 

 

 

5， Functions  可自定义的逻辑的工具类

下面定义了逻辑1，Integer::valueOf 逻辑2，String::valueOf，后面apply的是时候就依次执行这个逻辑组合

 

Function<String, Integer> toInteger = Integer::valueOf;  

Function<String, String> backToString = toInteger.andThen(String::valueOf);  

   

backToString.apply("123");     // "123"  

 

 

 

6，Suppliers 返回给定类型的结果，一般用于返回对象

 

Supplier<Person> personSupplier = Person::new;  ---由后面的get()知，就是无参数的构造方方法的引用，由get触发

personSupplier.get();   // new Person  

 

7，Consumers 类似Functions也是打包一个功能，只是这个功能是有参数的，由accept触发

Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);  

greeter.accept(new Person("Luke", "Skywalker"));  

 

 

 

8，Comparators  这个工具类就相对于固定，即你传入的lambda只能是2个参数的

Comparator<Person> comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);  

   

Person p1 = new Person("John", "Doe");  

Person p2 = new Person("Alice", "Wonderland");  

   

comparator.compare(p1, p2);             // > 0  

comparator.reversed().compare(p1, p2);  // < 0  

 

 

 

9，Optionals 为了防止空指针，把结果给Optional对象，这个Optional始终不会是空，真正的数据放在get()中，ifPresent的时候直接用get()获取的值操作

 

 

Optional<String> optional = Optional.of("bam");  

   

optional.isPresent();           // true  

optional.get();                 // "bam"  

optional.orElse("fallback");    // "bam"  

   

optional.ifPresent((s) -> System.out.println(s.charAt(0)));     // "b"  

 

 

 

 

10，可重复注解（注解数组，列表）

 

@interface Hints {  

    Hint[] value();  

}  

   

   @Repeatable，Java 8 允许我们对同一类型使用多重注解：

@Repeatable(Hints.class)  

@interface Hint {  

    String value();  

}  

 

 

变体1：使用注解容器（老方法）： 

 

Java代码 

@Hints({@Hint("hint1"), @Hint("hint2")})  

class Person {}  

 

变体2：使用可重复注解（新方法）： 

 

Java代码 

@Hint("hint1")  

@Hint("hint2")  

class Person {}  

 

 

java编译器能够在内部自动对@Hint进行设置。这对于通过反射来读取注解信息来说，是非常重要的。 在实际中子注解会关联上父注解的信息

 

 

 

 

 

Hint hint = Person.class.getAnnotation(Hint.class);  

System.out.println(hint);                   // null  

   

Hints hints1 = Person.class.getAnnotation(Hints.class);  

System.out.println(hints1.value().length);  // 2  

   

Hint[] hints2 = Person.class.getAnnotationsByType(Hint.class);  

System.out.println(hints2.length);          // 2  

 

尽管我们绝对不会在Person类上声明@Hints注解，但是它的信息仍然可以通过getAnnotation(Hints.class)来读取。

并且，getAnnotationsByType方法会更方便，因为它赋予了所有@Hints注解标注的方法直接的访问权限。 

 

参考：

https://www.iteye.com/magazines/129-Java-8-Tutorial