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

凯发app官方网站-凯发k8官网下载客户端中心 | | 凯发app官方网站-凯发k8官网下载客户端中心

碧海蓝天

凯发app官方网站首页　| 　博文目录　| 　关于我

sudayly

  • 博客访问： 99971
  • 博文数量： 18
  • 博客积分： 681
  • 博客等级： 中士
  • 技术积分： 295
  • 用 户 组： 普通用户
  • 注册时间： 2010-04-17 13:33
文章分类

全部博文（18）

文章存档

2012年（8）

2011年（10）

我的朋友
最近访客
推荐博文
相关博文
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
java写的list processing utils

分类： java

2012-05-24 20:07:13

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

点击(此处)折叠或打开

  1. package listutils;

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


  8. /**
  9.  * 列表工具

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

点击(此处)折叠或打开

  1. package listutils;

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

  6. public class listutilstest {

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

  10.     public static void main(string[] args) {
  11.         
  12.         inlist.add(1);
  13.         inlist.add(2);
  14.         inlist.add(3);
  15.         inlist.add(4);

  17.         testfilter();
  18.         testmap();
  19.         testaccumulate();
  20.         testreverse();
  21.         testfoldright();
  22.     }

  24.     public static void testfilter() {
  25.         // 列表过滤器，过滤掉所有大于1的元素
  26.         listutils.predicator<integer> predicator = new listutils.predicator<integer>() {
  27.             @override
  28.             public boolean predicate(integer e) {
  29.                 return e > 1;
  30.             }
  31.         };

  33.         list<integer> outlist = listutils.filter(inlist, predicator);
  34.         system.out.println(inlist);
  35.         system.out.println(outlist);
  36.     }

  38.     public static void testmap() {
  39.         // 列表映射，映射成相反数
  40.         list<integer> outlist = listutils.map(inlist,
  41.                 new listutils.mapper<integer, integer>() {
  42.                     @override
  43.                     public integer map(integer e) {
  44.                         return e * -1;
  45.                     }
  46.                 });

  48.         system.out.println(inlist);
  49.         system.out.println(outlist);
  50.     }

  52.     public static void testreverse() {
  53.         system.out.println(listutils.reverse(inlist));
  54.     }
  55.     
  56.     public static void testaccumulate() {
  57.         
  58.         // 列表累加
  59.         integer sum = listutils.accumulate(inlist, 0, new listutils.binaryoperator<integer>() {

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

  109. }

阅读(2311) | 评论(0) | 转发(0) |
0

上一篇：

下一篇：mysql length encoded integer的编码与解码

给主人留下些什么吧！~~
| | | | |

凯发app官方网站 copyright 2001-2010 chinaunix.net all rights reserved 北京皓辰网域网络信息技术有限公司. 凯发k8官网下载客户端中心的版权所有

感谢所有关心和支持过chinaunix的朋友们
")); function link(t){ var href= $(t).attr('href'); href ="?url=" encodeuricomponent(location.href); $(t).attr('href',href); //setcookie("returnouturl", location.href, 60, "/"); }
网站地图