23、匿名类的排序、Lambda 表达式、方法引用_java 排序匿名函数

    System.out.println(Arrays.toString(ints));
}

}

> 
> ☘️ 通过该方法还可对数组进行倒顺序排序，这就需要通过匿名类语法传入排序逻辑了。
> 
> 
> 


`Arrays.sort() 进行降序排序：`

public class TestDemo {
public static void main(String[] args) {
Integer[] intArr = {5, 2, 0, 1, 3, 1, 4, 8, 7, 22, 35, 51, 6};

    /\* 使用 Arrays.toString() 可以打印数组里面的内容 \*/
    // [5, 2, 0, 1, 3, 1, 4, 8, 7, 22, 35, 51, 6]
    System.out.println(Arrays.toString(intArr));

    /\* Arrays.sort() 可对数组进行降序排序 \*/
    Arrays.sort(intArr, new Comparator<Integer>() {
        @Override
        public int compare(Integer i1, Integer i2) {
            // return 0; // 相当于没有进行排序操作
            // return i1 - i2; // 升序排序
            return i2 - i1; // 降序排序
        }
    });

    // [51, 35, 22, 8, 7, 6, 5, 4, 3, 2, 1, 1, 0]
    System.out.println(Arrays.toString(intArr));
}

}

> 
> ☘️ `Comparator` 是 jdk 自带的一个接口  
>  ☘️ `Comparator` 中有一个 **compare** 方法（**compare** 方法中可以指定是降序还是升序）【具体看上面的代码】
> 
> 
> 


## 二、Lambda 表达式


### (1) Lambda 基本使用


🔖 Lambda Expression 是 Java8 开始才有的语法


🔖 函数式接口（Functional Interface）：只包含**1个抽象方法**的接口（可以包含多个默认方法和静态方法）



> 
> 📕 可以在接口上加上`@FunctionalInterface`注解，表示它是一个函数式接口
> 
> 
> 


🔖 当匿名类实现的是**函数式接口**的时候，可以使用 Lambda 表达式简化代码的书写（但是匿名类和 Lambda 在作用域上还是有点区别的）




---


`Lambda 表达式格式：`

/*
Lambda 表达式格式：
(parameter list) -> {
return xxx;
}
*/

> 
> 📕 **Lambda** 表达式的格式和 **JavaScript** 中的**箭头函数**非常相似  
>  📕 **parameter list**：指函数式接口里面唯一的**抽象方法的参数列表**（若那个唯一的抽象方法没有参数，可不写）
> 
> 
> 


`计算代码执行时间的工具类（上篇文章介绍的）：`

/**
* 计算某段代码的执行时间
*/
public class CodeTimes {

@FunctionalInterface
public interface BlockInter {
    void passCode();
}

public static void check(String description, BlockInter codeBlock) {
	if(codeBlock == null) return;
	
    System.out.println("\n----------------------------");
    System.out.println("测试功能：" + description);
    long beginTime = System.currentTimeMillis();

    codeBlock.passCode();

    long endTime = System.currentTimeMillis();
    long duration = (endTime - beginTime) / 1000;
    System.out.println("代码执行花费时间：" + duration + "秒");
    System.out.println("----------------------------");
}

}

public class TestDemo {
public static void main(String[] args) {
CodeTimes.check(“简单测试1”, () -> {
String string = “Happy”;
for (int i = 0; i < 50000; i++) {
string += i;
}
});

    CodeTimes.check("简单测试2", () -> {
        test();
    });
}

private static void test() {
    StringBuilder string = new StringBuilder("Happy");
    for (int i = 0; i < 50000; i++) {
        string.append(i);
    }
}

/\*

---

测试功能：简单测试1
代码执行花费时间：6秒

---

测试功能：简单测试2
代码执行花费时间：0秒

*/
}

> 
> 📕 本篇文章第一节中用到的 `Arrays.sort()` 进行降序排序的时候使用到的 **Comparator** 也是函数式接口  
>  📕 它的书写方式也可以使用 Lambda 表达式进行简化
> 
> 
> 


`Lambda 简化 Arrays.sort() 进行降序排序时候的 Comparator 接口的写法：`

public class TestDemo {
public static void main(String[] args) {
Integer[] intArr = {1, 3, 5, 7, 9, 2, 6, 8, 10};

    // 降序排序
    Arrays.sort(intArr, (Integer i1, Integer i2) -> {
        return i2 - i1;
    });

    // [10, 9, 8, 7, 6, 5, 3, 2, 1]
    System.out.println(Arrays.toString(intArr));
}

}

### (2) Lambda 更加简化


✏️ 参数列表可以省略参数类型  
 ✏️ 当只有一条语句的时候：可以省略大括号、分号和`return`  
 ✏️ 当只有一个参数的时候：可以省略小括号（一个参数都没有的时候不能省略小括号）  
 `更加简化后的降序排序代码：`

public class TestDemo {
public static void main(String[] args) {
Integer[] intArr = {1, 3, 5, 7, 9, 2, 6, 8, 10};

    // 降序排序
    Arrays.sort(intArr, (i1, i2) -> i2 - i1);

    // [10, 9, 8, 7, 6, 5, 3, 2, 1]
    System.out.println(Arrays.toString(intArr));
}

}

### (3) Lambda 使用注意


✏️ **Lambda** 只能访问 **final** 或有效 **final** 的局部变量（和匿名类一样）  
 ✏️ **Lambda 没有引入新的作用域**（和匿名类不同）

@FunctionalInterface
interface Testable {
void test(int p);
}

public class OuterClass {
private int age = 666;

public class InnerClass {
    private int age = 888;

    void inner() {
        // int p = 123; // ERROR: Variable p is already defined in the scope
        Testable t = p -> { // p 只能在 Lambda 的大括号里面使用
            System.out.println(p); // 678
            System.out.println(age); // 888 (Lambda 表达式没有引入新的作用域)
            System.out.println(this.age); // 888 (Lambda 表达式没有引入新的作用域)
            System.out.println(InnerClass.this.age); // 888
            System.out.println(OuterClass.this.age); // 666
        };
        t.test(678);
    }
}

}

class TestDemo {
public static void main(String[] args) {
OuterClass outerClass = new OuterClass();
OuterClass.InnerClass innerClass = outerClass.new InnerClass();
innerClass.inner();
}
}

![img](https://img-blog.csdnimg.cn/img_convert/65a264ff4ea73a71f861549b7036a631.png)
![img](https://img-blog.csdnimg.cn/img_convert/24affd865e2855c01c5ac6288d454a17.png)

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

erClass = outerClass.new InnerClass();
        innerClass.inner();
    }
}

[外链图片转存中…(img-PmPxrgpa-4702036474441)]
[外链图片转存中…(img-EIqyznos-4702036474442)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！