Arrays in Java

Updating Elements of an Array in Java

An Update in Java arrays means modifying an already present value in a given index. Since Java arrays are fixed size, you cannot change their size, but you can interchange values in any valid index.

How to Update an Array Element?

Updating an array element is as easy as assigning a new value to the index you want to update with the assignment operator (=).

Basic Example: Updating Elements in an Integer Array

Output:

Accessing Elements of an Array in Java

Once an array is created and initialized, the elements can be accessed by their array position. Java is zero-based, so the first element is in position 0, the second is in position 1, and so on. Arrays have constant-time access (O(1)) to the items because they are in contiguous memory locations. This makes retrieving data from an array highly efficient compared to other data types, including linked lists.

1. How Array Indexing Works in Java

Java arrays are of fixed length and hold their elements in consecutive memory slots. The index of an array serves as an identifier for each of its elements, and Java supports direct element access by index.

Basic Syntax to Access Array Elements

arrayName[index];  // Retrieves the element at the specified index

• arrayName is the variable of the array.
• index is an integer that represents the location of the element.

Example: Accessing Array Elements in Java

2. Accessing Array Elements Using a Loop

Accessing all the elements manually is not an effective approach in large arrays. Loops are used to iterate over all the elements instead.

2.1 Using a For Loop

• The for loop runs from 0 to arr.length – 1 to ensure that all the elements are accessed one by one.

2.2 Using an Enhanced For Loop

• The enhanced for loop or for each loop traverses all the elements without the use of an index variable.

3. Array Index Out of Bounds Exception Handling

The most frequent error made in accessing an array is an invalid index. Arrays in Java are fixed-size, and attempting to access an index outside the valid range (0 to length – 1) will result in an exception.

Example of an Out-of-Bounds Error:

4. Preventing Out-of-Bounds Errors

To avoid this, always validate the index before accessing an element:

Deleting an Array in Java

Arrays in Java are objects that are generally stored in the heap memory. Java, unlike C or C++, lacks explicit deletion methods (e.g., free() or delete). Instead of that Java uses garbage collection (GC) to automatically deallocate the memory when an array is no longer in use.

Can You Delete an Array in Java?

You can “delete” an array in Java by:

• Set the reference to the array to null – mark it for garbage collection.
• Assign the array to a new object – The old array is no longer available.

Deleting an Entire Array by Nullifying the Reference

The Garbage Collector (GC) will reclaim the used memory of numbers when it runs.

Finding the Size or Length of an Array in Java

In Java, an array is fixed in size once initialized. The size of an array is the number of items it can hold, and it is determined when an array is created. Unlike an ArrayList, the size of an array cannot be changed dynamically.

How to Find the Length of an Array?

Java has a built-in property called length, which returns the number of elements present in the array.

Syntax:

arrayName.length;

• arrayName refers to the array variable.
• .length returns the number of elements in the array.

Example: Finding the Length of a 1D Array

• The length of the numbers array is 5, as it contains 5 elements.

Operations on Arrays in Java

Arrays are the most used concept in Java as they are efficient as well as they provide direct memory access However, if you want to use arrays efficiently, there are several operations including searching, sorting, reversing, copying, merging, filling, and comparing that are usually required. These operations can either be done manually by loops or simply by built-in utility methods from the class java.util.Arrays.

1. Searching in an Array

Searching is generally used to locate an element within an array. Two standard search techniques are available in Java.

a) Linear Search (For Unsorted Arrays)

Linear search generally traverses every element one by one until the desired value is located or the end of the array is encountered. Linear search applies to sorted as well as unsorted arrays, but it is not suitable for large data due to the O(n) time complexity.

Example: Implementing Linear Search

Output:

Linear search applies to small sets but is not suitable for large arrays.

b) Binary Search (For Sorted Arrays)

Binary search is typically a more effective search method that is used only to sort lists. Binary search simply follows the divide and conquer approach, whereas the array is continuously divided by half until we find the required element. The time complexity of this search algorithm is O(log n).

Example: Implementing Binary Search

Output:

The binary search is significantly faster than linear search, particularly in large sorted lists

2. Sorting an Array

Sorting means just arranging the items in an array in ascending or descending order to increase searching efficiency and overall data processing.

a) Bubble Sort (Manual Sorting)

Bubble sort swaps adjacent items repeatedly if they are in the wrong order. It is an O(n²) algorithm and therefore is not appropriate for larger arrays.

Example: Implementing Bubble Sort

Output:

Bubble Sort is less efficient but is helpful to learn basic sorting techniques.

b) Using Arrays.sort() (Optimized Sorting)

Java typically provides the Arrays.sort() method, which is highly optimized and internally makes use of Dual-Pivot Quicksort for primitive types and TimSort for objects.

Example: Sorting an Array Using Arrays.sort()

Output:

In most cases, Arrays.sort() is the best choice to sort an array efficiently.

3. Reversing an Array

