Chapter: Java The Complete Reference - The Java Language - Data Types, Variables, and Arrays

Study Material, Lecturing Notes, Assignment, Reference, Wiki description explanation, brief detail

Arrays - Java

An array is a group of like-typed variables that are referred to by a common name. Arrays of any type can be created and may have one or more dimensions. A specific element in an array is accessed by its index. Arrays offer a convenient means of grouping related information.

Arrays

An array is a group of like-typed variables that are referred to by a common name. Arrays of any type can be created and may have one or more dimensions. A specific element in an array is accessed by its index. Arrays offer a convenient means of grouping related information.

One-Dimensional Arrays

 

A one-dimensional array is, essentially, a list of like-typed variables. To create an array, you first must create an array variable of the desired type. The general form of a one-dimensional array declaration is

 

type var-name[ ];

 

Here, type declares the element type (also called the base type) of the array. The element type determines the data type of each element that comprises the array. Thus, the element type for the array determines what type of data the array will hold. For example, the following declares an array named month_days with the type “array of int”:

int month_days[];

 

 

Although this declaration establishes the fact that month_days is an array variable, no array actually exists. To link month_days with an actual, physical array of integers, you must allocate one using new and assign it to month_days. new is a special operator that allocates memory.

 

You will look more closely at new in a later chapter, but you need to use it now to allocate memory for arrays. The general form of new as it applies to one-dimensional arrays appears as follows:

 

array-var = new type [size];

 

Here, type specifies the type of data being allocated, size specifies the number of elements in the array, and array-var is the array variable that is linked to the array. That is, to use new to allocate an array, you must specify the type and number of elements to allocate. The elements in the array allocated by new will automatically be initialized to zero (for numeric types), false (for boolean), or null (for reference types, which are described in a later chapter). This example allocates a 12-element array of integers and links them to month_days:

 

month_days = new int[12];

 

After this statement executes, month_days will refer to an array of 12 integers. Further, all elements in the array will be initialized to zero.

 

Let’s review: Obtaining an array is a two-step process. First, you must declare a variable of the desired array type. Second, you must allocate the memory that will hold the array, using new, and assign it to the array variable. Thus, in Java all arrays are dynamically allocated. If the concept of dynamic allocation is unfamiliar to you, don’t worry. It will

be described at length later in this book.

 

Once you have allocated an array, you can access a specific element in the array by specifying its index within square brackets. All array indexes start at zero. For example, this statement assigns the value 28 to the second element of month_days:

 

month_days[1] = 28;

 

The next line displays the value stored at index 3:

 

System.out.println(month_days[3]);

 

Putting together all the pieces, here is a program that creates an array of the number of days in each month:

 

// Demonstrate a one-dimensional array. class Array {

 

public static void main(String args[]) { int month_days[];

 

month_days = new int[12]; month_days[0] = 31; month_days[1] = 28; month_days[2] = 31; month_days[3] = 30; month_days[4] = 31; month_days[5] = 30;

month_days[6] = 31; month_days[7] = 31; month_days[8] = 30; month_days[9] = 31; month_days[10] = 30; month_days[11] = 31;

 

System.out.println("April has " + month_days[3] + " days.");

 

}

 

}

When you run this program, it prints the number of days in April. As mentioned, Java array indexes start with zero, so the number of days in April is month_days[3] or 30.

 

It is possible to combine the declaration of the array variable with the allocation of the array itself, as shown here:

 

int month_days[] = new int[12];

 

This is the way that you will normally see it done in professionally written Java programs. Arrays can be initialized when they are declared. The process is much the same as that

used to initialize the simple types. An array initializer is a list of comma-separated expressions surrounded by curly braces. The commas separate the values of the array elements. The array will automatically be created large enough to hold the number of elements you specify in the array initializer. There is no need to use new. For example, to store the number of days in each month, the following code creates an initialized array of integers:

 

// An improved version of the previous program. class AutoArray {

 

public static void main(String args[]) {

 

int month_days[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

 

System.out.println("April has " + month_days[3] + " days.");

 

}

 

}

 

When you run this program, you see the same output as that generated by the previous version.

 

Java strictly checks to make sure you do not accidentally try to store or reference values outside of the range of the array. The Java run-time system will check to be sure that all array indexes are in the correct range. For example, the run-time system will check the value of each index into month_days to make sure that it is between 0 and 11 inclusive. If you try to access elements outside the range of the array (negative numbers or numbers greater than the length of the array), you will cause a run-time error.

 

Here is one more example that uses a one-dimensional array. It finds the average of a set of numbers.

 

// Average an array of values. class Average {

 

public static void main(String args[]) {

 

double nums[] = {10.1, 11.2, 12.3, 13.4, 14.5}; double result = 0;

 

int i;

 

for(i=0; i<5; i++)

 

result = result + nums[i]; System.out.println("Average is " + result / 5);

 

}

 

}

 

Multidimensional Arrays

 

In Java, multidimensional arrays are actually arrays of arrays. These, as you might expect, look and act like regular multidimensional arrays. However, as you will see, there are a couple of subtle differences. To declare a multidimensional array variable, specify each additional index using another set of square brackets. For example, the following declares a two-dimensional array variable called twoD:

 

int twoD[][] = new int[4][5];

 

This allocates a 4 by 5 array and assigns it to twoD. Internally, this matrix is implemented as an array of arrays of int. Conceptually, this array will look like the one shown in Figure 3-1.

The following program numbers each element in the array from left to right, top to bottom, and then displays these values:

 

// Demonstrate a two-dimensional array. class TwoDArray {

 

