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