Lambda表达式-敲开函数式编程的大门

 

面向对象的束缚

在正式讲Lambda表达式和函数式编程之前我们先完成一个需求分析一下我们之前面向对象编程的不足！

需求:启动一个线程并输出一句话

     @Test
    public void testTradition() throws Exception {
        new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println("使用传统方式开启线程");
            }
        }).start();
    }

本着“万物皆对象”的思想，创建一个Runnable接口的匿名内部类对象(线程对象)来指定任务内容，再启动该线程。这种做法是Ok的,但是……

我们真的想创建一个匿名内部类对象吗？

不。我们只是为了做这件事情而不得不创建一个对象。

我们真正希望做的事情是：将 run方法方法体内的代码传递给Thread类。

传递并执行这一段代码，才是我们真正的目的。

而创建对象只是受限于面向对象语法而不得不采取的一种手段方式。

那，有没有更加简单的办法？

如果我们将关注点从“怎么做”回归到“做什么”的本质上，就会发现只要能够更好地达到目的，过程与形式其实并不重要。

函数式编程的解放

函数式编程思想让我们更加关注我们的目标也就是:“做什么”

 @Test

public void testLambda() throws Exception {

    new Thread(()->System.out.println("使用Lambda方式开启线程")).start();;

}

这段代码和刚才的执行效果是完全一样的。

从代码的语义中可以看出：我们启动了一个线程，而线程任务的内容以一种更加简洁的形式被指定。

瞬间感觉得到了解放！不再有“不得不创建 Runnable接口对象”的束缚，不再有“覆盖重写抽象方法”的负担，就是这么简单！

总结：

Java语言一大特点与优势就是面向对象，但是随着技术的发展，我们会发现面向对象思想在某些场景下并非是最优的思想。能够简单快速满足需求、达到目标效果的思想有时候可能更加适合。这种思想就是函数式编程思想！Java8中的Lambda表达式就可以让我们把这种思想发挥的淋漓尽致！

感觉不过瘾？那我们再来几个案例对比下！

感受函数式编程的魅力-应对不断变化的需求

需求：

根据用户提出的不同条件筛选出满足相应条件的商品，比如：
筛选出所有名称包含手机的商品
筛选出所有价格大于1000的商品
准备工作

方式一:传统做法

@Getter
@Setter
@ToString
@AllArgsConstructor
@NoArgsConstructor
public class Product {
private Long id; //商品编号
private String name; //商品名称
private Double price;; //商品价格
}

//需求：筛选出所有名称包含手机的商品

//需求：筛选出所有价格大于1000的商品

public class MagicLambda {
    private List<Product> products = new ArrayList<>();

    @Before
    public void init(){
      products.add(new Product(1L,"苹果手机",8888.88));
      products.add(new Product(2L,"华为手机",6666.66));
      products.add(new Product(3L,"联想笔记本",7777.77));
      products.add(new Product(4L,"机械键盘",999.99));
      products.add(new Product(5L,"雷蛇鼠标",222.22));
    }

}

我们先使用传统Java编程完成以下几个需求,代码如下:

 //需求：筛选出所有名称包含手机的商品
public List<Product> filterProductByName(List<Product> products){
    List<Product> list = new ArrayList<>();
    for (Product product : products) {
        if (product.getName().contains("手机")) {
            list.add(product);
        }
    }
    return list;
}
//需求：筛选出所有价格大于1000的商品
public List<Product> filterProductByPrice(List<Product> products){
    List<Product> list = new ArrayList<>();
    for (Product product : products) {
        if (product.getPrice() > 1000) {
            list.add(product);
        }
    }
    return list;
}
@Test
public void test1() throws Exception {
    //List<Product> list = filterProductByName(products);
    List<Product> list = filterProductByPrice(products);
    for (Product product : list) {
        System.out.println(product);
    }
}    

完成需求后我们发现了问题，针对不同的需求我们要写不同的方法实现，而每一个不同的实现我们需要编写不同的方法，这里是不是可以使用策略设计模式优化一下？
完成需求后我们发现了问题，针对不同的需求我们要写不同的方法实现，而每一个不同的实现我们需要编写不同的方法，这里是不是可以使用策略设计模式优化一下？

完成需求后我们发现了问题，针对不同的需求我们要写不同的方法实现，而每一个不同的实现我们需要编写不同的方法，这里是不是可以使用策略设计模式优化一下？

方式二:使用策略设计模式优化

编写策略接口

public interface MyPredicate<T> {
    boolean test(T t);
}

编写策略实现类

public class FilterProductByName implements MyPredicate<Product> {
    @Override
    public boolean test(Product t) {
        return t.getName().contains("手机");
    }
}

public class FilterProductByPrice implements MyPredicate<Product> {
    @Override
    public boolean test(Product t) {
        return t.getPrice() > 1000;
    }
}

修改方法实现

修改方法实现

public List<Product> filterProduct(List<Product> products,MyPredicate<Product> predicate){
    List<Product> list = new ArrayList<>();
    for (Product product : products) {
        if (predicate.test(product)) {
            list.add(product);
        }
    }
    return list;
}

@Test
public void test2() throws Exception {
    List<Product> list = filterProduct(products, new FilterProductByName());
    //List<Product> list = filterProduct(products, new FilterProductByPrice());
    for (Product product : list) {
        System.out.println(product);
    }
}

到这里我们又发现要针对不同的需求写不同的策略类！很麻烦！可不可以不写？—使用匿名内部类优化！

方式三:使用匿名内部类优化

 @Test
public void test3() throws Exception {
    List<Product> list = filterProduct(products, new MyPredicate<Product>() {
        @Override
        public boolean test(Product t) {
            return t.getName().contains("手机");
        }
    });

    for (Product product : list) {
        System.out.println(product);
    }
}

到这里我们感觉还是很麻烦！仅仅是想执行一个比较判断的条件表达式！却要创建接口的匿名对象重写抽象方法！很不爽，怎么办？—使用Lambda表达式

方式四:使用Lambda表达式优化

  @Test
public void test4() throws Exception {
    filterProduct(products, (p) -> p.getPrice() > 1000).forEach(System.out::println);
}

到这里是不是已经渐渐感受到了Lambda表达式的强大了？接下来更会让你爱上她的！—使用Stream
到这里是不是已经渐渐感受到了Lambda表达式的强大了？接下来更会让你爱上她的！—使用Stream

(总结下:Lambda表达式可以理解为是一个匿名函数，也就是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。)

方式五:使用Stream API优化

 //获取价格从高到低排行前三的商品信息
 @Test
public void test5() throws Exception {
    //获取价格从高到低排行前三的商品信息
    products.stream().sorted((x,y) -> y.getPrice().compareTo(x.getPrice()))
    .limit(3).forEach(System.out::println);
}

到这里是不是已经充分感受到了Java8函数式编程的强大和魅力了？那下一篇来我们就来揭下她神秘的面纱！本文为叩丁狼java老师原创，转载请标明出处（http://www.wolfcode.cn/index.htm）