Different ways to initialize an array

[Miles Davis]

I've seen multiple ways to initialize arrays in Java:

int[] array1 = new int[5]
int[] array2 = {1, 2, 3, 4, 5}
int[] array3 = new int[] (1, 2, 3, 4, 5}

I understand that the first way is useful when you don't know the values you want in the array when you initialize it, and the second way is good when you do. However, I don't understand the difference between the second and the third way. Why should one be preferred over the other, and when should I use one rather than the other?

[A.J. Côté]

Hello,

The only thing I can think off is to specify the type of the array....

package array;

import java.util.LinkedHashMap;
import java.util.HashMap;
import java.util.Map;

import javax.print.attribute.standard.PrinterStateReasons;

public class TestInit {

	public static void main(String[] args) {
	  Map[] a = {new LinkedHashMap(),new PrinterStateReasons()};
	  Map[] b = new HashMap[] {new LinkedHashMap(),new PrinterStateReasons()};
    
	  System.out.println(a instanceof HashMap[]);
	  System.out.println(b instanceof HashMap[]);
	}

}

output:
false
true

[Campbell Ritchie]

The difference between the first and second methods in OP's post are that one creates an array with elements and the other an empty array. You can see that so much better with arrays of reference types than of primitives. If you have code like this (from this post):-

String[] words;
// ...
words = new String[]{"Most", "ranchers", "want", "to", "strangle", "Campbell"};

If you print that out with methods of the Arrays class you get the obvious output:-

// as before
System.out.println(Arrays.toString(words)); // try it and see

What you have here is a declaration and array initialiser later. The normal form of an array initialiser is this:-
words = new String[]{"Most", "ranchers", "want", "to", "strangle", "Campbell"};
but if you have the declaration and initialisation on the same line you are allowed to miss part of it out:-
String[] words = {"Most", "ranchers", "want", "to", "strangle", "Campbell"};
So that would have the same effect on the words array, and the second and third versions of Miles Davis' code will have the same effect.

The first line however declares and initialises the same array but does not initalise the individual elements. In the case of an array of primitives, the default values might be usable; the int[] shown will be filled with zeroes. But in the case of an array of primitives, the default values are nulls (see the thread I got the earlier code from). It is potentially dangerous, and probably poor practice, to have nulls, but you can see what happens if you try a different initialisation of that words array.-

String[] words;
// ...
words = new String[5];
System.out.println(Arrays.toString(words)); // prints [null, null, null, null, null]

I would say try to put known values into the array; if you don't know the values get them assigned as soon as you can. Avoid arrays full of nulls as far as possible. Avoid nulls as far as possible.

[Campbell Ritchie]

A few minutes ago, I wrote:. . . In the case of an array of primitives, the default values might be usable . . .

If you print out an array of primitives, you can see the effect:-

int[] numbers = new int[100000000];
System.out.println(Arrays.toString(numbers));
/* You will die of boredom trying to read all the zeroes printed */

[A.J. Côté]

Hi Campbell,

Sorry I do not understand your reply, see my previous post to what I believe was a valid answer to the OP question which was:

However, I don't understand the difference between the second and the third way. Why should one be preferred over the other, and when should I use one rather than the other?

So here, again an example of the difference between the second and the third way:

Hello,

The only thing I can think off is to specify the type of the array....

package array;


import java.util.Arrays;


public class TestInit {

	public static void main(String[] args) {
	  Object[] a = {new Integer(1),new Float(2)};
	  Object[] b = new Number[] {new Integer(1),new Float(2)};
    
	  System.out.println(a instanceof Number[]);
	  System.out.println(b instanceof Number[]);
	  
	  System.out.println(Arrays.toString(a));
	  System.out.println(Arrays.toString(b));
	}

}

output:
false
true
[1, 2.0]
[1, 2.0]

Cheers,

[A.J. Côté]

Miles Davis wrote:

I understand that the first way is useful when you don't know the values you want in the array when you initialize it, and the second way is good when you do.

[Campbell Ritchie]

I am afraid your replies were not at all helpful because they do not answer the OP's question.

[A.J. Côté]

Campbell Ritchie wrote:I am afraid your replies were not at all helpful because they do not answer the OP's question.

He asked for the difference between 2 and 3 and you explained the difference between 1 and 2. Do you have a better answer for the difference between 2 and 3 and why you should use one over the other, other than the answer I already provided in the first reply?

"3 allows you to specify the type of the Array"

Again, here the arrays are sorted differently if you use 2 instead of 3:

package array;


import java.util.Arrays;
import java.util.Comparator;


public class TestInit {
	
	public final static Comparator<Object> NUMBER_COMPARATOR =
			new Comparator<Object>() {

		@Override
		public int compare(Object o1, Object o2) {
	    double doubleo1 = ((Number)o1).doubleValue();
	    double doubleo2 = ((Number)o2).doubleValue();
			if ( doubleo1 == doubleo2 ) {
				return 0;
			}
			else {
				return  doubleo1 >  doubleo2?1:-1;
			}
		}
  };
  
  public final static Comparator<Object> OBJECT_COMPARATOR =
			new Comparator<Object>() {

		@Override
		public int compare(Object o1, Object o2) {
	    return o1.toString().compareTo(o2.toString());
		}
  };
			
	
	public static void sortArray(Object [] array) {
		if (array instanceof Number[]) {
			Arrays.sort(array,NUMBER_COMPARATOR);
		}
		else {
			Arrays.sort(array,OBJECT_COMPARATOR);
		}
	}
	


