Java8学习笔记整理二----策略模式

女爷i 2023-06-04 04:55 49阅读 0赞

**案例：  
一个Apple类，它有getColor方法，还有一个变量inventory保存一个Apples列表。请筛选出绿苹果并且返回一个列表**  
Apple实体类：

package lambdasinaction.Java8_1;
    
    
    public class Apple { 
    
        private String color;
    
        private long weight;
    
        public Apple(String color, long weight) { 
            this.color = color;
            this.weight = weight;
        }
    
        public String getColor() { 
            return color;
        }
    
        public void setColor(String color) { 
            this.color = color;
        }
    
        public long getWeight() { 
            return weight;
        }
    
        public void setWeight(long weight) { 
            this.weight = weight;
        }
    
        @Override
        public String toString() { 
            return "Apple{" +
                    "color='" + color + '\'' +
                    ", weight=" + weight +
                    '}';
        }
    }

Java8之前：  
（1）选出绿色苹果

public static List<Apple> filterGreenApples(List<Apple> inventory) { 
            List<Apple> list = new ArrayList<>();
            for (Apple apple : inventory) { 
                if ("green".equals(apple.getColor())) { 
                    list.add(apple);
                }
            }
            return list;
        }

现在**改变需求**：选出大于150g的苹果

//如果选出苹果的重量大于或者等于150g
        public static List<Apple> filterHeavyApples(List<Apple> inventory) { 
            List<Apple> list = new ArrayList<>();
            for (Apple apple : inventory) { 
                if (apple.getWeight() >= 150) { 
                    list.add(apple);
                }
            }
            return list;
        }

## main函数： ##

public static void main(String[] args) { 
            List<Apple> list = Arrays.asList(new Apple("green", 80),
                    new Apple("green", 150),
                    new Apple("red", 120));
    
            List<Apple> greenApples = filterGreenApples(list);
            assert greenApples.size() == 2;
            System.out.println(greenApples);
            System.out.println(“-----------------”);
            List<Apple> appleWeight = filterHeavyApples(list);
            System.out.println(appleWeight );

**问题**：那如果我现在需要按颜色以及重量来查找苹果呢？—发现重复性代码太多，不好！

**优化方法：采用策略模式**

AppleFilter:

@FunctionalInterface
    public interface AppleFilter { 
        /** * 策略模式： * * @param apple * @return true/false */
        boolean filter(Apple apple);
    }

**第一步优化：**

public static List<Apple> finddApple(List<Apple> apples, String color) { 
            List<Apple> list = new ArrayList<>();
            for (Apple apple : apples) { 
                if (color.equals(apple.getColor())) { 
                    list.add(apple);
                }
            }
            return list;
        }
    
    main里面：
    
    ```java
      List<Apple> greenApples2 = finddApple(list, "green");
            System.out.println(greenApples2);

**发现还是需要很多变量，继续优化：**  
策略模式环境角色:

public static List<Apple> findApple(List<Apple> apples, AppleFilter appleFilter) { 
            List<Apple> list = new ArrayList<>();
            for (Apple apple : apples) { 
                if (appleFilter.filter(apple)) { 
                    list.add(apple);
                }
            }
            return list;
        }

\*\*需求：\*\*选出绿色以及重量是150g的苹果

import lambdasinaction.Java8_1.Apple;
    import lambdasinaction.Java8_1.AppleFilter;
    
    /** * 这个是策略模式的具体实现了类 */
    public class GreenAnd150WeightFilter implements AppleFilter { 
        @Override
        public boolean filter(Apple apple) { 
            return (apple.getColor().equals("green") && apple.getWeight() >= 150);
        }
    }

main里面：

List<Apple> result = findApple(list, new GreenAnd150WeightFilter());
       System.out.println(result);

**优化的好处：如果有新的需求，那么只需要在写一个策略模式的具体实现类就行了。简单、方便、代码冗余少！**

附上最终优化后的代码（与上面有些差异，不是完全一样的代码）：

package lambdasinaction.Java8_1;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    import java.util.function.Predicate;
    
    public class Java8 { 
    
        public static boolean isGreenApple(Apple apple) { 
            return "green".equals(apple.getColor());
        }
    
        public static boolean isHeavyApple(Apple apple) { 
            return apple.getWeight() >= 120;
        }
    
        public static boolean colorAndWeight(Apple apple) { 
            return (apple.getColor().equals("green") && apple.getWeight() >= 120);
        }
        
        public static List<Apple> filterApples(List<Apple> inventory, Predicate<Apple> p) { 
            List<Apple> result = new ArrayList<>();
            for (Apple apple : inventory) { 
                if (p.test(apple)) { 
                    result.add(apple);
                }
            }
            return result;
        }
    
        public static void main(String[] args) throws InterruptedException { 
            List<Apple> list = Arrays.asList(new Apple("green", 80),
                    new Apple("green", 150),
                    new Apple("red", 120));
            
            List<Apple> greenApples = filterApples(list, Java8::isGreenApple);
            System.out.println(greenApples);
    
            System.out.println("------------------------------------------");
            List<Apple> weightApple = filterApples(list, Java8::isHeavyApple);
            System.out.println(weightApple);
    
            System.out.println("--------根据颜色和重量筛选条件--------------");
            List<Apple> colorAndWeight = filterApples(list, Java8::colorAndWeight);
            System.out.println(colorAndWeight);
    
            //在AppleFilter加上@FunctionalInterface后，展示
            System.out.println("----------Lambda表达式----------------------");
            System.out.println("选出所有类绿色的苹果");
            List<Apple> lambdaResult = filterApples(list, (Apple apple) -> { 
                return apple.getColor().equals("green");
            });
            System.out.println(lambdaResult);
            System.out.println("选出所有重量大于80g的苹果");
            List<Apple> appleList = filterApples(list, (Apple apple) -> { 
                return (apple.getWeight() > 80);
            });
            System.out.println(appleList);
    
            System.out.println("颜色和重量");
            List<Apple> redAndWeightLess80 = filterApples(list, apple -> { 
                return (apple.getColor().equals("red") && apple.getWeight() <= 80);
            });
            System.out.println(redAndWeightLess80);
    
    
    
            System.out.println("----------匿名内部类写一个线程--------------------------");
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    System.out.println("匿名内部类写的线程，线程名为" + Thread.currentThread().getName());
                }
            }).start();
    
            //Lambda表达式的写法
            new Thread(() -> System.out.println("Lambda表达式写的线程，线程名为"+Thread.currentThread().getName())).start();
            Thread.currentThread().join();
        }
    
    }