有时候Java（针对JDK8）和Kotlin混合开发，相互调用过程中，经常有一些集合和数组的互转，使用不当或不清楚会出现调用类型不匹配问题或其它报错，本篇整理一下。国际规则，直接上测试代码，仅供参考

List、Set、Map、数组互转(Java版本)

/**
 * List 转为 String 数组
 */
private static void listToStringArr() {
    List<String> list=new ArrayList<>();
    list.add("a");
    list.add("b");
    list.add("c");
    // 方法1:
    String[] str = list.toArray(new String[list.size()]);
    // 方法2:
    String[] str2 = new String[list.size()];
    for(int i=0;i<list.size();i++) {
        str2[i] = list.get(i);
    }
}

/**
 * String 数组 转为List
 */
private static void stringArrToList() {
    String[] strs = {"a","b","c"};
    // 方法1:
    List<String> list = Arrays.asList(strs);
    //list这个集合是不可修改的，还需要进一步转换
    List<String> list2 = new ArrayList<>(list);
    // 方法2:
    List<String> list3 = new ArrayList<>();
    Collections.addAll(list3, strs); //内部循环赋值
}


/**
 * list转set
 */
private static void listToSet() {
    List<String> list=new ArrayList<>();
    list.add("a");
    list.add("b");
    list.add("c");
    Set<String> set = new HashSet(list);

}

/**
 * set转list
 */
private static void setToList() {
    Set<String> set = new HashSet();
    set.add("a");
    set.add("b");
    set.add("c");
    List<String> list=new ArrayList<>(set);
}



/**
 * map转set
 */
private static void mapToSet() {
    Map<String,Integer> map = new HashMap();
    map.put("a", 1);
    map.put("b", 2);
    map.put("c", 3);

    Set<String> keySet = new HashSet(map.keySet());
    //value同理

}

/**
 * map转list
 */
private static void mapToList() {
    Map<String,Integer> map = new HashMap();
    map.put("a", 1);
    map.put("b", 2);
    map.put("c", 3);

    List<String> keyList = new ArrayList(map.keySet());
    //value同理
}

List、Set、Map、数组互转(Kotlin版本,含可变和不可变集合转换)

    /**
     * List 转为 String 数组
     */
    fun listToStringArr() {
        val list: MutableList<String> = ArrayList()
        list.add("a")
        list.add("b")
        list.add("c")
        // 方法1:
        val str = list.toTypedArray()

        // 方法2:
        val str2 = arrayOfNulls<String>(list.size)
        for (i in list.indices) {
            str2[i] = list[i]
        }
    }

  /**
     * String 数组 转为List
     */
    fun stringArrToList() {
        val strs = arrayOf("a", "b", "c")

        //转为不可变集合
        val list1= Arrays.asList(strs) 
        // or
        val list2 = strs.asList()
        //or
        val list3 = listOf(strs)


        //转为转为可变集合

        val mutableList: MutableList<String> = strs.toMutableList()


    }



    /**
     * list转set
     */
    fun listToSet() {
        val list: MutableList<String> = ArrayList()
        list.add("a")
        list.add("b")
        list.add("c")
        //转为不可变集合
        val set1: Set<String> = HashSet<String>(list)
        //or
        val set2 = setOf(list)

        //转为可变集合
        val mutableSet= HashSet(list)
        //or
        val mutableSet1= mutableSetOf(list)
        //or
        val mutableSet2= hashSetOf(list)


    }

    /**
     * set转list
     */
    fun setToList() {
        val set: MutableSet<String> = HashSet<String>()
        set.add("a")
        set.add("b")
        set.add("c")
        //转为不可变集合
        val list1: List<String> = ArrayList<String>(set)
        //or
        val list2 = listOf(set)

        //转为可变集合
        val mutableList =ArrayList(set)
        //or
        val mutableList1 =mutableListOf(set)
        //or
        val mutableList2 = arrayListOf(set)
    }




    /**
     * map转set
     */
    fun mapToSet() {
//        val map: MutableMap<String, Int> = HashMap()
        //or
//        val map: MutableMap<String, Int> = hashMapOf()
        //or
        val map= hashMapOf<String, Int>() //mutableMapOf对应LinkedHashMap
        map["a"] = 1
        map["b"] = 2
        map["c"] = 3
        //转为不可变集合
        val keySet1: Set<String> = HashSet<String>(map.keys)
        //or
        val keySet2= setOf(map.keys)


        //转为可变集合
        val keyMutableSet= HashSet(map.keys) //对应HashSet
        //or
        val keyMutableSet1= mutableSetOf(map.keys) //对应LinkedHashSet
        //or
        val keyMutableSet2= hashSetOf(map.keys) //对应HashSet


    }

    /**
     * map转list
     */
    fun mapToList() {
        val map= hashMapOf<String, Int>()
        map["a"] = 1
        map["b"] = 2
        map["c"] = 3
        //转为不可变集合
        val keyList1: List<String> = ArrayList<String>(map.keys)
        //or
        val keyList2 = listOf(map.keys)

        //转为可变集合
        //or
        val keyMutableList = ArrayList(map.keys)
        //or
        val keyMutableList1 =mutableListOf(map.keys)
        //or
        val keyMutableList2 = arrayListOf(map.keys)

    }

根据上面可知，在Kotlin中调用Java方法传参，必须使用Kotlin可变集合对应Java的可变集合，Java不可变集合是JDK9 以上版本的新特征,道理是一样的。