https://github.com/eloyhere/semantic-java

Semantic-Java is a modern, maven Java stream processing framework with zero dependencies. It elegantly blends the fluency of Java Streams, the laziness of JavaScript generators, and intelligent index-based control inspired by database indexing — perfect for time-series, event streams, and high-performance data pipelines as a maven pendency.
https://github.com/eloyhere/semantic-java

data functional functional-programming java pipeline stream

Last synced: 3 days ago
JSON representation

Host: GitHub
URL: https://github.com/eloyhere/semantic-java
Owner: eloyhere
License: mit
Created: 2026-04-06T19:11:29.000Z (4 days ago)
Default Branch: main
Last Pushed: 2026-04-06T22:27:12.000Z (3 days ago)
Last Synced: 2026-04-06T23:15:23.676Z (3 days ago)
Topics: data, functional, functional-programming, java, pipeline, stream
Language: Java
Homepage:
Size: 115 KB
Stars: 0
Watchers: 0
Forks: 0
Open Issues: 0
Metadata Files:
- Readme: README.cn.md
- License: LICENSE

Awesome Lists containing this project

README

# Semantic-Java：下一代 Java 流式处理框架

## 引言

在当今数据驱动的时代，高效的流式数据处理已成为现代应用程序的核心需求。无论是处理实时传感器数据、分析金融时间序列，还是构建高性能事件处理管道，开发者都需要一个既强大又灵活的工具。Java 标准库中的 `Stream API` 自 Java 8 引入以来，极大地改善了集合处理体验，但其设计仍存在一些限制：严格的一次性消费、有限的索引控制、以及缺乏原生的窗口操作支持。

Semantic-Java 应运而生，它是一个零依赖的现代 Maven Java 流处理框架，旨在弥补这些缺口。它巧妙地融合了 Java Streams 的流畅表达、JavaScript 生成器的惰性求值哲学，以及受数据库索引启发的智能索引控制机制。无论您是处理时间序列数据、事件流，还是构建复杂的数据转换管道，Semantic-Java 都提供了优雅而强大的解决方案。

本文将深入探讨 Semantic-Java 的核心概念、设计哲学、API 使用方式以及最佳实践，帮助您全面掌握这一革新性的流处理工具。

## 核心优势与设计理念

### 为什么选择 Semantic-Java？

1. **零依赖与轻量级**
Semantic-Java 不依赖任何外部库，确保了极致的轻量和纯净。您可以轻松地将其集成到任何 Java 项目中，无需担心依赖冲突或臃肿的部署包。

2. **无缝融合多种范式**
- **Java Streams 的流畅性**：提供类似 `filter`、`map`、`flatMap` 等直观的操作符，让数据处理管道清晰可读。
- **JavaScript 生成器的惰性**：流元素仅在需要时被计算和消费，最大化内存效率，支持处理无限或超大规模数据流。
- **数据库索引的智能控制**：引入了独特的索引重定向 (`redirect`、`translate`、`reverse`) 机制，允许您像操作数据库记录一样，灵活地控制流中元素的逻辑位置。
- **原生窗口操作支持**：新增的 `WindowCollectable` 提供了原生的滑动窗口和翻滚窗口操作，极大地简化了时间序列分析和流式聚合。

3. **为现代场景量身打造**
框架特别适合处理**时间序列数据**（如股票报价、传感器读数）、**事件流**（如用户行为日志、消息队列）以及任何需要高性能、可组合数据转换的**管道**。

4. **丰富的原生统计支持**
内置了从 `Byte` 到 `BigDecimal` 等多种数值类型的专门统计类（如 `IntStatistics`、`DoubleStatistics`），开箱即用地支持求和、平均、极值等聚合计算，无需编写样板代码。

### Semantic-Java vs. Java Stream API

为了清晰展示 Semantic-Java 的独特价值，下表将其与 Java 标准 Stream API 进行了关键特性的对比：

**总结**：Java Stream API 是一个优秀且通用的标准工具。而 Semantic-Java 在其基础上，通过引入**索引控制**和**原生窗口操作**这两个核心抽象，显著增强了对**有序数据流**和**时间/序列敏感计算**的处理能力，是处理此类问题的专业化、现代化框架。

### 核心概念解析

在深入 API 之前，理解以下几个核心抽象至关重要：

