java8 --新特性汇总

1. 接口中有默认的实现方法

interface Formula{
    double calculate(int num);

    default double sqrt(int n){ // 实现类自动获得default标记的方法
        return Math.sqrt(n);
    }
}

public class Java8 {
    public static void main(String[] args) {
        Formula formula = new Formula(){
            @Override
            public double calculate(int n) {
                return sqrt(n * 100);
            }
        };
        System.out.println(formula.calculate(4));//4*10开平方 = 20.0
        System.out.println(formula.sqrt(900)); // 900开平方 = 30.0
    }
}

 2.lambda 表达式-排序

    public static void main(String[] args) {
        List<String> fruits = Arrays.asList("apple", "banana", "corn", "pear", "mango", "orange");
        //1.传统排序
        Collections.sort(fruits, new Comparator<String>() {
            @Override
            public int compare(String a, String b) {
                return b.compareTo(a); //后面b在前面a就是逆序
            }
        });
        System.out.println(fruits); //[pear, orange, mango, corn, banana, apple] 后面的排在前面

       //2. lambda 排序
        Collections.sort(fruits, (String a, String b) ->{return a.compareTo(b);});
        System.out.println(fruits); //顺序[apple, banana, corn, mango, orange, pear]

        Collections.sort(fruits,(String a, String b) -> b.compareTo(a));
        System.out.println(fruits); // 逆序[pear, orange, mango, corn, banana, apple]
    }    

 3. 函数式接口@FunctionalInterface： 接口中只能有一个抽象方法！可以有多个默认方法！

@FunctionalInterface
public interface Converter<F, T> {
    T convert(F from);
}
//(from) ->Integer.valueOf(from)？？？
public static void main(String[] args) {
    Converter<String, Integer> converter = (from) ->Integer.valueOf(from);
    Integer converted = converter.convert("1234");
    System.out.println(converted);//1234
}

4. 方法与构造方法的引用  ::

//4.1
@FunctionalInterface
public interface Converter<F, T> {
    T convert(F from);
}
//  Integer::valueOf???
public class Java8 {
    public static void main(String[] args) {
        Converter<String, Integer> converter = Integer::valueOf;
        Integer converted = converter.convert("123");
        System.out.println(converted); //123
    }
}

//4.2
public class Person {
    String firstName;
    String lastName;
    
    Person(){}
    Person(String firstName, String lastName){
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

public interface PersonFactory<P extends Person> { // P 是泛型
    P create(String firstName, String lastName);
}

public class Java8 {
    public static void main(String[] args) {
        PersonFactory<Person> personFactory = Person::new; 
        Person coco = personFactory.create("coco","可可");
        System.out.println(coco.firstName + ":" + coco.lastName); // coco:可可
    }
}

 5. Lambda作用域

@FunctionalInterface
public interface Converter<F, T> {
    T convert(F from);
}
// lambda对本地变量只有读操作， 对静态变量和对象属性有读写操作
public class Java8 {

    public static void main(String[] args) {
        int num = 1; // 加final也可以
        Converter<Integer, String> stringConverter = (from) -> String.valueOf(from + num);
        String result = stringConverter.convert(301);
        System.out.println(result); //31
       // num = 8; //被lambda表达式用过就具有final属性，不能更改它的value ：如下则报错
       // System.out.println(num); //Error:(13, 86) java: 从lambda 表达式引用的本地变量必须是最终变量或实际上的最终变量
    }
}

 6.Optinal接口 防止NullPointerException异常的辅助类型，推荐不返回null而是返回Optional

public class Java8 {

    public static void main(String[] args) {
        Optional<String> optional = Optional.of("bam"); // Optional<String> optional = new Optional<String>(value);
        System.out.println(optional.isPresent()); // true   return value != null;
        System.out.println(optional.get()); // bam  value !=null ? value : throw new NoSuchElementException("No value present");
        System.out.println(optional.orElse("fallback")); //bam  value != null ? value : other
        optional.ifPresent((str) -> System.out.println(str.charAt(0))); //b if (value != null) consumer.accept(value);
    }
}

 7. Stream 接口

java.util.Stream 表示能应用在一组元素上一次执行的操作序列。Stream 操作分为中间操作或者最终操作两种，最终操作返回一特定类型的计算结果，而中间操作返回Stream本身，这样你就可以将多个操作依次串起来。Stream 的创建需要指定一个数据源，比如 java.util.Collection的子类，List或者Set， Map不支持。Stream的操作可以串行执行或者并行执行。

public class Java8 {

    public static void main(String[] args) {

        List<String> stringCollection = new ArrayList<>();
        stringCollection.add("aaa1");
        stringCollection.add("bbb1");
        stringCollection.add("ccc1");
        stringCollection.add("ddd1");
        stringCollection.add("aaa2");
        stringCollection.add("bbb2");
        stringCollection.add("ccc2");
        stringCollection.add("ddd2");

        stringCollection.stream().filter((str) ->str.startsWith("a")).forEach(System.out::println);  // aaa1 aaa2
        stringCollection.forEach(System.out :: println); //遍历数组方式1
        stringCollection.stream().forEach(System.out :: println); //遍历数组方式2
       
        //map 映射 map会将元素根据指定的Function接口来依次将元素转成另外的对象
        stringCollection.stream()
                .map(String :: toUpperCase)
                .sorted((a, b) ->b.compareTo(a))
                .forEach(System.out::println); //先大写后逆序排序， 原集合内容顺序不变
      
        //match 匹配
        boolean anyStartWithA = stringCollection.stream().anyMatch((s) ->s.startsWith("a"));
        System.out.println(anyStartWithA); // true, 只要有一个匹配即为真

        boolean allStartWithA = stringCollection.stream().allMatch((str) -> str.startsWith("a"));
        System.out.println(allStartWithA); // false
        
        boolean noneStartWithZ = stringCollection.stream().noneMatch((s) ->s.startsWith("z"));
        System.out.println(noneStartWithZ); // true;　
    }
}

 8. count计数， reduce规约， 并行stream

        //计数
        long startWithB = stringCollection.stream().filter((s) ->s.startsWith("b")).count();
        System.out.println(startWithB);

        //reduce规约 最终操作，多个元素规约成一个元素通过Optional接口
        Optional<String> reduced = stringCollection.stream().sorted().reduce((s1, s2) -> s1 + "#" + s2);
        reduced.ifPresent(System.out::println); // 元素通过# 分隔开

        // 并行 Stream
        int max = 1000000;
        List<String> values = new ArrayList<>(max);
        for(int i =0; i < max ; i++) {
            UUID uuid = UUID.randomUUID();
            values.add(uuid.toString());
        }

        long t1 = System.nanoTime(); System.out.println(t1); //98447121117166
        long count = values.stream().sorted().count(); //一百万个数排序
        System.out.println(count);
        long t2 = System.nanoTime();
        long mills = TimeUnit.NANOSECONDS.toMillis(t2 - t1);
        System.out.println(mills); //905

        long t3 = System.nanoTime(); System.out.println(t3);
        long count1 = values.parallelStream().sorted().count();
        System.out.println(count1);
        long t4 = System.nanoTime();
        long mills_diff = TimeUnit.NANOSECONDS.toMillis(t4 - t3);
        System.out.println(mills_diff); // 546