0 
int arr[][] = new int[2][];
System.out.println(Arrays.toString(arr));

The above code snippet when run, creates a new 2D array with 2 elements, each element an array itself. But since I haven't specified the second pair of [] during array initialization, the print statement gives me [null, null].

My question is why do I get only [] when I run the below code;

ArrayList<ArrayList<Integer>> arrList = new ArrayList<ArrayList<Integer>>(2);
System.out.println(arrList);

According to me, since I created an ArrayList of initial capacity = 2, when I print the ArrayList I should've gotten [null,null], similar to what I got when I printed the above array.

I'm new to Java, so any help would be appreciated.

Improve this question
1
  • The array list is empty, while the array has two entries, both null. Commented Oct 15, 2022 at 6:47

4 Answers 4

Reset to default
2

I'm pretty new myself, but I will try my best to answer this.

During the first print line:

The Arrays.toString method is iterating over the outer array only. Since it is only traversing the top/outer array, it is outputting the toString method of each nested array, which outputs the hex code which I think is a reference to where the array is stored. I am guessing because the two nested arrays were never instantiated with a length, they are showing null values (they don’t exist yet). Also, primitive types such as int cannot be null, so it's not saying an int is null.

In reference to the second print line:

The ArrayList is instantiated, passing a 2 as a parameter. I don’t believe setting the initial capacity has any impact to the print statement. The ArrayList does not contain any nested ArrayLists within it, so printing its contents is showing that it is empty: []

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

As the arrayList doesn't contain any ArrayList within it, even the Array doesn't have any arrays within it. new int[2][] tells us that the array will contain 2 elements inside the array both of which will be arrays. But since I haven't added any elements inside it shows null. I thought the ArrayList will have the same behaviour as an Array in this case.
@div2047 It won't, an array list, even if it has an initial capacity, has a length of zero, meaning it contains nothing. These are two separate concepts: capacity: how many items can fit, and length: how many items it actually contains. On the other hand an array has a fixed length, and your (outer) array has length two, both items are null.
0

According to me once you declare an array with size by default jvm allocates the memory and assign a null values to it even though you didn't assign any value to it in java by default it stores null value

But in the case of arraylist it doesn't allocates memory because you don't need to mention any size

ArrayList<ArrayList<Integer>> arrList = new ArrayList<ArrayList<Integer>>(2);

here the 2 doesn't mean that you are allocated the size of 2 ArrayList is dynamic you don't need to mention the size ArrayList

for your reference if you need to create 2d ArrayList then use this site 2d ArrayList

Improve this answer

1 Comment

'public ArrayList(int initialCapacity) Constructs an empty list with the specified initial capacity.' This is what Oracle says about the constructor. If it does create an empty list with the capacity mentioned. It should have created an arraylist with size 2. But since I didn't add any elements, shouldn't it show 2 null values ?
0

ArrayList doestn't need any initial value and simple List requires initial values

Improve this answer

Comments

0

because the implementation of the function called toString() is different for both of them.

this is the implementation of the toString() for the ArrayList

/**
 * Returns a string representation of this collection.  The string
 * representation consists of a list of the collection's elements in the
 * order they are returned by its iterator, enclosed in square brackets
 * ({@code "[]"}).  Adjacent elements are separated by the characters
 * {@code ", "} (comma and space).  Elements are converted to strings as
 * by {@link String#valueOf(Object)}.
 *
 * @return a string representation of this collection
 */
public String toString() {
    Iterator<E> it = iterator();
    if (! it.hasNext())
        return "[]";

    StringBuilder sb = new StringBuilder();
    sb.append('[');
    for (;;) {
        E e = it.next();
        sb.append(e == this ? "(this Collection)" : e);
        if (! it.hasNext())
            return sb.append(']').toString();
        sb.append(',').append(' ');
    }
}

notice that when there is no next element, this String "[]" will be returned.

this is the implementation of the toString() for the Arrays

/**
 * Returns a string representation of the contents of the specified array.
 * If the array contains other arrays as elements, they are converted to
 * strings by the {@link Object#toString} method inherited from
 * {@code Object}, which describes their <i>identities</i> rather than
 * their contents.
 *
 * <p>The value returned by this method is equal to the value that would
 * be returned by {@code Arrays.asList(a).toString()}, unless {@code a}
 * is {@code null}, in which case {@code "null"} is returned.
 *
 * @param a the array whose string representation to return
 * @return a string representation of {@code a}
 * @see #deepToString(Object[])
 * @since 1.5
 */
public static String toString(Object[] a) {
    if (a == null)
        return "null";

    int iMax = a.length - 1;
    if (iMax == -1)
        return "[]";

    StringBuilder b = new StringBuilder();
    b.append('[');
    for (int i = 0; ; i++) {
        b.append(String.valueOf(a[i]));
        if (i == iMax)
            return b.append(']').toString();
        b.append(", ");
    }
}

notice that when the array is empty then it's null, then the line b.append(String.valueOf(a[i])); will append this string "null" to "["

you can view the source code in your IDE and debug it for more understanding

Improve this answer

2 Comments

Does that mean internally even the ArrayList that I mentioned above will have 2 null values inside, since the initial capacity = 2 ?
yes, but if you debug it, the code if (! it.hasNext()) for the ArrayList will be true and return "[]" will be executed, while in case of the array, it will enter into for (int i = 0; ; i++) causing the print of the value you mentioned, it's the matter of the fact how is toString() is implemented

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.