【Java常用工具类】集合操作常用方法

其他工具类

【Java常用工具类】数学计算

【Java常用工具类】字符串

【Java常用工具类】easyexcel基本使用演示

【Java常用工具类】日期类

介绍

本工具类主要包含了list、map之间的转换，过滤、聚合等常用方法

方法简介

mapKeyToList， 将map中的key转list

mapValueToList，将map中的value转list

mapValueToSet，将map中的value转set

getListSomeValues，根据List元素中T的方法获取到的值，放入到另一个list元素中

filterBySomeValue，根据predicate表达式对list中的元素进行过滤

distinct，对list元素进行去重

max，返回list元素中最大值

min，返回list元素中最小值

mapToJsonString，map转json字符串

mapToObject，map转对象

jsonStringToMap，json字符串转map

partition，把一个大list分割成多个小list

charactersOf，把字符串转换成不可变的字符集合

difference，获取两个set集合的差集

intersection，获取两个set集合的交集

union，获取两个set集合的并集，返回不可变的set集合

permute，set集合全排列

filterKeys，过滤map中符合条件的key值

filterValues，过滤map中符合条件的value值

transformValues，按照function修改map中的value值

unmodifiableMap，获取不可变的map

unmodifiableList，获取不可变的list

unmodifiableSet，获取不可变的set

newThreadSafeSet，获取线程安全的set集合，区分与CopyOnWriteArraySet的使用场景

arrayToList，数组转list

具体方法

/**
 * 集合工具类
 */
public class CollectionsUtils {

    /**
     * 将map中的key转list
     *
     * @param map an argument
     * @param <K> the class of the map keys
     * @param <V> the class of the map values
     * @return list
     */
    public static <K, V> List<K> mapKeyToList(Map<K, V> map) {
        return Collections.unmodifiableList(new ArrayList<>(map.keySet()));
    }

    /**
     * 将map中的value转list
     *
     * @param map an argument
     * @param <K> the class of the map keys
     * @param <V> the class of the map values
     * @return list
     */
    public static <K, V> List<V> mapValueToList(Map<K, V> map) {
        return Collections.unmodifiableList(new ArrayList<>(map.values()));
    }

    /**
     * 将map中的value转set
     *
     * @param map an argument
     * @param <K> the class of the map keys
     * @param <V> the class of the map values
     * @return set
     */
    public static <K, V> Set<V> mapValueToSet(Map<K, V> map) {
        return new HashSet<>(map.values());
    }

    /**
     * 根据List元素中T的方法获取到的值，放入到另一个list元素中
     *
     * @param list   an argument
     * @param mapper Function
     * @param <T>    list中的元素
     * @param <R>    Function中的返回值
     * @return list
     */
    public static <T, R> List<R> getListSomeValues(List<T> list, Function<? super T, ? extends R> mapper) {
        return list.stream().map(mapper).collect(Collectors.toList());
    }

    /**
     * 根据predicate表达式对list中的元素进行过滤
     *
     * @param list      an argument
     * @param predicate 支持验证表达式的一个接口
     * @param <T>       list中的元素
     * @return list
     */
    public static <T> List<T> filterBySomeValue(List<T> list, Predicate<? super T> predicate) {
        return list.stream().filter(predicate).collect(Collectors.toList());
    }

    /**
     * 对list元素进行去重
     *
     * @param list an argument
     * @param <T>  list中的元素
     * @return list
     */
    public static <T> List<T> distinct(List<T> list) {
        return list.stream().distinct().collect(Collectors.toList());
    }

    /**
     * 返回list元素中最大值
     *
     * @param list       an argument
     * @param comparator 比较器
     * @param <T>        list中的元素
     * @return 最大值
     */
    public static <T> T max(List<T> list, Comparator<? super T> comparator) {
        Optional<T> max = list.stream().max(comparator);
        return max.orElse(null);
    }

