java lambda表达式

java lambda表达式

• 1. lambda表达式写法 ： (o1,o2) -> Integer.compare(o1, o2);

• 2.格式： ->:lambda操作符，箭头操作符

  • ​ ->左边： lambda形参列表（其实就是接口中的抽象方法的形参列表）
  • ->右边： lambda体（其实就是重写的抽象方法的方法体）

• 3.语法使用：（分6种情况）

• 总结：

  • ->左边 ：lanmbda形参列表的参数类型可以省略（类型推断）：若果只有一个参数，（）也可以省略
  • ->右边： lambda体应该用{}包括，若体只有一句执行语句，则{}可省略和return

• 4.lambda本质：在java中，作为函数式接口的实例

• 5.若果一个接口只声明一个抽象方法，则此接口称为函数式接口。

  语法格式1：无参，无返回

//语法格式1：无参，无返回
@Test
public void test1() {
    Runnable r1=new Runnable() {

        @Override
        public void run() {
            System.out.println("我爱北京！");
        }
    };
    r1.run();
    System.out.println("---------------");

    Runnable r2=()-> {
        System.out.println("我也爱北京");
    };
    r2.run();
}

//语法格式2： lambda需要一个参数，但是没有返回值。
@Test
public void test3() {
    Consumer<String> con=new Consumer<String>() {
        @Override
        public void accept(String t) {
            System.out.println(t);
        }
    };
    con.accept("谎言和实验");
    System.out.println("--------------");
    Consumer<String> con1=(String s) -> {
        System.out.println(s);
    } ;
    con1.accept("lambda需要一个参数，但是没有返回值。");

}
	

//语法格式3：数据类型可以省略，因为编译器可以推断出，称为“类型推断”

//语法格式3：数据类型可以省略，因为编译器可以推断出，称为“类型推断”
@Test
public void test4() {
    System.out.println("--------------");
    Consumer<String> con4=( s) -> {
        System.out.println(s);
    } ;
    con4.accept("数据类型可以省略");

    ArrayList<String> list=new ArrayList<>();//类型推断
    int[] arr= {1,2,3};
}

语法格式四：lambda若只需要一个参数，参数的小括号可以省略

//语法格式四：lambda若只需要一个参数，参数的小括号可以省略
@Test
public void Test5() {
    System.out.println("--------------");
    Consumer<String> con1=(s) -> {
        System.out.println(s);
    } ;
    con1.accept("lambda若只需要一个参数，参数的小括号可以省略");
    System.out.println("-");
    Consumer<String> con2= s -> {
        System.out.println(s);
    } ;
    con2.accept("lambda若只需要一个参数，参数的小括号可以省略");
}

语法格式5：需要两个以上参数，多条执行语句，并且可以有返回值。

//语法格式5：需要两个以上参数，多条执行语句，并且可以有返回值。
	
@Test
public void test2() {
    Comparator<Integer> com1=new Comparator<Integer>() {

        @Override
        public int compare(Integer o1, Integer o2) {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        }
    };
    int compare1=com1.compare(12, 21);
    System.out.println(compare1);

    System.out.println("*-------------------------");

    Comparator<Integer> com2=(o1,o2) -> Integer.compare(o1, o2);//lambda表达式写法
    int compare2=com2.compare(32, 21);
    System.out.println(compare2);

    System.out.println("*-------------------------");
    Comparator<Integer> com3=Integer::compare;  //方法引用
    int compare3=com3.compare(32, 21);
    System.out.println(compare3);

}

语法格式6：当lambda只有一条语句时，return与大括号若有，都可省略

//语法格式6：当lambda只有一条语句时，return与大括号若有，都可省略
@Test
public void Test7() {
    Comparator<Integer> com1=(o1,o2) ->{
        return o1.compareTo(o2);
    };
    System.out.println(com1.compare(12, 6));
    System.out.println("-----*-*-*-----------");
    Comparator<Integer> com2=(o1,o2) -> o1.compareTo(o2);   //省略

    System.out.println(com2.compare(12, 6));
}

java内置4大核心函数式接口

• 消费型接口 Consumer void accept(T t)
• 供给型接口 Supplier T get()
• 函数型接口 Function<T`,R> R apply(T t)
• 断定型接口 Predicate boolean test(T t)

1.消费型接口，有形参，无返回值

@Test
public void test1() {
    happyTime(500, new Consumer<Double>() {

        @Override
        public void accept(Double t) {
            System.out.println("学习太累，去天上人间买水，价格："+t);
        }
    });
    System.out.println("************************");

    happyTime(400, money -> System.out.println("玩太累，再去lambda天上人间买可乐，价格："+money));
}
public void happyTime(double money,Consumer<Double> con) {
    con.accept(money);
}

2.断定型接口 Predicate boolean test(T t)

@Test
public void test2() {
    List<String> list=Arrays.asList("北京","南京","天津","东京","西京","普京");
    List<String> filterStrs=filterString(list, new Predicate<String>() {
        @Override
        public boolean test(String t) {
            return t.contains("京");
        }
    });
    System.out.println(filterStrs);
    System.out.println("************************");
    List<String> filterStrs1=filterString(list,s -> s.contains("京"));  //lambda表达式
    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 filterList;
}