One Dimensional Array In Java | Operations & More (+Code Examples)

11 mins read

In Java, arrays serve as a foundational data structure, offering a way to store and manipulate collections of data efficiently. A one-dimensional array, the simplest form of an array, acts as a linear collection of elements, all of the same data type, arranged in contiguous memory locations. This makes it particularly useful for handling lists of items such as numbers, names, or objects in a structured manner.

In this article, we will understand the concept of one-dimensional arrays in Java, covering their declaration, initialization, and common operations. By the end, you’ll have a clear understanding of how to work with these arrays to streamline data management in your Java programs.

What Is A One-Dimensional Array In Java?

A one-dimensional array is a linear collection of elements stored in contiguous memory locations. Each element is identified by an index or subscript, allowing easy access and manipulation. It is one of the simplest forms of data organization, frequently used in programming to group related data of the same type.

Real-World Analogy

Imagine a row of lockers in a gym. Each locker:

• Has a unique number (index) that helps you identify and access it.
• Can store only one item type (homogeneity, like gym gear).
• Has a fixed number of lockers (size).

This concept closely resembles how a one-dimensional array works.

Key Characteristics Of One-Dimensional Arrays In Java

Some of the key characteristics of one-dimensional arrays in Java programming are:

• Fixed Size: The size of an array is defined at the time of creation and cannot be changed later.
• Homogeneous Data Type: All elements in the array must be of the same data type.
• Zero-Based Indexing: Array elements are accessed using indices starting from 0.
• Contiguous Memory Allocation: Elements are stored in consecutive memory locations.
• Efficient Indexed Access: Arrays provide constant-time access to elements using their index.
• Default Initialization: Arrays are automatically initialized with default values based on their data type.
• Length Property: Each array comes with a built-in property to determine its size.
• Immutable Size: While the size of the array is fixed, its elements can be modified.
• Supports Iteration: Arrays can be easily traversed using loops.
• Prone to IndexOutOfBoundsException: Accessing invalid indices will result in a runtime exception.

Explore this amazing course and master all the key concepts of Java programming effortlessly!

Declaration Of One-Dimensional Array In Java

To declare a one-dimensional array, use the following syntax:

dataType[] arrayName;  // Preferred style
dataType arrayName[];  // Also valid (less common)

Here:

• dataType: The type of data the array will store (e.g., int, float, char).
• arrayName: The name used to identify the array.

Initialization Of One-Dimensional Array In Java 

After declaring an array, you must allocate memory for its elements. This can be done in one of two ways:

1. Using The new Keyword:

In this method, we allocate memory for the array elements and initialize them to default values based on their data type using the new keyword in Java.

arrayName = new dataType[size];

For Example:

int[] numbers = new int[5];  // Allocates memory for 5 integers

2. Using An Array Literal:

In this, we directly initialize the array with specified values without needing to allocate memory separately.

dataType[] arrayName = {value1, value2, ..., valueN};

For Example: 

int[] numbers = {10, 20, 30, 40, 50};  // Directly initializes the array

Let’s now look at a code example to demonstrate declaration, initialization, and usage of a one-dimensional array in Java:

Code Example: 

public class OneDimensionalArrayExample {

    public static void main(String[] args) {

        // Declaration and memory allocation
        int[] numbers = new int[5];

        // Initialization using index
        numbers[0] = 10;
        numbers[1] = 20;
        numbers[2] = 30;
        numbers[3] = 40;
        numbers[4] = 50;

        // Declaration and initialization using array literal
        String[] fruits = {"Apple", "Banana", "Cherry", "Date", "Elderberry"};

        // Accessing and printing elements
        System.out.println("Numbers Array:");
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("Index " + i + ": " + numbers[i]);
        }

        System.out.println("\nFruits Array:");
        for (int i = 0; i < fruits.length; i++) {
            System.out.println("Index " + i + ": " + fruits[i]);
        }
    }
}

Output (set code file name as OneDimensionalArrayExample.java): 

Numbers Array:
Index 0: 10
Index 1: 20
Index 2: 30
Index 3: 40
Index 4: 50

Fruits Array:
Index 0: Apple
Index 1: Banana
Index 2: Cherry
Index 3: Date
Index 4: Elderberry

