Single-Dimensional Arrays
Tags: java, programming, learning, beginners
Published: 2024-05-11 19:40:00

A single array variable can reference a large collection of data. Often you will have to store a large number of values during the execution of a program. Suppose, for instance, that you need to read 100 numbers, compute their average, and find out how many numbers are above the average. Your program first reads the numbers and computes their average, then compares each number with the average to determine whether it is above the average. In order to accomplish this task, the numbers must all be stored in variables. You have to declare 100 variables and repeatedly write almost identical code 100 times. Writing a program this way would be impractical. So, how do you solve this problem?

An efficient, organized approach is needed. Java and most other high-level languages provide a data structure, the _array_, which stores a fixed-size sequential collection of elements of the same type. In the present case, you can store all 100 numbers into an array and access them through a single array variable.

Once an array is created, its size is fixed. An array reference variable is used to access the elements in an array using an index. An array is used to store a collection of data, but often we find it more useful to think of an array as a collection of variables of the same type. Instead of declaring individual variables, such as **number0**, **number1**, . . . , and **number99**, you declare one array variable such as **numbers** and use **numbers[0]**, **numbers[1]**, . . . , and **numbers[99]** to represent individual variables.

##  Declaring Array Variables

To use an array in a program, you must declare a variable to reference the array and specify the array’s _element type_. Here is the syntax for declaring an array variable:

`elementType[] arrayRefVar;`

The **elementType** can be any data type, and all elements in the array will have the same data type. For example, the following code declares a variable **myList** that references an array of double elements.

`double[] myList;`

You can also use **elementType arrayRefVar[]** to declare an array variable. This style comes from the C/C++ language and was adopted in Java to accommodate C/C++ programmers. The style **elementType[] arrayRefVar** is preferred.

## Creating Arrays

Unlike declarations for primitive data type variables, the declaration of an array variable does not allocate any space in memory for the array. It creates only a storage location for the reference to an array. If a variable does not contain a reference to an array, the value of the variable is **null**. You cannot assign elements to an array unless it has already been created. After an array variable is declared, you can create an array by using the **new** operator and assign its reference to the variable with the following syntax:

`arrayRefVar = new elementType[arraySize];`

This statement does two things: (1) it creates an array using **new elementType[arraySize]**; (2) it assigns the reference of the newly created array to the variable **arrayRefVar**.

Declaring an array variable, creating an array, and assigning the reference of the array to the variable can be combined in one statement as:

`elementType[] arrayRefVar = new elementType[arraySize];`

or

`elementType arrayRefVar[] = new elementType[arraySize];`

Here is an example of such a statement:

`double[] myList = new double[10];`

This statement declares an array variable, **myList**, creates an array of ten elements of **double** type, and assigns its reference to **myList**. To assign values to the elements, use the syntax:

`arrayRefVar[index] = value;`

This array is illustrated below:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/f5qd8ozrndwkjate7hs0.png)

An array variable that appears to hold an array actually contains a reference to that array. Strictly speaking, an array variable and an array are different, but most of the time the distinction can be ignored. Thus it is all right to say, for simplicity, that **myList** is an array, instead of stating, at greater length, that **myList** is a variable that contains a reference to an array of ten double elements.

## Array Size and Default Values

When space for an array is allocated, the array size must be given, specifying the number of elements that can be stored in it. The size of an array cannot be changed after the array is created.
Size can be obtained using **arrayRefVar.length**. For example, **myList.length** is **10**.

When an array is created, its elements are assigned the default value of **0** for the numeric primitive data types, **\u0000** for **char** types, and **false** for **boolean** types.

## Accessing Array Elements

The array elements are accessed through the index. Array indices  are **0** based; that is, they range from **0** to **arrayRefVar.length-1**. In the image above, **myList** holds ten **double** values, and the indices are from **0** to **9**.

Each element in the array is represented using the following syntax, known as an _indexed variable_:

`arrayRefVar[index];`

For example, **myList[9]** represents the last element in the array **myList**.

Some programming languages use parentheses to reference an array element, as in **myList(9)**, but Java uses brackets, as in **myList[9]**.

An indexed variable can be used in the same way as a regular variable. For example, the following code adds the values in **myList[0]** and **myList[1]** to **myList[2]**.

```
myList[2] = myList[0] + myList[1];
```

The following loop assigns **0** to **myList[0]**, **1** to **myList[1]**, . . . , and **9** to **myList[9]**:

```
for (int i = 0; i < myList.length; i++) {
 myList[i] = i;
}
```

##  Array Initializers

Java has a shorthand notation, known as the _array initializer_, which combines the declaration, creation, and initialization of an array in one statement using the following syntax:

`elementType[] arrayRefVar = {value0, value1, ..., valuek};`

For example, the statement

```
double[] myList = {1.9, 2.9, 3.4, 3.5};
```

declares, creates, and initializes the array **myList** with four elements, which is equivalent to the following statements:

```
double[] myList = new double[4];
myList[0] = 1.9;
myList[1] = 2.9;
myList[2] = 3.4;
myList[3] = 3.5;
```

The **new** operator is not used in the array-initializer syntax. Using an array initializer, you have to declare, create, and initialize the array all in one statement. Splitting it would
cause a syntax error. Thus, the next statement is wrong:

```
double[] myList;
myList = {1.9, 2.9, 3.4, 3.5};
```

## Processing Arrays

When processing array elements, you will often use a **for** loop—for two reasons:

