Java的LINQ：Linq4j简明介绍

开发JAVA一段时间，面临的一大问题就是集合操作，习惯了LINQ的简洁语法，对JAVA的集合操作实在是无甚好感，只能通过C系的循环实现筛选等操作，由于没有延迟执行特性，内存占用实在不敢恭维。因此便在网上找到了linq4j, 一个针对JAVA的linq移植版本。下面的文章，就会对这一工具进行简要的介绍。

创新互联是一家以网络技术公司，为中小企业提供网站维护、成都网站设计、成都网站建设、网站备案、服务器租用、国际域名空间、软件开发、小程序制作等企业互联网相关业务，是一家有着丰富的互联网运营推广经验的科技公司，有着多年的网站建站经验，致力于帮助中小企业在互联网让打出自已的品牌和口碑，让企业在互联网上打开一个面向全国乃至全球的业务窗口：建站服务热线：13518219792

一. 安装

该项目的Github地址是：https://github.com/julianhyde/linq4j. 显然是一个个人项目，向作者致敬。

它并没有部署在标准的maven库里，因此需要手动编译生成。使用标准命令行:

 
 
 
    
  
  
  
  1. git clone git://github.com/julianhyde/linq4j.git linq4j    #git克隆到linq4j目录下  
    2.   
  
  
  2.  
    3.   
  
  
  3.      mvn compile  #编译  
    4.   
  
  
  4.  
    5.   
  
  
  5.      mvn test #测试  
    6.   
  
  
  6.  
    7.   
  
  
  7.      mvn jar:jar  #生成jar包 
    8.

使用了maven以后，工作效率大大提升，.当然NET下也有类似的工具nuget.

二. Linq4j的扩展功能

由于JAVA目前还没有匿名函数和扩展函数，而且内置的标准迭代器接口Iterator功能偏弱。 因此Linq4j增加了一个一系列泛型接口和函数：

1.  新迭代器接口： Enumerable，它扩展了Iterator的功能

2.  一组类似“委托”性质的函数：

（1）返回R的泛型委托：public interface Function {}

（2）接收T, 返回R的泛型委托：public interface Function1 {}

（3）接收T1，T2， 返回R的泛型委托，定义如下：

 
 
 
    
  
  
  
  1. /**   
    2.   
  
  
  2.  * Function with two parameters.   
    3.   
  
  
  3.  *   
    4.   
  
  
  4.  * @param  result type   
    5.   
  
  
  5.  * @param  type of parameter 1   
    6.   
  
  
  6.  * @param  type of parameter 2   
    7.   
  
  
  7.  */   
    8.   
  
  
  8. public interface Function2 extends Function {   
    9.   
  
  
  9.   R apply(T1 v1, T2 v2);   
    10.   
  
  
  10. } 
    11.

当然，内置的函数不止这些，还有一系列非泛型的委托，包括返回bool型的Predicate函数。由于篇幅限制，此处不一一介绍。

3. 一系列Expressions，具体使用下面有介绍。

三. 使用方法

该库实现了大部分LINQ的功能，其中包括了筛选器，排序器，分组器，类型转换等功能。下面我们以一个实例来介绍它。

先定义一个实体：

 
 
 
    
  
  
  
  1. public class Person  
    2.   
  
  
  2.     {  
    3.   
  
  
  3.     public int Age;  
    4.   
  
  
  4.     public String     Name;  
    5.   
  
  
  5.     public boolean Sex;  
    6.   
  
  
  6.     } 
    7.

我们的基本任务，是将一个Person集合中，所有性别为男（true）的名字取出来，并按照string的默认降序排列。***得到的应该是List类型。

 
 
 
    
  
  
  
  1. //Linq4j:  
    2.   
  
  
  2. public void Test(ArrayList persList)  
    3.   
  
  
  3.      {  
    4.   
  
  
  4.     java.util.List nameStrings=  Linq4j.asEnumerable(persList).where(new Predicate1()  
    5.   
  
  
  5.     {  
    6.   
  
  
  6.           
    7.   
  
  
  7.         public boolean apply(Person arg0)  
    8.   
  
  
  8.         {  
    9.   
  
  
  9.           
    10.   
  
  
  10.          return arg0.Sex;  
    11.   
  
  
  11.         }  
    12.   
  
  
  12.     }).select(new Function1()  
    13.   
  
  
  13.     {  
    14.   
  
  
  14.  
    15.   
  
  
  15.         public String apply(Person arg0)  
    16.   
  
  
  16.         {  
    17.   
  
  
  17.          return arg0.Name;  
    18.   
  
  
  18.         }  
    19.   
  
  
  19.     }).orderByDescending(new Function1()  
    20.   
  
  
  20.     {  
    21.   
  
  
  21.  
    22.   
  
  
  22.         public String apply(String arg0)  
    23.   
  
  
  23.         {  
    24.   
  
  
  24.         // TODO Auto-generated method stub  
    25.   
  
  
  25.         return arg0;  
    26.   
  
  
  26.         }  
    27.   
  
  
  27.     }).toList();  
    28.   
  
  
  28.      } 
    29.

