使用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);
- }
- }
阅读(2311) | 评论(0) | 转发(0) |