1. **`Generator` (生成器)**
这是整个框架的源头。它是一个函数式接口，负责按需"生成"流中的元素。其核心方法是 `accept`，它接收一个消费者（处理元素）和一个中断谓词（决定是否提前终止）。所有 `Semantic` 流都构建在 `Generator` 之上，这为实现惰性求值和无界流奠定了基础。

2. **`Semantic` (语义流)**
这是框架的主入口和主要操作对象。它封装了一个 `Generator`，并提供了所有流式操作（如 `filter`, `map`, `distinct` 等）。每个操作都返回一个新的 `Semantic` 实例，实现了不可变性和链式调用。其内部持有 `concurrent` 属性，为并行处理预留了可能。

3. **`Collector` (收集器)**
这是流的终端操作。它定义了如何将流中的元素累积到一个可变的结果容器(`A`)中，以及如何将最终容器转换为结果(`R`)。`Collectors` 工具类提供了大量静态工厂方法（如 `toList()`, `useGroup()`, `useJoin()`）来创建常见的收集器。`Collector` 支持短路操作（如 `findFirst`）和并行收集。

4. **`IndexedControl` (索引控制)**
这是 Semantic-Java 的"秘密武器"。每个流元素都附带一个 `long` 类型的索引。大部分操作（如 `filter`、`map`）会保持或传递原始索引。而 `redirect`、`translate`、`reverse` 等操作可以显式地修改这个索引。`Collector` 的累积函数 `IndexedAccumulator` 和中断判断 `IndexedInterrupt` 也都接收索引参数，使得操作可以基于元素位置进行，极大地增强了表达能力。

5. **`Collectable` 及其子类**
这是可收集流的状态。`OrderedCollectable` 和 `UnorderedCollectable` 分别代表需要保持顺序和无需保持顺序的终端状态。它们提供了 `collect` 方法，接收一个 `Collector` 来执行最终的聚合。各种 `Statistics` 类（如 `IntStatistics`）继承自 `OrderedCollectable`，专门用于数值统计。

6. **`WindowCollectable` (窗口可收集流)**
这是 Semantic-Java 新增的重要特性，继承自 `OrderedCollectable`。它专门用于处理窗口操作，提供了两种窗口模式：滑动窗口(`slide`)和翻滚窗口(`tumble`)。窗口操作在时间序列分析、流式聚合和模式检测中至关重要。

## 快速开始

### 1. 添加 Maven 依赖

将以下依赖添加到您的 `pom.xml` 文件中：

```xml

pers.eloyhere
semantic-java
1.0.0

```

### 2. 创建您的第一个流

让我们从一个简单的例子开始，了解如何创建和消费一个流。

```java
import pers.eloyhere.semantic.Semantic;
import pers.eloyhere.semantic.Collectors;
import java.util.List;

public class QuickStart {
public static void main(String[] args) {
// 1. 从数组创建流
List names = Semantic.useFrom(new String[]{"Alice", "Bob", "Charlie"})
.toUnordered()
.collect(Collectors.toList());

System.out.println(names); // 输出: [Alice, Bob, Charlie]

// 2. 从集合创建流
List numbers = Semantic.useFrom(List.of(1, 2, 3, 4, 5))
.toUnordered()
.collect(Collectors.toList());

// 3. 创建数值范围流
List range = Semantic.useRange(5, 10) // 生成 5,6,7,8,9
.toUnordered()
.collect(Collectors.toList());

System.out.println(range); // 输出: [5, 6, 7, 8, 9]
}
}
```

### 3. 基础操作链

一个典型的数据处理管道包含多个中间操作和一个终端操作。

```java
import pers.eloyhere.semantic.Semantic;
import pers.eloyhere.semantic.Collectors;
import java.util.List;

public class BasicPipeline {
public static void main(String[] args) {
List result = Semantic.useFrom(new String[]{"apple", "banana", "apricot", "cherry", "avocado"})
.filter(fruit -> fruit.startsWith("a")) // 1. 过滤: 只保留以'a'开头的水果
.map(String::toUpperCase) // 2. 映射: 转为大写
.toUnordered()
.collect(Collectors.toList()); // 3. 收集: 转为List

System.out.println(result); // 输出: [APPLE, APRICOT, AVOCADO]
}
}
```

## 核心 API 详解

### 流创建 (`Semantic` 静态工厂方法)

