Now, let’s look at the individual steps in a little more detail.<\/p>\n
Declaration<\/h3>\n
This is how we declare a one-dimensional array in Java –<\/p>\n
\nint[] array;\n<\/pre>\nWell, you should have guesses it because we’ve been declaring arrays right from our first program…! Really..? Yeah..! In the main()<\/span><\/b> method’s declaration..!<\/p>\n
\npublic static void main(String[] args) {\n \/\/ code\n}\n<\/pre>\nThe formal parameter of the main()<\/span><\/b> method is a one-dimensional array of String<\/span><\/b>s. Well, for C programmers, it might look like we are almost done with creating an array… But no..! We have just merely declared it, we have not allocated any memory yet.
\nThere is another syntax by which we can declare arrays –<\/p>\n\nint array[];\n<\/pre>\nThis is looks almost like the C’s array declaration. But here, we don’t specify the size… Not yet..! But this style of declaration is considered to be ugly..! Oracle recommends that you use the previously discussed declaration syntax for declaring arrays.
\nHere are some other examples of legal declarations –<\/p>\n\n\/\/ One Dimensional Arrays\nint[] intArray; \/\/ Good\ndouble[] doubleArray;\n\n\/\/ One Dimensional Arrays\nbyte byteArray[]; \/\/ Ugly!\nlong longArray[];\n\n\/\/ Two Dimensional Arrays\nint[][] int2DArray; \/\/ Good\ndouble[][] double2DArray;\n\n\/\/ Two Dimensional Arrays\nbyte[] byte2DArray[]; \/\/ Ugly\nlong[] long2DArray[];\n<\/pre>\nAnd these are some examples of illegal declarations –<\/p>\n
\nint[5] intArray; \/\/ Don't mention size!\ndouble{} doubleArray; \/\/ Square Brackets please!\n<\/pre>\nInstantiation<\/h3>\n
This is how we “instantiate”, or allocate memory for an array –<\/p>\n
\nint[] array = new int[5];\n<\/pre>\nWhen the JVM encounters the new<\/span><\/b> keyword, it understands that it must allocate memory for something. And by specifying int<\/span>[5]<\/span><\/b>, we mean that we want an array of int<\/span><\/b>s, of size 5.
\nSo, the JVM creates the memory and assigns the reference of the newly allocated memory to array<\/span><\/b> which a “reference” of type int<\/span>[]<\/span><\/b>. Bit confusing isn’t it..? We can understand it better if we put the JVM’s job in a step-by-step process, but you’ll have to get used to the terminology –<\/p>\n\n
- We create a reference<\/strong> of type int<\/span>[]<\/span><\/b>, or, vaguely, we create a reference to an array of integers. The syntax is –\n
\nint[] array;\n<\/pre>\n<\/li>\n- Then, we allocate the memory, or, create an object<\/strong> of type int<\/span>[]<\/span><\/b>, or, we create an object of an array. In this step, we mention the size of the dimensions –\n
\nint[] array = new int[5];\nint[][] bigArray = new int[5][5];\n<\/pre>\n<\/li>\n- Now, the JVM allocates the required memory an assigns the address of the newly allocated memory to the reference variable, or, object reference<\/strong>, the array variable. The array is initialized to the default value of the data type.<\/li>\n<\/ol>\n
Let’s write a super simple code to practise the things we learnt so far. This program computes and stores the first 100 Fibonacci numbers –<\/p>\n
\npublic class SimpleFib {\n\n public static void main(String[] args) {\n int[] fib; \/\/ Declaration\n fib = new int[100]; \/\/ Instantiation\n\n fib[0] = 1;\n fib[1] = 1;\n\n for (int i = 2; i < 100; ++i) {\n fib[i] = fib[i - 1] + fib[i - 2];\n }\n }\n\n}\n<\/pre>\nNote<\/strong><\/h4>\n
Arrays in Java always know their sizes. The size of an array is available to you as the length property. You can use the dot operator ‘.’ on the object reference to access the length<\/span><\/strong> property. So, we can re-write the SimpleFib<\/strong><\/span> class using this feature –<\/p>\n
\npublic class SimpleFib {\n\n public static void main(String[] args) {\n int[] fib; \/\/ Declaration\n fib = new int[100]; \/\/ Instantiation\n\n fib[0] = 1;\n fib[1] = 1;\n\n for (int i = 2; i < fib.length; ++i) {\n fib[i] = fib[i - 1] + fib[i - 2];\n }\n }\n\n}\n<\/pre>\nThis is a more robust and maintenance free way of writing arrays with loops. This is a good practice and is recommended by many experienced programmers.<\/p>\n
Initialization<\/h3>\n
\n
- Using a Loop<\/strong> – Using a for loop to initialize elements of an array is the most common way to get the array going. There’s no need to run a for loop if you are going to assign the default value itself, because JVM does it for you.<\/li>\n
- All in One..!<\/strong> – We can Declare, Instantiate and Initialize our array in one go. Here’s the syntax –\n
\nint[] arr = {1, 2, 3, 4, 5};\n<\/pre>\nC programmers shouldn’t feel too weird about this syntax. Here, we don’t mention the size, because JVM can see that we are giving 5 values, so it says, “I’m not that dumb..!! \ud83d\ude1b ” … So the JVM does these bunch of things when it encounters such a statement –<\/p>\n
\n
- Creates a variable named arr<\/span><\/b> of type int<\/span>[]<\/span><\/b>, that is, it becomes an array object reference variable.<\/li>\n
- Constructs an array object, or Instantiates, an int<\/span><\/b> array of size 5.<\/li>\n
- Fills the newly constructed array with 1, 2, 3, 4, 5.<\/li>\n
- Assigns this array object to the array object reference variable, arr<\/span><\/b>. A low level note…. It assigns the bit pattern corresponding to the memory allocated to the array. Well, you needn’t be too concerned about it. \ud83d\ude09<\/li>\n<\/ul>\n<\/li>\n<\/ol>\n
Anonymous Array<\/h3>\n
There is another “All in one..!” syntax to create arrays which is often called as an Anonymous Array<\/strong>. The syntax is –<\/p>\n
\nint[] arr = new int[] {1, 2, 3, 4, 5};\n<\/pre>\nUh… What is this thing..? It looks like we added an additional “new int<\/span>[]<\/span><\/b>” to our previous version of “All in one..!” syntax. And we also know that the statement works fine even without that additional decoration.
\nThen why bother about this syntax at all..? This is handy in creating just-in-time arrays. Such requirement commonly arises when we are supposed to pass ever-changing values to a very frequently used function. Let’s assume you have a function that searches for some names in your phonebook and returns true if all the names were present. It would look like this –<\/p>\n\npublic class AnonymousArray {\n\n public static void main(String[] args) {\n IsThere(new String[] {"Bill Gates", "Steve Jobs"});\n IsThere(new String[] {"James Gosling", "Ritchie"});\n IsThere(new String[] {"Emma Watson", "Emma Stone"});\n }\n\n static boolean IsThere(String[] names) {\n \/\/ Do some searching on something\n return true; \/\/ if found, else false\n }\n\n}\n<\/pre>\nAs you can see, you are frequently searching for names in your phonebook. Sometimes millionaires, or fathers of programming languages, or sometimes gorgeous actresses..! And based on whether the method returns true or false, you would like to take some action.
\nSo, why exactly is Anonymous Arrays handy here..? Imagine you used the regular array syntax for the program –<\/p>\n\npublic class RegularArray {\n\n public static void main(String[] args) {\n String[] millnrs = {"Bill Gates", "Steve Jobs"};\n String[] fathers = {"James Gosling", "Ritchie"};\n String[] actresses = {"Emma Watson", "Emma Stone"};\n\n IsThere(millnrs);\n IsThere(fathers);\n IsThere(actresses);\n }\n\n static boolean IsThere(String[] names) {\n \/\/ Do some searching on something\n return true; \/\/ if found, else false\n }\n\n}\n<\/pre>\nNotice anything..? Well, it was just 3 arrays, so you may not notice anything. But imagine if you are creating a hundred such arrays..! They would all be lying in the memory with no purpose at all..! Plus… You’ll simply run out of names for the variables to create..! So, these two are the advantages of Anonymous Arrays in Java –<\/p>\n
![\"two-dimensional-array-in-java\"](\"https:\/\/i0.wp.com\/theoryofcoding.com\/wp-content\/uploads\/2015\/06\/two-dimensional-array-in-java-e1437328955885.png?ssl=1\")
<\/a>