Lambda表达式

Lambda表达式

1.Lambda初体验

public static void main(String[] args) {
        //初识Lambda表达式
//        Integer[] arr = {2, 3, 1, 5, 6, 7, 8, 4, 9};
//        Arrays.sort(arr, new Comparator<Integer>() {
//
//            @Override
//            public int compare(Integer o1, Integer o2) {
//                return o1 - o2;
//            }
//        });
//        System.out.println(Arrays.toString(arr));
    	
    //相同的效果  可以转换为下边的代码（还可以更简洁 见5

        Integer[] arr = {2, 3, 1, 5, 6, 7, 8, 4, 9};
        Arrays.sort(arr, (Integer o1, Integer o2) ->{
                return o1 - o2;
            }
        );
        System.out.println(Arrays.toString(arr));
    }

2.函数式编程

• 函数式编程是一种思想特点
• 面向对象：先找对象，再让对象做事情
• 函数式编程,忽略面向对象的复杂语法，强调做什么，而不是谁去做

3.Lambda表达式的标准格式

• Lambda表达式可以用来简化匿名内部类的书写

• Lambda表达式只能简化函数式接口的匿名内部类的写法

• 函数式接口:

  ​ 有且仅有一个抽象方法的接口叫做函数式接口，接口上方可以加@FunctionalInterface注解

public class LambdaDemo1 {
    public static void main(String[] args) {
     /*   
        method(new Swim() {
            @Override
            public void swimming() {
                System.out.println("正在swimming");
            }
        });
    }
    */
        // 可以转换为下边的形式
        method(
                () -> System.out.println("正在swimming")
        );
    

    public static void method(Swim s) {
        s.swimming();
    }
}

@FunctionalInterface
interface Swim {
    public abstract void swimming();
}

4.总结

5.Lambda的省略写法

省略核心：可推导，可省略

lambda的省略规则:

1. 参数类型可以省略不写。
2. 如果只有一个参数，参数类型可以省略，同时()也可以省略。
3. 如果Lambda表达式的方法体只有一行，大括号，分号，return可以省略不写，需要同时省略。

package com.grg.day12.test;

import java.util.Arrays;
import java.util.Comparator;

/**
 * @Author Grg
 * @Date 2023/11/13 16:24
 * @PackageName:com.grg.day12.test
 * @ClassName: LambdaDemo1
 * @Description: 又是码代码的一天
 * @Version plus max 宇宙无敌终极版本
 */
public class LambdaDemo1 {
    public static void main(String[] args) {
        
        Integer[] arr = {2, 3, 1, 5, 6, 7, 8, 4, 9};
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
        
        //Lambda完整格式
        Arrays.sort(arr,(Integer o1, Integer o2) ->{
            return o1 - o2;
        });
        
        //Lambdas省略格式
        Arrays.sort(arr,( o1,  o2) -> o1 - o2);
        
        //使用Comparator.comparingInt()方法
        Arrays.sort(arr, Comparator.comparingInt(o -> o));
        
       
        System.out.println(Arrays.toString(arr));

    }
}

package com.grg.day12.test;


import java.util.Arrays;
import java.util.Comparator;

/**
 * @Author Grg
 * @Date 2023/11/13 16:24
 * @PackageName:com.grg.day12.test
 * @ClassName: LambdaDemo1
 * @Description: 又是码代码的一天
 * @Version plus max 宇宙无敌终极版本
 */
public class LambdaDemo1 {
    public static void main(String[] args) {

        String[] arr = {"a", "aaaa", "aaa", "aa"};

        //按照指定方式排列,就需要sort方法 并指定排序规则
        
        Arrays.sort(arr, new Comparator<String>() {

            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();
            }
        });

        Arrays.sort(arr, (o1, o2) -> o1.length() - o2.length());

        Arrays.sort(arr, Comparator.comparingInt(String::length));
        
        //打印数组
        System.out.println(Arrays.toString(arr));

    }
}