Java写的List Processing Utils

使用Java写的几个列表处理函数,有以下几个函数：

• filter，过滤，根据一个谓词判断过滤列表；
• reverse，把一个列表反转；
• map，把一个列表元素映射按照一定规则转换成另外一个列表；
• accumulate，累“加”，加可定制；
• foldLeft，向左折叠，同accumulate；
• foldRight，向右折叠。

代码如下：

package listutils;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;


/**
 * 列表工具
 *
 * 函数式编程中使用的一些常用列表函数
 *
 * @author lingyun.yang
 */
public class ListUtils {

    /**
     * 谓词接口
     * @param  参数类型
     */
    public interface Predicator<T> {
        /**
         * 谓词判断
         * @param e        输入参数
         * @return        true或false
         */
        boolean predicate(T e);
    }

    /**
     * 映射器接口
     * @param  映射前参数类型
     * @param  映射后参数类型
     */
    public interface Mapper<T1, T2> {
        /**
         * @param e        输入参数
         * @return        映射后结果
         */
        T2 map(T1 e);
    }

    /**
     * 二元操作符，在accumulate中使用
     * @param     参数类型
     */
    public interface BinaryOperator<T> {
        /**
         * @param e1    输入参数
         * @param e2    输入参数
         * @return        两个输入参数之和
         */
        T operate(T e1, T e2);
    }

    /**
     * 列表过滤
     *
     * @param              列表元素类型
     * @param sequence        输入列表
     * @param predicate     谓词
     * @return                过滤后的列表
     *
     * 遍历列表，当列表元素的判断为真时就留下该元素
     */
    public static <T> List<T> filter(List<T> sequence, Predicator<T> predicate) {
        List<T> outSeq = new ArrayList<T>();
        for (T e : sequence) {
            if (predicate.predicate(e)) {
                outSeq.add(e);
            }
        }
        return outSeq;
    }

    /**
     * 反转一个列表
     *
     * @param         列表元素 类型
     * @param sequence    输入列表
     * @return            反转过后的列表
     */
    public static <T> List<T> reverse(List<T> sequence) {
        List<T> outSeq = new ArrayList<T>();
        ListIterator<T> it = sequence.listIterator(sequence.size());
        while (it.hasPrevious()) {
            outSeq.add(it.previous());
        }
        return outSeq;
    }

    /**
     * 列表映射
     *
     * @param         输入列表元素类型
     * @param         输出列表元素类型
     * @param sequence    输入列表
     * @param map        映射函数，使用接口实现
     * @return            映射后的列表
     *
     * 遍历列表，映射每个元素
     */
    public static <T1, T2> List<T2> map(List<T1> sequence, ListUtils.Mapper<T1, T2> map) {
        List<T2> outSeq = new ArrayList<T2>();
        for (T1 e: sequence) {
            outSeq.add(map.map(e));
        }
        return outSeq;
    }


    /**
     * 列表累加
     *
     * @param         列表元素类型
     * @param sequence    列表
     * @param initial    初始值
     * @param op        二元操作符
     * @return            列表综合
     * @note            同foldLeft
     */
    public static <T> T accumulate(List<T> sequence, T initial, ListUtils.BinaryOperator<T> op) {
        T sum = initial;
        for (T e : sequence) {
            sum = op.operate(sum, e);
        }
        return sum;
    }

    /**
     * 列表左折叠，即从左往右遍历
     *
     * @param         列表元素类型
     * @param op        二元操作符
     * @param initial    初始值
     * @param sequence    列表
     * @return            列表综合值
     * @note            同accumulate，建议使用accumulate本函数
     */
    public static <T> T foldLeft(List<T> sequence, T initial, ListUtils.BinaryOperator<T> op) {
        T sum = initial;
        for (T e : sequence) {
            sum = op.operate(sum, e);
        }
        return sum;
    }

    /**
     * 列表右折叠，即从右往左遍历
     *
     * @param         列表元素类型
     * @param op        操作符
     * @param initial    初始值
     * @param sequence    列表
     * @return            列表综合值
     */
    public static <T> T foldRight(List<T> sequence, T initial, ListUtils.BinaryOperator<T> op) {
        T sum = initial;
        ListIterator<T> it = sequence.listIterator(sequence.size());
        while (it.hasPrevious()) {
            sum = op.operate(it.previous(), sum);
        }
        return sum;
    }
}

测试代码：

package listutils;

import java.util.ArrayList;
import java.util.List;

public class ListUtilsTest {

    private static final List<Integer> inList = new ArrayList<Integer>();

    public static void main(String[] args) {

        inList.add(1);
        inList.add(2);
        inList.add(3);
        inList.add(4);

        testFilter();
        testMap();
        testAccumulate();
        testReverse();
        testFoldRight();
    }

    public static void testFilter() {
        // 列表过滤器，过滤掉所有大于1的元素
        ListUtils.Predicator<Integer> predicator = new ListUtils.Predicator<Integer>() {
            @Override
            public boolean predicate(Integer e) {
                return e > 1;
            }
        };

        List<Integer> outList = ListUtils.filter(inList, predicator);
        System.out.println(inList);
        System.out.println(outList);
    }

    public static void testMap() {
        // 列表映射，映射成相反数
        List<Integer> outList = ListUtils.map(inList,
                new ListUtils.Mapper<Integer, Integer>() {
                    @Override
                    public Integer map(Integer e) {
                        return e * -1;
                    }
                });

        System.out.println(inList);
        System.out.println(outList);
    }

    public static void testReverse() {
        System.out.println(ListUtils.reverse(inList));
    }

    public static void testAccumulate() {

        // 列表累加
        Integer sum = ListUtils.accumulate(inList, 0, new ListUtils.BinaryOperator<Integer>() {

            @Override
            public Integer operate(Integer e1, Integer e2) {
                return e1 + e2;
            }
        });
        System.out.println(sum);
    }

    public static void testFoldRight() {

        // 加操作符
        ListUtils.BinaryOperator<Integer> adder = new ListUtils.BinaryOperator<Integer>() {
            @Override
            public Integer operate(Integer e1, Integer e2) {
                return e1 + e2;
            }
        };

        // 列表累加
        Integer sum = ListUtils.foldLeft(inList, 0, adder);
        // 反向累加
        Integer reversedSum = ListUtils.foldLeft(ListUtils.reverse(inList), 0,
            adder);

        System.out.println(sum);
        System.out.println(reversedSum);

        // 除操作符
        ListUtils.BinaryOperator<Double> diver = new ListUtils.BinaryOperator<Double>() {
            @Override
            public Double operate(Double e1, Double e2) {
                return e1 / e2;
            }
        };

        List<Double> newInList = ListUtils.map(inList, new ListUtils.Mapper<Integer, Double>() {
            @Override
            public Double map(Integer e) {
                return e.doubleValue();
            }
        });

        Double div = ListUtils.foldLeft(newInList, 1.0, diver);
        Double reverseDiv = ListUtils.foldRight(newInList, 1.0, diver);
        System.out.println(div);
        System.out.println(reverseDiv);
    }

}