java8为什么这么优秀？

**j

java8新特性

**

时至今日,ORACLE发布java8已有3年之久,由于一直对java8的新特性怀着极高的好奇心, 特此详细学习下,请各位赐教

学习目录

• java8介绍
• lamda表达式实战
• 方法引用
• streamAPI实战

直接上代码

匿名函数实现

    /**
     * 利用java8之前的语法实现: 创建一个比较器
     * 并且初始化一个TreeSet 集合
     */
    @Test
    public void test1() {
        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1, o2);
            }
        };
        TreeSet<Integer> treeSet = new TreeSet<>(comparator);
        System.out.println(treeSet);

    }

利用匿名函数的方式，是java8之前最优秀的方法，但是匿名函数的无用代码很多，上面最重要的一行代码
就是: Integer.compare(o1,o2);

lamda表达式

    /**
     * 利用lamda表达式实现上面的功能
     */
    @Test
    public void test2() {
        Comparator<Integer> comparator = (x, y) -> Integer.compare(x, y);
        TreeSet<Integer> treeSet = new TreeSet<>(comparator);
    }

利用java8中lamda表达式，将代码优化到2行，我个人感觉很棒(少些代码开心)

考虑实际需求
需求：从汽车厂中挑出价格大于20（万）的轿车

1. 首先定义汽车对象

public class Car {
    
    private double price;
    
    private String name;
    
    private String color;

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

  //.......get | set 方法省略
}

2. 利用java8之前的方法实现

    @Test
    public void test3() {
        List<Car> carList = filterCar(lists);

        for (Car car : carList) {
            System.out.println(car);
        }
    }


    public static List<Car> filterCar(List<Car> cars) {
        List<Car> list = new ArrayList<>();


        for (Car car : cars) {
            if (car.getPrice() > 20) {
                list.add(car);
            }
        }
        return list;
    }

后面有需求更改，那是灾难，频繁的修改fiterCar方法，里面改变的只有if条件，其他代码一毛一样。
那现在该怎么做呢？CV大法，哈哈，这不是一个好的答案！（写这代码，容易让批啊);

设计模式实现
这里可以应用 策略设计模式 的思想

1. 首先定义一个抽象接口

public interface MyPredicate<T> {

    /**
     * 过滤符合条件的Class
     * @param t
     * @return
     */
    boolean test(T t);
}

2. 创建具体的过滤对象

public class MyPricePredicate implements MyPredicate<Car> {
    @Override
    public boolean test(Car car) {
        return car.getPrice()>20;
    }
}

3.定义过滤方法

public class DemoTestMain {
    private List<Car> lists = Arrays.asList(
            new Car("白色", "奔驰", 19),
            new Car("黄色", "奥迪", 45),
            new Car("蓝色", "雪佛兰", 10),
            new Car("棕色", "大众", 11),
            new Car("白色", "特斯拉", 46),
            new Car("黑色", "奔驰", 14)
    );
    //过滤集合中符合条件的对象
    public static List<Car> filterCarByCondition(List<Car> cars, MyPredicate my) {
        List<Car> list = new ArrayList<>();
        for (Car car : cars) {
            if (my.test(car)) {
                list.add(car);
            }
        }
        return list;
    }

    @Test
    public void test1() {
      //客户端调用上面的过滤方法，只需要根据不同的需求传入不同的实现类即可
        List<Car> list = filterCarByCondition(lists, new MyPricePredicate());

        for (Car car : list) {
            System.out.println(car);
        }
    }
}

利用设计模式之后，虽然不需要频繁的CV,但是有需求就需要创建一个类，类里只有简单的一个方法，觉得这样
也不是特别好，那怎么办呢？

lamda表达式
java8中lamda表达式就很好的解决了这个问题

同样实现上面的功能

@Test
    public void test2(){
        List<Car> list = filterCarByCondition(lists,(x) -> x.getPrice()>20);
        list.forEach(System.out::println);
    }

将接口中的方法实现的代码作为参数传递，这种方式就是lamda表达式。
接口中方法test(T t)
语法：（x）-> x.get.getPrice（）>20;
x 对应 test方法中参数，然后表达式是对接口方法的实现。