Hello. I have recently been thinking of the difference between the two ways of defining an array:
Is there a difference? I havent found anything in my Java book explaining me the difference and googling the question isnt bringing me any closer... I just dont know what to google after.
Thanks
They are semantically identical. The "int array[]" syntax was only added to help C programmers get used to java.
"int[] array" is much preferable, and less confusing.
In Java, these are simply different syntactic methods of saying the same thing.
They are completely equivalent. int [] array is the preferred style. int array[] is just provided as an equivalent, C-compatible style.
The two commands are the same thing.
You can use the syntax to declare multiple objects:
int[] arrayOne, arrayTwo; //both arrays
int arrayOne[], intOne; //one array one int
see: http://java.sun.com/docs/books/jls/second_edition/html/arrays.doc.html
There is one slight difference, if you happen to declare more than one variable in the same declaration:
int[] a, b; // Both a and b are arrays of type int
int c[], d; // WARNING: c is an array, but d is just a regular int
Note that this is bad coding style, although the compiler will almost certainly catch your error the moment you try to use d.
I didn't even know that int array[] was possible. Please don't do it. :)
There isn't any difference between the two; both declare an array of ints. However, the former is preferred since it keeps the type information all in one place. The latter is only really supported for the benefit of C/C++ programmers moving to Java.
No difference.
Quoting from Sun:
The
[]may appear as part of the type at the beginning of the declaration, or as part of the declarator for a particular variable, or both, as in this example:byte[] rowvector, colvector, matrix[];This declaration is equivalent to:
byte rowvector[], colvector[], matrix[][];
There is no difference.
I prefer the "type[] name" format at is is clear that the variable is an array (less looking around to find out what it is).
EDIT:
Oh wait there is a difference (I forgot because I never declare more than one variable at a time):
int[] foo, bar; // both are arrays int foo[], bar; // foo is an array, bar is an int.
There is no real difference; however,
double[] items = new double[10];
is preferred as it clearly indicates that the type is an array.
there isn't really any difference between the two, most of it is purely personal preference though. I personally prefer using type[] name; as it clearly shows the type, and makes it a lot easier when scanning through your own code (as long as it is indented properly - and if you don't know how use some software that does it for you i.e. notepad++ - good for many languages, though just a text editor, and then learn from them - you can't program unless you indent!!!!!)
Yep, exactly the same. Personally, I prefer
int[] integers;
because it makes it immediately obvious to anyone reading your code that integers is an array of int's, as opposed to
int integers[];
which doesn't make it all that obvious, particularly if you have multiple declarations in one line. But again, they are equivalent, so it comes down to personal preference.
Check out this page on arrays in Java for more in depth examples.
Both are ok. I suggest to pick one and stick with it. (I do the second one)
They are the same, but there is an important difference between these statements:
// 1.
int regular, array[];
// 2.
int[] regular, array;
in 1. regular is just an int, as opposed to 2. where both regular and array are arrays of int's.
The second statement you have is therefore preferred, since it is more clear. The first form is also discouraged according to this tutorial on Oracle.
While the int integers[] solution roots in the C language (and can be thus considered the "normal" approach), many people find int[] integers more logical as it disallows to create variables of different types (i.e. an int and an array) in one declaration (as opposed to the C-style declaration).