jdk compiler maturity

[Raja Nagendra Kumar]

Why does a code like this result in compile time error of Index Out of Bound error

public class A
{
public static void main(String[] args)
{
String[] test = new String[10];
test[1000] = "iii";
}
}


I understand the code would have been test[k] = "iii"; where k is some other variable. However in this case it is a direct number 1000.

I tried to compile in both Sun JDK and Oracle JRockit but both of them does not complain at compile time.


Regards,
Nagendra

[Christophe Verré]

Why does a code like this result in compile time error of Index Out of Bound error

Are you sure about "compile time error" ?

I tried to compile in both Sun JDK and Oracle JRockit but both of them does not complain at compile time.

So with which compiler are you getting a compile time error ??

[Muhammad Khojaye]

Raja Nagendra Kumar wrote:Why does a code like this result in compile time error of Index Out of Bound error

Its a runtime not compile time error.

[Rob Spoor]

Compare an array to a street. The street has 10 houses. You then try to go to the 1001st house. Doesn't make sense, does it? It doesn't make sense to the JVM either so it throws an ArrayIndexOutOfBoundsException.

[David Newton]

I think the OP is asking why, since it's "obvious" that the index is out-of-bounds, the compiler doesn't complain.

[Rob Spoor]

Ah right. I think because that wouldn't be as easy as it seems. The size of the array can change; if I add just one line between these two statements it would become valid all of a sudden:

test = new String[2000];

Or even this:

public class A 
{ 
    public static void main(String[] args) 
    { 
        String[] test = new String[10]; 
        test = createArray(2000);
        test[1000] = "iii"; 
    }

    private static String[] createArray(int size)
    {
        return new String[size];
    }
}

The compiler cannot keep track of all possible values a variable (including arrays) can have, especially if the value can come from a method call, that perhaps delegates to another method, etc.

During runtime the actual value is known and therefore it is easier to check.

[fred rosenberger]

What about this:

public class A   
{   
    public static void main(String[] args)   
    {   
        String[] test = new String[10];   
        test = createArray(2000);  
        test[1000] = "iii";   
    }  
  
    private static String[] createArray(int size)  
    {  
        if (file.exits())
        {
            return new String[5000];  
        }
        else
        {
            return new String[size];
        }

    }  
}  

There is no possible way the compiler can know what the size of the returned array will be. Yes, in some trivial cases, it might be able to determine such things, but since it can't all the time, my guess is they said "why bother?"