Java基础（9）——从匿名内部类到函数式编程Lamda表达式 & List的函数式编程案例

电玩女神 2023-10-11 23:41 7阅读 0赞

#### 目录 ####

*  引出
 *  什么是匿名内部类
 *  List的匿名内部类
 *  函数式编程--lamda表达式
 *   *  完整的实现类：
     *  匿名内部类
     *  lamda表达式：
 *  List的函数式编程
 *   *  排序
     *  limit:限制数量
     *  最大/小
     *  计算价格和、平均价格
     *  去重，映射
 *  更多集合的lamda案例
 *  总结

## 引出 ##

从匿名内部类到函数式编程的进化

--------------------

![在这里插入图片描述][2a8efbeaa9ad45ceaed5419eaf050624.png]

## 什么是匿名内部类 ##

没有类名----匿名内部类

![在这里插入图片描述][f7d872b2781b47ffa4accd8d827e6328.png]没有类名----匿名内部类

![在这里插入图片描述][61a040f967cb4e70a24b410d124237c8.png]

![在这里插入图片描述][a945a26901514b20bbd5a6e85d5a8224.png]

## List的匿名内部类 ##

@FunctionalInterface 注解![在这里插入图片描述][b65afff017ff4a0591067af01a07f86a.png]  
![在这里插入图片描述][7fa5e06c0ff3431c832181b80d780703.png]

Collections.sort(list, new Comparator<Emp>() {
        
        @Override
        public int compare(Emp o1, Emp o2) {
        
            return (int) (o1.getAge()-o2.getAge());
        }
     });

o1和o2是啥：

![在这里插入图片描述][342e85ea59a84ce5ab2db1994232d2de.png]

> Returns:  
> a **negative** integer, zero, or a **positive** integer as the **first** argument is **less than**, equal to, or greater than the second.

进一步的简化：

Collections.sort(list,(o1, o2)->{
        
        return (int) (o1.getAge()-o2.getAge());
    });

## 函数式编程–lamda表达式 ##

从完整的实现类 到 匿名内部类 到函数式编程

### 完整的实现类： ###

public class EatImpl implements IEat {
        
        @Override
        public void eat() {
        
            System.out.println("吃快餐");
        }
    }

### 匿名内部类 ###

IEat e = new IEat() {
        
        @Override
        public void eat() {
        
            System.out.println("吃面条...");
        }
    };
    e.eat();

### lamda表达式： ###

![在这里插入图片描述][7d51bf7e7d3b4d26901c4cde320f01c5.png]接口：@ FunctionalInterface

只有一个唯一的方法需要实现

@FunctionalInterface
    public interface Comparator<T> {
        
        int compare(T o1, T o2);   //需要实现类实现
        boolean equals(Object obj);
        default Comparator<T> reversed() {
        
            return Collections.reverseOrder(this);
        }
    }

![在这里插入图片描述][0d94c944c51342cab867ebb85c50f3f0.png]

## List的函数式编程 ##

@FunctionalInterface

出现在接口，此接口可以使用Lamda表达式。  
![在这里插入图片描述][d311c8a54a8846dc952f9e05329a4698.png]  
List.stream()

![在这里插入图片描述][59225d47b0994d288c51dac4c966ae8c.png]

创建一个lsit

List<Car> list = new ArrayList<>();
    list.add(new Car(1, "BMW", "黑色", 350000.00, 1789.0));
    list.add(new Car(2, "QQ", "橙色", 50000.00, 589.0));
    list.add(new Car(3, "Benz", "白色", 450000.00, 1889.0));
    list.add(new Car(4, "BYD", "绿色", 1080000.00, 2989.0));
    list.add(new Car(5, "Audi", "红色", 880000.00, 1489.0));

需求：查询价格低于500000.00的车

1.普通方法：循环

for(Car c :list){
        
    if(c.getPrice()<500000.00){
        
        System.out.println(c);
    }
    }

