java8：新特性及Lamber表达式语法及四大函数接口

java8：新特性及Lamber表达式

如果左侧只有一个参数可以省略括号，如果右侧只有一个表达式可以省略括号

如果左侧有一个参数也可以添加括号，可以不写参数类型，有类型推断

 

如果右侧有返回值，一个表达式：则可以不加括号，不加ruturn关键字

如果右侧有返回值，一个表达式：可以加括号，但是加了括号必须加return关键字。

如果右侧有多行语句必须有大括号，有返回值的需要添加reuturn关键字

1 语法：

    lambda 表达式的语法格式如下：

    (parameters) -> expression或(parameters) ->{statements; }

          可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。

·        可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。

·        可选的大括号：如果主体包含了一个语句，就不需要使用大括号。

·        可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。
 

/*
     * 一、Lambda 表达式的基础语法：Java8中引入了一个新的操作符 "->" 该操作符称为箭头操作符或 Lambda 操作符
     * 						    箭头操作符将 Lambda 表达式拆分成两部分：
     *
     * 左侧：Lambda 表达式的参数列表
     * 右侧：Lambda 表达式中所需执行的功能， 即 Lambda 体
     *
     * 语法格式一：无参数，无返回值
     * 		() -> System.out.println("Hello Lambda!");
     *
     * 语法格式二：有一个参数，并且无返回值
     * 		(x) -> System.out.println(x)
     *
     * 语法格式三：若只有一个参数，小括号可以省略不写
     * 		x -> System.out.println(x)
     *
     * 语法格式四：有两个以上的参数，有返回值，并且 Lambda 体中有多条语句
     *		Comparator<Integer> com = (x, y) -> {
     *			System.out.println("函数式接口");
     *			return Integer.compare(x, y);
     *		};
     *
     * 语法格式五：若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写
     * 		Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
     *
     * 语法格式六：Lambda 表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即“类型推断”
     * 		(Integer x, Integer y) -> Integer.compare(x, y);
     *
     * 上联：左右遇一括号省
     * 下联：左侧推断类型省
     * 横批：能省则省
     *
     * 二、Lambda 表达式需要“函数式接口”的支持
     * 函数式接口：接口中只有一个抽象方法的接口，称为函数式接口。 可以使用注解 @FunctionalInterface 修饰
     * 			 可以检查是否是函数式接口
     */

 

 

二、 Java8 内置的四大函数式接口
  
 1  Consumer<T> : 消费型接口
         void accept(T t);
 
 2  Supplier<T> : 供给型接口
         T get(); 
 
 3  Function<T, R> : 函数型接口
        R apply(T t);

 4   Predicate<T> : 断言型接口
         boolean test(T t);

 

 /**
     * 消费性Consumer
     */
    @Test
    public void testConsumer() {
        happy(1000L,(x) -> System.out.println("消费"+x));
    }


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

    /**
     * 测试供给型接口
     */
    @Test
    public void testSupplier() {

        List<Integer> list = getNum(5, () -> (int) (Math.random() * 100));
        list.stream().forEach(System.out::println);
    }

    //产生指定个数的整数，并放入集合中
    public List<Integer> getNum(int num, Supplier<Integer> supplier) {
        List<Integer> list = new ArrayList<>();
        for(int i =0;i<num;i++) {
            Integer integer = supplier.get();
            list.add(integer);

        }
        return list;
    }

    @Test
    public void testFunction() {
        String s = strHandler(" aaaabbb ", (x) -> x.trim());
        System.out.println(s);
    }

    //需求：用于处理字符串
    public String strHandler(String str, Function<String,String> function) {
        String apply = function.apply(str);
        return apply;
    }


    //Predicate<T> 断言型接口：
    @Test
    public void testPredicate(){
        List<String> list = Arrays.asList("Hello", "atguigu", "Lambda", "www", "ok");
        List<String> strList = filterStr(list, (s) -> s.length() > 3);

        for (String str : strList) {
            System.out.println(str);
        }
    }
    
//    Function<T, R> : 函数型接口
//    需求：将满足条件的字符串，放入集合中

    public List<String> filterStr(List<String> list, Predicate<String> predicate){
        List<String> strList = new ArrayList<>();

        for (String str : list) {
            if(predicate.test(str)){
                strList.add(str);
            }
        }

        return strList;

    }