Explore our sites

Stack Exchange
tour help careers 2.0
Take the 2-minute tour ×
Stack Overflow is a question and answer site for professional and enthusiast programmers. It's 100% free, no registration required.
up vote 5 down vote favorite

I was just checking some OCJP questions and came across this difference during String array initialization and exceptions.

Case 1

try {
        String[][] b = new String[10][10];//1
        System.out.println(b[0][0]);//2
    } catch (Exception e) {
        System.out.println("Exception during array 'b' initialization");
        e.printStackTrace();
    }

Case 2

try {
        String[][] a = new String[10][];//3
        System.out.println(a[0][0]);//4
    } catch (Exception e) {
        System.out.println("Exception during array 'a' initialization");
        e.printStackTrace();
    }

Line 2 does not throw any exception whereas line 4 throws a null pointer exception. Line 2 does output the value as null though.

Does java have a difference in default values for initialization when the size of an array is specified and when its not?

share|improve this question
add comment

3 Answers

up vote 3 down vote accepted

This sets the type of a, as array of arrays :

String[][] a

When you write

String[][] a = new String[10][];

you initialize the external array, but you don't create the internal arrays, so that a[0] is null.

When you write 

String[][] b = new String[10][10];

the runtime creates also the internal arrays. It's described here in the specification :

At run time, evaluation of an array creation expression behaves as follows:

If there are no dimension expressions, then there must be an array initializer.

A newly allocated array will be initialized with the values provided by the array initializer as described in §10.6.

The value of the array initializer becomes the value of the array creation expression.

Otherwise, there is no array initializer, and:

First, the dimension expressions are evaluated, left-to-right. If any of the expression evaluations completes abruptly, the expressions to the right of it are not evaluated.

Next, the values of the dimension expressions are checked. If the value of any DimExpr expression is less than zero, then a NegativeArraySizeException is thrown.

Next, space is allocated for the new array. If there is insufficient space to allocate the array, evaluation of the array creation expression completes abruptly by throwing an OutOfMemoryError.

Then, if a single DimExpr appears, a one-dimensional array is created of the specified length, and each component of the array is initialized to its default value (§4.12.5).

Otherwise, if n DimExpr expressions appear, then array creation effectively executes a set of nested loops of depth n-1 to create the implied arrays of arrays.

A multidimensional array need not have arrays of the same length at each level.

share|improve this answer
 
and each component of the array is initialized to its default value so Line 3 should assign 10 1-D arrays and assign null as value to each of its elements right? The same as it happens for Line 1 as well. Am i right? –  redDevil May 26 '13 at 18:16
1  
It assigns null to a[0], a[1], etc. While line 1 assigns null to b[0][0], b[0][1], etc. –  dystroy May 26 '13 at 18:19
add comment
up vote 1 down vote 
String[][] a = new String[3][];

is equivalent to:

String[] a1 = null;
String[] a2 = null;
String[] a3 = null;
String[][] a = {a1, a2, a3};

and a[0][0] is similar to a1[0] which throws NPE.

You have two options here:

  • Either define the array as:
String[][] a = new String[3][3];
  • Or create new arrays inside a:
a[0] = new String[2];
a[1] = new String[4];
a[2] = new String[3];

Note that using the latter approach you will be able to have different sizes for the internal arrays.

share|improve this answer
add comment
up vote 1 down vote

Good discovery. When you initialize a 2D array with both parameters, what happens is:

String[][] a = new String[5][5]

2D Array with both bounds

But when you don't specify the second bound, what happens is:

String[][] a = new String[5][];

2D Array with no inner bound

In your line 4, you get the exact NullPointerException because:

String[][] a = new String[10][];
System.out.println(a[0][0]); // << a[0] is null!

But why would you even need this behavior? Its quite simple. It is for the cases where each element in a two-dimensional array can have different number of elements. The potential use case scenario is:

enter image description here

And there are pretty good use cases for this kind of behavior, such as Priority Queues (each priority can have a different number of items in queue), Hash table (the overflow part of it), etc.

share|improve this answer
add comment

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.