这段代码的风格和C#的很像，由于接口Enumerable可以拼接，因此通过简单的Where，Select和 orderByDescending即可实现。但由于LINQ没有匿名函数，不得不在函数中加入函数，看起来实在是让人头疼。另外，由于没有扩展函数，需要在方法前使用Linq4j的静态方法。

该功能利用标准Linq实现如下：

 
 
 
    
  
  
  
  1. var userNames = from d in persons where d.Sex orderby d.Name descending select d.Name; 
    2.

在.NET中，我们可以使用闭包，例如在筛选函数的实现中，访问到外部的数据。但我们可以看如下的例子：

该函数的基本逻辑是找到personList中名字在黑名单里的人。套了两个Linq4j， 但是，注意blacklist数组的final关键字, 如果没有该关键字会报错，JAVA没有闭包，因此blacklist数组就不应该修改，这个语法糖到底是不是利大于弊，还需要读者讨论。

 
 
 
    
  
  
  
  1. public List SelectBlackList(ArrayList persList)  
    2.   
  
  
  2.     {  
    3.   
  
  
  3.     final String[] blackList = { "zhang", "wang", "li" };  
    4.   
  
  
  4.     return Linq4j.asEnumerable(persList)  
    5.   
  
  
  5.         .where(new Predicate1()  
    6.   
  
  
  6.         {  
    7.   
  
  
  7.  
    8.   
  
  
  8.             public boolean apply(Person arg0)  
    9.   
  
  
  9.             {  
    10.   
  
  
  10.             return Linq4j.asEnumerable(blackList).contains(  
    11.   
  
  
  11.                 arg0.Name);  
    12.   
  
  
  12.             }  
    13.   
  
  
  13.  
    14.   
  
  
  14.         }).toList();  
    15.   
  
  
  15.  
    16.   
  
  
  16.     } 
    17.

该功能使用标准Linq实现如下：

 
 
 
    
  
  
  
  1. public  List GetBlacklist(IEnumerable persons)  
    2.   
  
  
  2.          {  
    3.   
  
  
  3.              String[] blackList = { "zhang", "wang", "li" };  
    4.   
  
  
  4.              var result= from d in persons where blackList.Contains(d.Name) select d;  
    5.   
  
  
  5.              return result.ToList();  
    6.   
  
  
  6.          } 
    7.

***讨论一下集合类型转换，例如类Worker继承实现了Person接口.

 
 
 
    
  
  
  
  1. public class Worker : Person  
    2.   
  
  
  2.     {  
    3.   
  
  
  3.         public string Commpay ;  
    4.   
  
  
  4.     }  
    5.   
  
  
  5.  
    6.

那么，一个函数的定义是  void Func(List nodes). 而我要传入的参数类型是List，编译器肯定是要报错的！怎么办？

对于.NET来说，有逆变和协变特性，或者我可以这么做：

 
 
 
    
  
  
  
  1. public  void Test3(Listworkers )  
    2.   
  
  
  2.         {  
    3.   
  
  
  3.             this.Func1(workers); //编译器会报错  
    4.   
  
  
  4.             this.Func1(workers.OfType());  
    5.   
  
  
  5.         }  
    6.   
  
  
  6.         public void Func1(IEnumerablepersons )  
    7.   
  
  
  7.         {  
    8.   
  
  
  8.             //只是演示，没有实现功能  
    9.   
  
  
  9.       } 
    10.