Reversing an array simply means swapping the elements from the beginning and the end until the entire array gets reversed.

Example: Reversing an Array

Output:

Reversing an array is a common technique used in data manipulation and algorithm problems

4. Copying an Array

Copying an array creates a copy, without modifying the original.

Example: Using Arrays.copyOf()

Output:

Arrays.copyOf() is generally the simplest and most useful way to copy an array.

5. Merging Two Arrays

Merging two arrays means combining all the elements of two or more arrays into a single array.

Example: Merging Two Arrays

Output:

Merging arrays is generally very useful when working with multiple data sources.

6. Comparing Two Arrays

Java provides Arrays.equals() to compare if two arrays are equal.

Output:

Use Arrays.equals() to compare arrays instead of ==, which compares reference equality.

Types of Arrays in Java

Arrays in Java can be divided into several types based on their structure and use cases. The most common types are:

1. One-Dimensional Arrays (1D Arrays): An array containing only one row where all the elements are stored.
2. Two-Dimensional Arrays (2D Arrays): An array having a row and column-like matrices.
3. Array of Objects: An array that contains objects instead of primitive data types.
4. Jagged Arrays: They are a type of 2D array where the row lengths can be different.

1. One-Dimensional Arrays (1D Arrays)

A one-dimensional array is typically an array of the same type of items in sequential storage in the computer’s memory. It is the simplest form of an array in Java. We’ve been discussing the One Dimensional arrays, in this article, until now.

Example of a 1D Array

Output:

One-dimensional arrays are most commonly used to store simple data, such as lists of numbers or strings.

2. Two-Dimensional Arrays (2D Arrays)

A two-dimensional array, or 2D array, is an array that consists of elements grouped together in the form of rows and columns and is like a tabular format. It is an array of arrays, where each row is an array.

2.1 Declaration and Initialization of a 2D Array

A 2D array may be declared and initialized in a variety of ways:

2.2 Accessing Elements in a 2D Array

Each item in a 2D array is accessed by two indices:

• The first index is the row.
• The second index is the column.

Output:

Advantages of 2D Arrays

• Very beneficial in demonstrating grids, matrices, and tables.
• Better suited to hold ordered data like images, spreadsheets, and game boards.

Disadvantages of 2D Arrays

• Fixed size: Once you initialize any 2D array, you cannot change its rows and columns sizes.
• Usage of Memory: Typically requires contiguous memory allocation, which can result in wastage of memory.

3. Array of Objects

In Java, an array of objects is an array that generally holds the object references instead of primitive values. Each element in the array holds the reference to an object that typically belongs to a certain class.

Declaring and Initializing an Array of Objects

Example: Array of Objects in Java

Output:

Use Cases of Array of Objects

• Student record keeping: Keeping names, ages, and grades of students.
• Library system: Maintaining title, author, and ISBN of books.
• Inventory management: Monitoring items by attributes including name, price, and quantity.

4. Jagged Arrays

A jagged array is a special type of two-dimensional array where each row can have a variable number of columns. Unlike 2D arrays, jagged arrays are not rectangular in shape.

Declaration and Initialization of a Jagged Array

Example: Printing a Jagged Array

Output:

Advantages of Jagged Arrays

• Memory efficiency: It typically uses the needed space instead of wasting memory on empty columns.
• Versatile Structure: Very useful when dealing with variable-sized data.

Disadvantages of Jagged Arrays

• Complex memory handling: Each row must be allocated separately, and that creates management overhead.
• Complexity: Access is more complex than in regular 2D arrays.

Passing Arrays to Methods in Java

In Java, methods can take array arguments as they do with primitive data types. Since an array is a reference type, passing an array to a method is passing the reference, not a copy of the contents. This allows methods to modify the original contents of the array directly.

How to Pass an Array to a Method?

Passing an array to a method is as simple as declaring the array type as the parameter to the method.

Example: Passing an Array to a Method

Output:

Since arrays are generally reference parameters, any change to the array in the method will be reflected in the original array.

Java Array Members

Arrays in Java are objects and, like all objects, they have built-in members providing them with useful functionalities. Java arrays only have one built-in member, length, and they also have methods inherited from the Object class.

1. The length Property

The length property is used to determine the size of an array. It provides the total number of elements stored in the array.

Example: Using the length Property

Output:

The length property is final and cannot be modified. An array’s size is set once it is initialized.

2. Methods Inherited from Object Class

Since Java arrays are objects, they have inherited several useful methods from the Object class. Some of the most commonly used ones are:

2.1. clone() Method

• Returns a shallow copy of the array.
• Used when we are copying an array.

2.2. toString() Method

• Returns the string representation of the array object’s reference to memory (not the contents).
• We use Arrays.toString() to print an array properly.

Example: Using toString()

Output:

Always use Arrays.toString() to correctly print arrays instead of normal methods.

Cloning of Arrays