    /**
     * 返回list元素中最小值
     *
     * @param list       an argument
     * @param comparator 比较器
     * @param <T>        list中的元素
     * @return 最小值
     */
    public static <T> T min(List<T> list, Comparator<? super T> comparator) {
        Optional<T> min = list.stream().min(comparator);
        return min.orElse(null);
    }

    /**
     * map转json字符串
     *
     * @param map an argument
     * @param <K> K
     * @param <V> V
     * @return json字符串
     */
    public static <K, V> String mapToJsonString(Map<K, V> map) {
        return JSONObject.toJSONString(map);
    }

    /**
     * map转对象
     *
     * @param map   an argument
     * @param clazz 对象类型
     * @param <K>   map中的Key
     * @param <V>   map中的Value
     * @param <T>   对象类型
     * @return 对象
     */
    public static <K, V, T> T mapToObject(Map<K, V> map, Class<T> clazz) {
        return parseObject(mapToJsonString(map), clazz);
    }

    /**
     * json字符串转map
     *
     * @param jsonString json字符串
     * @return map
     */
    public static Map jsonStringToMap(String jsonString) {
        return parseObject(jsonString, Map.class);
    }

    /**
     * 把一个大list分割成多个小list
     *
     * @param list
     * @param size
     * @param <T>
     * @return
     */
    public static <T> List<List<T>> partition(List<T> list, int size) {
        return Lists.partition(list, size);
    }

    /**
     * 把字符串转换成不可变的字符集合
     *
     * @param string
     * @return
     */
    public static ImmutableList<Character> charactersOf(String string) {
        return Lists.charactersOf(string);
    }

    /**
     * 获取两个set集合的差集
     *
     * @param set1
     * @param set2
     * @param <E>
     * @return
     */
    public static <E> Set<E> difference(final Set<E> set1, final Set<?> set2) {
        return Sets.difference(set1, set2);
    }

    /**
     * 获取两个set集合的交集
     *
     * @param set1
     * @param set2
     * @param <E>
     * @return
     */
    public static <E> Set<E> intersection(final Set<E> set1, final Set<?> set2) {
        return Sets.intersection(set1, set2);
    }

    /**
     * 获取两个set集合的并集，返回不可变的set集合
     *
     * @param set1
     * @param set2
     * @param <E>
     * @return
     */
    public static <E> ImmutableSet<Object> union(final Set<E> set1, final Set<?> set2) {
        return Sets.union(set1, set2).immutableCopy();
    }

    /**
     * set集合全排列
     *
     * @param set
     * @param <E>
     * @return
     */
    public static <E> Set<Set<E>> permute(Set<E> set) {
        return Sets.powerSet(set);
    }

    /**
     * 过滤map中符合条件的key值
     *
     * @param unfiltered
     * @param keyPredicate
     * @param <K>
     * @param <V>
     * @return
     */
    public static <K, V> Map<K, V> filterKeys(
            Map<K, V> unfiltered, final Predicate<? super K> keyPredicate) {
        return Maps.filterKeys(unfiltered, keyPredicate::test);
    }

    /**
     * 过滤map中符合条件的value值
     *
     * @param unfiltered
     * @param valuePredicate
     * @param <K>
     * @param <V>
     * @return
     */
    public static <K, V> Map<K, V> filterValues(
            Map<K, V> unfiltered, final Predicate<? super V> valuePredicate) {
        return Maps.filterValues(unfiltered, valuePredicate::test);
    }

    /**
     * 按照function修改map中的value值
     *
     * @param fromMap
     * @param function
     * @param <K>
     * @param <V1>
     * @param <V2>
     * @return
     */
    public static <K, V1, V2> Map<K, V2> transformValues(
            Map<K, V1> fromMap, Function<? super V1, @Nullable V2> function) {
        return Maps.transformValues(fromMap, function::apply);
    }

    /**
     * 获取不可变的map
     * 可在作为常量时用到
     *
     * @param m
     * @param <K>
     * @param <V>
     * @return
     */
    public static <K, V> Map<K, V> unmodifiableMap(Map<? extends K, ? extends V> m) {
        return Collections.unmodifiableMap(m);
    }