- All of the elements in an array are of the same type. They are evenly processed in the same fashion repeatedly using a loop.
- Since the size of the array is known, it is natural to use a **for** loop.

Assume the array is created as follows:

```
double[] myList = new double[10];
```

The following are some examples of processing arrays.

_Initializing arrays with input values:_ The following loop initializes the array **myList** with user input values.

```
java.util.Scanner input = new java.util.Scanner(System.in);
System.out.print("Enter " + myList.length + " values: ");
for (int i = 0; i < myList.length; i++)
 myList[i] = input.nextDouble();
```

_Initializing arrays with random values:_ The following loop initializes the array **myList** with random values between **0.0** and **100.0**, but less than **100.0.**

```
for (int i = 0; i < myList.length; i++) {
 myList[i] = Math.random() * 100;
}
```

_Displaying arrays:_ To print an array, you have to print each element in the array using a loop like the following:

```
for (int i = 0; i < myList.length; i++) {
 System.out.print(myList[i] + " ");
}
```

For an array of the **char[]** type, it can be printed using one print statement. For example, the following code displays **Dallas**:

```
char[] city = {'D', 'a', 'l', 'l', 'a', 's'};
System.out.println(city);
```

_Summing all elements:_ Use a variable named **total** to store the sum. Initially **total** is **0**. Add each element in the array to **total** using a loop like this:

```
double total = 0;
for (int i = 0; i < myList.length; i++) {
 total += myList[i];
}
```

_Finding the largest element:_ Use a variable named **max** to store the largest element. Initially **max** is **myList[0]**. To find the largest element in the array **myList**, compare each element with **max**, and update **max** if the element is greater than **max**.

```
double max = myList[0];
for (int i = 1; i < myList.length; i++) {
if (myList[i] > max) max = myList[i];
}
```

_Finding the smallest index of the largest element:_ Often you need to locate the largest element in an array. If an array has multiple elements with the same largest value, find the smallest index of such an element. Suppose the array **myList** is {**1**, **5**, **3**, **4**, **5**, **5**}. The largest element is **5** and the smallest index for **5** is **1**. Use a variable named **max** to store the largest element and a variable named **indexOfMax** to denote the index of the largest element. Initially **max** is **myList[0]**, and **indexOfMax** is **0**. Compare each element in **myList** with **max**, and update **max** and **indexOfMax** if the element is greater than **max**.

```
double max = myList[0];
int indexOfMax = 0;
for (int i = 1; i < myList.length; i++) {
if (myList[i] > max) {
 max = myList[i];
 indexOfMax = i;
 }
}
```

_Random shuffling:_ In many applications, you need to randomly reorder the elements in an array. This is called shuffling. To accomplish this, for each element **myList[i]**, randomly generate an index **j** and swap **myList[i]** with **myList[j]**, as follows:

```
for (int i = myList.length – 1; i > 0; i––) {
// Generate an index j randomly with 0 <= j <= i
int j = (int)(Math.random()
 * (i + 1));
// Swap myList[i] with myList[j]
double temp = myList[i];
 myList[i] = myList[j];
 myList[j] = temp;
}
```
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/947cxv02kmjj4urm7hbn.png)

_Shifting elements:_ Sometimes you need to shift the elements left or right. Here is an example of shifting the elements one position to the left and filling the last element with the first element:

```
double temp = myList[0]; // Retain the first element
// Shift elements left
for (int i = 1; i < myList.length; i++) {
 myList[i - 1] = myList[i];
}
// Move the first element to fill in the last position
myList[myList.length - 1] = temp;
```
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/3x7wxtqv7pbbr9ptprge.png)

_Simplifying coding:_ Arrays can be used to greatly simplify coding for certain tasks. For example, suppose you wish to obtain the English name of a given month by its number. If the month names are stored in an array, the month name for a given month can be accessed simply via the index. The following code prompts the user to enter a month number and displays its month name:

```
String[] months = {"January", "February", ..., "December"};
System.out.print("Enter a month number (1 to 12): ");
int monthNumber = input.nextInt();
System.out.println("The month is " + months[monthNumber - 1]);
```

If you didn’t use the **months** array, you would have to determine the month name using a lengthy multi-way **if-else** statement as follows:

```
if (monthNumber == 1)
 System.out.println("The month is January");
else if (monthNumber == 2)
 System.out.println("The month is February");
...
else
 System.out.println("The month is December");
```

##  Foreach Loops

Java supports a convenient **for** loop, known as a **foreach loop**, which enables you to traverse the array sequentially without using an index variable. For example, the following code displays all the elements in the array **myList**:

```
for (double e: myList) {
 System.out.println(e);
}
```

You can read the code as “for each element **e** in **myList**, do the following.” Note that the variable, **e**, must be declared as the same type as the elements in **myList**.

In general, the syntax for a foreach loop is

```
for (elementType element: arrayRefVar) {
// Process the element
}
```

You still have to use an index variable if you wish to traverse the array in a different order or change the elements in the array.

Accessing an array out of bounds is a common programming error that throws a runtime **ArrayIndexOutOfBoundsException**. To avoid it, make sure that you do not use an index beyond **arrayRefVar.length – 1**.

Programmers often mistakenly reference the first element in an array with index **1**, but it should be **0**. This is called the _off-by-one error_. Another common off-by-one error in a loop is using **<=** where **<** should be used. For example, the following loop is wrong.

```
for (int i = 0; i <= list.length; i++)
 System.out.print(list[i] + " ");
```

The **<=** should be replaced by **<**.