Java ArrayList Filter Sorted Map

• 创建一个 ArrayList 的父类

import java.util.ArrayList;

public class LGFArrayList<O> extends ArrayList<O> {

    // 接口部分, 用法可参考 ES6
    public interface mapI<O, T> { T map(O obj); }
    public interface filterI<O> { Boolean filter(O obj); }
    public interface sortedI<O> { Boolean sorted(O obj1, O obj2); }
    public interface findI<O> { Boolean find(O obj); }
    public interface everyI<O> { Boolean every(O obj); }
    public interface someI<O> { Boolean some(O obj); }

    /**
     * 过滤语法糖
     * @param I 返回一个 bool 值，用来决定过滤条件
     * @return 返回一个新初始化的过滤后的 ArrayList（新地址）
     */
    public LGFArrayList<O> lgf_Filter(filterI<O> I) {
        LGFArrayList<O> currentList = new LGFArrayList<>();
        for (O obj : this) {
            if (I.filter(obj)) {
                currentList.add(obj);
            }
        }
        return currentList;
    }

    /**
     * map 重构语法糖
     * @param I 返回一个新的元素
     * @param <T> 返回新重构 ArrayList 的泛型类型
     * @return 返回一个新初始化的 ArrayList（新地址）
     */
    public <T> LGFArrayList<T> lgf_Map(mapI<O, T> I) {
        LGFArrayList<T> list = new LGFArrayList<>();
        for (O obj : this) {
            T new_obj = I.map(obj);
            list.add(new_obj);
        }
        return list;
    }

    /**
     * find 查找第一次满足条件元素语法糖
     * @param I 返回一个 bool 值，用来决定查找条件
     * @return 第一次满足条件元素
     */
    public O lgf_Find(findI<O> I) {
        for (O obj : this) {
            if (I.find(obj)) {
                return obj;
            }
        }
        return null;
    }

    /**
     * every 回调条件都返回 true 则返回 true
     * @param I 返回一个 bool 值，用来决定条件
     * @return 布尔值
     */
    public Boolean lgf_Every(everyI<O> I) {
        for (O obj : this) {
            if (!I.every(obj)) {
                return false;
            }
        }
        return true;
    }

    /**
     * some 回调条件一个返回 true 则返回 true
     * @param I 返回一个 bool 值，用来决定条件
     * @return 布尔值
     */
    public Boolean lgf_Some(someI<O> I) {
        for (O obj : this) {
            if (I.some(obj)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 快排语法糖
     * @param I 返回一个 bool 值，用来决定排序条件
     * @return 返回排序后的本体
     */
    public LGFArrayList<O> lgf_Sorted(sortedI<O> I) {
        quickSort(this, 0, this.size() - 1, I);
        return this;
    }
    private void quickSort(LGFArrayList<O> arr, int low, int high, sortedI<O> I){
        int i, j;
        O temp, t;
        if (low > high){ return; }
        i = low;
        j = high;
        temp = arr.get(low);
        while (i < j) {
            while ((temp == arr.get(j) || I.sorted(temp, arr.get(j))) && i < j) { j--; }
            while ((temp == arr.get(i) || !I.sorted(temp, arr.get(i))) && i < j) { i++; }
            if (i < j) {
                t = arr.get(j);
                arr.set(j, arr.get(i));
                arr.set(i, t);
            }
        }
        arr.set(low, arr.get(i));
        arr.set(i, temp);
        quickSort(arr, low, j - 1, I);
        quickSort(arr, j + 1, high, I);
    }

}

• 不使用(CGLIB, ASM)等运行时工具，仅支持继承后使用，对于前端1000条以内的数据处理，可以有效提升代码可读性

public class LGFTest {

    LGFArrayList<Integer> testArray;

    public void Test() {
        testArray = new LGFArrayList<>();
        testArray.addAll(Arrays.asList(1, 2, 3, 4, 5, 6));

        // 1, 2, 3, 4, 5, 6

        testArray = testArray.lgf_Filter(new LGFArrayList.filterI<Integer>() {
            @Override
            public Boolean filter(Integer obj) {
                return obj != 4 && obj != 3;
            }
        });

        // 1, 2, 5, 6

        testArray.lgf_Sorted(new LGFArrayList.sortedI<Integer>() {
            @Override
            public Boolean sorted(Integer obj1, Integer obj2) {
                return obj1 > obj2;
            }
        });

        // 6, 5, 2, 1

        testArray = testArray.lgf_Map(new LGFArrayList.mapI<Integer, Integer>() {
            @Override
            public Integer map(Integer obj) {
                return obj * 2;
            }
        });

        // 12, 10, 4, 2

        boolean everyHave = testArray.lgf_Every(new LGFArrayList.everyI<Integer>() {
            @Override
            public Boolean every(Integer obj) {
                return obj == 2 || obj == 4 || obj == 10 || obj == 12;
            }
        });

        // true

        boolean someHave = testArray.lgf_Some(new LGFArrayList.someI<Integer>() {
            @Override
            public Boolean some(Integer obj) {
                return obj == 2;
            }
        });

        // true

        LGFArrayList<String> stringArray = testArray.lgf_Map(new LGFArrayList.mapI<Integer, String>() {
            @Override
            public String map(Integer obj) {
                return obj.toString();
            }
        });

        // "12", "10", "4", "2"

        String find_obj = stringArray.lgf_Find(new LGFArrayList.findI<String>() {
            @Override
            public Boolean find(String obj) {
                return obj.equals("10");
            }
        });

        // "10"

        System.out.print(testArray);
    }

 }