Java Arrays: Declaration, Initialization, Types & Examples

Q: Can I change the size of Java arrays after they are created?

No Java arrays have a fixed size. When you first create a Java array, you have to say how many things can fit in it. Thereafter, you can't make the Java array bigger or smaller. If you need something that can get bigger or smaller an ArrayList is a choice. These are fixed-size, but an ArrayList can change size.

Q: How do I determine the total number of elements in a Java array example?

You can use the Arrays length property to find out how many things are in an array. For example, if you have an array called 'data', you can use 'data'.length to get its size. The 'data' array is numbered by slots and data. length will tell you exactly how many slots are in the 'data' array.

Q: What is the main difference between Java arrays and ArrayLists?

The main difference between Java arrays and ArrayLists is that arrays have a fixed size. They can also hold things, like numbers. On the other hand, ArrayList is flexible and can change size, but it can only hold objects. When it comes to things you do with them, arrays are usually faster.

When you start with Java, you might create separate variables to hold related data. Instead of declaring individual variables for each item, an array lets you group similar data types into one unit that’s easy to manage. Java arrays are useful whether you are building a calculator or a complex data processing engine. Understanding how to store and access data through arrays is a must-know skill for every developer working with Java arrays.

It will also show you the differences between arrays and other kinds of collections that’re more flexible. It will cover many things, including how arrays and collections are different from each other.

Table of Contents

What are Java arrays?

In the simplest terms, Java arrays are objects that hold a fixed number of values of a single type. Imagine a row of lockers in a school hallway; each locker has a specific number (an index), and every locker in that row is designed to hold the same kind of items.

In Java, arrays are index-based. This means the first element is stored at index 0, the second at index 1, and so on. This structure allows for very fast data retrieval because the computer knows exactly where each “locker” is located in the memory.

Java Arrays Declaration and Initialization

You must tell Java the type and number of items an array will hold before using it. This process involves two main steps: the declaration and initialization.

Java Arrays declaration

To create an array, you define the type of variables it will hold, followed by square brackets.

Syntax: type[] arrayName;
Example: int[] studentScores; or String[] carBrands;

At this stage, you have only created a reference; the actual “container” doesn’t exist in the memory yet.

Java Arrays initialization

Once declared, you must allocate memory to the array. This is where you specify the size.

Method 1 (Using a new keyword): studentScores = new int[5]; This creates an array capable of holding five integers.
Method 2 (Literal Initialization): If you already know the values, you can combine declaration and initialization: int[] studentScores = {85, 90, 78, 92, 88};

Using an example like the one above makes it much easier to see how data is grouped together. By using curly braces, Java automatically calculates the size of the array for you.

Accessing and Modifying Elements in Java Arrays

Once your array is set up, you interact with it using the index. Remember, Java starts counting at zero.

Accessing: System.out.println(studentScores[0]); would print 85.
Modifying: studentScores[1] = 95; changes the second value in your list from 90 to 95.

Trying to access an index that doesn’t exist (like index 5 in a 5-element array) will result in an ArrayIndexOutOfBoundsException. Beginners often face this challenge, so it’s important to always monitor your index numbers.

The Length of Java Arrays

One of the most useful features of an array is the ability to check its size dynamically. This is done using the .length property.

Unlike some other programming languages where you might need to call a function, Java arrays length is a built-in property.

Code Example:
String[] fruits = {“Apple”, “Banana”, “Cherry”};
System.out.println(fruits.length); // Outputs 3

This property is incredibly helpful when you need to loop through an array. Instead of hardcoding the number 3, you use fruits. length to ensure your code doesn’t break if you add more fruits to the list later.

Java Arrays Methods

While arrays in Java are somewhat basic compared to other objects, the java.util.Arrays class provides several powerful Java Arrays methods that simplify common tasks:

sort(): This method arranges the elements in ascending order.
binarySearch(): Used to find the location of a specific value (the array must be sorted first).
equals(): Checks if two arrays are identical in terms of both length and content.
fill(): Assigns a specific value to every element in the array.
copyOf(): Creates a new array that is a duplicate of the original.

Using these methods saves you from writing complex loops for simple tasks like sorting a list of names or numbers.

Practical Java Arrays program

Let’s look at a simple Java Arrays program that calculates the average of a set of numbers. This brings together the declaration, initialization, and length properties.

Java

public class ArrayAverage {
public static void main(String[] args) {
// Declaration and initialization
double[] temperatures = {22.5, 25.0, 19.8, 30.2, 28.4};
double sum = 0;

// Using a loop to traverse the array
for (int i = 0; i < temperatures.length; i++) {
sum += temperatures[i];
}

double average = sum / temperatures.length;
System.out.println(“The average temperature is: “ + average);
}
}

This logic is the backbone of data processing. You can replace temperatures with prices, grades, or any other numerical data.

Java Arrays vs ArrayList

Feature	Java Arrays	ArrayList
Size	Fixed (cannot change after creation)	Dynamic (grows and shrinks automatically)
Type	Can hold primitives (int, double) and objects	Can only hold objects (uses Wrapper classes)
Performance	Faster and uses less memory	Slightly slower due to overhead
Flexibility	Low	High (easy to add/remove elements)

Java Arrays Example

To better understand how these look in a real script, consider a Java Arrays example involving a list of fruits.

Java

String[] fruits = {“Apple”, “Banana”, “Orange”, “Mango”};
// Accessing the first fruit
System.out.println(fruits[0]); // Output: Apple

In this case, the array is automatically sized to 4, and each fruit is assigned an index from 0 to 3.

Practices for Using Java Arrays

To write efficient code, remember these tips:

Use Enhanced For-Loops: when you just need to look at the data and not change it. For example, you can use this kind of loop like this: for (int score : studentScores) {… }.
Choose Meaningful Names: Do not call an array something like arr. Instead, call it something like ‘userAgeList’ or ‘productPrices’.
Check Length Before Accessing: Always check how long something is before you try to get to it. This will help you avoid getting errors when your code is running.
Prefer Arrays for Performance: If you need to make your code go fast, like for a game or for trading, use arrays. Arrays are better than collections when every single millisecond counts.

FAQs

Can I change the size of Java arrays after they are created?