public static void main(String args[]) { int twoD[][]= new int[4][5];

 

int i, j, k = 0;

 

for(i=0; i<4; i++) for(j=0; j<5; j++) {

 

twoD[i][j] = k; k++;

 

}

 

for(i=0; i<4; i++) { for(j=0; j<5; j++)

 

System.out.print(twoD[i][j] + " "); System.out.println();

 

}

 

}

 

}

 

This program generates the following output:

 

0 1 2 3 4

 

5 6 7 8 9

 

10 11 12 13 14

 

15 16 17 18 19

When you allocate memory for a multidimensional array, you need only specify the memory for the first (leftmost) dimension. You can allocate the remaining dimensions


separately. For example, this following code allocates memory for the first dimension of twoD when it is declared. It allocates the second dimension manually.

 

int twoD[][] = new int[4][]; twoD[0] = new int[5]; twoD[1] = new int[5]; twoD[2] = new int[5]; twoD[3] = new int[5];

 

While there is no advantage to individually allocating the second dimension arrays in this situation, there may be in others. For example, when you allocate dimensions manually, you do not need to allocate the same number of elements for each dimension. As stated earlier, since multidimensional arrays are actually arrays of arrays, the length of each array is under your control. For example, the following program creates a two-dimensional array in which the sizes of the second dimension are unequal:

 

// Manually allocate differing size second dimensions. class TwoDAgain {

 

public static void main(String args[]) { int twoD[][] = new int[4][];

 

twoD[0] = new int[1]; twoD[1] = new int[2]; twoD[2] = new int[3]; twoD[3] = new int[4];

 

int i, j, k = 0;

 

for(i=0; i<4; i++) for(j=0; j<i+1; j++) { twoD[i][j] = k;

 

k++;

}

 

for(i=0; i<4; i++) { for(j=0; j<i+1; j++)

 

System.out.print(twoD[i][j] + " "); System.out.println();

 

}

 

}

 

}

 

This program generates the following output:

 

0

 

1 2

 

3 4 5

 

6 7 8 9

 

The array created by this program looks like this:


The use of uneven (or irregular) multidimensional arrays may not be appropriate for many applications, because it runs contrary to what people expect to find when a multidimensional array is encountered. However, irregular arrays can be used effectively in some situations. For example, if you need a very large two-dimensional array that is sparsely populated (that is, one in which not all of the elements will be used), then an irregular array might be a perfect solution.

 

It is possible to initialize multidimensional arrays. To do so, simply enclose each dimension’s initializer within its own set of curly braces. The following program creates a matrix where each element contains the product of the row and column indexes. Also notice that you can use expressions as well as literal values inside of array initializers.

 

// Initialize a two-dimensional array. class Matrix {

 

public static void main(String args[]) { double m[][] = {

 

{ 0*0, 1*0, 2*0, 3*0 }, { 0*1, 1*1, 2*1, 3*1 }, { 0*2, 1*2, 2*2, 3*2 }, { 0*3, 1*3, 2*3, 3*3 }

};

 

int i, j;

 

for(i=0; i<4; i++) { for(j=0; j<4; j++)

 

System.out.print(m[i][j] + " "); System.out.println();

 

}

 

}

 

}

 

When you run this program, you will get the following output:

 

0.0  0.0  0.0

 

1.0  2.0  3.0

 

2.0  4.0  6.0

 

0.0    3.0 6.0        9.0

 

As you can see, each row in the array is initialized as specified in the initialization lists. Let’s look at one more example that uses a multidimensional array. The following program creates a 3 by 4 by 5, three-dimensional array. It then loads each element with

the product of its indexes. Finally, it displays these products.

 

// Demonstrate a three-dimensional array. class ThreeDMatrix {

 

public static void main(String args[]) { int threeD[][][] = new int[3][4][5]; int i, j, k;

 

for(i=0; i<3; i++) for(j=0; j<4; j++)

 

for(k=0; k<5; k++) threeD[i][j][k] = i * j * k;

 

for(i=0; i<3; i++) { for(j=0; j<4; j++) {

 

for(k=0; k<5; k++) System.out.print(threeD[i][j][k] + " ");

System.out.println();

 

}

 

System.out.println();

 

}

 

}

 

}

 

This program generates the following output:

 

0 0 0 0 0

 

0 0 0 0 0

 

0 0 0 0 0

0   0        0        0        0       

0   1        2        3        4       

0   2        4        6        8       

0   3        6        9        12

0   0        0        0        0       

0   2        4        6        8       

0   4        8        12               16

0 6         12 18 24

Alternative Array Declaration Syntax

 

There is a second form that may be used to declare an array:

 

type[ ] var-name;

 

Here, the square brackets follow the type specifier, and not the name of the array variable. For example, the following two declarations are equivalent:

 

int al[] = new int[3]; int[] a2 = new int[3];

 

The following declarations are also equivalent:

 

char twod1[][] = new char[3][4]; char[][] twod2 = new char[3][4];

 

This alternative declaration form offers convenience when declaring several arrays at the same time. For example,

 

int[] nums, nums2, nums3; // create three arrays

 

creates three array variables of type int. It is the same as writing

 

int nums[], nums2[], nums3[]; // create three arrays

 

The alternative declaration form is also useful when specifying an array as a return type for a method. Both forms are used in this book.

 

Study Material, Lecturing Notes, Assignment, Reference, Wiki description explanation, brief detail


Copyright © 2018-2020 BrainKart.com; All Rights Reserved. Developed by Therithal info, Chennai.