java写的list processing utils-凯发app官方网站

凯发app官方网站-凯发k8官网下载客户端中心 | | 凯发app官方网站-凯发k8官网下载客户端中心
  • 博客访问: 99971
  • 博文数量: 18
  • 博客积分: 681
  • 博客等级: 中士
  • 技术积分: 295
  • 用 户 组: 普通用户
  • 注册时间: 2010-04-17 13:33
文章分类
文章存档

2012年(8)

2011年(10)

相关博文
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·

分类: java

2012-05-24 20:07:13

使用java写的几个列表处理函数,有以下几个函数:
  • filter,过滤,根据一个谓词判断过滤列表;
  • reverse,把一个列表反转;
  • map,把一个列表元素映射按照一定规则转换成另外一个列表;
  • accumulate,累“加”,加可定制;
  • foldleft,向左折叠,同accumulate;
  • foldright,向右折叠。
代码如下:

点击(此处)折叠或打开

  1. package listutils;

  2. import java.util.arraylist;
  3. import java.util.list;
  4. import java.util.listiterator;


  5. /**
  6.  * 列表工具

  7.  *
  8.  * 函数式编程中使用的一些常用列表函数
  9.  *
  10.  * @author lingyun.yang
  11.  */
  12. public class listutils {
  13.     
  14.     /**
  15.      * 谓词接口
  16.      * @param 参数类型
  17.      */
  18.     public interface predicator<t> {
  19.         /**
  20.          * 谓词判断
  21.          * @param e        输入参数
  22.          * @return        truefalse
  23.          */
  24.         boolean predicate(t e);
  25.     }
  26.     
  27.     /**
  28.      * 映射器接口
  29.      * @param 映射前参数类型
  30.      * @param 映射后参数类型
  31.      */
  32.     public interface mapper<t1, t2> {
  33.         /**
  34.          * @param e        输入参数
  35.          * @return        映射后结果
  36.          */
  37.         t2 map(t1 e);
  38.     }
  39.     
  40.     /**
  41.      * 二元操作符,在accumulate中使用
  42.      * @param     参数类型
  43.      */
  44.     public interface binaryoperator<t> {
  45.         /**
  46.          * @param e1    输入参数
  47.          * @param e2    输入参数
  48.          * @return        两个输入参数之和
  49.          */
  50.         t operate(t e1, t e2);
  51.     }
  52.     
  53.     /**
  54.      * 列表过滤
  55.      *
  56.      * @param             列表元素类型
  57.      * @param sequence        输入列表
  58.      * @param predicate     谓词
  59.      * @return                过滤后的列表
  60.      *
  61.      * 遍历列表,当列表元素的判断为真时就留下该元素
  62.      */
  63.     public static <t> list<t> filter(list<t> sequence, predicator<t> predicate) {
  64.         list<t> outseq = new arraylist<t>();
  65.         for (t e : sequence) {
  66.             if (predicate.predicate(e)) {
  67.                 outseq.add(e);
  68.             }
  69.         }
  70.         return outseq;
  71.     }
  72.     
  73.     /**
  74.      * 反转一个列表
  75.      *
  76.      * @param         列表元素 类型
  77.      * @param sequence    输入列表
  78.      * @return            反转过后的列表
  79.      */
  80.     public static <t> list<t> reverse(list<t> sequence) {
  81.         list<t> outseq = new arraylist<t>();
  82.         listiterator<t> it = sequence.listiterator(sequence.size());
  83.         while (it.hasprevious()) {
  84.             outseq.add(it.previous());
  85.         }
  86.         return outseq;
  87.     }
  88.     
  89.     /**
  90.      * 列表映射
  91.      *
  92.      * @param         输入列表元素类型
  93.      * @param         输出列表元素类型
  94.      * @param sequence    输入列表
  95.      * @param map        映射函数,使用接口实现
  96.      * @return            映射后的列表
  97.      *
  98.      * 遍历列表,映射每个元素
  99.      */
  100.     public static <t1, t2> list<t2> map(list<t1> sequence, listutils.mapper<t1, t2> map) {
  101.         list<t2> outseq = new arraylist<t2>();
  102.         for (t1 e: sequence) {
  103.             outseq.add(map.map(e));
  104.         }
  105.         return outseq;
  106.     }
  107.     
  108.     
  109.     /**
  110.      * 列表累加
  111.      *
  112.      * @param         列表元素类型
  113.      * @param sequence    列表
  114.      * @param initial    初始值
  115.      * @param op        二元操作符
  116.      * @return            列表综合
  117.      * @note            同foldleft
  118.      */
  119.     public static <t> t accumulate(list<t> sequence, t initial, listutils.binaryoperator<t> op) {
  120.         t sum = initial;
  121.         for (t e : sequence) {
  122.             sum = op.operate(sum, e);
  123.         }
  124.         return sum;    
  125.     }
  126.     
  127.     /**
  128.      * 列表左折叠,即从左往右遍历
  129.      *
  130.      * @param         列表元素类型
  131.      * @param op        二元操作符
  132.      * @param initial    初始值
  133.      * @param sequence    列表
  134.      * @return            列表综合值
  135.      * @note            同accumulate,建议使用accumulate本函数
  136.      */
  137.     public static <t> t foldleft(list<t> sequence, t initial, listutils.binaryoperator<t> op) {
  138.         t sum = initial;
  139.         for (t e : sequence) {
  140.             sum = op.operate(sum, e);
  141.         }
  142.         return sum;
  143.     }
  144.     
  145.     /**
  146.      * 列表右折叠,即从右往左遍历
  147.      *
  148.      * @param         列表元素类型
  149.      * @param op        操作符
  150.      * @param initial    初始值
  151.      * @param sequence    列表
  152.      * @return            列表综合值
  153.      */
  154.     public static <t> t foldright(list<t> sequence, t initial, listutils.binaryoperator<t> op) {
  155.         t sum = initial;
  156.         listiterator<t> it = sequence.listiterator(sequence.size());
  157.         while (it.hasprevious()) {
  158.             sum = op.operate(it.previous(), sum);
  159.         }
  160.         return sum;
  161.     }
  162. }
