java8_Lambda

lambda表达式的学习
- 基础语法格式

package com.diedline.java8;

import org.junit.jupiter.api.Test;

import java.util.*;
import java.util.function.Consumer;

/**
 * Lambda 的基础语法 新的操作符 "->"  称为 lambda 操作符
 *                      该操作符将lambda 分为两部分
 * 左侧：Lambda 表达式中的参数列表
 * 右侧：Lambda中所需要的功能
 *
 * 语法格式一： 无参无返回值
 *  () ->System.out,println("123");
 * 语法格式二： 有一个参数，无返回值的方法
 *  (x) -> System.out.println(x);
 * 语法格式三：只有一个参数，小括号可以省略不写
 *  x -> System.out.println(x);
 * 语法格式四：有两个以上的参数，并且lambda体中有多条语句,需要使用大括号和return
 *    Comparator<Integer> con = (x,y) -> {
 *             System.out.println("函数式接口");
 *             return Integer.compare(x,y);
 *         };
 * 语法格式五：若lambda体中只有一条语句,return 和大括号都可以省略不写
 *      Comparator<Integer> con = (x,y) ->  Integer.compare(x,y);
 * 语法格式六：Lambda表达式的参数列表的数据类型可以省略不写，因为jvm的编译期可以通过上下文推断出数据类型
 *      (Integer x,Integer y) ->  Integer.compare(x,y);
 *
 * 左右遇一括号省
 * 左侧推断类型省
 *
 * 二：lambda表达式需要“函数式接口的支持”
 * 函数式接口：接口中只有一个抽象方法时，就是函数式接口可以使用 @FunctionalInterface 修饰
 *              可以检查是否是函数式接口
 * */
public class TestLambda2 {
    @Test
    public void test1(){
        //使用匿名内部类
        int num = 0;
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello,world!" + num);
            }
        };
        r.run();
        System.out.println("----------------");
        //使用lambda 表达式
        Runnable r1 = ()-> System.out.println("Hello,world!");
        r1.run();
    }

    @Test
    public void test2(){
        Consumer<String> con = x -> System.out.println(x);
        con.accept("厉害了");
    }

    @Test
    public void test3(){
        Comparator<Integer> con = (x,y) -> {
            System.out.println("函数式接口");
            return Integer.compare(x,y);
        };
    }
    @Test
    public void test4(){
        Comparator<Integer> con = (x,y) ->  Integer.compare(x,y);
    }

    @Test
    public void test5(){
        Comparator<Integer> con = (Integer x,Integer y) ->  Integer.compare(x,y);
    }

    //类型推断
    public void test6(){
//        String[] strs;
//        strs  = {"aaa","bbb","ccc"};
        List<String> list = new ArrayList<>();
        show(new HashMap<>());
    }

    public void show(Map<String,Integer> map){
    }

    //需求：对一个数进行运算
    @Test
    public void test7(){
        Integer num = operation(100,(x) -> x * x);
        System.out.println(num);
        System.out.println(operation(200,(y) -> y + 200));
    }

    public Integer operation(Integer num, MyFun mf){
        return mf.getValue(num);
    }
}

函数式接口MyFun

package com.diedline.java8;

@FunctionalInterface
public interface MyFun {
    public Integer getValue(Integer num);
}

#####Lambda练习

1.调用collections.sort方法,通过定制排序比较两个employee(先按照年龄比较，年龄相同按照姓名比较)，使用Lambda作为参数传递。

package com.diedline.exer;

import com.diedline.java8.Employee;
import org.junit.jupiter.api.Test;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class TestLambda {
    List<Employee> employees = Arrays.asList(
            new Employee("张三",18,9999.99),
            new Employee("李四",38,2323.99),
            new Employee("王五",78,4349.99),
            new Employee("赵六",8,23539.99),
            new Employee("田气",16,91233.99)
    );

    @Test
    public void test1(){
        Collections.sort(employees,(e1,e2) ->{
            if(e1.getAge() == e2.getAge()){
                return e1.getName().compareTo(e2.getName());
            } else {
               return Integer.compare(e1.getAge(),e2.getAge());     //如果使用减号可以倒过来排序
            }
        });
        for (Employee e:employees
             ) {
            System.out.println(e);
        }
    }

}

1.声明函数式接口，接口中声明抽象方法,public String getValue(String str);
2.声明类TestLambda,类中编写方法使用接口作为参数，将第一个字符转换成大写，并作为方法的返回值
3.在将一个字符串的第二个和第四个索引位置进行截取子串