Explanation: 

In the above code example-

1. We begin by declaring and allocating memory for a one-dimensional integer array named numbers with a size of 5. This creates an array capable of storing five integer values.
2. Next, we initialize each element of the numbers array using its index. We assign specific values (10, 20, 30, 40, 50) to indices 0 through 4, respectively.
3. Alongside, we also declare and initialize a string array called fruits using an array literal. This allows us to directly assign values ("Apple", "Banana", "Cherry", "Date", "Elderberry") to the array without explicitly specifying the size.
4. To display the elements of the numbers array, we iterate over it using a for loop. For each iteration, we print the index and the corresponding value.
5. Similarly, we loop through the fruits array to access and print its elements. Each fruit is displayed along with its respective index.

Sharpen your coding skills with Unstop's 100-Day Coding Sprint and compete now for a top spot on the leaderboard!

Common Operations On One-Dimensional Array In Java

Basic operations on one-dimensional arrays in Java allow us to perform essential tasks like inserting, accessing, updating, and deleting elements efficiently:

Let’s now look at a code example to understand the implementation of these operations in one-dimensional array in Java-

Code Example: 

import java.util.Arrays;

public class ArrayOperationsDemo {

    public static void main(String[] args) {

        // 1. Insertion
        int[] array = new int[5]; // Array with default values (0)
        array[0] = 10; // Insert at specific index
        array[1] = 20;
        array[2] = 30;
        System.out.println("After Insertion: " + Arrays.toString(array));

        // 2. Access
        System.out.println("Access Element at Index 1: " + array[1]);

        // 3. Update
        array[1] = 25; // Update element at index 1
        System.out.println("After Update: " + Arrays.toString(array));

        // 4. Search
        int target = 30;
        int index = -1;
        for (int i = 0; i < array.length; i++) {
            if (array[i] == target) {
                index = i;
                break;
            }
        }
        System.out.println("Search: Element " + target + " found at index " + index);

        // 5. Deletion
        int deleteIndex = 1; // Remove element at index 1
        for (int i = deleteIndex; i < array.length - 1; i++) {
            array[i] = array[i + 1];
        }
        array[array.length - 1] = 0; // Reset last element after shift
        System.out.println("After Deletion: " + Arrays.toString(array));

        // 6. Traverse
        System.out.println("Traverse Array:");
        for (int element : array) {
            System.out.print(element + " ");
        }
    }
}

Output (set code file name as ArrayOperationsDemo.java): 

After Insertion: [10, 20, 30, 0, 0] 
Access Element at Index 1: 20 
After Update: [10, 25, 30, 0, 0] 
Search: Element 30 found at index 2 
After Deletion: [10, 30, 0, 0, 0] 
Traverse Array: 
10 30 0 0 0  

Explanation: 

In the above code example-

1. We start by creating an integer array array with a size of 5, which is initialized with default values of 0. We then insert specific values (10, 20, 30) at the first three indices (0, 1, and 2). After insertion, we print the updated array using Arrays.toString(), showing the array as [10, 20, 30, 0, 0].
2. Next, we demonstrate how to access an element at a specific index. In this case, we print the element at index 1, which is initially 20.
3. We then update the value at index 1 by changing it from 20 to 25. After the update, we print the updated array again, showing [10, 25, 30, 0, 0].
4. We proceed to search for the value 30 within the array. We use a for loop to iterate over the array and compare each element to the target value. When we find the target at index 2, we print the result.
5. In the deletion step, we remove the element at index 1 by shifting all subsequent elements to the left. We reset the last element to 0 after the shift, and the array becomes [10, 30, 0, 0, 0]. We print the array to show the result of the deletion.
6. Finally, we demonstrate how to traverse the array using an enhanced for loop. Each element is printed one by one, producing the output: "10 30 0 0 0".

Advantages Of One-Dimensional Arrays In Java

Some common advantages are: 

1. Simple and Efficient: One-dimensional arrays are easy to declare, initialize, and access. They allow direct indexing for fast retrieval of elements.
2. Memory Contiguity: Elements are stored in contiguous memory locations, leading to efficient memory usage and faster access times.
3. Fixed Size: Once the size is defined, it provides efficient and predictable memory allocation, as it avoids the overhead of dynamic resizing (like in other data structures).
4. Access Speed: Accessing elements by index is an O(1) operation, making it very fast.

