ArrayList in Java

Arrays in Java have a fixed size that needs to be specified at the time of declaration. This can be inconvenient when the number of elements to be stored in the array is not known beforehand. Java provides a class called ArrayList that implements something called a dynamic array. ArrayList allows storage of any number of elements, adding elements dynamically as needed.

If you don’t have a medium membership, you can use this link to reach the article without a paywall.

What is ArrayList?

ArrayList is a class in Java that implements a dynamic array data structure. ArrayList is a part of the Java Collections Framework and it is a class that implements the List interface. It provides all the benefits of a traditional array in terms of storing and accessing elements by index, but with the added flexibility of being able to grow and shrink in size as needed.

Unlike traditional arrays, ArrayLists can dynamically resize themselves to accommodate varying numbers of elements. This flexibility makes ArrayLists incredibly versatile and widely used in Java programming.

Understanding the Essentials

• Dynamic Nature: Unlike traditional arrays with fixed sizes, ArrayLists can grow or shrink on demand, adapting to your data’s needs. This flexibility eliminates the need for manual array resizing, preventing potential errors and memory management issues.
• List Interface Implementation: ArrayLists conform to the List interface, providing a standardized set of methods for accessing, modifying, and iterating over elements. This consistency simplifies code interaction with different list implementations.
• Internal Workings: Internally, ArrayLists utilize an array to store elements. When the array fills up, a new, larger array is created, and elements are copied over. This resizing mechanism ensures scalability but can introduce performance implications, which we’ll explore later.

Declaring an ArrayList

To use ArrayList, you need to import the java.util package. Here is how you would declare an ArrayList object:

import java.util.ArrayList; 

ArrayList<Type> listName = new ArrayList<>();

The ArrayList constructor allocates an empty array internally to store elements. The angle brackets <> specify the data type of elements in the list. Common data types used with ArrayLists are String, Integer, Double etc.

In the above example, Type denotes the type of elements that the ArrayList will contain, and listName is the identifier assigned to the ArrayList instance. The angle brackets (<>) represent generics, allowing ArrayLists to store elements of a specific type.

Adding Elements to ArrayList

The add() method is used to append elements to an ArrayList:

ArrayList<String> fruits = new ArrayList<>();
fruits.add("Apple"); 
fruits.add("Orange");
fruits.add("Banana");

The add method adds elements to the end of the list sequentially. The list size increases dynamically as it adds elements.

Accessing Elements in ArrayList

Elements can be accessed by their index, just like a traditional array. Here, index denotes the position of the element within the ArrayList, starting from 0. So, the index of the first element in an ArrayList is 0

String fruit = fruits.get(0); // Apple

The index must be within bounds, or the method throws an IndexOutOfBoundsException

You can also modify an existing element:

fruits.set(0, "Strawberry");

This changes the first element to Strawberry.

Removing Elements from ArrayList

ArrayLists allow for the removal of elements based on their values or indices. To remove a specific element, you can use the remove() method:

fruits.remove(0); // Remove first element

This shifts any subsequent elements to the left.

You can also remove by object reference:

fruits.remove("Orange");

This removes the Orange from the list. If the ArrayList contains multiple occurrences of the element, it removes only the first occurrence of the element.

To remove all elements, use clear():

fruits.clear();

The list size is reset to zero, but internal array remains allocated.

ArrayList’s Size and Iteration

The size() method returns the number of elements currently in the ArrayList:

int numFruits = fruits.size();

To iterate over the list, you can use a standard for loop:

for (int i = 0; i < fruits.size(); i++) {
  System.out.println(fruits.get(i)); 
}

Or you can use the enhanced for-each style loop:

for (String fruit : fruits) {
  System.out.println(fruit);
}

The for-each loop hides the array indexing, directly giving you access to the elements.

Moreover, You can use functional programing approach and iterate over the list with stream() or foreach() methods.

Sorting and Searching an ArrayList

ArrayList does not provide any sorting functionality. However, You can use Collections.sort(list) method to sort an ArrayList in ascending order.

Collections.sort(list);

If you want to have the list sorted in descending order. You can use Collections.sort(list, Collections.reverseOrder()) method

Collections.sort(list, Collections.reverseOrder());  

Another way to sort an ArrayList is by converting it to an array. You can convert the list first to an array using toArray(), then use Arrays.sort():

String[] fruitArray = fruits.toArray(new String[fruits.size()]);
Arrays.sort(fruitArray);

To check if an ArrayList contains a particular value, use indexOf():

if (fruits.indexOf("Mango") != -1) {
  // Found Mango
} else {
  // Mango not found
}

indexOf() returns the index of first occurrence of the element, or -1 if not found.

Useful ArrayList Methods

Here are some other useful methods provided by the ArrayList class:

• isEmpty() — Returns true if list size is 0
• contains(obj) — Returns true if list contains obj
• toArray() — Converts list to array
• trimToSize() — Trims internal array to current list size
• ensureCapacity(int) — Increases capacity if needed

ArrayList provides a flexible, responsive and efficient resizable array implementation for Java. With features like dynamic sizing, easy insertions and deletions, sorting/searching methods, it should be your default choice in place of traditional Java arrays in most scenarios.

👏 Thank You for Reading!

👨‍💼 I appreciate your time and hope you found this story insightful. If you enjoyed it, don’t forget to show your appreciation by clapping 👏 for the hard work!

📰 Keep the Knowledge Flowing by Sharing the Article!

✍ Feel free to share your feedback or opinions about the story. Your input helps me improve and create more valuable content for you.

✌ Stay Connected! 🚀 For more engaging articles, make sure to follow me on social media:

• Twitter
• Instagram

🔍 Explore More! 📖 Dive into a treasure trove of knowledge at Codimis. There’s always more to learn, and we’re here to help you on your journey of discovery.