Array cloning in Java generally allows us to create a separate copy of an array. Java typically provides an inbuilt method called clone() to do so. However, cloning is performed differently for one-dimensional and multi-dimensional arrays.

1. Cloning a One-Dimensional Array (Shallow Copy)

For 1D arrays, the clone() method creates a new array but only copies values, not references.

Example: Cloning a One-Dimensional Array

Output:

Shallow Copy: The original array is left unchanged, so the primitive types are individually copied.

2. Cloning a Multi-Dimensional Array (Shallow Copy)

In 2D arrays, the operation clone() only makes a copy in the first dimension, and the inner arrays still reference the original locations.

Example: Cloning a 2D Array

Output:

Problem with Shallow Copy: Changing the clonedArray will reflect in the original, as only the outer array is being copied and the inner arrays contain reference pointers.

3. Deep Cloning of a Multi-Dimensional Array

We have to copy every row manually through a loop to achieve an exact deep copy.

Example: Deep Cloning a 2D Array

Output:

Deep Copy: Modifications to deepClonedArray do not affect the original array anymore.

Advanced Topics in Java Arrays

Besides the basic operations and different types of arrays, several advanced concepts in Java can significantly add to the application of arrays. These concepts provide more insight into performance tuning, handling memory, multithreading, and functional programming with arrays.

1. Sparse Arrays

A sparse array is an array where most of the elements are simply null (or zero in the case of numerical arrays). Instead of keeping large arrays with most elements being empty, sparse arrays typically conserve memory by simply keeping only non-zero elements in data structures like hash tables or lists.

Example: Using a HashMap for Sparse Arrays

Output:

Why sparse arrays? Because they save memory when working with large sets with lots of default values (null or zeros).

2. Dynamic Arrays (Using ArrayList as a Flexible Alternative)

Java arrays are generally fixed in size and so are not efficient when the resizing operation is performed. Dynamic arrays, like ArrayList in Java, are a very flexible alternative where size is simply increased dynamically.

Example: Using ArrayList Instead of Arrays

Output:

ArrayList grows dynamically, unlike arrays, and is hence more suitable when working with variable-length data.

3. Multithreading with Arrays

In a multithreaded system, multiple threads can simply access or modify an array simultaneously. Without synchronization, there is a chance of data inconsistency and race conditions.

Example: Using Synchronized Blocks for Thread-Safe Arrays

Output:

Synchronization simply prevents simultaneous threads from corrupting common array data.

4. Memory Management in Arrays

Arrays generally occupy contiguous memory in Java Programming Language. Knowing how Java allocates arrays in memory is very important to optimize the overall performance.

Important Memory Features of Arrays

• Primitive vs Object Storage
  • Arrays of primitives (e.g., int[]) hold real values in memory.
  • Arrays of objects (for example, String[]) hold references, but the data is in the heap.
• Garbage Collection and Unused Arrays
  • Once an array is no longer in use, it is ready to be garbage collected.

Example: Garbage Collection for Unused Arrays

Output:

Heap usage is reduced by minimizing array handling.

5. Performance Comparison: Arrays vs. Other Data Structures

Utilize arrays for rapid access, ArrayList for dynamic resizing, and LinkedList for constant additions/deletions.

6. Functional Programming with Arrays (Streams API)

The Java Streams API allows functional programming with arrays, leading to clearer and more effective code.

Example: Filtering Even Numbers Using Streams

Output:

Streams API offers a more readable syntax for operations such as filtering, mapping, and reducing data.

Advantages and Disadvantages of Arrays in Java

Advantages of Arrays

1. Fast Access (O(1)): Accessing Arrays in Java is of constant time because there is direct indexing.
2. Effective Memory Use: Supports contiguous memory allocation, reducing overhead.
3. Cache-friendly: Arrays are better suited to CPU caching because they have sequential memory allocation.
4. Simpler to implement: Less complex to use than linked lists to hold fixed-size data.
5. Better performance with small data sets: There is no extra memory usage as in ArrayList or LinkedList.

Disadvantages of Arrays

1. Fixed Size: You cannot dynamically resize the arrays, you must specify length when created. Costly Insertion/Deletion: Shifting elements in an array is O(N) in time complexity.
2. Waste Memory: When prefilled with excess space, empty slots take up memory.
3. Limited Built-in Methods: Lacks operations like dynamic resizing, direct sorting, and searching (unlike ArrayList).
4. Not Thread-Safe: Requires synchronization in multithreaded applications.

Conclusion

With this, you have come to the end of this Java Arrays Tutorial. We have learned that Arrays in Java are a primitive data type that generally provides storage and fast access to elements. They typically provide fixed-size, contiguous storage in memory, and they are best utilized in programs where high-performance access and predictable use are required.

With the help of sparse arrays, streams, and dynamic alternatives, one can achieve maximum performance while keeping code simple. To write optimized and scalable applications, one must master Java arrays.

int[] numbers = {10, 20, 30};  
System.out.println(numbers.length); // Output: 3