`Semantic` 类提供了多种静态方法来创建流：

- **`useFrom(Iterable)` / `useFrom(E[])`**：从集合或数组创建流。
- **`useRange(long start, long end)`**：创建一个连续的 `Long` 流，从 `start` (包含) 到 `end` (不包含)。非常适合生成索引或序列。
- **`useBlob(InputStream)`**：从输入流读取字节创建 `Byte` 流。用于处理二进制数据。
- **`useBlob(InputStream, Charset)`**：从输入流按指定字符集读取字符创建 `Character` 流。
- **`useText(String)`**：将整个字符串作为单个元素创建流。
- **`useText(String, String delimiter)`**：按分隔符分割字符串创建流。
- **`useCodePoint(String)`**：按 Unicode 代码点分割字符串创建流，正确处理代理对。

### 中间操作 (`Semantic` 实例方法)

中间操作是流处理的核心，它们对元素进行转换、过滤、排序等，并返回一个新的流。

#### 过滤与选择
- **`filter(Predicate)` / `filter(BiPredicate)`**：根据元素值或元素值+索引决定是否保留。
- **`distinct()`**：去除重复元素（基于 `equals` 和 `hashCode`）。
- **`distinct(Comparator)`**：根据自定义比较器去重。
- **`limit(long n)`**：限制流最多包含 `n` 个元素。
- **`skip(long n)`**：跳过前 `n` 个元素。
- **`sub(long start, long end)`**：截取索引在 `(start, end)` 区间内的元素。
- **`takeWhile(Predicate/BP)`**：**惰性**地从开头开始取元素，直到条件不满足为止。这是与 `filter` 的关键区别，`filter` 会检查所有元素，而 `takeWhile` 遇到第一个不满足条件的元素就会停止生成。
- **`dropWhile(Predicate/BP)`**：**惰性**地跳过开头的元素，直到条件不满足，然后保留之后的所有元素。

#### 映射与转换
- **`map(Function)` / `map(BiFunction)`**：将每个元素转换为另一种类型。这是最常用的操作之一。
- **`flatMap(Function>)`**：将每个元素映射为一个流，然后将所有这些流"扁平化"为一个流。例如，将句子流映射为单词流。
- **`flat(Function>)`**：`flatMap` 的特化版本，输入输出元素类型相同。

#### 索引控制（核心特性）
- **`redirect(BiFunction)`**：**最强大的索引操作**。允许您为每个元素动态计算一个新的索引。这是实现复杂窗口、分组偏移的基石。
- **`translate(long delta)`**：将所有元素的索引平移固定的值（`newIndex = oldIndex + delta`）。
- **`reverse()`**：反转所有元素的索引（`newIndex = -oldIndex`）。结合排序可以实现倒序。

**重要提示**：索引控制操作（特别是 `redirect`）通常应在操作链的**最后调用**，因为像 `distinct`、`filter`、`sorted` 等操作可能会改变或依赖原有的索引顺序。

#### 调试与副作用
- **`peek(Consumer)` / `peek(BiConsumer)`**：在不改变流的情况下，对每个元素执行一个操作（如打印日志）。主要用于调试。

#### 连接与排序
- **`concatenate(Semantic/Iterable/Array)`**：将当前流与另一个数据源连接起来。
- **`sorted()`**：按元素的自然顺序排序（元素需实现 `Comparable`）。这会返回一个 `OrderedCollectable`。
- **`sorted(Comparator)`**：按自定义比较器排序，返回 `OrderedCollectable`。

#### 并行处理
- **`parallel()`**：将流的并发度在当前基础上加1。
- **`parallel(long concurrent)`**：设置流的并发度。这为下游的 `Collector` 并行收集提供了提示。

### 终端操作与收集

流必须通过一个**终端操作**来触发计算并产生结果。在 Semantic-Java 中，这主要通过将流转换为 `Collectable` 或 `Statistics`，然后调用 `collect` 方法实现。

