From cc3156572ff78835c1ccc106c023d398c9b38b66 Mon Sep 17 00:00:00 2001 From: minglipro Date: Mon, 15 Sep 2025 17:26:39 +0800 Subject: [PATCH] =?UTF-8?q?refactor(stream):=20=E9=87=8D=E6=9E=84=E6=B5=81?= =?UTF-8?q?=E5=A4=84=E7=90=86=E7=9B=B8=E5=85=B3=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 移除 InOutSteam、InputStreanWrapper、OutputStreamWrapper 类 - 删除 Getable、GetIdable、GetKeyable、GetNameable 接口- 更新 ByteUtils 和 Collection.kt 中的流处理逻辑 - 新增 InputStreamUtils.kt 文件，提供输入流相关扩展函数 - 更新项目版本号至 4.0.5 --- gradle.properties | 4 +- .../mingliqiye/utils/stream/InOutSteam.java | 279 ---- .../utils/stream/InputStreamUtils.java | 123 -- .../utils/stream/InputStreanWrapper.java | 120 -- .../utils/stream/OutputStreamWrapper.java | 81 - .../mingliqiye/utils/stream/SuperStream.java | 1467 ----------------- .../utils/stream/interfaces/GetIdable.java | 9 - .../utils/stream/interfaces/GetKeyable.java | 9 - .../utils/stream/interfaces/GetNameable.java | 9 - .../utils/stream/interfaces/Getable.java | 5 - .../com/mingliqiye/utils/bytes/ByteUtils.kt | 6 +- .../mingliqiye/utils/collection/Collection.kt | 10 +- .../mingliqiye/utils/io/InputStreamUtils.kt | 50 + .../mingliqiye/utils/stream/SuperStream.kt | 122 ++ 14 files changed, 181 insertions(+), 2113 deletions(-) delete mode 100644 src/main/java/com/mingliqiye/utils/stream/InOutSteam.java delete mode 100644 src/main/java/com/mingliqiye/utils/stream/InputStreamUtils.java delete mode 100644 src/main/java/com/mingliqiye/utils/stream/InputStreanWrapper.java delete mode 100644 src/main/java/com/mingliqiye/utils/stream/OutputStreamWrapper.java delete mode 100644 src/main/java/com/mingliqiye/utils/stream/SuperStream.java delete mode 100644 src/main/java/com/mingliqiye/utils/stream/interfaces/GetIdable.java delete mode 100644 src/main/java/com/mingliqiye/utils/stream/interfaces/GetKeyable.java delete mode 100644 src/main/java/com/mingliqiye/utils/stream/interfaces/GetNameable.java delete mode 100644 src/main/java/com/mingliqiye/utils/stream/interfaces/Getable.java create mode 100644 src/main/kotlin/com/mingliqiye/utils/io/InputStreamUtils.kt create mode 100644 src/main/kotlin/com/mingliqiye/utils/stream/SuperStream.kt diff --git a/gradle.properties b/gradle.properties index 3321fcf..9ab28f1 100644 --- a/gradle.properties +++ b/gradle.properties @@ -16,10 +16,10 @@ # ProjectName mingli-utils # ModuleName mingli-utils # CurrentFile gradle.properties -# LastUpdate 2025-09-15 13:54:50 +# LastUpdate 2025-09-15 17:24:10 # UpdateUser MingLiPro # JDKVERSIONS=1.8 GROUPSID=com.mingliqiye.utils ARTIFACTID=mingli-utils -VERSIONS=4.0.4 +VERSIONS=4.0.5 diff --git a/src/main/java/com/mingliqiye/utils/stream/InOutSteam.java b/src/main/java/com/mingliqiye/utils/stream/InOutSteam.java deleted file mode 100644 index 40a0cdd..0000000 --- a/src/main/java/com/mingliqiye/utils/stream/InOutSteam.java +++ /dev/null @@ -1,279 +0,0 @@ -package com.mingliqiye.utils.stream; - -import java.io.*; -import java.util.ArrayList; -import java.util.List; -import java.util.concurrent.locks.Lock; -import java.util.concurrent.locks.ReentrantLock; -import org.jetbrains.annotations.NotNull; - -/** - * 自定义的输入输出流工具类，支持线程安全的数据读写操作。
- * 谁闲着没事干用本地输入输出
- * 实现了 AutoCloseable、Closeable 和 Flushable 接口，便于资源管理。 - * - * @author MingLiPro - */ -public class InOutSteam implements AutoCloseable, Closeable, Flushable { - - private final Lock lock = new ReentrantLock(); - - List bytes; - - /** - * 从内部缓冲区中读取最多 len 个字节到指定的字节数组 b 中。 - * - * @param b 目标字节数组，用于存储读取的数据 - * @param off 起始偏移位置 - * @param len 最大读取字节数 - * @return 实际读取的字节数；如果已到达流末尾，则返回 -1 - * @throws IndexOutOfBoundsException 如果 off 或 len 参数非法 - */ - public int read(byte@NotNull [] b, int off, int len) { - if (bytes == null) return -1; - if (bytes.isEmpty()) { - return 0; - } - - if (off < 0 || len < 0 || off + len > b.length) { - throw new IndexOutOfBoundsException(); - } - - try { - lock.lock(); - int bytesRead = Math.min(len, bytes.size()); - - for (int i = 0; i < bytesRead; i++) { - b[off + i] = bytes.get(i); - } - if (bytesRead > 0) { - bytes.subList(0, bytesRead).clear(); - } - - return bytesRead; - } finally { - lock.unlock(); - } - } - - /** - * 读取一个字节的数据。 - * - * @return 下一个字节数据（0~255），如果已到达流末尾则返回 -1 - */ - public int read() { - if (bytes == null) return -1; - try { - lock.lock(); - if (bytes.isEmpty()) { - return -1; - } - return bytes.remove(0); - } finally { - lock.unlock(); - } - } - - /** - * 从内部缓冲区中读取最多 b.length 个字节到指定的字节数组 b 中。 - * - * @param b 目标字节数组，用于存储读取的数据 - * @return 实际读取的字节数；如果已到达流末尾，则返回 -1 - */ - public int read(byte@NotNull [] b) { - if (bytes == null) return -1; - return read(b, 0, b.length); - } - - /** - * 跳过并丢弃此输入流中数据的 n 个字节。 - * - * @param n 要跳过的字节数 - * @return 实际跳过的字节数 - */ - public long skip(long n) { - if (bytes == null) return -1; - if (bytes.isEmpty()) { - return 0; - } - - try { - lock.lock(); - if (n <= 0) { - return 0; - } - long bytesToSkip = Math.min(n, bytes.size()); - - // 移除跳过的字节 - if (bytesToSkip > 0) { - bytes.subList(0, (int) bytesToSkip).clear(); - } - - return bytesToSkip; - } finally { - lock.unlock(); - } - } - - /** - * 返回此输入流下一个方法调用可以不受阻塞地从此输入流读取（或跳过）的估计字节数。 - * - * @return 可以无阻塞读取的字节数 - */ - public int available() { - if (bytes == null) return -1; - try { - lock.lock(); - return bytes.size(); - } finally { - lock.unlock(); - } - } - - /** - * 获取与当前对象关联的 InputStream 实例。 - * - * @return InputStream 实例 - */ - public InputStream getInputStream() { - if (inputStream == null) { - inputStream = inputStream(); - } - return inputStream; - } - - private InputStream inputStream; - private OutputStream outputStream; - - /** - * 获取与当前对象关联的 OutputStream 实例。 - * - * @return OutputStream 实例 - */ - public OutputStream getOutputStream() { - if (outputStream == null) { - outputStream = outputStream(); - } - return outputStream; - } - - /** - * 创建并返回一个包装后的 InputStream 实例。 - * - * @return 新创建的 InputStream 实例 - */ - private InputStream inputStream() { - return new InputStreanWrapper( - new InputStream() { - @Override - public int read() { - return InOutSteam.this.read(); - } - - @Override - public int read(byte@NotNull [] b, int off, int len) { - return InOutSteam.this.read(b, off, len); - } - - @Override - public long skip(long n) { - return InOutSteam.this.skip(n); - } - - @Override - public int available() { - return InOutSteam.this.available(); - } - } - ); - } - - /** - * 创建并返回一个 OutputStream 实例。 - * - * @return 新创建的 OutputStream 实例 - */ - private OutputStream outputStream() { - return new OutputStream() { - @Override - public void write(int b) { - InOutSteam.this.write(b); - } - - @Override - public void write(byte@NotNull [] b, int off, int len) { - InOutSteam.this.write(b, off, len); - } - }; - } - - /** - * 构造函数，初始化内部字节列表。 - */ - public InOutSteam() { - bytes = new ArrayList<>(); - } - - /** - * 将指定的字节写入此输出流。 - * - * @param b 要写入的字节 - */ - public void write(int b) { - try { - lock.lock(); - bytes.add((byte) b); - } finally { - lock.unlock(); - } - } - - /** - * 将指定字节数组中的部分数据写入此输出流。 - * - * @param b 数据源字节数组 - * @param off 起始偏移位置 - * @param len 写入的字节数 - * @throws IndexOutOfBoundsException 如果 off 或 len 参数非法 - */ - public void write(byte@NotNull [] b, int off, int len) { - if (off < 0 || len < 0 || off + len > b.length) { - throw new IndexOutOfBoundsException("Invalid offset or length"); - } - - try { - lock.lock(); - for (int i = off; i < off + len; i++) { - bytes.add(b[i]); - } - } finally { - lock.unlock(); - } - } - - /** - * 将整个字节数组写入此输出流。 - * - * @param b 要写入的字节数组 - */ - public void write(byte@NotNull [] b) { - write(b, 0, b.length); - } - - /** - * 刷新此输出流并强制写出所有缓冲的输出字节。 - * 当前实现为空方法。 - */ - @Override - public void flush() {} - - /** - * 关闭此流并释放与其相关的所有资源。 - * 清空并置空内部字节列表。 - */ - @Override - public void close() { - bytes.clear(); - bytes = null; - } -} diff --git a/src/main/java/com/mingliqiye/utils/stream/InputStreamUtils.java b/src/main/java/com/mingliqiye/utils/stream/InputStreamUtils.java deleted file mode 100644 index 686e9ae..0000000 --- a/src/main/java/com/mingliqiye/utils/stream/InputStreamUtils.java +++ /dev/null @@ -1,123 +0,0 @@ -/* - * Copyright 2025 mingliqiye - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * ProjectName mingli-utils - * ModuleName mingli-utils.main - * CurrentFile InputStreamUtils.java - * LastUpdate 2025-09-15 08:30:57 - * UpdateUser MingLiPro - */ - -package com.mingliqiye.utils.stream; - -import com.mingliqiye.utils.collection.Collections; -import lombok.val; -import org.jetbrains.annotations.NotNull; - -import java.io.ByteArrayOutputStream; -import java.io.IOException; -import java.io.InputStream; -import java.io.OutputStream; -import java.util.List; - -/** - * 输入流工具类，提供对InputStream的常用操作封装 - */ -public class InputStreamUtils { - - /** - * 默认缓冲区大小：1MB - */ - public static final int DEFAULT_BUFFER_SIZE = 1024 * 1024; - - /** - * 将输入流读取到字节数组中
- * 请在外部自行关闭输入流对象 避免资源泄露 - * - * @param inputStream 输入流对象，用于读取数据 - * @return 包含输入流所有数据的字节数组 - * @throws IOException 当读取输入流或写入输出流时发生IO异常 - */ - public static byte[] readToArray(InputStream inputStream) - throws IOException { - // 使用ByteArrayOutputStream来收集输入流中的所有数据 - try (val byteArrayOutputStream = new ByteArrayOutputStream()) { - val bytes = new byte[DEFAULT_BUFFER_SIZE]; - int length; - // 循环读取输入流数据，直到读取完毕 - while ((length = inputStream.read(bytes)) != -1) { - byteArrayOutputStream.write(bytes, 0, length); - } - return byteArrayOutputStream.toByteArray(); - } - } - - /** - * 将输入流读取到Byte列表中
- * 请在外部自行关闭输入流对象 避免资源泄露 - * - * @param inputStream 输入流对象，用于读取数据 - * @return 包含输入流所有数据的Byte列表 - * @throws IOException 当读取输入流时发生IO异常 - */ - public static @NotNull List readToList(InputStream inputStream) - throws IOException { - return Collections.newArrayLists(readToArray(inputStream)); - } - - /** - * 将输入流读取为字符串
- * 请在外部自行关闭输入流对象 避免资源泄露 - * - * @param inputStream 输入流对象，用于读取数据 - * @return 输入流对应的字符串内容 - * @throws IOException 当读取输入流时发生IO异常 - */ - public static String readToString(InputStream inputStream) - throws IOException { - return new String(readToArray(inputStream)); - } - - /** - * 将输入流的数据传输到输出流中
- * 请在外部自行关闭输入流输出流对象 避免资源泄露 - * - * @param inputStream 源输入流，用于读取数据 - * @param outputStream 目标输出流，用于写入数据 - * @return 传输的总字节数 - * @throws IOException 当读取或写入流时发生IO异常 - */ - public static long transferTo( - InputStream inputStream, - OutputStream outputStream - ) throws IOException { - if (inputStream == null) { - throw new IllegalArgumentException("inputStream can not be null"); - } - if (outputStream == null) { - throw new IllegalArgumentException("outputStream can not be null"); - } - val bytes = new byte[DEFAULT_BUFFER_SIZE]; - int length; - long readAll = 0L; - // 循环读取并写入数据，直到输入流读取完毕 - while ((length = inputStream.read(bytes)) != -1) { - outputStream.write(bytes, 0, length); - readAll += length; - } - outputStream.flush(); - return readAll; - } -} diff --git a/src/main/java/com/mingliqiye/utils/stream/InputStreanWrapper.java b/src/main/java/com/mingliqiye/utils/stream/InputStreanWrapper.java deleted file mode 100644 index b3c70a2..0000000 --- a/src/main/java/com/mingliqiye/utils/stream/InputStreanWrapper.java +++ /dev/null @@ -1,120 +0,0 @@ -/* - * Copyright 2025 mingliqiye - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * ProjectName mingli-utils - * ModuleName mingli-utils.main - * CurrentFile InputStreanWrapper.java - * LastUpdate 2025-09-14 22:12:16 - * UpdateUser MingLiPro - */ - -package com.mingliqiye.utils.stream; - -import lombok.Getter; -import org.jetbrains.annotations.NotNull; - -import java.io.IOException; -import java.io.InputStream; -import java.io.OutputStream; -import java.util.List; - -public class InputStreanWrapper extends InputStream implements AutoCloseable { - - @Getter - private final InputStream inputStream; - - public InputStreanWrapper(InputStream inputStream) { - this.inputStream = inputStream; - } - - private static InputStreanWrapper of(InputStream inputStream) { - return new InputStreanWrapper(inputStream); - } - - @Override - public int available() throws IOException { - return inputStream.available(); - } - - @Override - public int read() throws IOException { - return inputStream.read(); - } - - @Override - public int read(byte@NotNull [] b) throws IOException { - return inputStream.read(b); - } - - @Override - public int read(byte@NotNull [] b, int off, int len) throws IOException { - return inputStream.read(b, off, len); - } - - @Override - public long skip(long n) throws IOException { - return inputStream.skip(n); - } - - @Override - public void mark(int readlimit) { - inputStream.mark(readlimit); - } - - @Override - public void reset() throws IOException { - inputStream.reset(); - } - - @Override - public boolean markSupported() { - return inputStream.markSupported(); - } - - @Override - public void close() { - try { - inputStream.close(); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - /** - * 输入流转换为输出流
- * jdk8 兼容实现 jdk9+
- * 请使用 InputStream.transferTo() - * - * @param outputStream 输出流 - * @return 转换的字节数 - * @throws IOException IO错误 - */ - public long transferToOutputStream(OutputStream outputStream) - throws IOException { - return InputStreamUtils.transferTo(inputStream, outputStream); - } - - public byte[] readToArray() throws IOException { - return InputStreamUtils.readToArray(inputStream); - } - - public List readToList() throws IOException { - return InputStreamUtils.readToList(inputStream); - } - - public String readToString() throws IOException { - return InputStreamUtils.readToString(inputStream); - } -} diff --git a/src/main/java/com/mingliqiye/utils/stream/OutputStreamWrapper.java b/src/main/java/com/mingliqiye/utils/stream/OutputStreamWrapper.java deleted file mode 100644 index 2aee383..0000000 --- a/src/main/java/com/mingliqiye/utils/stream/OutputStreamWrapper.java +++ /dev/null @@ -1,81 +0,0 @@ -package com.mingliqiye.utils.stream; - -import java.io.ByteArrayOutputStream; -import java.io.IOException; -import java.io.InputStream; -import java.io.OutputStream; -import java.util.List; -import lombok.Getter; -import org.jetbrains.annotations.NotNull; - -public class OutputStreamWrapper extends OutputStream implements AutoCloseable { - - @Getter - private final OutputStream outputStream; - - private final ByteArrayOutputStream byteArrayOutputStream = - new ByteArrayOutputStream(); - - public OutputStreamWrapper(OutputStream outputStream) { - this.outputStream = outputStream; - } - - public static OutputStreamWrapper of(OutputStream outputStream) { - return new OutputStreamWrapper(outputStream); - } - - @Override - public void write(int b) throws IOException { - byteArrayOutputStream.write(b); - } - - @Override - public void write(byte@NotNull [] b) throws IOException { - byteArrayOutputStream.write(b); - } - - public void write(List b) throws IOException { - write(b, 0, b.size()); - } - - @Override - public void write(byte@NotNull [] b, int off, int len) throws IOException { - byteArrayOutputStream.write(b, off, len); - } - - public void write(List b, int off, int len) throws IOException { - byte[] bytes = new byte[b.size()]; - for (int i = 0; i < b.size(); i++) { - bytes[i] = b.get(i); - } - byteArrayOutputStream.write(bytes, off, len); - } - - @Override - public void flush() throws IOException { - outputStream.write(byteArrayOutputStream.toByteArray()); - byteArrayOutputStream.reset(); - } - - public int getBufferCachedSize() { - return byteArrayOutputStream.size(); - } - - public byte[] getBufferCachedBytes() { - return byteArrayOutputStream.toByteArray(); - } - - @Override - public void close() { - try { - outputStream.close(); - } catch (IOException e) { - throw new RuntimeException(e); - } - } - - public long transferFromOutputStream(InputStream inputStream) - throws IOException { - return InputStreamUtils.transferTo(inputStream, outputStream); - } -} diff --git a/src/main/java/com/mingliqiye/utils/stream/SuperStream.java b/src/main/java/com/mingliqiye/utils/stream/SuperStream.java deleted file mode 100644 index db14f77..0000000 --- a/src/main/java/com/mingliqiye/utils/stream/SuperStream.java +++ /dev/null @@ -1,1467 +0,0 @@ -/* - * Copyright 2025 mingliqiye - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * ProjectName mingli-utils - * ModuleName mingli-utils.main - * CurrentFile SuperStream.java - * LastUpdate 2025-09-15 09:30:37 - * UpdateUser MingLiPro - */ - -package com.mingliqiye.utils.stream; - -import com.mingliqiye.utils.map.Maps; -import com.mingliqiye.utils.stream.interfaces.Getable; -import java.util.*; -import java.util.concurrent.ConcurrentMap; -import java.util.function.*; -import java.util.stream.*; -import lombok.val; -import org.jetbrains.annotations.NotNull; - -/** - * 自定义的 SuperStream 实现类，用于对集合进行流式操作。 - * 该类实现了 Java 标准库中的 Stream 接口，并基于 List 数据结构提供了一系列流式处理方法。 - * - * @param 流中元素的类型 - * @author MingLiPro - */ -public class SuperStream implements Stream { - - /** - * 内部流对象，用于执行实际的流操作。 - */ - private final Stream stream; - - /** - * 构造函数，使用给定的流对象初始化 SuperStream。 - * - * @param stream 流对象 - */ - public SuperStream(Stream stream) { - this.stream = stream; - } - - /** - * 创建一个 SuperStream 实例，基于给定的集合。 - * - * @param collection 集合 - * @param parallel 是否并行流 - * @param 元素类型 - * @return SuperStream 实例 - */ - public static SuperStream of( - Collection collection, - boolean parallel - ) { - return new SuperStream<>( - parallel ? collection.parallelStream() : collection.stream() - ); - } - - /** - * 创建一个 SuperStream 实例，基于给定的集合。 - * - * @param collection 集合 - * @param 元素类型 - * @return SuperStream 实例 - */ - public static SuperStream of(Collection collection) { - return of(collection, false); - } - - /** - * 创建一个 SuperStream 实例，基于给定的 Map。 - * - * @param map Map - * @param parallel 是否并行流 - * @param 键类型 - * @param 值类型 - * @return SuperStream 实例 - */ - public static SuperStream> of( - Map map, - boolean parallel - ) { - return new SuperStream<>( - parallel ? map.entrySet().parallelStream() : map.entrySet().stream() - ); - } - - /** - * 创建一个 SuperStream 实例，基于给定的 Map。 - * - * @param map Map - * @param 键类型 - * @param 值类型 - * @return SuperStream 实例 - */ - public static SuperStream> of(Map map) { - return of(map, false); - } - - /** - * 创建一个 SuperStream 构建器。 - * - * @param 元素类型 - * @return 构建器 - */ - public static Builder builder() { - return new Builder() { - private final List list = new ArrayList<>(); - - @Override - public void accept(T t) { - list.add(t); - } - - @Override - public @NotNull SuperStream build() { - return new SuperStream<>(list.stream()); - } - }; - } - - /** - * 创建一个空的 SuperStream 实例。 - * - * @param 元素类型 - * @return SuperStream 实例 - */ - public static @NotNull SuperStream empty() { - return new SuperStream<>(Stream.empty()); - } - - /** - * 创建一个包含单个元素的 SuperStream 实例。 - * - * @param t 元素 - * @param 元素类型 - * @return SuperStream 实例 - */ - public static @NotNull SuperStream of(T t) { - return new SuperStream<>(Stream.of(t)); - } - - /** - * 创建一个包含多个元素的 SuperStream 实例。 - * - * @param values 元素数组 - * @param 元素类型 - * @return SuperStream 实例 - */ - @SafeVarargs - public static @NotNull SuperStream of(T... values) { - return new SuperStream<>(Stream.of(values)); - } - - /** - * 创建一个无限流，使用指定的种子和函数生成元素。 - * - * @param seed 种子 - * @param f 函数 - * @param 元素类型 - * @return SuperStream 实例 - */ - public static @NotNull SuperStream iterate( - T seed, - UnaryOperator f - ) { - return new SuperStream<>(Stream.iterate(seed, f)); - } - - /** - * 创建一个无限流，使用指定的供应商生成元素。 - * - * @param s 供应商 - * @param 元素类型 - * @return SuperStream 实例 - */ - public static @NotNull SuperStream generate(Supplier s) { - return new SuperStream<>(Stream.generate(s)); - } - - /** - * 连接两个流。 - * - * @param a 第一个流 - * @param b 第二个流 - * @param 元素类型 - * @return SuperStream 实例 - */ - public static @NotNull SuperStream concat( - @NotNull Stream a, - @NotNull Stream b - ) { - return new SuperStream<>(Stream.concat(a, b)); - } - - public T get(int index) { - return find(index).orElse(null); - } - - public Optional find(int index) { - if (index < 0 || index >= size()) { - return Optional.empty(); - } - return Optional.of(toList().get(index)); - } - - public boolean isEmpty() { - return !findAny().isPresent(); - } - - public long size() { - return count(); - } - - /** - * 将流中的元素收集到 List 中。 - * - * @return 包含流中所有元素的 List - */ - public List toList() { - return stream.collect(Collectors.toList()); - } - - /** - * 将流中的元素收集到 Set 中。 - * - * @return 包含流中所有元素的 Set - */ - public Set toSet() { - return stream.collect(Collectors.toSet()); - } - - /** - * 将流中的元素转换为 Map，键由 mapper 生成，值为元素本身。 - * - * @param mapper 键映射函数 - * @param 键类型 - * @return 包含流中所有元素的 Map - */ - public Map toMap(Function mapper) { - return stream.collect(Collectors.toMap(mapper)); - } - - /** - * 将流中的元素转换为 Map.Entry 列表，并使用 Maps.ofEntries 方法转换为 Map。 - * - * @param 键类型 - * @param 值类型 - * @return 包含流中所有元素的 Map - */ - @SuppressWarnings("unchecked") - public Map entryToMap() { - return Maps.ofEntries((List>) toList()); - } - - /** - * 返回一个顺序流。 - * - * @return SuperStream 实例 - */ - @Override - public @NotNull SuperStream sequential() { - return new SuperStream<>(stream.sequential()); - } - - /** - * 过滤流中的元素。 - * - * @param predicate 谓词函数 - * @return SuperStream 实例 - */ - @Override - public SuperStream filter(Predicate predicate) { - return new SuperStream<>(stream.filter(predicate)); - } - - /** - * 过滤流中的元素，使用 Function 作为谓词。 - * - * @param predicate 谓词函数 - * @return SuperStream 实例 - * @since 3.2.5 - */ - public SuperStream filterBoolean(Function predicate) { - return new SuperStream<>(stream.filter(predicate::apply)); - } - - /** - * 映射流中的元素。 - * - * @param mapper 映射函数 - * @param 映射后的元素类型 - * @return SuperStream 实例 - */ - @Override - public SuperStream map(Function mapper) { - return new SuperStream<>(stream.map(mapper)); - } - - /** - * 扁平化映射流中的元素。 - * - * @param mapper 映射函数 - * @param 映射后的元素类型 - * @return SuperStream 实例 - */ - @Override - public SuperStream flatMap( - Function> mapper - ) { - return new SuperStream<>(stream.flatMap(mapper)); - } - - /** - * 将流中的元素映射为 int 值。 - * - * @param mapper 映射函数 - * @return IntStream 实例 - */ - @Override - public IntStream mapToInt(ToIntFunction mapper) { - return stream.mapToInt(mapper); - } - - /** - * 将流中的元素映射为 long 值。 - * - * @param mapper 映射函数 - * @return LongStream 实例 - */ - @Override - public LongStream mapToLong(ToLongFunction mapper) { - return stream.mapToLong(mapper); - } - - /** - * 将流中的元素映射为 double 值。 - * - * @param mapper 映射函数 - * @return DoubleStream 实例 - */ - @Override - public DoubleStream mapToDouble(ToDoubleFunction mapper) { - return stream.mapToDouble(mapper); - } - - /** - * 扁平化映射流中的元素为 IntStream。 - * - * @param mapper 映射函数 - * @return IntStream 实例 - */ - @Override - public IntStream flatMapToInt( - Function mapper - ) { - return stream.flatMapToInt(mapper); - } - - /** - * 扁平化映射流中的元素为 LongStream。 - * - * @param mapper 映射函数 - * @return LongStream 实例 - */ - @Override - public LongStream flatMapToLong( - Function mapper - ) { - return stream.flatMapToLong(mapper); - } - - /** - * 扁平化映射流中的元素为 DoubleStream。 - * - * @param mapper 映射函数 - * @return DoubleStream 实例 - */ - @Override - public DoubleStream flatMapToDouble( - Function mapper - ) { - return stream.flatMapToDouble(mapper); - } - - /** - * 去除流中的重复元素。 - * - * @return SuperStream 实例 - */ - @Override - public SuperStream distinct() { - return new SuperStream<>(stream.distinct()); - } - - /** - * 对流中的元素进行排序。 - * - * @return SuperStream 实例 - */ - @Override - public SuperStream sorted() { - return new SuperStream<>(stream.sorted()); - } - - /** - * 使用指定的比较器对流中的元素进行排序。 - * - * @param comparator 比较器 - * @return SuperStream 实例 - */ - @Override - public SuperStream sorted(Comparator comparator) { - return new SuperStream<>(stream.sorted(comparator)); - } - - /** - * 对流中的每个元素执行操作。 - * - * @param action 操作函数 - * @return SuperStream 实例 - */ - @Override - public SuperStream peek(Consumer action) { - return new SuperStream<>(stream.peek(action)); - } - - /** - * 限制流中的元素数量。 - * - * @param maxSize 最大元素数量 - * @return SuperStream 实例 - */ - @Override - public SuperStream limit(long maxSize) { - return new SuperStream<>(stream.limit(maxSize)); - } - - /** - * 跳过流中的前 n 个元素。 - * - * @param n 跳过的元素数量 - * @return SuperStream 实例 - */ - @Override - public SuperStream skip(long n) { - return new SuperStream<>(stream.skip(n)); - } - - /** - * 对流中的每个元素执行操作。 - * - * @param action 操作函数 - */ - @Override - public void forEach(Consumer action) { - stream.forEach(action); - } - - /** - * 对流中的每个元素按顺序执行操作。 - * - * @param action 操作函数 - */ - @Override - public void forEachOrdered(Consumer action) { - stream.forEachOrdered(action); - } - - /** - * 将流中的元素转换为数组。 - * - * @return 包含流中所有元素的数组 - */ - @Override - public @NotNull Object@NotNull [] toArray() { - return stream.toArray(); - } - - /** - * 将流中的元素转换为指定类型的数组。 - * - * @param generator 数组生成器 - * @param 数组元素类型 - * @return 包含流中所有元素的数组 - */ - @Override - public @NotNull A@NotNull [] toArray(IntFunction generator) { - return stream.toArray(generator); - } - - /** - * 使用指定的初始值和累加器对流中的元素进行归约。 - * - * @param identity 初始值 - * @param accumulator 累加器 - * @return 归约结果 - */ - @Override - public T reduce(T identity, BinaryOperator accumulator) { - return stream.reduce(identity, accumulator); - } - - /** - * 使用指定的累加器对流中的元素进行归约。 - * - * @param accumulator 累加器 - * @return 归约结果 - */ - @Override - public @NotNull Optional reduce(BinaryOperator accumulator) { - return stream.reduce(accumulator); - } - - /** - * 使用指定的初始值、累加器和组合器对流中的元素进行归约。 - * - * @param identity 初始值 - * @param accumulator 累加器 - * @param combiner 组合器 - * @param 归约结果类型 - * @return 归约结果 - */ - @Override - public U reduce( - U identity, - BiFunction accumulator, - BinaryOperator combiner - ) { - return stream.reduce(identity, accumulator, combiner); - } - - /** - * 使用指定的供应商、累加器和组合器对流中的元素进行收集。 - * - * @param supplier 供应商 - * @param accumulator 累加器 - * @param combiner 组合器 - * @param 收集结果类型 - * @return 收集结果 - */ - @Override - public R collect( - Supplier supplier, - BiConsumer accumulator, - BiConsumer combiner - ) { - return stream.collect(supplier, accumulator, combiner); - } - - /** - * 使用指定的收集器对流中的元素进行收集。 - * - * @param collector 收集器 - * @param 收集结果类型 - * @param 收集器中间结果类型 - * @return 收集结果 - */ - @Override - public R collect(Collector collector) { - return stream.collect(collector); - } - - /** - * 找出流中的最小元素。 - * - * @param comparator 比较器 - * @return 最小元素 - */ - @Override - public @NotNull Optional min(Comparator comparator) { - return stream.min(comparator); - } - - /** - * 找出流中的最大元素。 - * - * @param comparator 比较器 - * @return 最大元素 - */ - @Override - public @NotNull Optional max(Comparator comparator) { - return stream.max(comparator); - } - - /** - * 计算流中的元素数量。 - * - * @return 元素数量 - */ - @Override - public long count() { - return stream.count(); - } - - /** - * 判断流中是否有任意元素满足谓词。 - * - * @param predicate 谓词函数 - * @return 是否满足 - */ - @Override - public boolean anyMatch(Predicate predicate) { - return stream.anyMatch(predicate); - } - - /** - * 判断流中是否所有元素都满足谓词。 - * - * @param predicate 谓词函数 - * @return 是否满足 - */ - @Override - public boolean allMatch(Predicate predicate) { - return stream.allMatch(predicate); - } - - /** - * 判断流中是否没有元素满足谓词。 - * - * @param predicate 谓词函数 - * @return 是否满足 - */ - @Override - public boolean noneMatch(Predicate predicate) { - return stream.noneMatch(predicate); - } - - /** - * 找出流中的第一个元素。 - * - * @return 第一个元素 - */ - @Override - public @NotNull Optional findFirst() { - return stream.findFirst(); - } - - /** - * 找出流中的任意元素。 - * - * @return 任意元素 - */ - @Override - public @NotNull Optional findAny() { - return stream.findAny(); - } - - /** - * 返回流的迭代器。 - * - * @return 迭代器 - */ - @Override - public @NotNull Iterator iterator() { - return stream.iterator(); - } - - /** - * 返回流的 Spliterator。 - * - * @return Spliterator - */ - @Override - public @NotNull Spliterator spliterator() { - return stream.spliterator(); - } - - /** - * 判断流是否为并行流。 - * - * @return 是否为并行流 - */ - @Override - public boolean isParallel() { - return stream.isParallel(); - } - - /** - * 返回一个并行流。 - * - * @return SuperStream 实例 - */ - @Override - public @NotNull SuperStream parallel() { - return new SuperStream<>(stream.parallel()); - } - - /** - * 返回一个无序流。 - * - * @return SuperStream 实例 - */ - @Override - public @NotNull SuperStream unordered() { - return new SuperStream<>(stream.unordered()); - } - - /** - * 注册流关闭时的处理器。 - * - * @param closeHandler 关闭处理器 - * @return SuperStream 实例 - */ - @Override - public @NotNull SuperStream onClose(@NotNull Runnable closeHandler) { - return new SuperStream<>(stream.onClose(closeHandler)); - } - - /** - * 关闭流。 - */ - @Override - public void close() { - stream.close(); - } - - public Optional findLast() { - if (isEmpty()) { - return Optional.empty(); - } - val l = stream.collect(Collectors.toList()); - return Optional.of(l.get(l.size() - 1)); - } - - public T getFirst() { - return findFirst().orElse(null); - } - - public T getLast() { - return findLast().orElse(null); - } - - public T getAny() { - return findAny().orElse(null); - } - - /** - * 内部静态类 Collectors，用于提供常用的收集器实现。 - * 所有方法均是对 java.util.stream.Collectors 的封装或扩展。 - */ - public static class Collectors { - - /** - * 返回一个收集器，用于将元素映射为 long 值并求和。 - * - * @param mapper 映射函数，将元素转换为 long 值 - * @param 元素类型 - * @return 收集器 - */ - public static Collector summingLong( - @NotNull ToLongFunction mapper - ) { - return java.util.stream.Collectors.summingLong(mapper); - } - - /** - * 返回一个收集器，将元素收集到指定类型的集合中。 - * - * @param collectionFactory 集合工厂，用于创建目标集合 - * @param 元素类型 - * @param 目标集合类型 - * @return 收集器 - */ - public static > Collector< - T, - ?, - C - > toCollection(@NotNull Supplier collectionFactory) { - return java.util.stream.Collectors.toCollection(collectionFactory); - } - - /** - * 返回一个收集器，将元素收集到 List 中。 - * - * @param 元素类型 - * @return 收集器 - */ - public static Collector> toList() { - return java.util.stream.Collectors.toList(); - } - - /** - * 返回一个收集器，将元素收集到 Set 中。 - * - * @param 元素类型 - * @return 收集器 - */ - public static Collector> toSet() { - return java.util.stream.Collectors.toSet(); - } - - /** - * 返回一个收集器，将字符序列连接成字符串。 - * - * @return 收集器 - */ - public static Collector joining() { - return java.util.stream.Collectors.joining(); - } - - /** - * 返回一个收集器，将字符序列使用指定分隔符连接成字符串。 - * - * @param delimiter 分隔符 - * @return 收集器 - */ - public static Collector joining( - @NotNull CharSequence delimiter - ) { - return java.util.stream.Collectors.joining(delimiter); - } - - /** - * 返回一个收集器，将字符序列使用指定前缀、后缀和分隔符连接成字符串。 - * - * @param delimiter 分隔符 - * @param prefix 前缀 - * @param suffix 后缀 - * @return 收集器 - */ - public static Collector joining( - @NotNull CharSequence delimiter, - @NotNull CharSequence prefix, - @NotNull CharSequence suffix - ) { - return java.util.stream.Collectors.joining( - delimiter, - prefix, - suffix - ); - } - - /** - * 返回一个收集器，先对元素进行映射，再使用下游收集器进行收集。 - * - * @param mapper 映射函数 - * @param downstream 下游收集器 - * @param 输入元素类型 - * @param 映射后的元素类型 - * @param 下游收集器的中间结果类型 - * @param 最终结果类型 - * @return 收集器 - */ - public static Collector mapping( - @NotNull Function mapper, - @NotNull Collector downstream - ) { - return java.util.stream.Collectors.mapping(mapper, downstream); - } - - /** - * 返回一个收集器，在下游收集完成后应用 finisher 函数。 - * - * @param downstream 下游收集器 - * @param finisher 完成后应用的函数 - * @param 元素类型 - * @param 下游收集器的中间结果类型 - * @param 下游收集器的结果类型 - * @param 最终结果类型 - * @return 收集器 - */ - public static Collector collectingAndThen( - @NotNull Collector downstream, - @NotNull Function finisher - ) { - return java.util.stream.Collectors.collectingAndThen( - downstream, - finisher - ); - } - - /** - * 返回一个收集器，用于统计元素数量。 - * - * @param 元素类型 - * @return 收集器 - */ - public static Collector counting() { - return java.util.stream.Collectors.counting(); - } - - /** - * 返回一个收集器，找出最小元素。 - * - * @param comparator 比较器 - * @param 元素类型 - * @return 收集器 - */ - public static Collector> minBy( - @NotNull Comparator comparator - ) { - return java.util.stream.Collectors.minBy(comparator); - } - - /** - * 返回一个收集器，找出最大元素。 - * - * @param comparator 比较器 - * @param 元素类型 - * @return 收集器 - */ - public static Collector> maxBy( - @NotNull Comparator comparator - ) { - return java.util.stream.Collectors.maxBy(comparator); - } - - /** - * 返回一个收集器，将元素映射为 int 值并求和。 - * - * @param mapper 映射函数 - * @param 元素类型 - * @return 收集器 - */ - public static Collector summingInt( - @NotNull ToIntFunction mapper - ) { - return java.util.stream.Collectors.summingInt(mapper); - } - - /** - * 返回一个收集器，将元素映射为 double 值并求和。 - * - * @param mapper 映射函数 - * @param 元素类型 - * @return 收集器 - */ - public static Collector summingDouble( - @NotNull ToDoubleFunction mapper - ) { - return java.util.stream.Collectors.summingDouble(mapper); - } - - /** - * 返回一个收集器，计算元素映射为 int 值的平均值。 - * - * @param mapper 映射函数 - * @param 元素类型 - * @return 收集器 - */ - public static Collector averagingInt( - @NotNull ToIntFunction mapper - ) { - return java.util.stream.Collectors.averagingInt(mapper); - } - - /** - * 返回一个收集器，计算元素映射为 long 值的平均值。 - * - * @param mapper 映射函数 - * @param 元素类型 - * @return 收集器 - */ - public static Collector averagingLong( - @NotNull ToLongFunction mapper - ) { - return java.util.stream.Collectors.averagingLong(mapper); - } - - /** - * 返回一个收集器，计算元素映射为 double 值的平均值。 - * - * @param mapper 映射函数 - * @param 元素类型 - * @return 收集器 - */ - public static Collector averagingDouble( - @NotNull ToDoubleFunction mapper - ) { - return java.util.stream.Collectors.averagingDouble(mapper); - } - - /** - * 返回一个收集器，使用指定的初始值和二元操作符进行归约。 - * - * @param identity 初始值 - * @param op 二元操作符 - * @param 元素类型 - * @return 收集器 - */ - public static Collector reducing( - T identity, - @NotNull BinaryOperator op - ) { - return java.util.stream.Collectors.reducing(identity, op); - } - - /** - * 返回一个收集器，使用指定的二元操作符进行归约。 - * - * @param op 二元操作符 - * @param 元素类型 - * @return 收集器 - */ - public static Collector> reducing( - @NotNull BinaryOperator op - ) { - return java.util.stream.Collectors.reducing(op); - } - - /** - * 返回一个收集器，先对元素进行映射，再使用指定的初始值和二元操作符进行归约。 - * - * @param identity 初始值 - * @param mapper 映射函数 - * @param op 二元操作符 - * @param 元素类型 - * @param 映射后的元素类型 - * @return 收集器 - */ - public static Collector reducing( - U identity, - @NotNull Function mapper, - @NotNull BinaryOperator op - ) { - return java.util.stream.Collectors.reducing(identity, mapper, op); - } - - /** - * 返回一个收集器，按分类器对元素进行分组。 - * - * @param classifier 分类器函数 - * @param 元素类型 - * @param 分类键类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull Map> - > groupingBy(@NotNull Function classifier) { - return java.util.stream.Collectors.groupingBy(classifier); - } - - /** - * 返回一个收集器，按分类器对元素进行分组，并使用下游收集器处理每个组。 - * - * @param classifier 分类器函数 - * @param downstream 下游收集器 - * @param 元素类型 - * @param 分类键类型 - * @param 下游收集器的中间结果类型 - * @param 下游收集器的结果类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull Map - > groupingBy( - @NotNull Function classifier, - @NotNull Collector downstream - ) { - return java.util.stream.Collectors.groupingBy( - classifier, - downstream - ); - } - - /** - * 返回一个收集器，按分类器对元素进行分组，并使用指定的 Map 工厂和下游收集器。 - * - * @param classifier 分类器函数 - * @param mapFactory Map 工厂 - * @param downstream 下游收集器 - * @param 元素类型 - * @param 分类键类型 - * @param 下游收集器的结果类型 - * @param 下游收集器的中间结果类型 - * @param Map 类型 - * @return 收集器 - */ - public static > Collector< - T, - ?, - M - > groupingBy( - @NotNull Function classifier, - @NotNull Supplier mapFactory, - @NotNull Collector downstream - ) { - return java.util.stream.Collectors.groupingBy( - classifier, - mapFactory, - downstream - ); - } - - /** - * 返回一个并发收集器，按分类器对元素进行分组。 - * - * @param classifier 分类器函数 - * @param 元素类型 - * @param 分类键类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull ConcurrentMap> - > groupingByConcurrent( - @NotNull Function classifier - ) { - return java.util.stream.Collectors.groupingByConcurrent(classifier); - } - - /** - * 返回一个并发收集器，按分类器对元素进行分组，并使用下游收集器处理每个组。 - * - * @param classifier 分类器函数 - * @param downstream 下游收集器 - * @param 元素类型 - * @param 分类键类型 - * @param 下游收集器的中间结果类型 - * @param 下游收集器的结果类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull ConcurrentMap - > groupingByConcurrent( - @NotNull Function classifier, - @NotNull Collector downstream - ) { - return java.util.stream.Collectors.groupingByConcurrent( - classifier, - downstream - ); - } - - /** - * 返回一个并发收集器，按分类器对元素进行分组，并使用指定的 Map 工厂和下游收集器。 - * - * @param classifier 分类器函数 - * @param mapFactory Map 工厂 - * @param downstream 下游收集器 - * @param 元素类型 - * @param 分类键类型 - * @param 下游收集器的结果类型 - * @param 下游收集器的中间结果类型 - * @param Map 类型 - * @return 收集器 - */ - public static > Collector< - T, - ?, - M - > groupingByConcurrent( - @NotNull Function classifier, - @NotNull Supplier mapFactory, - @NotNull Collector downstream - ) { - return java.util.stream.Collectors.groupingByConcurrent( - classifier, - mapFactory, - downstream - ); - } - - /** - * 返回一个收集器，按谓词对元素进行分区。 - * - * @param predicate 谓词函数 - * @param 元素类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull Map<@NotNull Boolean, @NotNull List> - > partitioningBy(@NotNull Predicate predicate) { - return java.util.stream.Collectors.partitioningBy(predicate); - } - - /** - * 返回一个收集器，按谓词对元素进行分区，并使用下游收集器处理每个分区。 - * - * @param predicate 谓词函数 - * @param downstream 下游收集器 - * @param 元素类型 - * @param 下游收集器的结果类型 - * @param 下游收集器的中间结果类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull Map<@NotNull Boolean, D> - > partitioningBy( - @NotNull Predicate predicate, - @NotNull Collector downstream - ) { - return java.util.stream.Collectors.partitioningBy( - predicate, - downstream - ); - } - - /** - * 返回一个收集器，将元素转换为 Map。 - * - * @param keyMapper 键映射函数 - * @param valueMapper 值映射函数 - * @param 元素类型 - * @param 键类型 - * @param 值类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull Map - > toMap( - @NotNull Function keyMapper, - @NotNull Function valueMapper - ) { - return java.util.stream.Collectors.toMap(keyMapper, valueMapper); - } - - /** - * 返回一个收集器，将元素转换为 Map，并指定合并函数。 - * - * @param keyMapper 键映射函数 - * @param valueMapper 值映射函数 - * @param mergeFunction 合并函数 - * @param 元素类型 - * @param 键类型 - * @param 值类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull Map - > toMap( - @NotNull Function keyMapper, - @NotNull Function valueMapper, - @NotNull BinaryOperator mergeFunction - ) { - return java.util.stream.Collectors.toMap( - keyMapper, - valueMapper, - mergeFunction - ); - } - - /** - * 返回一个收集器，将元素转换为 Map，并指定合并函数和 Map 工厂。 - * - * @param keyMapper 键映射函数 - * @param valueMapper 值映射函数 - * @param mergeFunction 合并函数 - * @param mapSupplier Map 工厂 - * @param 元素类型 - * @param 键类型 - * @param 值类型 - * @param Map 类型 - * @return 收集器 - */ - public static > Collector toMap( - @NotNull Function keyMapper, - @NotNull Function valueMapper, - @NotNull BinaryOperator mergeFunction, - @NotNull Supplier mapSupplier - ) { - return java.util.stream.Collectors.toMap( - keyMapper, - valueMapper, - mergeFunction, - mapSupplier - ); - } - - /** - * 返回一个并发收集器，将元素转换为 ConcurrentMap。 - * - * @param keyMapper 键映射函数 - * @param valueMapper 值映射函数 - * @param 元素类型 - * @param 键类型 - * @param 值类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull ConcurrentMap - > toConcurrentMap( - @NotNull Function keyMapper, - @NotNull Function valueMapper - ) { - return java.util.stream.Collectors.toConcurrentMap( - keyMapper, - valueMapper - ); - } - - /** - * 返回一个并发收集器，将元素转换为 ConcurrentMap，并指定合并函数。 - * - * @param keyMapper 键映射函数 - * @param valueMapper 值映射函数 - * @param mergeFunction 合并函数 - * @param 元素类型 - * @param 键类型 - * @param 值类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull ConcurrentMap - > toConcurrentMap( - @NotNull Function keyMapper, - @NotNull Function valueMapper, - @NotNull BinaryOperator mergeFunction - ) { - return java.util.stream.Collectors.toConcurrentMap( - keyMapper, - valueMapper, - mergeFunction - ); - } - - /** - * 返回一个并发收集器，将元素转换为 ConcurrentMap，并指定合并函数和 Map 工厂。 - * - * @param keyMapper 键映射函数 - * @param valueMapper 值映射函数 - * @param mergeFunction 合并函数 - * @param mapSupplier Map 工厂 - * @param 元素类型 - * @param 键类型 - * @param 值类型 - * @param Map 类型 - * @return 收集器 - */ - public static > Collector< - T, - ?, - M - > toConcurrentMap( - @NotNull Function keyMapper, - @NotNull Function valueMapper, - @NotNull BinaryOperator mergeFunction, - @NotNull Supplier mapSupplier - ) { - return java.util.stream.Collectors.toConcurrentMap( - keyMapper, - valueMapper, - mergeFunction, - mapSupplier - ); - } - - /** - * 返回一个收集器，计算元素映射为 int 值的统计信息。 - * - * @param mapper 映射函数 - * @param 元素类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull IntSummaryStatistics - > summarizingInt(@NotNull ToIntFunction mapper) { - return java.util.stream.Collectors.summarizingInt(mapper); - } - - /** - * 返回一个收集器，计算元素映射为 long 值的统计信息。 - * - * @param mapper 映射函数 - * @param 元素类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull LongSummaryStatistics - > summarizingLong(@NotNull ToLongFunction mapper) { - return java.util.stream.Collectors.summarizingLong(mapper); - } - - /** - * 返回一个收集器，计算元素映射为 double 值的统计信息。 - * - * @param mapper 映射函数 - * @param 元素类型 - * @return 收集器 - */ - public static Collector< - T, - ?, - @NotNull DoubleSummaryStatistics - > summarizingDouble(@NotNull ToDoubleFunction mapper) { - return java.util.stream.Collectors.summarizingDouble(mapper); - } - - /** - * 返回当前元素本身。 - * - * @param t 元素 - * @param 元素类型 - * @return 元素本身 - */ - public static T getThis(T t) { - return t; - } - - /** - * 返回一个收集器，将元素收集到 List 中。 - * - * @param 元素类型 - * @param Map.Key - * @param Map.Value - * @return 收集器 - */ - public static , K, V> Collector< - T, - ?, - @NotNull Map - > toEntryMap() { - return toMap(Map.Entry::getKey, Map.Entry::getValue); - } - - public static , K> Collector< - T, - ?, - @NotNull Map - > toMap() { - return toMap(Getable::get, Collectors::getThis); - } - - /** - * 返回一个收集器，将元素转换为 Map，键由 keyMapper 生成，值为元素本身。 - * - * @param keyMapper 键映射函数 - * @param 元素类型 - * @param 键类型 - * @return 收集器 - */ - public static Collector> toMap( - @NotNull Function keyMapper - ) { - return Collectors.toMap(keyMapper, Collectors::getThis); - } - } -} diff --git a/src/main/java/com/mingliqiye/utils/stream/interfaces/GetIdable.java b/src/main/java/com/mingliqiye/utils/stream/interfaces/GetIdable.java deleted file mode 100644 index 6dd30db..0000000 --- a/src/main/java/com/mingliqiye/utils/stream/interfaces/GetIdable.java +++ /dev/null @@ -1,9 +0,0 @@ -package com.mingliqiye.utils.stream.interfaces; - -public interface GetIdable extends Getable { - T getId(); - - default T get() { - return getId(); - } -} diff --git a/src/main/java/com/mingliqiye/utils/stream/interfaces/GetKeyable.java b/src/main/java/com/mingliqiye/utils/stream/interfaces/GetKeyable.java deleted file mode 100644 index b1153cc..0000000 --- a/src/main/java/com/mingliqiye/utils/stream/interfaces/GetKeyable.java +++ /dev/null @@ -1,9 +0,0 @@ -package com.mingliqiye.utils.stream.interfaces; - -public interface GetKeyable { - T getKey(); - - default T get() { - return getKey(); - } -} diff --git a/src/main/java/com/mingliqiye/utils/stream/interfaces/GetNameable.java b/src/main/java/com/mingliqiye/utils/stream/interfaces/GetNameable.java deleted file mode 100644 index e785ded..0000000 --- a/src/main/java/com/mingliqiye/utils/stream/interfaces/GetNameable.java +++ /dev/null @@ -1,9 +0,0 @@ -package com.mingliqiye.utils.stream.interfaces; - -public interface GetNameable extends Getable { - T getName(); - - default T get() { - return getName(); - } -} diff --git a/src/main/java/com/mingliqiye/utils/stream/interfaces/Getable.java b/src/main/java/com/mingliqiye/utils/stream/interfaces/Getable.java deleted file mode 100644 index 72d4d13..0000000 --- a/src/main/java/com/mingliqiye/utils/stream/interfaces/Getable.java +++ /dev/null @@ -1,5 +0,0 @@ -package com.mingliqiye.utils.stream.interfaces; - -public interface Getable { - T get(); -} diff --git a/src/main/kotlin/com/mingliqiye/utils/bytes/ByteUtils.kt b/src/main/kotlin/com/mingliqiye/utils/bytes/ByteUtils.kt index d79f21c..6e64407 100644 --- a/src/main/kotlin/com/mingliqiye/utils/bytes/ByteUtils.kt +++ b/src/main/kotlin/com/mingliqiye/utils/bytes/ByteUtils.kt @@ -16,15 +16,13 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile ByteUtils.kt - * LastUpdate 2025-09-15 00:07:22 + * LastUpdate 2025-09-15 17:26:34 * UpdateUser MingLiPro */ @file:JvmName("ByteUtils") package com.mingliqiye.utils.bytes -import com.mingliqiye.utils.stream.SuperStream - const val ESC_ASC: Byte = 0x10 const val ESC_DESC: Byte = 0x1B const val ESC_NONE: Byte = 0x00 @@ -43,6 +41,6 @@ const val ESC_RESERVED: Byte = 0x06 fun ByteArray.getByteArrayString(): MutableList { return this.toList().stream() .map { a -> String.format("0X%02X", a!!.toInt() and 0xFF) } - .collect(SuperStream.Collectors.toList()) + .collect(com.mingliqiye.utils.stream.toList()) as MutableList } diff --git a/src/main/kotlin/com/mingliqiye/utils/collection/Collection.kt b/src/main/kotlin/com/mingliqiye/utils/collection/Collection.kt index 2df5c94..40558bf 100644 --- a/src/main/kotlin/com/mingliqiye/utils/collection/Collection.kt +++ b/src/main/kotlin/com/mingliqiye/utils/collection/Collection.kt @@ -16,7 +16,7 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile Collection.kt - * LastUpdate 2025-09-15 09:30:37 + * LastUpdate 2025-09-15 17:26:00 * UpdateUser MingLiPro */ @@ -24,8 +24,8 @@ package com.mingliqiye.utils.collection -import com.mingliqiye.utils.stream.SuperStream import java.util.* +import java.util.stream.Collectors inline fun Collection.toArray(): Array { @@ -34,15 +34,15 @@ inline fun Collection.toArray(): Array { inline fun Collection.toMap(noinline v: (T) -> V): Map { return this.stream().collect( - SuperStream.Collectors.toMap( - SuperStream.Collectors::getThis, v + com.mingliqiye.utils.stream.toMapValueThis( + v ) ) } inline fun Collection.toMap(noinline k: (T) -> K, noinline v: (T) -> V): Map { return this.stream().collect( - SuperStream.Collectors.toMap( + Collectors.toMap( k, v ) ) diff --git a/src/main/kotlin/com/mingliqiye/utils/io/InputStreamUtils.kt b/src/main/kotlin/com/mingliqiye/utils/io/InputStreamUtils.kt new file mode 100644 index 0000000..7265ec2 --- /dev/null +++ b/src/main/kotlin/com/mingliqiye/utils/io/InputStreamUtils.kt @@ -0,0 +1,50 @@ +/* + * Copyright 2025 mingliqiye + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * ProjectName mingli-utils + * ModuleName mingli-utils.main + * CurrentFile InputStreamUtils.kt + * LastUpdate 2025-09-15 17:26:34 + * UpdateUser MingLiPro + */ +@file:JvmName("InputStreamUtils") + +package com.mingliqiye.utils.io + +import java.io.InputStream +import java.io.OutputStream +import java.nio.charset.Charset + + +fun InputStream.readAllText(charset: Charset = Charsets.UTF_8): String { + return this.readAllBytes().toString(charset) +} + +fun InputStream.readAllBytes(): ByteArray { + return this.readBytes() +} + +fun InputStream.exportBytes(out: OutputStream) { + out.write(this.readAllBytes()) + out.flush() +} + +fun InputStream.readToList(): List { + return this.readBytes().toList() +} + + + + diff --git a/src/main/kotlin/com/mingliqiye/utils/stream/SuperStream.kt b/src/main/kotlin/com/mingliqiye/utils/stream/SuperStream.kt new file mode 100644 index 0000000..d21c95e --- /dev/null +++ b/src/main/kotlin/com/mingliqiye/utils/stream/SuperStream.kt @@ -0,0 +1,122 @@ +/* + * Copyright 2025 mingliqiye + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * ProjectName mingli-utils + * ModuleName mingli-utils.main + * CurrentFile SuperStream.kt + * LastUpdate 2025-09-15 17:17:48 + * UpdateUser MingLiPro + */ +@file:JvmName("Colls") + +package com.mingliqiye.utils.stream + + +import java.util.stream.Collector +import java.util.stream.Collectors +import java.util.stream.Stream + + +class SuperStream private constructor(val stream: Stream) : Stream by stream { + companion object { + @JvmStatic + fun of(stream: Stream): SuperStream { + return SuperStream(stream) + } + + @JvmStatic + fun of(collection: Collection): SuperStream { + return SuperStream(collection.stream()) + } + + @JvmStatic + fun , K, V> of(map: T): SuperStream> { + return of(map.entries) + } + + @JvmStatic + fun of(vararg array: T): SuperStream { + return of(array.toList()) + } + + @JvmStatic + fun of(iterator: Iterator): SuperStream { + val data = ArrayList(20) + while (iterator.hasNext()) { + data.add(iterator.next()) + } + return of(data) + } + } +} + +interface Gettable { + fun get(): T +} + +interface KeyGettable : Gettable { + + fun getKey(): T + override fun get(): T { + return getKey() + } +} + +interface IdGettable : Gettable { + fun getId(): T + override fun get(): T { + return getId() + } +} + +fun getThis(t: T): T { + return t +} + +fun toMapValueThis(valueMapper: java.util.function.Function): Collector> { + return Collectors.toMap( + java.util.function.Function { it }, + valueMapper + ) as Collector> +} + +fun toMap(keyMapper: java.util.function.Function): Collector> { + return Collectors.toMap( + keyMapper, + java.util.function.Function { it }, + ) as Collector> +} + +fun toMapGet(): Collector, *, Map>> { + return Collectors.toMap( + java.util.function.Function, K> { it.get() }, + java.util.function.Function, Gettable> { it }, + ) as Collector, *, Map>> +} + +fun toMap(): Collector, *, Map> { + return Collectors.toMap( + { entry: Map.Entry -> entry.key }, + { entry: Map.Entry -> entry.value } + ) as Collector, *, Map> +} + +fun toList(): Collector> { + return Collectors.toList() +} + +fun toSet(): Collector> { + return Collectors.toSet() +}