	public static void main(String[] args) {
	  Object[] a = {new Integer(111),
	  		          new Short((short) 2),
	                new Byte((byte) 22),
	                new Long(111111)};
	  Object[] b = new Number[] {new Integer(111),
					        new Short((short) 2),
					        new Byte((byte) 22),
					        new Long(111111)};
    
	  
	  sortArray(a);
	  sortArray(b);
	  
	  System.out.println(Arrays.toString(a));
	  System.out.println(Arrays.toString(b));	  
	
	
	}

}

output:
[111, 111111, 2, 22]
[2, 22, 111, 111111]

[Campbell Ritchie]

A.J. Côté wrote:. . . "3 allows you to specify the type of the Array" . . .

Not in the example which OP gave; he gave an array of primitives where you cannot specify the type like that.

int[] numbers = new byte[]{1, 2, 3}; // fails to compile

[Campbell Ritchie]

Yes, the example you gave works and shows your point, but I don't think it is what OP was asking.

[Miles Davis]

Campbell Ritchie wrote:The difference between the first and second methods in OP's post are that one creates an array with elements and the other an empty array. You can see that so much better with arrays of reference types than of primitives. If you have code like this (from this post):-

String[] words;
// ...
words = new String[]{"Most", "ranchers", "want", "to", "strangle", "Campbell"};

If you print that out with methods of the Arrays class you get the obvious output:-

// as before
System.out.println(Arrays.toString(words)); // try it and see

What you have here is a declaration and array initialiser later. The normal form of an array initialiser is this:-
words = new String[]{"Most", "ranchers", "want", "to", "strangle", "Campbell"};
but if you have the declaration and initialisation on the same line you are allowed to miss part of it out:-
String[] words = {"Most", "ranchers", "want", "to", "strangle", "Campbell"};
So that would have the same effect on the words array, and the second and third versions of Miles Davis' code will have the same effect.

The first line however declares and initialises the same array but does not initalise the individual elements. In the case of an array of primitives, the default values might be usable; the int[] shown will be filled with zeroes. But in the case of an array of primitives, the default values are nulls (see the thread I got the earlier code from). It is potentially dangerous, and probably poor practice, to have nulls, but you can see what happens if you try a different initialisation of that words array.-

String[] words;
// ...
words = new String[5];
System.out.println(Arrays.toString(words)); // prints [null, null, null, null, null]

I would say try to put known values into the array; if you don't know the values get them assigned as soon as you can. Avoid arrays full of nulls as far as possible. Avoid nulls as far as possible.

So essentially, the second and third ways of initializing an array are different in that the second is used only when the declaration is on the same line, and the third is used when the declaration is on a different line? If this is true, then should I just always use the third way since that is the more general case of the two?

[Mike. J. Thompson]

They both result in the same array in the case you posted (as opposed to the case that A.J. Côté posted).

It really doesn't matter which is used.

[Les Morgan]

public class JArrayForumJunk{

  public static void main(String[] args){
    String[] s  = new String[5]; //valid array declaration, but will have null values (default for String);
    String[] s2 = {"zero", "one", "two", "three", "four"}; //valid array declaration with initialization;
    String[] s3 = new String[] {"zero", "one", "two", "three", "four"}; //valid array declaration with initialization;
    String[] s4; //declares a reference variable to a String array, as does all the other left side expressions
                 //null reference until an object is assigned;
    s4 = new String[] {"zero", "one", "two", "three", "four"};          //creates a new String Array and initilaizes it;
    s4 = new String[] {"five", "six", "seven", "eight", "nine", "ten"}; //as you can see this can be used to assign an 
                                                                        //an Array object to an existing reference vaialbe
                                                                        //and as before it is initialized;
    String[] s5;
    //s5 = {"zero", "one", "two", "three", "four"}; // notice this is not valid, but can be used as in S2;
    
    int[] i = new int[5]; //creates an array initialized to default;
    int[] j = {0, 1, 2, 3, 4}; //create an array and initializes it to given values;
    int[] k = new int[]{0, 1, 2, 3, 4};
    int[] l;                         //only creates the reference variable and is initially null;
    l = new int[]{0, 1, 2, 3, 4};    //creates a new String Array and initilaizes it;
    for(int a=0; a<l.length; a++) System.out.println(l[a]);
    l = new int[]{5, 6, 7, 8, 9, 0}; //as you can see this can be used to assign an 
                                     //an Array object to an existing reference vaialbe
                                     //and as before it is initialized;
    
    int[] m;
    //m = {0, 1, 2, 3, 4}; // notice this is not valid, but can be used as in j;
    
    //Notice that in s4 and in l, when you declare an array variable, String[] s4 or int[] l, it is a varaible
    //that will contain a reference to an actual array object. It is dimensionless and can be reused to point to
    //arrays of the same type, but different dimension size, but not different dimensionality (a 1 dimensional
    //reference variable can handle other sizes of 1 dimensional arrays of the same type, but not a 2 dimensional array).
    for(int a=0; a<l.length; a++) System.out.println(l[a]);
  } 
}

[Campbell Ritchie]

You cannot get subtypes in those examples because you cannot declare an array type which is a subtype of int[].
You can create arrays which are subtypes of their declared type. But you cannot get subtypes of String[] because the String class is final. I shall have to go back to AJC's examples:-

Number[] numbers = {123, 456, 789, 1.23, 4.56, 7.89};
System.out.println(numbers);
System.out.println(Arrays.toString(numbers));
Number[] integers = new Integer[]{1, 2, 3, 4, 5, 6};
System.out.println(integers);
System.out.println(Arrays.toString(integers));

Note the number literals are converted to Objects by boxing and remember arrays have unoverridden toString methods so you can see their runtime type.