Disadvantages Of One-Dimensional Arrays In Java

Some common disadvantages are:

1. Fixed Size: Once an array is created, its size cannot be changed. If the array is full or under-utilized, resizing it (without re-declaring) requires creating a new array, which can be inefficient.
2. Limited Flexibility: One-dimensional arrays can only hold elements of the same data type, limiting flexibility when mixed data types are needed.
3. Inefficient for Complex Data: For complex data that involves multiple dimensions or structures (like matrices), one-dimensional arrays can become cumbersome and harder to manage.
4. Wasted Memory: If you allocate more space than required, you may end up wasting memory, as the array size is fixed once set.
5. Lack of Built-In Methods: Java's one-dimensional arrays do not come with built-in methods for resizing, sorting, or other operations that are available in more advanced data structures like ArrayList.

Are you looking for someone to answer all your programming-related queries? Let's find the perfect mentor here.

Conclusion

One-dimensional arrays are a versatile and essential data structure in Java, offering simplicity and efficiency for managing a collection of elements. While they provide fast access and memory efficiency, their fixed size and lack of flexibility can be limiting in certain use cases. Understanding the advantages and disadvantages of one-dimensional arrays helps developers make informed decisions when choosing the appropriate data structure for their applications. For more complex scenarios, exploring alternatives like dynamic arrays or other collections can offer additional flexibility and functionality.

Frequently Asked Questions

Q. What is the difference between an array and an ArrayList in Java?

An array in Java has a fixed size, meaning its size must be defined when it's created and cannot be changed later. It is ideal for storing a fixed number of elements of the same type. On the other hand, an ArrayList is a part of Java's collection framework and is dynamic, meaning it can grow or shrink in size as needed. While arrays offer better performance in terms of element access, ArrayLists provide more flexibility and come with built-in methods for resizing, adding, and removing elements.

Q. Can the size of a one-dimensional array be changed after initialization in Java?

No, the size of a one-dimensional array in Java is fixed once it is initialized. If you need a dynamic size, you would need to create a new array of a different size and copy the elements from the original array into the new one. This is why ArrayList is often preferred when the number of elements is subject to change.

Q. How do you initialize a one-dimensional array in Java?

You can initialize a one-dimensional array in Java in two main ways:

• Explicit Initialization: By specifying the array elements directly.

int[] numbers = {1, 2, 3, 4, 5};

• Dynamic Initialization: By defining the array's size and filling it later.

int[] numbers = new int[5]; // Initializes an array of size 5 with default values (0 for int)

Q. What happens if you try to access an index outside the bounds of a one-dimensional array?

In Java programming language, attempting to access an array element using an index that is outside its bounds (i.e., less than 0 or greater than or equal to the array's length) will throw an ArrayIndexOutOfBoundsException at runtime. It is essential to ensure the index is within the valid range (0 to array.length - 1) to avoid this error.

Q. Can a one-dimensional array store different data types in Java?

No, a one-dimensional array in Java is type-specific, meaning it can only store elements of the same data type. For example, an int[] can only store integers, and a String[] can only store strings. If you need to store mixed data types, you can use a Object[] array, as Object is the parent class of all Java classes. However, this may require type casting and can lead to potential errors.

Q. What is the time complexity for accessing an element in a one-dimensional array?

Accessing an element by its index in a one-dimensional array has a time complexity of O(1), also known as constant time. This means that the time taken to retrieve an element does not depend on the size of the array and is extremely fast. This is one of the key advantages of arrays compared to other data structures like lists or linked lists.

With this, we conclude our discussion on one-dimensional arrays in Java. Here are a few other topics that you might be interested in reading:

1. Convert String To Date In Java | 3 Different Ways With Examples
2. Final, Finally & Finalize In Java | 15+ Differences With Examples
3. Super Keyword In Java | Definition, Applications & More (+Examples)
4. How To Find LCM Of Two Numbers In Java? Simplified With Examples
5. How To Find GCD Of Two Numbers In Java? All Methods With Examples
6. Volatile Keyword In Java | Syntax, Working, Uses & More (+Examples)