场景

Java中数组与List互转的几种方式

数组转List

1、最简单的方式,Arrays.asList(array); 创建的是不可变列表，不能删除和新增元素

        String[] array = new String[]{"a","b"};
        List<String> stringList = Arrays.asList(array);
        System.out.println(stringList);//[a, b]

但是如果修改为如下

        String[] arrayA = new String[]{"a","b"};
        List<String> stringListA = Arrays.asList(arrayA);
//        System.out.println(stringListA);
//        stringListA.add("c");
//        System.out.println(stringListA);

运行直接抛出异常Exception in thread "main" java.lang.UnsupportedOperationException
这是因为通过Arrays.asList创建的List,虽然命名也是ArrayList，但是全路径为java.util.Arrays.ArrayList
不支持add,remove操作，但是可以更新列表中元素的值。

不支持add,remove操作，但是可以更新列表中元素的值。

        stringListA.set(1,"c");
        System.out.println(stringListA);

2、如果需要对转换后的list进行操作，可以用以下方式

        String[] arrayB = new String[]{"a","b"};
        ArrayList<String> strings = new ArrayList<>(Arrays.asList(arrayB));
        strings.add("c");
        System.out.println(strings);//[a, b, c]

相当于用列表创建列表，属于深拷贝的一种表现，获得的列表支持新增、删除

3、第三种借助于jdk提供的容器工具类Collections来实现-推荐写法

        String[] arrayC = new String[]{"a","b"};
        //创建列表，并指定长度，避免可能产生的扩容
        List<String> list= new ArrayList<>(arrayC.length);
        //实现数组添加到列表中
        Collections.addAll(list,arrayC);
        //因为列表为我们定义的ArrayList，所以可以对它进行增删改
        list.add("c");
        System.out.println(list);

列表转数组

列表转数组,直接调用List.toArray

        List<String> listA = Arrays.asList("a","b","c");
        //返回的是Object[]数组
        Object[] objects = listA.toArray();
        //如果需要指定数组类型，可以传一个指定各类型的空的数组
        String[] strings1 = listA.toArray(new String[]{});

Java中驼峰与下划线互转

1、使用guava

        //驼峰转下划线
        String baDao = CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, "baDao");
        System.out.println(baDao);
        //下划线转驼峰
        String ba_dao = CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, "ba_dao");
        System.out.println(ba_dao);

2、使用Hutool工具类

        String ba_dao1 = StrUtil.toCamelCase("ba_Dao");
        System.out.println(ba_dao1);
        String baDao1 = StrUtil.toUnderlineCase("baDao");
        System.out.println(baDao1);

Java中Map转换Map的几种方式

比如希望将一个Map<String,Integer>转换成Map<String,String>

首先提供一个创建Map的公共方法newMap

    private static <T> Map<String,T> newMap(String key,T val,Object... kv){
        Map<String,T> ans = new HashMap<>(8);
        ans.put(key,val);
        for (int i = 0,size = kv.length; i < size; i+=2) {
            ans.put(String.valueOf(kv[i]),(T)kv[i+1]);
        }
        return ans;
    }

1、基本的for循环转换

        Map<String, Integer> map = newMap("k", 1, "a", 2, "b", 3);
        HashMap<String,String> ans = new HashMap<>(map.size());
        for (Map.Entry<String,Integer> entry:map.entrySet()) {
            ans.put(entry.getKey(),String.valueOf(entry.getValue()));
        }
        System.out.println(ans);

2、容器的流式使用

        Map<String, Integer> map1 = newMap("k", 1, "a", 2, "b", 3);
        Map<String, String> collect = map1.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, s -> String.valueOf(s.getValue())));
        System.out.println(collect);

3、Guava的transform方式

        Map<String, Integer> map2 = newMap("k", 1, "a", 2, "b", 3);
        Map<String, String> stringStringMap = Maps.transformValues(map2, String::valueOf);
        System.out.println(stringStringMap);