#### 转换为可收集状态
- **`toOrdered()`**：转换为一个保持元素顺序的可收集流。内部可能使用 `TreeMap` 基于索引排序，适用于需要顺序结果的场景。**注意**：可能产生 O(n log n) 的时间和 O(n) 的空间开销。
- **`toUnordered()`**：转换为一个不保证顺序的可收集流。内部使用 `HashMap`，性能通常优于 `toOrdered`。当结果顺序不重要时首选此方法。
- **`toIntStatistics()` / `toDoubleStatistics()` 等**：转换为特定数值类型的统计流。这些类继承自 `OrderedCollectable`，并额外提供了 `sum()`, `average()`, `max()`, `min()`, `count()` 等便捷的统计方法。
- **`toWindow()`**：**新增方法**，转换为一个窗口可收集流。返回 `WindowCollectable` 实例，支持窗口操作。

#### 窗口操作 (`WindowCollectable`)

窗口操作是流处理中处理时间序列和滑动聚合的核心功能。`WindowCollectable` 继承自 `OrderedCollectable`，这意味着它内部维护了一个有序的缓冲区（基于 `TreeMap`），这使得窗口操作能够高效地进行。

- **`slide(long size, long step)`**：创建滑动窗口。
- `size`：窗口大小，即每个窗口包含的元素数量
- `step`：滑动步长，即窗口每次移动的元素数量
- 返回一个 `Semantic>`，即一个流的流，其中每个内层流代表一个窗口

- **`tumble(long size)`**：创建翻滚窗口（滑动窗口的特例，步长等于窗口大小）。
- `size`：窗口大小
- 等价于 `slide(size, size)`
- 窗口之间不重叠，每个元素只属于一个窗口

**窗口操作示例**：
```java
// 计算每3个元素的滑动窗口平均值（步长为1）
List prices = Arrays.asList(100.0, 101.0, 102.0, 103.0, 104.0);

List movingAverages = Semantic.useFrom(prices)
.toWindow() // 转换为窗口可收集流
.slide(3, 1) // 创建大小为3，步长为1的滑动窗口
.map(window -> window.collect(Collectors.useReduce(0.0, Double::sum)) / 3)
.toUnordered()
.collect(Collectors.toList());

System.out.println(movingAverages);
// 输出: [101.0, 102.0, 103.0]
// 解释:
// 窗口1: [100.0, 101.0, 102.0] -> 平均值 101.0
// 窗口2: [101.0, 102.0, 103.0] -> 平均值 102.0
// 窗口3: [102.0, 103.0, 104.0] -> 平均值 103.0
```

**重要提示**：窗口操作需要在流被完全物化到内存中之后才能进行，因为需要知道所有元素的位置来计算窗口。这意味着 `toWindow()` 会触发流的完全消费并将其存储到内部缓冲区中。对于无限流或非常大的流，请谨慎使用窗口操作。

#### 收集器 (`Collectors` 工具类)

`Collectors` 类包含了丰富的静态工厂方法，用于创建各种 `Collector`。

**归约与聚合**
- **`toList()` / `toHashSet()` / `useToTreeSet()`**：收集到标准集合。
- **`useToHashMap(Function)`**：根据键提取函数收集到 `HashMap`。
- **`useToTreeMap(Function, Function)`**：根据键和值提取函数收集到排序的 `TreeMap`。
- **`useReduce(identity, operator)`**：使用给定的初始值和结合操作符进行归约。
- **`useCount()`**：统计元素数量。

**查找与匹配**
- **`useFindFirst()` / `useFindLast()` / `useFindAny()`**：查找第一个/最后一个/任意一个元素。
- **`useFindAt(long index)`**：查找指定（非负）索引处的元素。
- **`useFindNegativeAt(long index)`**：查找指定（负）索引处的元素（支持从末尾倒数的索引，如 -1 表示最后一个）。
- **`useFindMaximum()` / `useFindMinimum()`**：查找最大/最小元素。
- **`useAnyMatch()` / `useAllMatch()` / `useNoneMatch()`**：判断流中是否存在/全部/没有满足条件的元素。

**分组与分区**
- **`useGroup(Function)`**：根据键提取函数分组，结果为 `Map>`。
- **`useGroupBy(Function, Function)`**：根据键和值提取函数分组，结果为 `Map>`。
- **`usePartition(long n)`**：将元素按索引模 `n` 均匀分区成 `n` 个列表。
- **`usePartitionBy(Function)`**：根据元素值计算的分区键进行分区。

**连接字符串**
- **`useJoin()`**：用 `", "` 连接，并用 `[]` 包裹。
- **`useJoin(delimiter)`**
- **`useJoin(prefix, delimiter, suffix)`**

