How To Use Arrays in Java

An array allows you to group and store multiple elements. Using an array, you can store any kind of data type—that is, a reference or primitive type. However, all the array elements must be of the same data type. The data type of the array is stated when the array is created and cannot be changed. Similarly, the length of the array—that is, how many elements it can store—is defined at the beginning and cannot be changed.

Arrays play a fundamental role in Java as many core data types are based on them. For example, the frequently used reference type String is in fact implemented as an array of char elements. So even though you might have not known it, you have already used arrays.

In this tutorial, you’ll use a char array to store a password securely. This is a common use case for arrays. A char array is a better choice than String for storing a password because a String object is immutable—that is, it cannot be overridden. So even though you might no longer need a password String object, you cannot just dispose of it. This means the object remains in memory, and as a result, an attacker could theoretically access this part of the memory and read the password. In contrast, you can easily override a password stored as a char array and make it unusable. Because of that, there is no chance for an attacker to learn a password from inspecting the memory.

To follow this tutorial, you will need:

• An environment in which you can execute Java programs to follow along with the examples. To set this up on your local machine, you will need the following:

• Java (version 11 or above) installed on your machine, with the compiler provided by the Java Development Kit (JDK). For Ubuntu and Debian, follow the steps for Option 1 in our tutorial How To Install Java with Apt on Ubuntu 22.04. For other operating systems, including Mac and Windows, follow the download options for Java installation.
• To compile and run the code examples, this tutorial uses Java Shell, which is a Read-Evaluate-Print Loop (REPL) run from the command line. To get started with JShell, check out the Introduction to JShell guide. To avoid redundant instructions, all examples are executed in one JShell session and use the same variables.

• Familiarity with Java and object-oriented programming, which you can find in our tutorial How To Write Your First Program in Java.
• An understanding of Java data types, which is discussed in our tutorial Understanding Data Types in Java.

To begin using an array, you have to create it first. There are a few ways to create an array, and the way you create one depends on whether you know what elements the array is going to hold.

If you don’t know the array elements, then you can create an empty array and define its size, like this:

char[] password = new char[6];

The combination [] after the char keyword defines the variable password as an array. The char keyword means that the variable holds char primitives. To create the array object, you use the new keyword with the array defined as char[6] , which means that it is an array that contains char primitives and holds six elements.

When you run the preceding code, you will receive the following output:

password ==> char[6] { '\000', '\000', '\000', '\000', '\000', '\000' }

The output confirms that a new char array has been created under the name password. It can store six elements ([6]), which are currently empty (\000).

Alternatively, if you already know the array elements, you can create an array called password with char elements, like this:

char[] password = new char[] {'s', 'e', 'c', 'r', 'e', 't'};