Java中List转Map的几种方式

如何将List转为Map<Object,List<Object>>

1、基本写法

        List<String> list = new ArrayList<String>(){{
            add("badao");
            add("de");
            add("cheng");
            add("xv");
            add("yuan");
        }};
        Map<Integer,List<String>> ans = new HashMap<>();
        for (String str:list) {
            List<String> sub = ans.get(str.length());
            if(sub == null){
                sub = new ArrayList<>();
                ans.put(str.length(),sub);
            }
            sub.add(str);
        }
        System.out.println(ans);

2、对于jdk8,上面for循环的内容可以利用Map.computeIfAbsent来替换

computeIfAbsent:如果key对应的value不存在，则使用获取 mappingFunction 计算后的值，

并保存为该 key 的 value，否则返回 value。

        Map<Integer,List<String>> ans2 = new HashMap<>();
        for (String str:list) {
            ans2.computeIfAbsent(str.length(),k->new ArrayList<>()).add(str);
        }
        System.out.println(ans2);

3、在jdk8中借助stream的流处理，可以将上面更一步进行简化

        Map<Integer, List<String>> collect = list.stream().collect(Collectors.groupingBy(String::length));
        System.out.println(collect);

4、上面是针对特定的列表，针对业务进行开发转换，下面构建一个通用的工具类toMapList

    /**
     * List<V> 转换成Map<K,List<V>>  特点在于Map中的value是个列表，且列表中的元素就是从原列表中的元素获取
     * @param list
     * @param func
     * @param <K>
     * @param <V>
     * @return
     */
    public static <K,V> Map<K,List<V>> toMapList(List<V> list, Function<V,K> func){
        return list.stream().collect(Collectors.groupingBy(func));
    }

对应的调用可以改为

        Map<Integer, List<String>> integerListMap = toMapList(list, String::length);
        System.out.println(integerListMap);
        //{2=[de, xv], 4=[yuan], 5=[badao, cheng]}

5、如果希望对value也做处理，可以修改工具类

    /**
     * List<I> 转换成Map<K,List<V>> 特点在于Map中的value是个列表，且列表中的元素是由list.item转换而来
     * @param list
     * @param keyFunc
     * @param valFunc
     * @param <K>
     * @param <I>
     * @param <V>
     * @return
     */
    public static <K,I,V> Map<K,List<V>> toMapList(List<I> list,Function<I,K> keyFunc,Function<I,V> valFunc){
        return list.stream().collect(Collectors.groupingBy(keyFunc,Collectors.mapping(valFunc,Collectors.toList())));
    }

调用示例

        Map<Integer, List<String>> integerListMap1 = toMapList(list, String::length, String::toUpperCase);
        System.out.println(integerListMap1);
        //{2=[DE, XV], 4=[YUAN], 5=[BADAO, CHENG]}

6、guava工具包中提供了一个HashMultimap的工具类，它的使用和平常的map的区别是，它的value是个集合

        HashMultimap<Integer, String> map = HashMultimap.create();
        for (String str:list) {
            map.put(str.length(),str);
        }
        System.out.println(map);
        //{2=[de, xv], 4=[yuan], 5=[badao, cheng]}

Java中进行进制转换的几种方式

1、toString实现进制转换

Integer/Long toString(int i,int radix)可以将任一进制的整数，转换为其他任意进制的整数
第一个参数：待转换的数字
第二个参数：转换后的进制位

        //十六进制转十进制
        System.out.println(Integer.toString(0x12, 10));
        //八进制转十进制
        System.out.println(Integer.toString(012,10));
        //八进制转二进制
        System.out.println(Integer.toString(012,2));

2、除了使用上面的方式，还可直接使用toBinaryString来实现转二进制

        //十进制转二进制
        System.out.println(Integer.toBinaryString(2));
        //十进制转八进制
        System.out.println(Integer.toOctalString(9));
        //十进制转十六进制
        System.out.println(Integer.toHexString(10));