**频率与模式**
- **`useFrequency()`**：计算每个元素出现的频率，结果为 `Map`。
- **`useMode()`**：找出出现次数最多的元素（众数）。

**遍历**
- **`useForEach(Consumer)`**：对每个元素执行操作，并返回处理过的元素数量。

### 统计类 (`Statistics`)

对于数值流，直接使用对应的 `Statistics` 类是最便捷的方式。它们内部优化了统计计算。

```java
DoubleStatistics stats = Semantic.useFrom(new Double[]{1.5, 2.5, 3.5, 4.5})
.filter(x -> x > 2.0)
.toDoubleStatistics(); // 转换为Double统计流

System.out.println("Count: " + stats.count());
System.out.println("Sum: " + stats.sum());
System.out.println("Average: " + stats.average());
System.out.println("Min: " + stats.min());
System.out.println("Max: " + stats.max());

// 当然，也可以使用collect终端操作
Double sum = stats.collect(Collectors.useReduce(0.0, Double::sum));
```

## 深入探讨：高级模式与最佳实践

### 场景一：基于时间窗口的移动平均（使用原生窗口API）

假设我们有一个按时间戳排序的股票价格流，我们想计算每3个数据点为一个窗口的移动平均。使用新增的窗口API，这变得非常简单：

```java
// 模拟股票价格数据
List prices = Arrays.asList(100.0, 101.0, 102.0, 103.0, 104.0);

// 计算窗口大小为3的移动平均
List movingAverages = Semantic.useFrom(prices)
.toWindow() // 转换为窗口可收集流
.slide(3, 1) // 创建大小为3，步长为1的滑动窗口
.map(window -> window // 对每个窗口计算平均值
.toUnordered()
.collect(Collectors.useReduce(0.0, Double::sum)) / 3
)
.toUnordered()
.collect(Collectors.toList());

System.out.println(movingAverages); // 输出: [101.0, 102.0, 103.0]
```

### 场景二：翻滚窗口聚合

计算每2个元素一个窗口的翻滚窗口求和：

```java
List numbers = Arrays.asList(1, 2, 3, 4, 5, 6);

List windowSums = Semantic.useFrom(numbers)
.toWindow()
.tumble(2) // 翻滚窗口，大小为2
.map(window -> window.collect(Collectors.useReduce(0, Integer::sum)))
.toUnordered()
.collect(Collectors.toList());
System.out.println(windowSums); // 输出: [3, 7, 11]
// 解释: [1+2=3, 3+4=7, 5+6=11]
```

### 场景三：分页与偏移

从流中取出第2页的数据（每页10条）。

```java
List allItems = infinity(); // 假设是一个很大的列表

List page2 = Semantic.useFrom(allItems)
.skip(10) // 跳过第一页的10条
.limit(10) // 取第二页的10条
.toUnordered()
.collect(Collectors.toList());
```

### 场景四：处理带逻辑位置的数据

假设我们有一系列事件，但某些事件需要被插入到前面（如优先级更高的事件）。

```java
List events = getEvents(); // 按时间顺序
List highPriorityEvents = getHighPriorityEvents();

// 将高优先级事件"插入"到流的最前面
List processedStream = Semantic.useFrom(highPriorityEvents)
.translate(-1000000) // 给高优先级事件一个极小的索引，确保排序在最前
.concatenate(Semantic.useFrom(events))
.toOrdered() // 根据索引排序
.collect(Collectors.toList());
```

## 设计理念与最佳实践

### 惰性求值与短路

与 Java Streams 一样，Semantic-Java 的中间操作是惰性的。这意味着直到终端操作被调用，数据才会被处理。这带来了巨大的优化潜力：

- **无限流**：可以表示和处理无限序列（例如，生成器生成的随机数序列），因为只在需要时才计算下一个元素。
- **性能优化**：如果终端操作是短路操作（如 `findFirst`、`anyMatch`），并且中间操作如 `filter` 和 `takeWhile` 能够提前确定结果，那么流可能不会处理所有元素。

**最佳实践**：将能过滤掉大量元素的操作（如 `filter`、`distinct`、`takeWhile`、`limit`、`skip`、`sub`）**尽早**放在操作链中，以减少后续不必要的计算。

### 索引的生命周期管理

理解索引的传递和覆盖规则对正确使用框架至关重要：