测试代码:

点击(此处)折叠或打开

  1. package listutils;

  2. import java.util.arraylist;
  3. import java.util.list;

  4. public class listutilstest {

  5.     private static final list<integer> inlist = new arraylist<integer>();

  6.     public static void main(string[] args) {
  7.         
  8.         inlist.add(1);
  9.         inlist.add(2);
  10.         inlist.add(3);
  11.         inlist.add(4);

  12.         testfilter();
  13.         testmap();
  14.         testaccumulate();
  15.         testreverse();
  16.         testfoldright();
  17.     }

  18.     public static void testfilter() {
  19.         // 列表过滤器,过滤掉所有大于1的元素
  20.         listutils.predicator<integer> predicator = new listutils.predicator<integer>() {
  21.             @override
  22.             public boolean predicate(integer e) {
  23.                 return e > 1;
  24.             }
  25.         };

  26.         list<integer> outlist = listutils.filter(inlist, predicator);
  27.         system.out.println(inlist);
  28.         system.out.println(outlist);
  29.     }

  30.     public static void testmap() {
  31.         // 列表映射,映射成相反数
  32.         list<integer> outlist = listutils.map(inlist,
  33.                 new listutils.mapper<integer, integer>() {
  34.                     @override
  35.                     public integer map(integer e) {
  36.                         return e * -1;
  37.                     }
  38.                 });

  39.         system.out.println(inlist);
  40.         system.out.println(outlist);
  41.     }

  42.     public static void testreverse() {
  43.         system.out.println(listutils.reverse(inlist));
  44.     }
  45.     
  46.     public static void testaccumulate() {
  47.         
  48.         // 列表累加
  49.         integer sum = listutils.accumulate(inlist, 0, new listutils.binaryoperator<integer>() {

  50.             @override
  51.             public integer operate(integer e1, integer e2) {
  52.                 return e1 e2;
  53.             }
  54.         });
  55.         system.out.println(sum);
  56.     }
  57.     
  58.     public static void testfoldright() {
  59.         
  60.         // 加操作符
  61.         listutils.binaryoperator<integer> adder = new listutils.binaryoperator<integer>() {
  62.             @override
  63.             public integer operate(integer e1, integer e2) {
  64.                 return e1 e2;
  65.             }
  66.         };
  67.         
  68.         // 列表累加
  69.         integer sum = listutils.foldleft(inlist, 0, adder);
  70.         // 反向累加
  71.         integer reversedsum = listutils.foldleft(listutils.reverse(inlist), 0,
  72.             adder);
  73.         
  74.         system.out.println(sum);
  75.         system.out.println(reversedsum);
  76.         
  77.         // 除操作符
  78.         listutils.binaryoperator<double> diver = new listutils.binaryoperator<double>() {
  79.             @override
  80.             public double operate(double e1, double e2) {
  81.                 return e1 / e2;
  82.             }
  83.         };
  84.         
  85.         list<double> newinlist = listutils.map(inlist, new listutils.mapper<integer, double>() {
  86.             @override
  87.             public double map(integer e) {
  88.                 return e.doublevalue();
  89.             }
  90.         });
  91.         
  92.         double div = listutils.foldleft(newinlist, 1.0, diver);
  93.         double reversediv = listutils.foldright(newinlist, 1.0, diver);
  94.         system.out.println(div);
  95.         system.out.println(reversediv);
  96.     }

  97. }

阅读(2311) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
")); function link(t){ var href= $(t).attr('href'); href ="?url=" encodeuricomponent(location.href); $(t).attr('href',href); //setcookie("returnouturl", location.href, 60, "/"); }
网站地图