java的LINQ :Linq4j簡明介紹

　　開發JAVA一段時間，面臨的一大問題就是集合操作，習慣了LINQ的簡潔語法，對JAVA的集合操作實在是無甚好感，只能通過C系的迴圈實現篩選等操作，由於沒有延遲執行特性，記憶體佔用實在不敢恭維。因此便在網上找到了linq4j, 一個針對JAVA的linq移植版本。下面的文章，就會對這一工具進行簡要的介紹。

　　一. 安裝

     該專案的Github地址是：https://github.com/julianhyde/linq4j. 顯然是一個個人專案，向作者致敬。

     它並沒有部署在標準的maven庫裡，因此需要手動編譯生成。使用標準命令列:

git clone git://github.com/julianhyde/linq4j.git linq4j    #git克隆到linq4j目錄下

     mvn compile  #編譯

     mvn test #測試

     mvn jar:jar  #生成jar包

     使用了maven以後，工作效率大大提升，.當然NET下也有類似的工具nuget.

　　二. Linq4j的擴充套件功能

     由於JAVA目前還沒有匿名函式和擴充套件函式，而且內建的標準迭代器介面Iterator功能偏弱。 因此Linq4j增加了一個一系列泛型介面和函式：

     1.  新迭代器介面： Enumerable<T>，它擴充套件了Iterator的功能

　　2.  一組類似“委託”性質的函式： 

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

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

         (3)  接收T1，T2， 返回R的泛型委託，定義如下：

/** 
 * Function with two parameters. 
 * 
 * @param <R> result type 
 * @param <T1> type of parameter 1 
 * @param <T2> type of parameter 2 
 */ 
public interface Function2<T1, T2, R> extends Function<R> { 
  R apply(T1 v1, T2 v2); 
}

　　當然，內建的函式不止這些，還有一系列非泛型的委託，包括返回bool型的Predicate函式。由於篇幅限制，此處不一一介紹。

　　3. 一系列Expressions，具體使用下面有介紹。

    三. 使用方法

     該庫實現了大部分LINQ的功能，其中包括了篩選器，排序器，分組器，型別轉換等功能。下面我們以一個例項來介紹它。

      先定義一個實體：

public class Person
{
    public int Age;
    public String     Name;
    public boolean Sex;
}

      我們的基本任務，是將一個Person集合中，所有性別為男（true）的名字取出來，並按照string的預設降序排列。最後得到的應該是List<String>型別。

//Linq4j:
public void Test(ArrayList<Person> persList)
{
    java.util.List<String> nameStrings=  Linq4j.asEnumerable(persList).where(new Predicate1<Linq4jTest.Person>()
    {
        
        public boolean apply(Person arg0)
        {
        
         return arg0.Sex;
        }
    }).select(new Function1<Linq4jTest.Person, String>()
    {

        public String apply(Person arg0)
        {
         return arg0.Name;
        }
    }).orderByDescending(new Function1<String, String>()
    {

        public String apply(String arg0)
        {
        // TODO Auto-generated method stub
        return arg0;
        }
    }).toList();
 }

      這段程式碼的風格和C#的很像，由於介面Enumerable可以拼接，因此通過簡單的Where，Select和orderByDescending即可實現。但由於LINQ沒有匿名函式，不得不在函式中加入函式，看起來實在是讓人頭疼。另外，由於沒有擴充套件函式，需要在方法前使用Linq4j的靜態方法。

　　該功能利用標準Linq實現如下：

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

     在.NET中，我們可以使用閉包，例如在篩選函式的實現中，訪問到外部的資料。但我們可以看如下的例子：

     該函式的基本邏輯是找到personList中名字在黑名單裡的人。套了兩個Linq4j， 但是，注意blacklist陣列的final關鍵字, 如果沒有該關鍵字會報錯，JAVA沒有閉包，因此blacklist陣列就不應該修改，這個語法糖到底是不是利大於弊，還需要讀者討論。

