Java1.8新特性

Java1.8新特性之Lambda表达式
1、语法

语法：-> :lambda操作符（箭头操作符）
->左边：lambda形参列表
->右边：lambda体（重写的抽象方法的方法体）
本质：作为函数式接口的实例

2、语法格式

//语法格式一：无参无返回值
@Test
public void test1(){
    Runnable r1 = new Runnable() {
        @Override
        public void run() {
            System.out.println("lambda无参无返回值");
        }
    };
    r1.run();

    System.out.println("=======================");

    Runnable r2= () -> {System.out.println("lambda无参无返回值");
    };
    r2.run();
}

//语法格式二：有一个参数，但是没有返回值
@Test
public void test2(){
    Consumer<String> s1 = new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    };
    s1.accept("今天是周一");
    System.out.println("=======================");
    Consumer<String> s2=(String s)->{
        System.out.println(s);
    };
    s2.accept("今天是周一");
}

//语法格式三：数据类型可以省略，由编译器(类型推断)推断
@Test
public void test3(){
    Consumer<String> s1 = new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    };
    s1.accept("今天是周一");
    System.out.println("=======================");
    Consumer<String> s2=(s)->{
        System.out.println(s);
    };
    s2.accept("今天是周一");
}

//语法格式四：Lambda若只有一个参数是，小括号可以省略
@Test
public void test4(){
    Consumer<String> s1 = new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    };
    s1.accept("今天是周一");
    System.out.println("=======================");

    Consumer<String> s2=s->{
        System.out.println(s);
    };
    s2.accept("今天是周一");
}

//语法格式五：Lambda需要两个或以上的参数，多条执行语句，并且有返回值
@Test
public void test5(){
    Comparator<Integer> c1=new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        }
    };
    System.out.println(c1.compare(12,21));
    System.out.println("=======================");
    Comparator<Integer> c2=(o1,o2)->{
        System.out.println(o1);
        System.out.println(o2);
        return o1.compareTo(o2);
    };
    System.out.println(c2.compare(21,12));
}

//语法格式六:当Lambda只有一条语句时，return与大括号若有可以省略
@Test
public void test6(){
    Comparator<Integer> c2=(o1,o2)->{
        return o1.compareTo(o2);
    };
    System.out.println(c2.compare(21,12));
    System.out.println("=======================");
    Comparator<Integer> c3=(o1,o2)->o1.compareTo(o2);
    System.out.println(c3.compare(12,21));
}

Java1.8新特性之函数式接口

只包含一个抽象方法的接口，称为函数式接口

可以再一个接口上使用@FunctionalInterface注解，可以检查它是否是一个函数式接口。同时javadoc也会包含一条声明，说明这个接口是一个函数式接口

在java.util.function包下定义了Java8的丰富函数式接口

以前用匿名实现类表示的都可以用lambda表达式

@Test
public void test1(){
    happyTime(500, new Consumer<Double>() {
        @Override
        public void accept(Double aDouble) {
            System.out.println("今天周二"+aDouble);
        }
    });
    System.out.println("===========================");
    happyTime(200,money->System.out.println("今天周二"+money));
}

public void happyTime(double money, Consumer<Double> con){
    con.accept(money);
}

@Test
public void test2(){
    List<String> list = Arrays.asList("梅花","荷花","兰花","菊花");
    List<String> filterStrs= filterString(list, new Predicate<String>() {
        @Override
        public boolean test(String s) {
            return s.contains("花");
        }
    });
    System.out.println(filterStrs);
    System.out.println("===========================");
    List<String> filterStrs1=filterString(list,s->s.contains("花"));
    System.out.println(filterStrs1);
}

//根据给定的规则，过滤集合中的字符串，此规则由Predicate的方法规定
public List<String> filterString(List<String> list, Predicate<String>pre){
    ArrayList<String> filterList = new ArrayList<>();
    for (String s : list) {
        if (pre.test(s)){
            filterList.add(s);
        }
    }
    return list;
}

Java1.8新特性之方法引用

1、使用情景：当要传递给lambda体的操作已经有实现的方法了，可以使用方法引用
2、方法引用本质上就是lambda表达式，
3、使用格式：类（或者对象）:: 方法名
4、分三种情况
对象 ::非静态方法
类::静态方法
类::非静态方法
5、方法引用要求，形参列表和返回值类型相同

代码示例

/**
 *  一：对象::实例方法
 *  Consumer中的void accept（T t）
 */
@Test
public void test1(){
    Consumer<String> con1=str -> System.out.println(str);
    con1.accept("上海");
    System.out.println("=====================");

    PrintStream ps=System.out;
    Consumer<String> con2=ps::println;
    con2.accept("shanghai");
}

/**
 * Supplier中的T get（）
 */
@Test
public void test2(){
    Employee emp=new Employee(1001,"Tom",23,6000);
    Supplier<String> s1=()->emp.getName();
    System.out.println(s1.get());

    System.out.println("=====================");
    Supplier<String> s2=emp::getName;
    System.out.println(s2.get());
}

/**
 * 二、类::静态方法
 * Comparator
 */
@Test
public void test3(){
    Comparator<Integer> c1=(t1,t2)->Integer.compare(t1,t2);
    System.out.println(c1.compare(12,21));

    System.out.println("=====================");

    Comparator<Integer> c2= Integer::compare;
    System.out.println(c2.compare(12,13));
}

/**
 * Function
 *
 */
@Test
public void test4(){
    Function<Double ,Long> f1=d->Math.round(d);
    System.out.println(f1.apply(12.3));

    System.out.println("=====================");
    Function<Double,Long> f2= Math::round;
    System.out.println(f2.apply(11.8));
}

/**
 * 三：类：实例方法
 * Comparator中的
 */
@Test
public void test5(){
    Comparator<String> c1=(s1,s2)->s1.compareTo(s2);
    System.out.println(c1.compare("abc","bcd"));
    System.out.println("=====================");
    Comparator<String> c2=String::compareTo;
    System.out.println(c2.compare("qwe","asd"));
}

/**
 * BiPredicate
 */

@Test
public void test6(){
    BiPredicate<String,String> b1=(s1,s2)->s1.equals(s2);
    System.out.println(b1.test("abc","abc"));

    BiPredicate<String,String> b2=String::equals;
    System.out.println(b2.test("abc","abc"));
}

/**
 * Function
 */
@Test
public void test7(){
    Employee emp=new Employee(1001,"Tom",23,6000);
    Function<Employee,String> f1=e->e.getName();
    System.out.println(f1.apply(emp));

    System.out.println("=====================");

    Function<Employee,String> f2=Employee::getName;
    System.out.println(f2.apply(emp));
}