Understanding an ArrayList - p137 (Java OCA 8 Programmer I Study Guide, Sybex)

[James Tedesco]

On p137: code-line 8
I do not understand what this code does:
String[] stringArray = list.toArray(new String[0]);
specifically the new String[0] part.

[Ganesh Patekar]

Welcome to CodeRanch!

James Tedesco wrote:specifically the new String[0] part

It returns an array containing all of the elements in this list in proper sequence (from first to last element); the runtime type of the returned array is that of the specified array.

<T> T[] toArray(T[] a) method allows you specify runtime type of the returned array but Object[] toArray() retruns an array of Object.

Read more about these methods, click here --->toArray(T[] a) and here --->Object[] toArray()

In your example specified array is of type String so It retruns array of String type. If you try to compile code of example 1, It gives compile time error saying Type mismatch: cannot convert from String[] to Integer[] because It is returning an array of String type and we are trying to assign It to array of Integer type.

Example1:

		List<String> list = new ArrayList<>();
		list.add("hawk");
		list.add("robin");
		/*
		 * Below code won't compile because It's runtime type of returned array
		 * is String but we are assigning it to array of type Integer
		 * 
		 */
		Integer[] stringArray = list.toArray(new String[0]);// Compile time error

If the list fits in the specified array with room to spare (i.e., the array has more elements than the list), the element in the array immediately following the end of the list is set to null. (This is useful in determining the length of the list only if the caller knows that the list does not contain any null elements.)

Example 2: Please read comments

import java.util.ArrayList;
import java.util.List;

public class Testing {

	private void getMethod() {
		List<String> listOne = new ArrayList<>();
		listOne.add("One");
		listOne.add("Two");

		System.out.println("Contents of listOne");
		System.out.println("No of elements in List listOne is: " + listOne.size());
		for (String str : listOne) {
			System.out.println(str);
		}

		/*
		 * Elements of List listOne doesn't fits in String array tempOne so
		 * returns new array with size of List listOne and assigns to
		 * stringArrayOne
		 */

		System.out.println("***************************************");
		System.out.println("String array tempOne with size 0");
		String[] tempOne = new String[0];
		String[] stringArrayOne = listOne.toArray(tempOne);

		if (tempOne == stringArrayOne) {
			System.out.println("Same Array tempOne returned and assigned "
					+ "to stringArrayOne");
		} else {
			System.out.println("New Array returned and assigned to stringArrayOne");
		}
		System.out.println();
		System.out.println("Contents of stringArrayOne");
		System.out.println("Size of stringArrayOne is: " + stringArrayOne.length);
		for (String str : stringArrayOne) {
			System.out.println(str);
		}

		System.out.println("***************************************");
		/*
		 * Elements of List listOne fits in String array tempTwo so returns same
		 * array and assigns to stringArrayTwo and sets null to remaining space
		 * i.e. 3
		 */
		System.out.println("String array tempTwo with size 5");
		String[] tempTwo = new String[5];
		String[] stringArrayTwo = listOne.toArray(tempTwo);
		if (tempTwo == stringArrayTwo) {
			System.out.println("Same Array tempTwo returned and assigned "
					+ "to stringArrayTwo");
		} else {
			System.out.println("New Array returned and assigned to stringArrayTwo");
		}
		System.out.println();
		System.out.println("Contents of stringArrayTwo");
		System.out.println("Size of stringArrayTwo is: " + stringArrayTwo.length);
		for (String str : stringArrayTwo) {
			System.out.println(str);
		}
	}

	public static void main(String args[]) {
		Testing obj = new Testing();
		obj.getMethod();
	}
}

Output:
Contents of listOne
No of elements in List listOne is: 2
One
Two
***************************************
String array tempOne with size 0
New Array returned and assigned to stringArrayOne

Contents of stringArrayOne
Size of stringArrayOne is: 2
One
Two
***************************************
String array tempTwo with size 5
Same Array tempTwo returned and assigned to stringArrayTwo

Contents of stringArrayTwo
Size of stringArrayTwo is: 5
One
Two
null
null
null

[Roel De Nijs]

Hi James Tedesco,

First of all, a warm welcome to CodeRanch!

James Tedesco wrote:I do not understand what this code does:
String[] stringArray = list.toArray(new String[0]);
specifically the new String[0] part.

The toArray() method will (according to the javadoc of the Collection interface) return an array containing all elements in this collection. And this method comes in two versions: one version without parameters and another one with an array parameter.
The first version will return an Object array containing all elements of this list. Here's a code example

List<String> list = Arrays.asList("one", "two", "three");
Object[] array = list.toArray();

So the return type of this method is always Object[]. But what if you want to convert the list of Strings into a String array? Enter the second version of this method (with the array parameter). It lets you define the runtime type of the array to contain the collection elements. If you create an array which is not big enough to store all collection elements, a new array will be created at runtime to store the collection elements. Consider this code snippet

List<String> list = Arrays.asList("one", "two", "three");
String[] array = new String[0];
String[] stringArray = list.toArray(array);
System.out.println(array == stringArray); // false
System.out.println(Arrays.toString(array)); // []
System.out.println(Arrays.toString(stringArray)); // [one, two, three]

So from the output of line4, you clearly see that a different array is created. And new String[0] is the code to create an empty array, so

String[] stringArray = list.toArray(new String[0]);

is the short-hand syntax for

String[] emptyArray = new String[0];
String[] stringArray = list.toArray(emptyArray);

Now let's see what happens if the array parameter is big enough to hold all collection elements

List<String> list = Arrays.asList("one", "two", "three");
String[] array = {
    "ten", "nine", "eight", "seven", "six",
    "five", "four", "three", "two", "one"
};
String[] stringArray = list.toArray(array);
System.out.println(array == stringArray);
System.out.println(Arrays.toString(stringArray));
System.out.println(Arrays.toString(stringArray));

And if you run this code, you get the following output:
true
[one, two, three, null, six, five, four, three, two, one]
[one, two, three, null, six, five, four, three, two, one]

So two important things to note: if the array is big enough to store all collection elements, no other array is created and thus the array used as a parameter is the same as the array returned by the toArray() method. If the array has more elements than the collection, the element in the array immediately following the end of the collection is set to null.

Hope it helps!
Kind regards,
Roel

PS. Please always QuoteYourSources and please note that many OCAJP8 study guides are currently available, so only mentioning a page number is not enough.