    /**
     * 获取不可变的list
     * 可在作为常量时用到
     *
     * @param list
     * @param <T>
     * @return
     */
    public static <T> List<T> unmodifiableList(List<? extends T> list) {
        return Collections.unmodifiableList(list);
    }

    /**
     * 获取不可变的set
     * 可在作为常量时用到
     *
     * @param s
     * @param <T>
     * @return
     */
    public static <T> Set<T> unmodifiableSet(Set<? extends T> s) {
        return Collections.unmodifiableSet(s);
    }

    /**
     * 获取线程安全的set集合，区分与CopyOnWriteArraySet的使用场景
     *
     * @param <E>
     * @return
     */
    public static <E> Set<E> newThreadSafeSet() {
        return Collections.newSetFromMap(new ConcurrentHashMap<>());
    }

    /**
     * 数组转list
     *
     * @param arr
     * @param <T>
     * @return
     */
    public static <T> List<T> arrayToList(T[] arr) {
        List<T> list = new ArrayList<>(arr.length);
        Collections.addAll(list, arr);
        return list;
    }

}

测试方法

public class CollectionsUtilsDemo {

    @Test
    public void mapKeyToList() {
        Map<String, String> map = new HashMap<>();
        map.put("a", "1");
        map.put("b", "2");
        map.put("c", "3");
        List<String> list = CollectionsUtils.mapKeyToList(map);
        Assert.assertArrayEquals(new String[]{"a", "b", "c"}, list.toArray());
    }

    @Test
    public void mapValueToList() {
        Map<String, String> map = new HashMap<>();
        map.put("a", "1");
        map.put("b", "2");
        map.put("c", "3");
        List<String> list = CollectionsUtils.mapValueToList(map);
        Assert.assertArrayEquals(new String[]{"1", "2", "3"}, list.toArray());
    }

    @Test
    public void mapValueToSet() {
        Map<String, String> map = new HashMap<>();
        map.put("a", "1");
        map.put("b", "2");
        map.put("c", "3");
        Set<String> sets = CollectionsUtils.mapValueToSet(map);
        Assert.assertArrayEquals(new String[]{"1", "2", "3"}, sets.toArray());
    }

    @Test
    public void getListSomeValues() {
        List<String> list = new ArrayList<>();
        list.add("1 ");
        list.add(" 2");
        list.add(" 3 ");
        List<String> trimList = CollectionsUtils.getListSomeValues(list, String::trim);
        Assert.assertArrayEquals(new String[]{"1", "2", "3"}, trimList.toArray());
    }

    @Test
    public void filterBySomeValue() {
        List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        List<String> trimList = CollectionsUtils.filterBySomeValue(list, str -> str.equals("2"));
        Assert.assertArrayEquals(new String[]{"2"}, trimList.toArray());
    }

    @Test
    public void distinct() {
        List<String> list = new ArrayList<>();
        list.add("2");
        list.add("2");
        list.add("2");
        List<String> trimList = CollectionsUtils.distinct(list);
        Assert.assertArrayEquals(new String[]{"2"}, trimList.toArray());
    }

    @Test
    public void max() {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        int max = CollectionsUtils.max(list, Integer::compareTo);
        Assert.assertEquals(3, max);
    }

    @Test
    public void min() {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        int min = CollectionsUtils.min(list, Integer::compareTo);
        Assert.assertEquals(1, min);
    }

    @Test
    public void mapToJsonString() {
        Map<String, String> map = new HashMap<>();
        map.put("a", "1");
        map.put("b", "2");
        map.put("c", "3");
        String jsonString = CollectionsUtils.mapToJsonString(map);
        Assert.assertEquals("{\"a\":\"1\",\"b\":\"2\",\"c\":\"3\"}", jsonString);
    }

    @Test
    public void mapToObject() {
        Map<String, String> map = new HashMap<>();
        map.put("a", "1");
        map.put("b", "2");
        map.put("c", "3");
        DemoEntity demoEntity = CollectionsUtils.mapToObject(map, DemoEntity.class);
        Assert.assertEquals("1", demoEntity.getA());
        Assert.assertEquals("2", demoEntity.getB());
        Assert.assertEquals("3", demoEntity.getC());
    }

