Java学习_20220621

Java 8 新特性

1. Lambda 表达式

特殊的匿名内部类，允许把函数作为一个方法的参数（函数作为方法参数传递），将代码像数据一样传递。

基本语法：

<函数式接口><变量名>=(参数1，参数2，.....) -> {

        //方法体

};

• 形参列表的数据类型会自动推断；
• 形参列表若为空，只需保留（）；
• 形参只有1个，（）可以省略，只需要写参数的名称即可；
• 执行语句只有一句，且无返回值，{}可以省略，若有返回值，则若想省去{}，则必须同时省略return，且执行语句保证只有一句；
• Lambda表达式不会单独生成内部类文件。

//匿名内部类
Runnable runnable = new Runnable() {
        @Override
        public void run() {
            System.out.println("线程执行了-----");
        }
    };
    new Thread(runnable).start(); //线程执行了-----
}
Runnable runnable2 = () -> System.out.println("线程2执行了-----");
new Thread(runnable2).start();//线程2执行了-----
new Thread(() -> System.out.println("线程3执行了-----")).start();//线程3执行了-----

//匿名内部类
        Comparator<String> comparator = new Comparator<String>() {
            @Override
            public int compare(String o, String t1) {
                return o.length()-t1.length();
            }
        };
        TreeSet<String> treeSet = new TreeSet<>(comparator);
        //Lambda表达式
        Comparator<String> comparator2 = (String o, String t1) -> {
            return o.length()-t1.length();
        };
        TreeSet<String> treeSet2 = new TreeSet<>(comparator2);
        Comparator<String> comparator3 = (String o, String t1) -> o.length()-t1.length();
        TreeSet<String> treeSet3 = new TreeSet<>(comparator3);

2. 函数式接口

如果一个接口只有一个抽象方法，则该接口称为函数式接口，函数式接口可以使用Lambda表达式，Lambda表达式会被匹配到这个抽象方法上。

（@FunctionalInterface注解会检测接口是否符合函数式接口。 ）

public static void main(String[] args) {
    //使用匿名内部类
    Usb usb = new Usb() {
        @Override
        public void service() {
            System.out.println("USB接口开始工作了====");
        }
    };
    run(usb);
    //Lambda表达式
    Usb mouse = () -> System.out.println("鼠标开始工作了=====");
    run(mouse);
}
private static void run(Usb usb) {
    usb.service();
}

 常见函数式接口

（1）Consumer<T>消费型接口  参数类型：T，返回类型：void，void accept(T t)；

public static void main(String[] args) {
    //匿名内部类
    Consumer<Double> con = new Consumer<Double>() {
        @Override
        public void accept(Double t) {
            System.out.println("聚餐消费"+t);
        }
    };
    happy(con,1000.0);   //聚餐消费1000.0
    //Lambda表达式
    Consumer<Double> con2 = t->System.out.println("总共聚餐消费"+t);
    happy(con2,2340.0);   //总共聚餐消费2340.0
    happy(t->System.out.println("本周总消费为："+t),6740.0); //本周总消费为：6740.0
}
//Consumer
public static void happy(Consumer<Double> consumer,Double money){
    consumer.accept(money);
}

（2）Supplier<T>供给型接口 参数类型：无，返回类型：T，T get();

public static void main(String[] args) {
    //匿名内部类
    Supplier<Integer> supplier = new Supplier() {
        @Override
        public Integer get() {
            int r = new Random().nextInt(100);
            return r;
        }
    };
    int[] arr = getNums(supplier,5);
    System.out.println(Arrays.toString(arr));   //[97, 48, 16, 34, 57]
    //Lambda
    int[] arra = getNums(()->new Random().nextInt(50),7);
    System.out.println(Arrays.toString(arra));  //[23, 6, 0, 31, 42, 33, 46] 
}
//Supplier
public static  int[] getNums(Supplier<Integer> supplier,int count){
    int[] arr = new int[count];
    for(int i = 0 ; i<count;i++){
        arr[i] = supplier.get();
    }
    return arr;
}

（3）Function<T,R>函数型接口 参数类型：T，返回类型：R，R apply(T t);

public static void main(String[] args) {
    //匿名内部类
    Function<String,String> function = new Function<String, String>() {
        @Override
        public String apply(String s) {
            return s.toUpperCase();
        }
    };
    System.out.println(handlerString(function,"abcdefg"));//  ABCDEFG
    //Lambda表达式toUpperCase
    String st = handlerString(s ->  s.trim(),"    qwertyuiop   ");
    System.out.println(st);  //qwertyuiop
}
//Function函数型接口
public  static String handlerString(Function<String,String> function,String str){
    return  function.apply(str);
}

 

（4）Predicate<T>断言型接口 参数类型：T，返回类型：boolean，boolean test(T t);

public static void main(String[] args) {
    List<String> names = new ArrayList<>();
    names.add("zhangsan");
    names.add("zhanghanyu");
    names.add("lisilso");
    names.add("王小五");
    List<String> results = filterNames(s->s.startsWith("zhang"),names);
    System.out.println(results.toString()); //[zhangsan, zhanghanyu]
    List<String> resultlength = filterNames(s->s.length()>5,names);
    System.out.println(resultlength.toString()); //[zhangsan, zhanghanyu, lisilso]
}
//Predicate 断言型接口
public static List<String> filterNames (Predicate<String> predicate , List<String> list){
    List<String> resultList = new ArrayList<>();
    for(String string : list){
        if(predicate.test(string)){
            resultList.add(string);
        }
    }
    return resultList;
}