2.用lamda改写  
要素：流对象，过滤条件，收集结果

list = list.stream() //流对象，函数编程
            .filter(car->car.getPrice()<500000.00) //过滤条件
            .collect(Collectors.toList()); //收集结果

多个条件的例子：

list.stream()
            .filter(car->car.getBrand().equals("BMW") && car.getStore()<10)
                    .collect(Collectors.toList());

### 排序 ###

list =  list.stream()
            .sorted((o1, o2) -> o1.getId()-o2.getId())
            .collect(Collectors.toList());

### limit:限制数量 ###

需求：找出价格最低5种车。

list= list.stream()
    .sorted((o1, o2) -> (int) (o1.getPrice() - o2.getPrice()))
    .limit(5)
    .collect(Collectors.toList());

### 最大/小 ###

需求找出库存最多的？

Car c = list.stream()
            .max((o1, o2) -> o1.getStore()-o2.getStore())
                    .get()  ;
    System.out.println(c);

### 计算价格和、平均价格 ###

*  计算price之和
 *  计算price\*store之和

System.out.println(list.stream()
           .mapToDouble(car -> car.getPrice())
            .sum());
    System.out.println(list.stream()
          .mapToDouble(car -> car.getPrice() *car.getStore())
           .sum());

*  计算price的平均价格
 *  计算总量的平均价格

System.out.println(list.stream()
            .mapToDouble(car -> car.getPrice() *car.getStore())
            .average().getAsDouble());

### 去重，映射 ###

统计出系统有哪些品牌的车？

List<String> brands = list.stream()
            .map(Car::getBrand)  //映射
            .distinct()   //去重
            .collect(Collectors.toList());
    System.out.println(brands);

## 更多集合的lamda案例 ##

[Java基础（2）——列表 & 集合List，函数式编程Lamda表达式][Java_2_ _ _List_Lamda]

## 总结 ##

1.匿名内部类是啥；  
2.函数编程是啥；  
3.从匿名内部类到函数式编程；  
4.list的函数式编程，案例；

[2a8efbeaa9ad45ceaed5419eaf050624.png]: https://img-blog.csdnimg.cn/2a8efbeaa9ad45ceaed5419eaf050624.png
[f7d872b2781b47ffa4accd8d827e6328.png]: https://img-blog.csdnimg.cn/f7d872b2781b47ffa4accd8d827e6328.png
[61a040f967cb4e70a24b410d124237c8.png]: https://img-blog.csdnimg.cn/61a040f967cb4e70a24b410d124237c8.png
[a945a26901514b20bbd5a6e85d5a8224.png]: https://img-blog.csdnimg.cn/a945a26901514b20bbd5a6e85d5a8224.png
[b65afff017ff4a0591067af01a07f86a.png]: https://img-blog.csdnimg.cn/b65afff017ff4a0591067af01a07f86a.png
[7fa5e06c0ff3431c832181b80d780703.png]: https://img-blog.csdnimg.cn/7fa5e06c0ff3431c832181b80d780703.png
[342e85ea59a84ce5ab2db1994232d2de.png]: https://img-blog.csdnimg.cn/342e85ea59a84ce5ab2db1994232d2de.png
[7d51bf7e7d3b4d26901c4cde320f01c5.png]: https://img-blog.csdnimg.cn/7d51bf7e7d3b4d26901c4cde320f01c5.png
[0d94c944c51342cab867ebb85c50f3f0.png]: https://img-blog.csdnimg.cn/0d94c944c51342cab867ebb85c50f3f0.png
[d311c8a54a8846dc952f9e05329a4698.png]: https://img-blog.csdnimg.cn/d311c8a54a8846dc952f9e05329a4698.png
[59225d47b0994d288c51dac4c966ae8c.png]: https://img-blog.csdnimg.cn/59225d47b0994d288c51dac4c966ae8c.png
[Java_2_ _ _List_Lamda]: https://blog.csdn.net/Pireley/article/details/130420836