    @Test
    public void jsonStringToMap() {
        String jsonStr = "{\"a\":\"1\",\"b\":\"2\",\"c\":\"3\"}";
        Map<String, String> resultMap = CollectionsUtils.jsonStringToMap(jsonStr);
        Assert.assertEquals("1", resultMap.get("a"));
        Assert.assertEquals("2", resultMap.get("b"));
        Assert.assertEquals("3", resultMap.get("c"));
    }

    @Test
    public void partition() {
        List<Integer> bigList = new ArrayList<>();
        bigList.add(1);
        bigList.add(2);
        bigList.add(3);
        bigList.add(4);
        bigList.add(5);
        bigList.add(6);
        List<List<Integer>> partitionList = CollectionsUtils.partition(bigList, 3);
        List<Integer> list = partitionList.get(0);
        Assert.assertArrayEquals(new Integer[]{1, 2, 3}, list.toArray());
        list = partitionList.get(1);
        Assert.assertArrayEquals(new Integer[]{4, 5, 6}, list.toArray());
    }

    @Test
    public void charactersOf() {
        String string = "123";
        ImmutableList<Character> characters = CollectionsUtils.charactersOf(string);
        Assert.assertArrayEquals(new Character[]{'1', '2', '3'}, characters.toArray());
    }

    @Test
    public void difference() {
        Set<String> set1 = new HashSet<>();
        set1.add("1");
        set1.add("2");
        Set<String> set2 = new HashSet<>();
        set2.add("2");
        set2.add("3");
        Set<String> resultSet = CollectionsUtils.difference(set1, set2);
        Assert.assertArrayEquals(new String[]{"1"}, resultSet.toArray());
    }

    @Test
    public void intersection() {
        Set<String> set1 = new HashSet<>();
        set1.add("1");
        set1.add("2");
        Set<String> set2 = new HashSet<>();
        set2.add("2");
        set2.add("3");
        Set<String> resultSet = CollectionsUtils.intersection(set1, set2);
        Assert.assertArrayEquals(new String[]{"2"}, resultSet.toArray());
    }

    @Test
    public void union() {
        Set<String> set1 = new HashSet<>();
        set1.add("1");
        set1.add("2");
        Set<String> set2 = new HashSet<>();
        set2.add("2");
        set2.add("3");
        ImmutableSet<Object> sets = CollectionsUtils.union(set1, set2);
        Assert.assertArrayEquals(new String[]{"1", "2", "3"}, sets.toArray());
    }

    @Test
    public void filterKeys() {
        Map<String, String> map = new HashMap<>();
        map.put("a", "1");
        map.put("b", "2");
        map.put("c", "3");
        Map<String, String> resultMap = CollectionsUtils.filterKeys(map, str -> str.equals("a"));
        Assert.assertEquals(1, resultMap.size());
        Assert.assertEquals("1", resultMap.get("a"));
    }

    @Test
    public void filterValues() {
        Map<String, String> map = new HashMap<>();
        map.put("a", "1");
        map.put("b", "2");
        map.put("c", "3");
        Map<String, String> resultMap = CollectionsUtils.filterValues(map, str -> str.equals("1"));
        Assert.assertEquals(1, resultMap.size());
        Assert.assertEquals("1", resultMap.get("a"));
    }

    @Test
    public void transformValues() {
        Map<String, String> map = new HashMap<>();
        map.put("a", "a");
        map.put("b", "b");
        map.put("c", "c");
        Map<String, String> resultMap = CollectionsUtils.transformValues(map, String::toUpperCase);
        Assert.assertEquals(3, resultMap.size());
        Assert.assertEquals("A", resultMap.get("a"));
        Assert.assertEquals("B", resultMap.get("b"));
        Assert.assertEquals("C", resultMap.get("c"));
    }

}