The left part of the statement, before the equals sign, is the same as the left part of statement in the first empty array example—a char array is defined under the name password. The second part of the statement, after the equal sign, starts again with the new keyword; however, the number of elements is not explicitly given. Instead, all six elements are listed. The list begins with an opening bracket, followed by the six elements. Since the elements are char primitives, they are surrounded by single quotes ('). The list ends with a closing bracket.

When you paste the preceding code in jshell, you will get the following output:

Output
password ==> char[6] { 's', 'e', 'c', 'r', 'e', 't' }

The output confirms that the password char array has been created and its elements are listed.

In the latter example, you specified the elements while creating the array. This saved you from writing additional instructions for assigning values to the elements. That’s the benefit of creating an array this way. Alternatively, you can create code to populate the elements with each new element defined separately. You will do this next.

You will not always know the elements of an array, so specifying them, along with creating the array, might not be an option. In any case, whether you have initially specified the array elements or not, you can always specify or change them later.

For example, you can change an element of the password array by referring to its index—that is, its place in the array—like this:

password[0] = 'n';

By using password[0], you are referring to the first element of the password array. Array elements are numbered starting at 0, so the first element will have an index of 0, as in this case. The array element index number is always specified between square brackets ([]). You redefine the array element and assign a new value to it—the 'n' char primitive.

After you execute the preceding statement in jshell, you will get output similar to the following:

Output
$8 ==> 'n'

The temporary variable $8 is used internally in jshell. It might be a different number in your case.

There is a unique feature in jshell you can use to confirm that the password array has changed as you intended. When you paste the name of the array, in this case password, in jshell, it will print the array along with its elements without the need for additional methods:

password

You will get the following output in jshell:

Output
password ==> char[6] { 'n', 'e', 'c', 'r', 'e', 't' }

This output confirms that you have successfully changed the password char array from s, e, c, r, e, t to n, e, c, r, e, t. Now, if attackers gains access to your server, they will get the altered password instead of the original one. Alternatively, if you used a String variable to store the password, the old value object will still remain in the memory for some time, even when you reassign a new value to it, and attackers could read it.

You will continue to use the password array throughout this tutorial, so for consistency reasons, restore the value of the first element to s by referring to it again and executing the command in jshell:

password[0] = 's';

This will give an output similar to the previous one with a temporary variable , $25 in this case, which confirms the change was successful:

Output
$25 ==> 's'

Once again you have the original password array with the elements 's', 'e', 'c', 'r', 'e', 't'. Now that you know how to create and alter the elements of an array, it is time to start reading and using its elements.

When getting a specific array element, you will be working with its index. For example, to get the second element of the password array, you can use the following code:

System.out.println(password[1]);

In this code, you use the println() method to print the second element of the password array. (For more on the System.out.println statement, check out our tutorial How To Write Your First Program in Java.) The second element has an index of 1 because array elements are numbered starting at 0, as already mentioned.

This code will result in the following output:

Output
e

The output prints the second array element, e. Just as printing it, you could use it in any other way where a char value is suitable.

Furthermore, you can also iterate over all the array elements using a foreach loop as explained in our tutorial How To Use Loops in Java. A loop is a structure for controlling repetitive program flow, and the foreach loop is especially useful for iterating over arrays because it requires minimum boilerplate code. Following is an example:

for (char c : password) {
	System.out.print(c);
}

This foreach loop iterates over the password array and uses a temporary char variable called c. With each iteration, c moves from the first to the last element of the password array. Once c gets the value of the array element, you can use c in any suitable way inside the block of code. In the preceding example, you print c with the print() method.

Notice that the print() method prints an argument without a new line. In contrast, in the tutorials so far you have used println() method which leaves a new line each time it is run. In this case, print() is more suitable since it will print all the elements from the password array on the same line and the result will be better visualized as a single word (“secret”).

If you follow the preceding steps precisely and run this code in jshell, you will get the following output:

Output
secret

If you miss the step for resetting the first array element from n back to s, you will get necret instead.

You can get all the elements of the array when you combine the knowledge you have built so far. From this point on, you are ready to go deeper into the topic of arrays and learn useful array methods for performing various functions.

Java has a very helpful Arrays class located in the java.util package. This class helps you when working with arrays by providing you with useful methods for common use cases. This means you don’t have to reinvent the wheel and you can save yourself redundant efforts. Here are some of the most frequently used methods:

char[] password2 = new char[] {'n', 'o', 'n', 'e'};

Output
password2 ==> char[4] { 'n', 'o', 'n', 'e' }

System.out.println(Arrays.equals(password, password2));

Output
false

Arrays.sort(password);

password;

Output
password ==> char[6] { 'c', 'e', 'e', 'r', 's', 't' }

System.out.println(Arrays.binarySearch(password, 'c'));

Output
0

password = Arrays.copyOf(password, 10);

Output
password ==> char[10] { 'c', 'e', 'e', 'r', 's', 't', '\000', '\000', '\000', '\000' }

System.out.println(password.length);

Output
10

In this tutorial, you used Java arrays to group related items. You learned how to create an array, how to view them, and how to use its contents. You also learned best practices and useful methods for working with arrays.

For more on Java, check out our How To Code in Java series.