Java8行为参数化

需求：提供一个橘子的筛选功能，可通过颜色、重量为条件

定义橘子实体：

@Getter
@Setter
public class Orange {

    private double weight;

    private String color;
}

初学者：通过定义橘子工具类来实现，如果增加属性，如果需要提供筛选功能，那么又要继续增加筛选方法

public class OrangeUtils {

    /**
     * 通过颜色筛选橘子工具类
     *
     * @param source 需要筛选的橘子
     * @param color  目标颜色
     * @return
     */
    public static List<Orange> filterOrangesbyColor(List<Orange> source, String color) {
        if (source != null && source.size() > 0 && StringUtils.hasText(color)) {
            List<Orange> result = new ArrayList<>();
            for (Orange orange : source) {
                if (color.equals(orange.getColor())) {
                    result.add(orange);
                }
            }
            return result;
        }
        return null;
    }

    /**
     * 通过重量筛选橘子
     *
     * @param source 需要筛选的橘子
     * @param weight 重量
     * @param bool   筛选符号
     * @return
     */
    public static List<Orange> filterOrangesByWeight(List<Orange> source, double weight, boolean bool) {
        List<Orange> result = new ArrayList<>();
        for (Orange orange : source) {
            if (bool && orange.getWeight() > weight) {
                result.add(orange);
            } else if (!bool && orange.getWeight() < weight) {
                result.add(orange);
            }
        }
        return result;
    }
}

进阶：

public interface OrangePredicate {
    boolean fileter(Orange orange, Object obj);
}

public class OrangeColorPredicate implements OrangePredicate {

    @Override
    public boolean fileter(Orange orange, Object obj) {
        return obj != null && StringUtils.hasText(obj.toString()) ? obj.toString().equals(orange.getColor()) : false;
    }
}

public class OrangeWeightPredicate implements OrangePredicate {

    @Override
    public boolean fileter(Orange orange, Object obj) {
        return obj != null && orange.getWeight() > (Double)obj;
    }
}

//调用
	public List<Orange> filterOranges(List<Orange> source,OrangePredicate p,Object obj){
        List<Orange> result = new ArrayList<>();
        for (Orange orange:source){
            if(p.fileter(orange, obj)){
                result.add(orange);
            }
        }
        return result;
    }

	//或者只定义策略，策略的具体实现在调用时
	public List<Orange> filterOranges(List<Orange> source){
        return filterOranges(source, new OrangePredicate() {
            @Override
            public boolean fileter(Orange orange, Object obj) {
                return orange.getWeight() > (Double) obj;
            }
        }, 100);
    }

	//Lambda初步使用：
	public List<Orange> filterOrangesFromLambda(List<Orange> source){
        List<Orange> oranges = filterOranges(source, (Orange orange, Object obj) -> (Double) obj < orange.getWeight()
                , 100);
        return oranges;
    }

通过此需求根据Java8更改为一个通用的工具：

public class FilterUtils {

    public interface Predicate<T> {
        boolean filter(T t);
    }

    public static <T> List<T> filter(List<T> list, Predicate<T> p) {
        List<T> result = new ArrayList<>();
        for (T t : list) {
            if (p.filter(t)) {
                result.add(t);
            }
        }
        return result;
    }
}

// 通过工具调用，此工具可用于其他地方重复使用
List<Orange> oranges = new ArrayList<>();
FilterUtils.filter(oranges, new FilterUtils.Predicate<Orange>() {
    @Override
    public boolean filter(Orange orange) {
        return orange.getWeight() > 100 && "green".equals(orange.getColor());
    }
});

更多文章：
点击跳转CSDN博客
点击跳转简书博客
公众号：代码小搬运