背景与动机

对于习惯C#开发模式的工程师而言，LINQ（Language Integrated Query）提供的声明式数据操作体验极为流畅。尽管Java 8引入了Stream API与函数式接口，部分实现了Lambda表达式能力，但在查询操作的完备性与表达力上仍存在明显差距——诸如多键排序、集合差集、类型安全转换等场景，标准库的支持尚显不足。

jLinqer正是为了弥合这一鸿沟而诞生的开源方案。它将C# LINQ的核心操作符移植到Java生态，使开发者能够以接近原生的方式编写链式查询逻辑，同时兼容Java 8的函数式编程范式。

快速集成

通过Maven依赖管理引入：

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

非Maven项目可直接获取独立JAR包：

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

核心能力对照

下表梳理了jLinqer与C# LINQ及Java Stream API在关键操作符上的映射关系：

分类	功能描述	C# LINQ	jLinqer	Java Stream
基础转换	条件过滤	Where	where	filter
	字段投影	Select	select	map
	升序排列	OrderBy	orderBy	sorted
	降序排列	OrderByDescending	orderByDescending	—
	次级升序	ThenBy	thenBy	—
	次级降序	ThenByDescending	thenByDescending	—
分段截取	跳过前N项	Skip	skip	skip
	条件跳过	SkipWhile	skipWhile	—
	取前N项	Take	take	limit
	条件截取	TakeWhile	takeWhile	—
集合运算	连接序列	Concat	concat	concat
	交集	Intersect	intersect	—
	并集	Union	union	—
	差集	Except	except	—
	内连接	Join	join	—
	分组连接	GroupJoin	groupJoin	—
	反转	Reverse	reverse	—
聚合统计	去重	Distinct	distinct	distinct
	累积计算	Aggregate	aggregate	reduce
	分组	GroupBy	groupBy	Collectors.groupingBy
	计数	Count/LongCount	count/longCount	count
	最大值	Max	max	max
	最小值	Min	min	min
	首元素（或默认值）	FirstOrDefault	firstOrDefault	—
	尾元素（或默认值）	LastOrDefault	lastOrDefault	—
	唯一元素（或默认值）	SingleOrDefault	singleOrDefault	—
	索引访问（或默认值）	ElementAtOrDefault	elementAtOrDefault	—

典型用法演示

数据过滤

List<Integer> nums = new List<>(2, 4, 6, 8, 10);
List<Integer> evens = nums.where(n -> n % 4 == 0).toList();
// 结果: [4, 8]

复合排序

class Employee {
    String dept;
    int salary;
    String name;
    Employee(String d, int s, String n) { dept = d; salary = s; name = n; }
}

List<Employee> staff = new List<>(
    new Employee("Dev", 5000, "Alice"),
    new Employee("Dev", 4000, "Bob"),
    new Employee("HR", 5000, "Carol")
);

List<Employee> sorted = staff
    .orderBy(e -> e.dept)
    .thenByDescending(e -> e.salary)
    .toList();

集合关系运算

List<Integer> setA = new List<>(1, 2, 3, 4);
List<Integer> setB = new List<>(3, 4, 5, 6);

List<Integer> unionResult = setA.union(setB).toList();       // [1,2,3,4,5,6]
List<Integer> diffResult = setA.except(setB).toList();      // [1,2]
List<Integer> interResult = setA.intersect(setB).toList();  // [3,4]

多表关联

List<Product> products = new List<>(
    new Product("P001", "Laptop"),
    new Product("P002", "Mouse")
);

List<Order> orders = new List<>(
    new Order("P001", 2),
    new Order("P001", 1),
    new Order("P003", 5)
);

List<String> summaries = products
    .join(
        orders,
        p -> p.sku,
        o -> o.productSku,
        (p, o) -> String.format("%s x%d", p.name, o.quantity)
    )
    .toList();
// 结果: ["Laptop x2", "Laptop x1"]

分组聚合

List<SaleRecord> records = new List<>(
    new SaleRecord("East", 120),
    new SaleRecord("West", 200),
    new SaleRecord("East", 80)
);

Map<String, IEnumerable<SaleRecord>> byRegion = records.groupBy(r -> r.region);
double eastTotal = byRegion.get("East")
    .aggregate((acc, r) -> acc + r.amount);
// eastTotal: 200

安全取值

List<String> tags = new List<>("java", "dotnet", "python");

String first = tags.firstOrDefault();                          // "java"
String filtered = tags.firstOrDefault(t -> t.startsWith("g")); // null
String atIndex = tags.elementAtOrDefault(10);                // null

序列生成

// 生成整数序列
List<Integer> rangeNums = IEnumerable.range(5, 3);  // [5,6,7]

// 重复值序列
List<String> repeated = IEnumerable.repeat(String.class, "ok", 4);
// ["ok","ok","ok","ok"]

设计特点与注意事项

jLinqer采用延迟执行策略，所有中间操作（where、select等）仅构建查询描述，直至调用toList()、count()等终止操作时才触发实际计算。这与Java Stream的设计理念一致，但提供了更贴近LINQ的API命名体系。

类型转换操作符cast与ofType在处理异构集合时尤为实用，能够安全地完成类型筛选与强制转换，避免ClassCastException风险。

源码获取

项目托管地址：https://github.com/k--kato/jLinqer