集合常用方法

List

把Object类型的集合转为List

/**
 * 把Object类型的集合转为ArrayList
 *
 * @param obj   需要转换的集合对象
 * @param clazz 集合内对象的类型
 * @param <E>   集合内对象的类型
 * @return 转化后的List集合
 */
public <E> List<E> castList(Object obj, Class<E> clazz) {
    return castList(obj, clazz, false);
}

/**
 * 把Object类型的集合转为List，可选LinkedList、ArrayList
 *
 * @param obj      需要转换的集合对象
 * @param clazz    集合内对象的类型
 * @param isLinked 是否转为LinkedList集合
 * @param <E>      集合内对象的类型
 * @return 转化后的List集合
 */
public <E> List<E> castList(Object obj, Class<E> clazz, boolean isLinked) {
    if (!(obj instanceof List<?>)) {
        throw new ClassCastException("obj[" + obj.getClass().getName() + "]无法转化为[" + clazz.getName() + "]");
    }
    List<E> result = isLinked ? new LinkedList<>() : new ArrayList<>();
    for (Object o : (List<?>) obj) {
        result.add(clazz.cast(o));
    }
    return result;
}

把一个集合按照指定长度拆分为多个

/**
 * 把一个集合按照指定长度拆分为多个
 *
 * @param sourceList 需要进行拆分集合
 * @param groupSize  每组指定长度
 * @param <E>        集合中元素的类型
 * @return 拆分后的集合
 */
public static <E> List<List<E>> splitList(Collection<E> sourceList, int groupSize) {
    List<E> temp = new ArrayList<>(sourceList);
    int length = temp.size();
    // 计算可以分成多少组
    int num = (length + groupSize - 1) / groupSize;
    List<List<E>> newList = new ArrayList<>(num);
    for (int i = 0; i < num; i++) {
        // 开始位置
        int fromIndex = i * groupSize;
        // 结束位置
        int toIndex = Math.min((i + 1) * groupSize, length);
        newList.add(temp.subList(fromIndex, toIndex));
    }
    return newList;
}

Map

创建一个HashMap实例，该实例具有足够高的“初始容量”

/**
 * 创建一个{@link HashMap}实例，该实例具有足够高的“初始容量”
 *
 * @param expectedSize 预计容量
 * @since 该方法摘自com.google.guava-30.1.1-jre版本, 由于公司项目没有用此jar包，所以这里摘出来方便使用
 */
public static <K, V> HashMap<K, V> newHashMapWithExpectedSize(int expectedSize) {
    return new HashMap<>(capacity(expectedSize));
}

/**
 * 返回一个容量，该容量足以使Map不被调整大小，只要它的大小不超过expectedSize，并且加载因子大于等于它的默认值（0.75）
 *
 * @since 该方法摘自com.google.guava-30.1.1-jre版本, 由于公司项目没有用此jar包，所以这里摘出来方便使用
 */
static int capacity(int expectedSize) {
    if (expectedSize < 3) {
        if (expectedSize < 0) {
            throw new IllegalArgumentException("容量不能为负数，但是现在是: " + expectedSize);
        }
        return expectedSize + 1;
    }
    // int的最大二次幂
    int maxPowerOfTwo = 1 << (Integer.SIZE - 2);
    if (expectedSize < maxPowerOfTwo) {
        //这是JDK8中用于在发生putAll时调整大小的计算；这似乎是我们能做的最保守的计算。0.75是默认负载系数。
        return (int) ((float) expectedSize / 0.75F + 1.0F);
    }
    // int值大于int的最大二次幂了，就没有更大的了
    return Integer.MAX_VALUE;
}