接口

package com.diedline.exer;

@FunctionalInterface
public interface MyFunction {
    public String getValue(String a);
}

实现

//需求：用于处理字符串的方法
   public String strHandler(String str,MyFunction myFunction){
       return myFunction.getValue(str);
   }

   @Test
   public void test2(){
       String str = strHandler("\t\t\t 威武23333  ", String::trim);
       System.out.println(str);

       String upper = strHandler("abcdf",(a) -> a.toUpperCase());
       System.out.println(upper);

       String newStr = strHandler("\t 威武23333  ",(a) -> a.substring(2,4));
       System.out.println(newStr);
   }

1.声明一个带两个泛型的函数式接口，泛型类型为<T,R> T为参数，R为返回值
2.接口中声明对应的抽象方法
3.在TestLambda中声明方法，使用接口作为参数，计算两个long型参数的和。
4.再计算两个long型参数的乘积

接口

package com.diedline.exer;

@FunctionalInterface
public interface MyInterface<T,R> {
    public  R getValue(T t1,T t2);
}

实现

//处理long字符串
   public Long longCheck(long a,long b,MyInterface<Long,Long> myInterface){
       return myInterface.getValue(a,b);
   }
   @Test
   public void test3(){
       Long l = longCheck(23, 100, (a, b) -> a + b);
       System.out.println(l);

       Long l2 = longCheck(23,100,(a,b) -> a * b);
       System.out.println(l2);
   }

#####大多数情况下其实都不用自己写接口，因为这样太麻烦了，所以可以使用java8中内置的四大核心函数式接口

package com.diedline.java8;

import org.junit.jupiter.api.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * java8 中内置的四大核心函数式接口
 * Consumer<T> 消费型接口
 *      void accept(T t);
 *
 * Supplier<T> 供给型接口
 *      T get();
 *
 * Function<T,R> 函数型接口
 *      R apply(T)  
 *
 * Predicate<T> 断言型接口
 *      boolean test(T t);
 */
public class TestLambda3 {
    //Consumer<T> 消费型接口
    @Test
    public void test1(){
        happy(10000,(m) -> System.out.println("出去保健消费"+m+"元"));
    }
    public void happy(double money, Consumer<Double> con  ){
        con.accept(money);
    }

    //Supplier<T> 供给型接口
    @Test
    public void test2(){
        //使用math的random 方法 每次产生十个随机数
        List<Integer> list = getNum(10,()-> (int) (Math.random() * 100));
        for (Integer a:list
             ) {
            System.out.println(a);
        }
    }
    //需求：产生指定个数的整数，并放入集合中
    public List<Integer> getNum(int num, Supplier<Integer> supplier){
        List<Integer> list = new ArrayList<>();     //创建集合
        for (int i = 0; i < num;i++){
            Integer a = supplier.get();
            list.add(a);
        }
        return list;
    }

    //Function<T,R> 函数型接口
    @Test
    public void test3(){
        //小写转大写
        String a = strOpr("abcde", String::toUpperCase);
        System.out.println(a);
        //去除空格
        String b = strOpr("\t\t我的方法 ",String::trim);
        System.out.println(b);
    }

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



    //Predicate<T> 断言型接口

    //需求:将满足条件的字符串放入到集合中
    @Test
    public void test4(){
        List<String> list= Arrays.asList("hello","123","Lambda","www","OK");
        //过滤获取字符长度大于3的字符串
        List<String> strList = getList(list,(a) -> a.length()>3);
        for (String a:strList
             ) {
            System.out.println(a);
        }
    }
    public  List<String> getList(List<String> list, Predicate<String> predicate){
        List<String> strlist = new ArrayList<>();
        for (String a:list
             ) {
            if(predicate.test(a)){
                strlist.add(a);
            }
        }
        return strlist;
    }

}

#####其他接口

BiFunction<T,U,R> 参数T，U返回R

UnaryOperator 是Function子接口参数T 返回T

BinaryOperator 参数类型T，T 返回类型T

BiComsumer<T,U> 参数类型T，U 返回类型void

ToIntFuntion 参数类型 T 返回int

ToLongFunction 参数类型T 返回long

ToDoubleFunction 参数类型T 返回double

IntFunction 参数类型 int 返回R

LongFunction 参数类型 long 返回R

DoubleFunction 参数类型 Double 返回R

Died line