Java的jLinqer包介绍

1.介绍

熟悉C#的lambda 表达式，想要使用 LINQ 在 Java，是个问题，虽然 Java8用函数式接口已经实现了部分lambda 表达式，但是还是不够灵活。

2.Linqer简介

Linqer 是在 Java 中的可以使用 LINQ 语言集成查询 (LINQ)。可以弥补目前Java8在 LINQ方面的一些不足，实现了在 c# 中 的(selectMany，Union, Intersect, Except等)。

3.使用方法

如果你使用 Maven，请在以下 pom.xml 应用以下包。

<dependency>
    <groupId>com.github.jlinqer</groupId>
    <artifactId>jlinqer</artifactId>
    <version>1.0.0</version>
</dependency>

如果没有使用Maven 时，直接使用 jLinqer jar，下载地址：

https://oss.sonatype.org/content/groups/public/com/github/jlinqer/jlinqer/1.0.0/jlinqer-1.0.0.jar

4.LINQ jLinqer 对比

功能 LINQ(C#) jLinqer(Java) Stream(Java)
【基本】      
筛选 Where where filter
投影 Select select map
排序（升序） OrderBy orderBy sorted
排序（降序） OrderByDescending orderByDescending n/a
按升序对序列中的元素执行后续排序 ThenBy thenBy n/a
按降序对序列中的元素执行后续排序。 ThenByDescending thenByDescending n/a
将序列的每个元素投影到 IEnumerable<T> 并将结果序列合并为一个序列。 SelectMany selectMany flatMap
【提取】      
跳过序列中指定数量的元素，然后返回剩余的元素。 Skip skip skip
只要满足指定的条件，就跳过序列中的元素，然后返回剩余元素。 SkipWhile skipWhile n/a
从序列的开头返回指定数量的连续元素。 Take take limit
只要满足指定的条件，就会返回序列的元素，然后跳过剩余的元素。 TakeWhile takeWhile n/a
【合成】      
连接两个序列 Concat concat concat
生成两个序列的交集 Intersect intersect n/a
生成两个序列的并集 Union union n/a
生成两个序列的差集 Except except n/a
基于匹配键对两个序列的元素进行关联 Join join n/a
基于键相等对两个序列的元素进行关联并对结果进行分组 GroupJoin groupJoin n/a
反转序列中元素的顺序 Reverse reverse n/a
将指定函数应用于两个序列的对应元素，以生成结果序列 Zip zip n/a
【分组和总计】      
返回序列中的非重复元素 Distinct distinct distinct
累加器函数 Aggregate aggregate reduce
对序列中的元素进行分组 GroupBy groupBy Collectors.groupingBy
计算数值序列的平均值 Average averageXXX Collectors.summarizingXXX
返回序列中的元素数量 Count count n/a
返回一个 Int64，表示序列中的元素的数量 LongCount longCount count
返回值序列中的最大值 Max max max
返回值序列中的最小值 Min min min
计算数值序列之和 Sum sumXXX Collectors.summarizingXXX
返回序列中的第一个元素 First first findFirst
返回序列中的第一个元素；如果未找到元素，则返回默认值 FirstOrDefault firstOrDefault n/a
返回序列的最后一个元素 Last last n/a
返回序列中的最后一个元素；如果未找到元素，则返回默认值 LastOrDefault lastOrDefault n/a
返回值序列的单个特定元素 Single single n/a
返回序列中单个特定元素，如果未找到这样的元素，则返回默认值 SingleOrDefault singleOrDefault n/a
返回指定序列的元素；如果序列为空，则返回集合中的类型参数的默认值。 DefaultIfEmpty defaultIfEmpty n/a
返回序列中指定索引处的元素 ElementAt elementAt n/a
返回序列中指定索引处的元素；如果索引超出范围，则返回默认值 ElementAtOrDefault elementAtOrDefault n/a
确定序列中的所有元素是否满足条件 All all allMatch
确定序列中的任何元素是否存在或满足条件 Any any anyMatch
【区间】      
返回一个具有指定的类型参数的空 Empty empty n/a
生成指定范围内的整数的序列 Range range n/a
生成包含一个重复值的序列 Repeat repeat n/a
【其他】      
根据相等比较器确定两个序列是否相等 SequenceEqual sequenceEqual n/a
强制转换为指定的类型 Cast cast n/a
根据指定类型筛选 IEnumerable 的元素 OfType ofType n/a

5.使用方法

Where

1 List<Integer> list = new List<>(1, 2, 3);
2
3 List<Integer> actual = list.where(x -> x == 1 || x == 3).toList();
4
5 assertEquals(true , actual.contains(1));
6 assertEquals(false, actual.contains(2));
7 assertEquals(true , actual.contains(3));

Select

 1 List<Person> list = new List<>(
 2 new Person("React" , 1),
 3 new Person("Angular" , 3),
 4 new Person("Backbone", 5)
 5 );
 6
 7 List<String> actual = list.select(x -> x.name).toList();
 8
 9 assertEquals("React" , actual.get(0));
10 assertEquals("Angular" , actual.get(1));
11 assertEquals("Backbone", actual.get(2));

OrderBy

1 List<String> list = new List<>("Backbone", "Angular", "React");
2
3 List<String> actual = list.orderBy(x -> x).toList();
4
5 assertEquals("Angular" , actual.get(0));
6 assertEquals("Backbone", actual.get(1));
7 assertEquals("React" , actual.get(2));

OrderByDescending

1 List<String> list = new List<>("Backbone", "Angular", "React");
2
3 List<String> actual = list.orderByDescending(x -> x).toList();
4
5 assertEquals("React" , actual.get(0));
6 assertEquals("Backbone", actual.get(1));
7 assertEquals("Angular" , actual.get(2));

ThenBy

 1 List<Person> list = new List<>(
 2 new Person("Angular2", 2),
 3 new Person("Angular1", 2),
 4 new Person("React" , 1)
 5 );
 6
 7 List<String> actual = list.orderBy(x -> x.age).thenBy(x -> x.name).toList();
 8
 9 assertEquals("React" , actual.get(0).name);
10 assertEquals("Angular1", actual.get(1).name);
11 assertEquals("Angular2" , actual.get(2).name);

ThenByDescending

 1 List<Person> list = new List<>(
 2 new Person("Angular2", 2),
 3 new Person("Angular1", 2),
 4 new Person("React" , 1)
 5 );
 6
 7 List<String> actual = list.orderBy(x -> x.age).thenByDescending(x -> x.name).toList();
 8
 9 assertEquals("React" , actual.get(0).name);
10 assertEquals("Angular2", actual.get(1).name);
11 assertEquals("Angular1" , actual.get(2).name);

SelectMany

 1 List<Person> list = new List<>(
 2 new Person("Angular", 3, new List("1.0.1", "1.0.2")),
 3 new Person("React" , 1, new List("2.0.1", "2.0.2"))
 4 );
 5
 6 List<String> actual = list.selectMany(x -> x.versionHistory).toList();
 7
 8 assertEquals("1.0.1", actual.get(0));
 9 assertEquals("1.0.2", actual.get(1));
10 assertEquals("2.0.1", actual.get(2));
11 assertEquals("2.0.2", actual.get(3));

Skip

1 List<Integer> list = new List<>(1, 2, 3);
2
3 List<Integer> actual = list.skip(2).toList();
4
5 assertEquals(3, actual.get(0).intValue());

SkipWhile

1 List<Integer> list = new List<>(1, 2, 3, 4, 5);
2
3 List<Integer> actual = list.skipWhile(x -> x <= 3).toList();
4
5 assertEquals(4, actual.get(0).intValue());
6 assertEquals(5, actual.get(1).intValue());

Take

1 List<String> list = new List<>("Backbone", "Angular", "React");
2
3 List<String> actual = list.take(2).toList();
4
5 assertEquals(2, actual.size());
6 assertEquals("Backbone", actual.get(0));
7 assertEquals("Angular" , actual.get(1));

TakeWhile

1 List<String> list = new List<>("Backbone", "Angular", "React");
2
3 List<String> actual = list.takeWhile(x -> x.equals("Backbone") || x.equals("Angular")).toList();
4
5 assertEquals(2, actual.size());
6 assertEquals("Backbone", actual.get(0));
7 assertEquals("Angular" , actual.get(1));

Concat

1 List<Integer> first = new List<>(1, 2);
2 List<Integer> second = new List<>(2, 3);
3
4 List<Integer> actual = first.concat(second).toList();
5
6 assertEquals(1, actual.get(0).intValue());
7 assertEquals(2, actual.get(1).intValue());
8 assertEquals(2, actual.get(2).intValue());
9 assertEquals(3, actual.get(3).intValue());

Intersect

1 List<Integer> first = new List<>(1, 2, 3);
2 List<Integer> second = new List<>(1, 3);
3
4 List<Integer> actual = first.intersect(second).toList();
5
6 assertEquals(1, actual.get(0).intValue());
7 assertEquals(3, actual.get(1).intValue());

Union

 1 List<Integer> first = new List<>(1, 2, 3);
 2 List<Integer> second = new List<>(0, 1, 3, 4);
 3
 4 List<Integer> actual = first.union(second).toList();
 5
 6 assertEquals(5, actual.size());
 7 assertEquals(1, actual.get(0).intValue());
 8 assertEquals(2, actual.get(1).intValue());
 9 assertEquals(3, actual.get(2).intValue());
10 assertEquals(0, actual.get(3).intValue());
11 assertEquals(4, actual.get(4).intValue());

Except

1 List<Integer> first = new List<>(1, 2, 3);
2 List<Integer> second = new List<>(1, 3);
3
4 List<Integer> actual = first.except(second).toList();
5
6 assertEquals(2, actual.get(0).intValue());

Join

 1 List<Javascript> outer = new List<>(
 2 new Javascript("Angular", 1),
 3 new Javascript("React" , 4),
 4 new Javascript("ES2016" , 5)
 5 );
 6 List<Javascript> inner = new List<>(
 7 new Javascript("Angular", 2),
 8 new Javascript("Angular", 3),
 9 new Javascript("ES2016" , 6),
10 new Javascript("ES7" , 7)
11 );
12
13 Function<Javascript, String> outerKey = (x) -> x.name;
14 Function<Javascript, String> innerKey = (y) -> y.name;
15 BiFunction<Javascript, Javascript, Javascript> selector = (x, y) -> new Javascript(x.name, y.age);
16 List<Javascript> actual = outer.join(inner, outerKey, innerKey, selector).toList();
17
18 assertEquals(3, actual.size());
19 assertEquals("Angular", actual.get(0).name);
20 assertEquals("Angular", actual.get(1).name);
21 assertEquals("ES2016" , actual.get(2).name);
22 assertEquals(2, actual.get(0).age);
23 assertEquals(3, actual.get(1).age);
24 assertEquals(6, actual.get(2).age);

GroupJoin

 1 List<Javascript> outer = new List<>(
 2 new Javascript("Angular", 1),
 3 new Javascript("React" , 4),
 4 new Javascript("ES2016" , 5)
 5 );
 6 List<Javascript> inner = new List<>(
 7 new Javascript("Angular", 2),
 8 new Javascript("Angular", 3),
 9 new Javascript("ES2016" , 6),
10 new Javascript("ES7" , 7)
11 );
12
13 Function<Javascript, String> outerKey = (x) -> x.name;
14 Function<Javascript, String> innerKey = (y) -> y.name;
15 BiFunction<Javascript, IEnumerable<Javascript>, Javascript> selector = (x, y) -> new Javascript(x.name, y.select(z -> z.age));
16 List<Javascript> actual = outer.groupJoin(inner, outerKey, innerKey, selector).toList();
17
18 assertEquals(3, actual.size());
19 assertEquals("Angular", actual.get(0).name);
20 assertEquals("React" , actual.get(1).name);
21 assertEquals("ES2016" , actual.get(2).name);
22 assertEquals(2, actual.get(0).ages.elementAt(0));
23 assertEquals(3, actual.get(0).ages.elementAt(1));
24 assertEquals(0, actual.get(1).ages.count());
25 assertEquals(6, actual.get(2).ages.elementAt(0));

Reverse

1 List<Integer> list = new List<>(1, 2, 3);
2
3 List<Integer> actual = list.reverse().toList();
4
5 assertEquals(3, actual.get(0).intValue());
6 assertEquals(2, actual.get(1).intValue());
7 assertEquals(1, actual.get(2).intValue());

Zip

1 List<Integer> first = new List<>(1, 2, 3);
2 List<String> second = new List<>("Angular", "React", "Backbone");
3
4 List<Integer> actual = first.zip(second, (x, y) -> String.format("%s %d", x, y)).toList();
5
6 assertEquals("1 Angular" , actual.get(0));
7 assertEquals("2 React" , actual.get(1));
8 assertEquals("3 Backbone", actual.get(2));

Distinct

1 List<Integer> list =new List<>(1, 2, 3,1, 2, 3, 4);
2
3 List<Integer> actual = list.distinct().toList();
4
5 assertEquals(1, actual.get(0).intValue());
6 assertEquals(2, actual.get(1).intValue());
7 assertEquals(3, actual.get(2).intValue());
8 assertEquals(4, actual.get(3).intValue());

Aggregate

1 List<Integer> list = new List<>(1, 2, 3);
2
3 int actual = list.aggregate((sum, elem) -> sum + elem);
4
5 assertEquals(6, actual);

GroupBy

 1 List<Person> list = new List<>(
 2 new Person("React" , 1),
 3 new Person("Angular" , 1),
 4 new Person("Backbone", 5)
 5 );
 6
 7 Map<Integer, IEnumerable<Person>> actual = list.groupBy(x -> x.age);
 8
 9 assertEquals(true, actual.get(1).any(x -> x.name.equals("React")));
10 assertEquals(true, actual.get(1).any(x -> x.name.equals("Angular")));
11 assertEquals(true, actual.get(5).any(x -> x.name.equals("Backbone")));

Average

1 List<Long> listLong = new List<>(1l, 2l, 3l, 4l);
2
3 double actualLong = listLong.averageLong(x -> x);
4
5 assertEquals(2.5d, actualLong, 0);

Count

1 List<String> list = new List<>("Backbone", "Angular", "React");
2
3 long actual = list.longCount();
4 int actualNone = list.count(x -> x.equals("jquery"));
5
6 assertEquals(3, actual);
7 assertEquals(0, actualNone);

Max

1 List<Double> listDouble = new List<>(1d, 2d, 3d);
2
3 double actualDouble = listDouble.max(x -> x);
4
5 assertEquals(3d, actualDouble, 0);

Min

1 List<BigDecimal> listBigDecimal = new List<>(
2 new BigDecimal(1d),
3 new BigDecimal(2d),
4 new BigDecimal(3d)
5 );
6
7 BigDecimal actualBigDecimal = listBigDecimal.min(x -> x);
8
9 assertEquals(1d, actualBigDecimal.doubleValue(), 0);

Sum

1 List<Integer> listInt = new List<>(1, 2, 3);
2
3 int actualInt = listInt.sumInt(x -> x);
4
5 assertEquals(6, actualInt);

FirstOrDefault

1 List<String> list = new List<>("Backbone", "Angular", "React");
2
3 String actualFirst = list.firstOrDefault();
4 String actualMatch = list.firstOrDefault(x -> x.equals("Angular"));
5 String actualUnMatch = list.firstOrDefault(x -> x.equals("jquery"));
6
7 assertEquals("Backbone", actualFirst);
8 assertEquals("Angular" , actualMatch);
9 assertEquals(null , actualUnMatch);

LastOrDefault

1 List<Integer> list = new List<>(1, 2, 3);
2 List<Integer> listEmpty = new List<>();
3
4 int actual = list.lastOrDefault();
5 Integer actualDefaultNone = listEmpty.lastOrDefault(x -> x == 0);
6
7 assertEquals(3, actual);
8 assertEquals(null, actualDefaultNone);

SingleOrDefault

1 List<Integer> listMany = new List<>(1, 2, 3);
2 List<Integer> listEmpty = new List<>();
3
4 int actualFilter = listMany.singleOrDefault(x -> x == 3);
5 Integer actualUnMatch = listEmpty.singleOrDefault(x -> x == 0);
6
7 assertEquals(3, actualFilter);
8 assertEquals(null, actualUnMatch);

DefaultIfEmpty

 1 List<String> listEmpty = new List<>();
 2
 3 List<String> actualDefault = listEmpty.defaultIfEmpty("ES7").toList();
 4
 5 assertEquals("ES7", actualDefault.get(0));
 6 ElementAtOrDefault
 7
 8 List<Integer> list = new List<>(1, 2, 3);
 9
10 int actual = list.elementAtOrDefault(2);
11 Integer actualDefault = list.elementAtOrDefault(3);
12
13 assertEquals(3, actual);
14 assertEquals(null, actualDefault);

All

1 List<String> list = new List<>("Backbone", "Angular", "React");
2
3 boolean actual = list.all(x -> x.equals("Angular") || x.equals("Backbone") || x.equals("React"));
4 boolean actualNotFound = list.all(x -> x.equals("Angular") || x.equals("React"));
5
6 assertEquals(true, actual);
7 assertEquals(false, actualNotFound);

Any

1 List<String> list = new List<>("Backbone", "Angular", "React");
2
3 boolean actual = list.any(x -> x.equals("Angular"));
4 boolean actualNotFound = list.any(x -> x.equals("jquery"));
5
6 assertEquals(true, actual);
7 assertEquals(false, actualNotFound);

Empty

1 List<Double> actual = IEnumerable.empty(Double.class);
2
3 assertEquals(0, actual.count());

Range

1 List<Integer> actual = IEnumerable.range(-2, 3);
2
3 assertEquals(-2, actual.get(0).intValue());
4 assertEquals(-1, actual.get(1).intValue());
5 assertEquals(0 , actual.get(2).intValue());

Repeat

 1 List<String> actual = IEnumerable.repeat(String.class, "Law of Cycles", 10);
 2
 3 assertEquals(10, actual.count());
 4 assertEquals("Law of Cycles", actual.get(9));
 5 SequenceEqual
 6
 7 List<Integer> first = new List<>(1, 2, 3);
 8 List<Integer> secondMatch = new List<>(1, 2, 3);
 9 List<Integer> secondUnMatchElem = new List<>(1, 2, 4);
10
11 boolean actualMatch = first.sequenceEqual(secondMatch);
12 boolean actualUnMatchElm = first.sequenceEqual(secondUnMatchElem);
13
14 assertEquals(true, actualMatch);
15 assertEquals(false, actualUnMatchElm);

Cast

1 List<Object> list = new List<>(1, 2, 3);
2
3 List<Integer> actual = list.cast(Integer.class).toList();
4
5 assertEquals(1, actual.get(0).intValue());
6 assertEquals(2, actual.get(1).intValue());
7 assertEquals(3, actual.get(2).intValue());

OfType

1 List<Object> list = new List<>(1, "2", 3, "4");
2
3 List<String> actualStr = list.ofType(String.class).toList();
4 List<Integer> actualInt = list.ofType(Integer.class).toList();
5
6 assertEquals("2", actualStr.get(0));
7 assertEquals("4", actualStr.get(1));
8 assertEquals(1 , actualInt.get(0).intValue());
9 assertEquals(3 , actualInt.get(1).intValue());

6.源代码

https://github.com/k--kato/jLinqer

时间： 2024-10-27 11:01:23

Java的jLinqer包介绍的相关文章

java concurrent包介绍及使用

说一说java的concurrent包1-concurrent包简介 前面一个系列的文章都在围绕hash展开,今天准备先说下concurrent包,这个系列可能会以使用场景说明为主,concurrent包本身的代码分析可能比较少: 我在这方面的实践经验较为有限,有错误欢迎批评指正 不过前一个系列并未结束,还有一些文章没有放出来,欢迎关注核桃博客 concurrent包是jdk1.5引入的重要的包,主要代码由大牛Doug Lea完成,其实是在jdk1.4时代,由于java语言内置对多线程编程的支持

《java.util.concurrent 包源码阅读》09 线程池系列之介绍篇

concurrent包中Executor接口的主要类的关系图如下: Executor接口非常单一,就是执行一个Runnable的命令. public interface Executor { void execute(Runnable command); } ExecutorService接口扩展了Executor接口,增加状态控制,执行多个任务返回Future. 关于状态控制的方法: // 发出关闭信号,不会等到现有任务执行完成再返回,但是现有任务还是会继续执行, // 可以调用awaitTe

JAVA 001 开发工具及第三方包介绍

目录 Eclipse在线和离线两种方式安装插件 Eclipse注释模块以及配置 第三方包介绍 打包方式 Eclipse在线和离线两种方式安装插件 在线方式 1 eclipse help -> eclipse Marketplace (例如:安装MAT,搜索Memory) 2 eclipse help -> install new SoftWare(输入待安装插件的地址) 离线方式(先下载相应的离线插件包) 1 link方式:在eclipse安装的根目录下创建两个文件夹 links,plugin

Java语言Lang包下常用的工具类介绍_java - JAVA

文章来源:嗨学网 敏而好学论坛www.piaodoo.com 欢迎大家相互学习 无论你在开发哪中 Java 应用程序,都免不了要写很多工具类/工具函数.你可知道,有很多现成的工具类可用,并且代码质量都很不错,不用你写,不用你调试,只要你发现. 在 Apache Jakarta Common 中, Lang 这个 Java 工具包是所有 Apache Jakarta Common 项目中被使用最广泛的,几乎你所知道的名气比较大的软件里面都有用到它,包括 Tomcat, Weblogic, Webs

java中的包以及内部类的介绍

1:形式参数和返回值的问题(理解)    (1)形式参数:        类名:需要该类的对象        抽象类名:需要该类的子类对象        接口名:需要该接口的实现类对象    (2)返回值类型:        类名:返回的是该类的对象        抽象类名:返回的是该类的子类对象        接口名:返回的是该接口的实现类的对象    (3)链式编程        对象.方法1().方法2().......方法n();                这种用法:其实在方法1()

深入探讨 java.lang.ref 包--转

概述 Java.lang.ref 是 Java 类库中比较特殊的一个包,它提供了与 Java 垃圾回收器密切相关的引用类.这些引用类对象可以指向其它对象,但它们不同于一般的引用,因为它们的存在并不防碍 Java 垃圾回收器对它们所指向的对象进行回收.其好处就在于使者可以保持对使用对象的引用,同时 JVM 依然可以在内存不够用的时候对使用对象进行回收.因此这个包在用来实现与缓存相关的应用时特别有用.同时该包也提供了在对象的“可达”性发生改变时,进行提醒的机制.本文通过对该包进行由浅入深的介绍与分析

家庭洗车APP --- Androidclient开展 之 网络框架包介绍（一）

家庭洗车APP --- Android客户端开发 之 网络框架包介绍(一) 上篇文章中给大家简单介绍了一些业务.上门洗车APP --- Android客户端开发 前言及业务简单介绍,本篇文章给大家介绍下网络框架.之前也了解过一些开源网络通讯架构.也大概看了一部分源代码.比方Afinal.Volley.AndBase.Android-async-http等,感觉各自都有各自的优劣,自己也曾封装过一些简单的网络架构,感觉有非常多地方须要注意和优化.这里就不贴出来献丑了,感兴趣的朋友能够去查阅学习上面

Java5对线程处理的新操作-concurrent包介绍

上节中简单介绍了传统的jdk中的线程的概念,本节中接着介绍下jdk5之后对线程处理有哪些改变. 首先,介绍下java.util.concurrent包下有个字包atomic(原子的)包,其中的一些类提供原子性操作类,分别是: 1 AtomicBoolean, 2 AtomicInteger,AtomicIntegerArray,AtomicIntegerFieldUpdater<T>, 3 AtomicLong,AtomicLongArray,AtomicLongFieldUpdater<

Java生成jar包\打包\Export

本文介绍一下如何通过Eclipse将自己的项目打包成jar 1.项目上右键单击 Export 2.选择 Java - JAR file - [next >] 3.进入jar包的配置界面,在这里勾选你想导出的jar所包含的文件 Export generated class files and resources导出时包含class文件和其他资源资源 Export all output folders for checked projects导出时包含项目的所有文件夹 Export Java sou