public List<Person> SelectBlackList(ArrayList<Person> persList)
 {
    final String[] blackList = { "zhang", "wang", "li" };
    return Linq4j.asEnumerable(persList)
        .where(new Predicate1<Linq4jTest.Person>()
        {

            public boolean apply(Person arg0)
            {
            return Linq4j.asEnumerable(blackList).contains(
                arg0.Name);
            }

        }).toList();

 }

     該功能使用標準Linq實現如下：

public  List<Person> GetBlacklist(IEnumerable<Person> persons)
{
             String[] blackList = { "zhang", "wang", "li" };
             var result= from d in persons where blackList.Contains(d.Name) select d;
             return result.ToList();
}

     最後討論一下集合型別轉換，例如類Worker繼承實現了Person介面.

public class Worker : Person
 {
        public string Commpay ;
 }

     那麼，一個函式的定義是  void Func(List<Person> nodes). 而我要傳入的引數型別是List<Worker>，編譯器肯定是要報錯的！怎麼辦？

     對於.NET來說，有逆變和協變特性，或者我可以這麼做：

public  void Test3(List<Worker>workers )
 {
            this.Func1(workers); //編譯器會報錯
            this.Func1(workers.OfType<Person>());
        }
        public void Func1(IEnumerable<Person>persons )
        {
            //只是演示，沒有實現功能
 }

    對於JAVA來說，一般的做法，是在外面加一個轉換，通過新建Person集合和foreach迭代器，利用強制型別轉換將其轉變為List<Person>. 這實在是太麻煩了。 利用LiNQ4J， 我們也有類似的語法：

public void Func2(List<Person> person)
 {
    //演示，不實現功能
    }
    public void Test3(List<Worker> workers)//1.通過最簡單粗暴的迴圈寫法，實現功能，不敢恭維。
    {
    // Func2(workers); // 此處編譯器會報錯
    List<Person> persons = new ArrayList<Linq4jTest.Person>();
    for (Person person : workers)
    {
        persons.add(person);  
    }
                    Func2(persons);
    }
    public void Test4linq(List<Worker> workers)  //2.linq4j寫法
    {
    List<Person> persons = Linq4j.asEnumerable(workers)
        .ofType(Person.class).toList(); 
    Func2(persons);
 }

    linq4j除了提供了這種顯式宣告函式的寫法，還實現了以下的表示式寫法，看起來真是高階洋氣上檔次：

// use lambda, this time call whereN
    ParameterExpression parameterE =
        Expressions.parameter(Employee.class);
    ParameterExpression parameterN =
        Expressions.parameter(Integer.TYPE);
    final Queryable<Employee> nh3 =
        Linq4j.asEnumerable(emps)
            .asQueryable()
            .whereN(
                Expressions.lambda(
                    Predicate2.class,
                    Expressions.andAlso(
                        Expressions.equal(
                            Expressions.field(
                                parameterE,
                                Employee.class,
                                "deptno"),
                            Expressions.constant(10)),
                        Expressions.lessThan(
                            parameterN,
                            Expressions.constant(3))),
                    parameterE,
                    parameterN));

     看起來很唬人，但想起來其實不難。該功能利用Expressions類的靜態方法，提供了一系列現成的函式供呼叫，一定程度上進一步提升了可用性。具體細節可以參照linq4j的原始碼，此處不打算深入討論。

      四. 總結

        Linq4j實現了標準Linq的絕大多數功能，同時利用Expression類簡化了很多簡單函式的實現。使用起來還是很方便的，但我沒有時間做具體的效能測試，因此在效能上沒有發言權。但不論如何，膜拜一下作者的技術水平。如果大家有空，可以看看linq4j的原始碼，一定會有很多收穫。

        集合操作是應用開發中最普遍的開發情形，可惜JAVA本身在該處並無太大建樹，linq4j能不能用在大型專案上很難說，如果能在語言本身享受這種便利，那是最好不過的了，.NET系同學應該感到幸福。我們只能期待JAVA8帶來的lamda表示式新特性，能更好的解決這個問題，當然這隻能在2014年了。

        為了方便那些不用maven的同學，附件加上linq4j的jar包下載。 注意下載後改字尾名為jar.