对于JAVA来说，一般的做法，是在外面加一个转换，通过新建Person集合和foreach迭代器，利用强制类型转换将其转变为List. 这实在是太麻烦了。 利用LiNQ4J， 我们也有类似的语法：

 
 
 
    
  
  
  
  1. public void Func2(List person)  
    2.   
  
  
  2.     {  
    3.   
  
  
  3.     //演示，不实现功能  
    4.   
  
  
  4.     }  
    5.   
  
  
  5.     public void Test3(List workers)//1.通过最简单粗暴的循环写法，实现功能，不敢恭维。  
    6.   
  
  
  6.     {  
    7.   
  
  
  7.     // Func2(workers); // 此处编译器会报错  
    8.   
  
  
  8.     List persons = new ArrayList();  
    9.   
  
  
  9.     for (Person person : workers)  
    10.   
  
  
  10.     {  
    11.   
  
  
  11.         persons.add(person);    
    12.   
  
  
  12.     }  
    13.   
  
  
  13.                     Func2(persons);  
    14.   
  
  
  14.     }  
    15.   
  
  
  15.     public void Test4linq(List workers)  //2.linq4j写法  
    16.   
  
  
  16.     {  
    17.   
  
  
  17.     List persons = Linq4j.asEnumerable(workers)  
    18.   
  
  
  18.         .ofType(Person.class).toList();   
    19.   
  
  
  19.     Func2(persons);  
    20.   
  
  
  20.     } 
    21.

linq4j除了提供了这种显式声明函数的写法，还实现了以下的表达式写法，看起来真是高端洋气上档次：

 
 
 
    
  
  
  
  1. // use lambda, this time call whereN  
    2.   
  
  
  2.     ParameterExpression parameterE =  
    3.   
  
  
  3.         Expressions.parameter(Employee.class);  
    4.   
  
  
  4.     ParameterExpression parameterN =  
    5.   
  
  
  5.         Expressions.parameter(Integer.TYPE);  
    6.   
  
  
  6.     final Queryable nh3 =  
    7.   
  
  
  7.         Linq4j.asEnumerable(emps)  
    8.   
  
  
  8.             .asQueryable()  
    9.   
  
  
  9.             .whereN(  
    10.   
  
  
  10.                 Expressions.lambda(  
    11.   
  
  
  11.                     Predicate2.class,  
    12.   
  
  
  12.                     Expressions.andAlso(  
    13.   
  
  
  13.                         Expressions.equal(  
    14.   
  
  
  14.                             Expressions.field(  
    15.   
  
  
  15.                                 parameterE,  
    16.   
  
  
  16.                                 Employee.class,  
    17.   
  
  
  17.                                 "deptno"),  
    18.   
  
  
  18.                             Expressions.constant(10)),  
    19.   
  
  
  19.                         Expressions.lessThan(  
    20.   
  
  
  20.                             parameterN,  
    21.   
  
  
  21.                             Expressions.constant(3))),  
    22.   
  
  
  22.                     parameterE,  
    23.   
  
  
  23.                     parameterN)); 
    24.

看起来很唬人，但想起来其实不难。该功能利用Expressions类的静态方法，提供了一系列现成的函数供调用，一定程度上进一步提升了可用性。具体细节可以参照linq4j的源码，此处不打算深入讨论。

四. 总结

Linq4j实现了标准Linq的绝大多数功能，同时利用Expression类简化了很多简单函数的实现。使用起来还是很方便的，但我没有时间做具体的性能测试，因此在性能上没有发言权。但不论如何，膜拜一下作者的技术水平。如果大家有空，可以看看linq4j的源码，一定会有很多收获。

集合操作是应用开发中最普遍的开发情形，可惜JAVA本身在该处并无太大建树，linq4j能不能用在大型项目上很难说，如果能在语言本身享受这种便利，那是***不过的了，.NET系同学应该感到幸福。我们只能期待JAVA8带来的lamda表达式新特性，能更好的解决这个问题，当然这只能在2014年了。

为了方便那些不用maven的同学，附件加上linq4j的jar包下载。 注意下载后改后缀名为jar.

原文链接：http://www.cnblogs.com/buptzym/p/3282020.html

网页题目：Java的LINQ：Linq4j简明介绍
当前网址：http://www.csdahua.cn/qtweb/news10/2260.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

App开发知识

行业网站建设

自适应网页设计　　 　温江服务器租用　　 　乐山中领科信　　 　云主机　　 　成都酒店服定制　　 　内江智速网站建设　　 　成都公司注册　　 　资阳做网站　　 　成都网站建设　　 　绵阳发电机　　 　德阳服务器托管　　 　企业邮箱　　 　简阳服务器托管　　 　成都网站推广　　 　建站定制开发　　 　营山产后护理　　 　消防维保　　 　定制网站建设　　 　成都网站建设哪家好　　 　乐山托管服务器