Primitive type and Wrapper type for Arrays.asList

As @Andy explains, generics only work with reference types. That means that List<char> is not allowed (so Arrays.asList cannot return List<char>). Instead Arrays.asList interprets its input as a single object and returns a list with that single element.

    Character[] chars1 = new Character[]{'a', 'b'};
    List<Character> list1 = Arrays.asList(chars1);

    char[] chars2 = new char[]{'a', 'b'};
    List<char[]> list2 = Arrays.asList(chars2);

Compare Arrays.asList(chars2) with this String example (where the input is also is a single element):

    String test = "test";
    List<String> asList = Arrays.asList(test);

Returns a list with size()==1

Collections can contain only objects not primitive types.

java.util.Arrays.asList(T... a) here T can be an object not primitive.

And in the case of Arrays.asList(char[]), it will be considering char[] as an object (T). so you will see unexpected characters on printing below:

System.out.println(Arrays.asList(chars2));

Output :

[[C@15db9742]

And the size will be one always for primitive types arrays.

It is so because List accepts only Objects not primitives. So when you pass an array of Objects it takes those Objects and creates a list of it. But when you pass an Array of primitives, it takes the Array itself (which is an Object) and creates the List. In the first case there were 2 objects so the length of list was 2. Whereas in the second case there is only one object (i.e. the array itself) so the length will be 1 now.

Following code will make it clear

import java.util.Arrays;

public class Test {

    public static void main(String[] args) {
        Test test = new Test();
        test.testArraysAsList();
    }
    public void testArraysAsList() {
        Character[] chars1 = new Character[]{'a', 'b'};
        System.out.println(Arrays.asList(chars1).size());


        char[] chars2 = new char[]{'a', 'b'};
        System.out.println(Arrays.asList(chars2).size());

        Integer[] int1 = new Integer[]{1, 2};
        System.out.println(Arrays.asList(int1));

        int[][] int2 = new int[][]{{1,2},{1,2} };
        System.out.println(Arrays.asList(int2));


    }
}

Now look at the output obtained by running the above code on my machine.

2
1
[1, 2]
[[I@1540e19d, [I@677327b6]

Since the int2 array is two dimensional array, it has 2 arrays in it. So it has 2 objects in it. So the length is 2 in this case. You can see it in the output, the [[I@1540e19d and [I@677327b6] are the 2 array objects this time.

Hope this makes it clear.

Because chars2 is an object, but 'a' and 'b' are chars, and char is a primitive type, not an object type. So chars2 is used as the first (and only) element in the resulting list.