java8新特性整理

java8主要有9个方面的新特性

  1.方法引用supplier<T>

  2.函数式接口function和Predicate，consumer,supplier

  3.lambda表达式

  4.默认方法

  5.Stream

  6.Optional类

  7.新的日期api

  8.Base64

  9.Nashorn JavaScript引擎

 

一.方法引用Supplier<T>

类型	语法	对应的Lambda表达式
静态方法引用	类名::staticMethod	(args) -> 类名.staticMethod(args)
实例方法引用	inst::instMethod	(args) -> inst.instMethod(args)
对象方法引用	类名::instMethod	(inst,args) -> 类名.instMethod(args)
构建方法引用	类名::new	(args) -> new 类名(args)

import java.util.Arrays;
import java.util.List;
import java.util.function.Supplier;

public class StudentDO {

    private String name;
    private String sex;
    private Integer age;

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

    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }

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

    //构造方法
    public static StudentDO create(Supplier<StudentDO> studentDOSupplier){
        return studentDOSupplier.get();
    }

    //静态方法
    public static void getStuName(StudentDO student){
        System.out.println("name："+student.getName());
    }

    //自定义方法
    public void getSex(StudentDO student){
        System.out.println("age:"+student.getAge());
    }
}

class testSupplier{
    public static void main(String[] args) {
        //引用构造器
        StudentDO studentDO = StudentDO.create(StudentDO::new);

        //引用静态防范
        studentDO.setName("路飞");
        studentDO.setAge(20);
        List<StudentDO> list = Arrays.asList(studentDO);
        list.forEach(StudentDO::getStuName);

        //自定义对象引用
        list.forEach(StudentDO::getSex);
        //引用示例
        list.forEach(System.out::print);
    }
}

二.函数式接口

 函数式接口是指：有且只有一个抽象方法的接口。java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。

 只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

@FunctionalInterface注解  标明此接口为函数式接口

@FunctionalInterface
interface  functionalInterface {
  
    void method();
}

方法实现

public class functionalInterfaceTest {

    public static void doSomthing(functionalInterface functionalInterface){
        functionalInterface.method();
    }

    public static void main(String[] args) {
        //调用函数式接口的方法
        doSomthing(()->System.out.println("excuter lambda!"));
    }
}

lambda的延迟执行，labmda表达式是延迟执行的

@FunctionalInterface
public interface functionalInterfaceTest2 {
    String method();
}

class functionalInterfaceTest2Impl{
   private static void info(int flag,functionalInterfaceTest2 interfaceTest2){
       if (flag == 1){
           System.out.println(interfaceTest2.method());
       }
   }

    public static void main(String[] args) {
        info(1,()->{
            System.out.println("是否执行");
            return "yes";
        });
    }
}

使用Lambda作为参数和返回值

private static Comparator<String> lambdaInfo(){
       return new Comparator<String>(){

           @Override
           public int compare(String o1, String o2) {
               return o1.length() - o2.length();
           }
       };
   }


  public static void main(String[] args) {
 
        String[] array = {"java","php","c"};
        Arrays.sort(array,lambdaInfo());
        System.out.println(Arrays.toString(array));
    }

2.1 Supplier接口

  private static String supplier(Supplier<String> msg){
       return msg.get();
   }


 System.out.println(supplier(()->"生产数据"));

//求数组最大长度
 String result = supplier(()->{
           int len = 0;
           for (int i=0;i<array.length;i++){
               len = Math.max(len,array[i].length());
           }
           return String.valueOf(len);
        });
        System.out.println("result:"+result);

2.2 Consumer接口

Consumer 接口中包含抽象方法 void accept(T t) ，意为消费一个指定泛型的数据 默认方法：andThen

private static void consumerTest(Consumer<String> consumer){
       consumer.accept("已消费");
 }

private static void consumerTest(Consumer<String> consumer,Consumer<String> consumer2){
        consumer.andThen(consumer2).accept("已消费");
 }

 consumerTest(s-> System.out.println(s));
        consumerTest(s-> {
            System.out.println(s);
        },s2->{
            System.out.println(s2);
        });

2.3 Predicate接口

Predicate 接口中包含一个抽象方法： boolean test(T t) 。用于条件判断的场景

    //判断是否存在
    private static void predicateTest(Predicate<String> predicate){
        predicate.test("java");
    }

    //判断是否同时存在
    private static void predicateTest(Predicate<String> predicate,Predicate<String> predicate2){
        predicate.and(predicate2).test("java");
    }
    //判断是否存在其中一方
    private static void predicateTestOr(Predicate<String> predicate,Predicate<String> predicate2){
        predicate.or(predicate2).test("java");
    }

    //判断是不存在
    private static void predicateTestNo(Predicate<String> predicate){
        predicate.negate().test("java");
    }

    private static void getpredictAndArr(Predicate<String> one,
                                         Predicate<String> two, String[] arr) {
        for (String string : arr) {
            if (one.and(two).test(string)) {
                System.out.println(string);
            }
        }
    }
    predicateTest((s)->s.contains("j"));
    predicateTest(s->s.contains("j"), s->s.contains("a"));
    predicateTestOr(s->s.contains("a"), s->s.contains("h"));
    predicateTestNo(s->s.contains("a"));
    getpredictAndArr((x)->x.concat(x).equals("j"),(y)->y.concat(y).equals("a"),array);

2.4 Function接口

接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件

Function 接口中有一个默认的 andThen  compose方法

private static void numberToString(Function<Integer, String> function) {
        String apply = function.apply(12);
        System.out.println("转换结果:"+apply);
}

numberToString((s)->String.valueOf(s));

三.lambda表达式