stream-utils

最新推荐文章于 2024-09-01 07:41:33 发布

捕風捉影

最新推荐文章于 2024-09-01 07:41:33 发布

阅读量236

点赞数

分类专栏：工具类文章标签： java jvm apache

本文链接：https://blog.youkuaiyun.com/qq_44833327/article/details/130797294

版权

该代码提供了一个名为StreamUtils的工具类，包含多种对集合进行操作的方法，如判断集合是否为空、拆分集合为子列表、转换为Map、去重、过滤、分组等。类中使用了Java8的StreamAPI，并行处理以提高性能，确保函数式接口的无状态和线程安全性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

package com.hengtiansoft.common.util;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * 集合流操作工具类，使用并行流，需要保证函数式是无状态、线程安全的
 *
 * @author SC
 * @since 1.0.0
 */
@Slf4j
public final class StreamUtils {
    private static final int BUFFER_NUMBER = 1024;

    private StreamUtils() {

    }

    /**
     * 将集合转换为并行流
     *
     * @param source 原集合
     * @return 并行流
     */
    private static <T> Stream<T> toStream(Collection<T> source) {
        return source.stream().parallel();
    }

    /**
     * 判断集合是否为空
     *
     * @param collection 集合
     * @return true表示集合为空
     */
    public static boolean isEmpty(Collection<?> collection) {
        return collection == null || collection.isEmpty();
    }

    /**
     * 将一个List拆分成多个子list，保留输入集合的null对象
     *
     * @param <T>     对象类型
     * @param source  对象列表
     * @param maxSize 子列表大小
     * @return 分组后的子列表
     */
    public static <T> List<List<T>> split(final List<T> source,
                                          final int maxSize) {
        if (isEmpty(source)) {
            return new ArrayList<>(0);
        }
        if (maxSize <= 0) {
            throw new IllegalArgumentException("maxSize must be positive"); // NOSONAR
        }

        final int size = source.size();
        if (size <= maxSize) {
            return Collections.singletonList(source); // NOSONAR
        }

        final int step = (size + maxSize - 1) / maxSize;

        return IntStream.range(0, step).parallel()
                .mapToObj(i -> {
                    int fromIdx = i * maxSize;
                    int toIdx = fromIdx + maxSize;
                    if (toIdx > size) {
                        toIdx = size;
                    }
                    return source.subList(fromIdx, toIdx);
                }).collect(Collectors.toList());
    }

    /**
     * 将一个集合拆分成多个子list，保留输入集合的null对象
     *
     * @param <T>     对象类型
     * @param source  对象集合
     * @param maxSize 子列表大小
     * @return 分组后的子列表
     */
    public static <T> List<List<T>> split(final Collection<T> source,
                                          final int maxSize) {
        if (isEmpty(source)) {
            return new ArrayList<>(0);
        }
        if (maxSize <= 0) {
            throw new IllegalArgumentException("maxSize must be positive");
        }

        final int size = source.size();
        if (size <= maxSize) {
            if (!(source instanceof List)) {
                return Collections.singletonList(new ArrayList<>(source));
            }
            return Collections.singletonList((List<T>) source);
        }

        final int step = (size + maxSize - 1) / maxSize;

        return IntStream
                .range(0, step).parallel().mapToObj(i -> source.stream()
                        .skip((long) i * maxSize).limit(maxSize).collect(Collectors.toList()))
                .collect(Collectors.toList());
    }

    /**
     * 将一个集合拆分成多个子Set，保留输入集合的null对象
     *
     * @param <T>     对象类型
     * @param source  对象集合
     * @param maxSize 子列表大小
     * @return 分组后的子列表
     */
    public static <T> List<Set<T>> splitToSet(final Collection<T> source,
                                              final int maxSize) {
        if (isEmpty(source)) {
            return new ArrayList<>(0);
        }
        if (maxSize <= 0) {
            throw new IllegalArgumentException("maxSize must be positive");
        }

        final int size = source.size();
        if (siz

最低0.47元/天解锁文章