1. **索引来源**：创建流时，元素被赋予初始索引（通常从0开始递增）。
2. **索引传递**：大多数操作（如 `filter`、`map`、`peek`）会保留元素的原始索引。`filter` 虽然移除元素，但剩余元素保持其原有索引。
3. **索引覆盖**：某些操作会重新计算或覆盖索引：
- `distinct`、`flatMap`、`sorted` 等操作会产生新的索引序列。`distinct` 后的元素索引是从1开始的新序列。`sorted` 会打乱原有的物理顺序，但 `OrderedCollectable` 会根据排序后的顺序重新分配逻辑索引用于收集。
4. **索引重定向**：`redirect`、`translate`、`reverse` 是显式修改索引的操作。由于它们直接操作索引，**通常应放在操作链的最后**（在排序、去重等可能依赖或改变索引的操作之后），以确保得到预期的索引逻辑。

**规则总结**：先过滤和转换，再排序，最后进行索引重定向。

### 窗口操作的使用时机

窗口操作是一个强大的特性，但需要注意其使用时机：

1. **物化要求**：窗口操作需要知道所有元素的位置，因此 `toWindow()` 会触发流的完全消费。对于非常大的数据集，请确保有足够的内存。
2. **性能考虑**：滑动窗口会创建多个重叠的窗口，每个窗口都是原始数据的一个视图。如果窗口很大且重叠多，可能会产生较大的开销。
3. **适用场景**：窗口操作最适合中等大小的数据集，或者可以分批次处理的数据流。对于无限流，考虑使用 `limit()` 限制处理的数据量。

### 并行处理

虽然 `Collector` 的 `collect` 方法包含了基于 `ThreadPoolExecutor` 的并行收集逻辑，`Semantic` 类也有 `concurrent` 属性和 `parallel()` 方法，但`Semantic` 的中间操作本身并未实现并行执行。并行性主要体现在终端收集器（`Collector.collect(generator, concurrent > 1)`）上。收集器可以将工作负载拆分到多个线程，然后合并结果。

**使用建议**：对于计算密集型的终端操作（如复杂的归约、大列表分组），且数据量足够大时，可以尝试使用 `.parallel().toUnordered()` 然后配合支持并行的 `Collector` 来获得性能提升。对于简单的操作或小数据量，顺序执行通常更高效。

## 总结

Semantic-Java 是一个设计精良、思想前卫的 Java 流处理框架。它通过引入**索引控制**和**原生窗口操作**等核心抽象，极大地扩展了流处理的能力边界，使其能够优雅地应对时间序列、事件流等需要复杂位置逻辑的场景。其零依赖的特性和对 Java 函数式编程的深度融合，使得集成和使用异常轻便。

**核心价值回顾**：
1. **强大而直观的 API**：融合了熟悉的 Stream 操作、创新的索引操作和原生窗口操作。
2. **无与伦比的灵活性**：`redirect` 等操作赋予开发者对数据流逻辑视图的完全控制力。
3. **原生窗口支持**：`WindowCollectable` 提供了开箱即用的滑动窗口和翻滚窗口操作，极大地简化了时间序列分析。
4. **卓越的性能基础**：惰性求值和短路优化保证了处理大规模甚至无限流时的效率。
5. **开箱即用的工具集**：丰富的 `Collectors` 和专门的 `Statistics` 类覆盖了绝大多数终端处理需求。

**与 Java Stream 的对比优势**：相较于标准的 Java Stream API，Semantic-Java 在保持相似易用性的同时，提供了**元素索引**和**原生窗口操作**这两大关键增强。这使得它在处理有序数据、时间序列分析、分页、数据重排等场景下，代码更简洁、意图更清晰、能力更强大。

Semantic-Java 不仅是一个工具库，更代表了一种处理流式数据的新思路。它鼓励开发者以更声明式、更富于语义的方式来思考和构建数据管道。随着函数式编程在 Java 社区的日益普及，Semantic-Java 这样的框架无疑将在大数据处理、实时计算和系统集成等领域发挥越来越重要的作用。

开始使用 Semantic-Java，重新定义您的 Java 流处理体验。

ecosyste.ms

Data

Tools

Indexes

Applications

Experiments

Awesome

https://github.com/eloyhere/semantic-java

Awesome Lists containing this project

README