Arraylist In Java: Explained Briefly

In the world of Java programming, ArrayList stands as a versatile and essential data structure. ArrayList is part of the Java Collections Framework and is designed to handle collections of objects dynamically. Unlike traditional arrays, ArrayLists offer flexibility in size, making them an indispensable tool for programmers. Read this blog to learn about ArrayList in Java, which includes several examples of how to utilise HTML, CSS, JavaScript, SQL, Python, PHP, Bootstrap, Java, and other technologies. 

Table of contents  

1) What is an ArrayList? 

2) How to create an ArrayList 

3) How to add and remove elements 

4) Accessing elements 

5) ArrayList methods 

    a) Common ArrayList methods 

    b) Iterating through an ArrayList 

    c)  Sorting an ArrayList 

6) ArrayList vs. Arrays 

7) When to use ArrayList 

8) Conclusion 

What is an ArrayList? 

An ArrayList is a dynamic array-like data structure in Java that belongs to the Java Collections Framework. It is part of the ‘java.util’ package and provides a flexible and convenient way to store and manipulate a collection of elements. Unlike traditional arrays in Java, ArrayLists can dynamically grow or shrink in size as needed, making them well-suited for scenarios where you need a collection of elements that can change in size. 

Master Java engineering and transform your career – register for our Java Engineer Training now! 

How to Create an ArrayList 

Creating an ArrayList in Java is straightforward. Here's how you can create one: 

Import the ArrayList class:  

Make sure you import the ArrayList class from the java.util package at the top of your Java file: 

import java.util.ArrayList; 

Declare an ArrayList 

Declare a variable of type ArrayList with the data type of the elements you want to store. For example, if you want to create an ArrayList of integers: 

ArrayList myArrayList = new ArrayList(); 

This line creates an empty ArrayList that can hold Integer objects. 

Initialise the ArrayList (optional):  

You can also initialise an ArrayList with initial elements by providing them in the constructor. For example: 

ArrayList names = new ArrayList(Arrays.asList("Alice", "Bob", "Charlie")); 

This line creates an ArrayList of Strings and initialises it with three elements. 

Here's a complete example: 

 

import java.util.ArrayList;  import java.util.Arrays;  public class ArrayListExample {      public static void main(String[] args) {          // Create an empty ArrayList of integers          ArrayList numbers = new ArrayList();          // Initialise an ArrayList of strings with elements          ArrayList names = new ArrayList(Arrays.asList("Alice", "Bob", "Charlie"));      }  }

 

Now you have an ArrayList ready to use, either empty or pre-initialised with data, depending on your requirements. You can start adding, removing, and accessing elements as needed. 

Empower your future with Java Training – Join us today! 

How to add and remove elements 

You can add and remove elements from an ArrayList in Java using various methods provided by the ArrayList class. Here's how to do it: 

Adding elements
 

add () Method  The add () method is used to insert an element at the end of the ArrayList.  ArrayList numbers = new ArrayList();  numbers.add(10); // Add 10 to the end of the ArrayList  numbers.add(20); // Add 20 to the end  add(index, element) Method

 

You can specify the index at which you want to insert an element using the add(index, element) method.
 

ArrayList names = new ArrayList();  names.add("Alice");  names.add("Charlie");  names.add(1, "Bob"); // Insert "Bob" at index 1, shifting "Charlie" to index 2

 

Removing elements

1) remove(index) Method 

You can remove an element at a specific index using the remove(index) method. This method returns the removed element.
 

ArrayList numbers = new ArrayList();  numbers.add(10);  numbers.add(20);  numbers.add(30);  int removed = numbers.remove(1); // Removes and returns the element at index 1 (20)

 

1) remove(object) Method 

You can remove the first occurrence of a specific object using the remove(object) method.
 

ArrayList names = new ArrayList();  names.add("Alice");  names.add("Bob");  names.add("Charlie");  names.remove("Bob"); // Removes the first occurrence of "Bob"

 

1) clear() Method 

To remove all elements and empty the ArrayList, use the clear() method.
 

ArrayList prices = new ArrayList();  prices.add(9.99);  prices.add(19.99);  prices.clear(); // Removes all elements, making the ArrayList empty

 

Accessing elements 

Accessing elements in an ArrayList in Java is straightforward. You can retrieve elements by their index, iterate through the ArrayList, or use various methods provided by the ArrayList class. Here's how you can access elements: 

Accessing elements by index 

You can access elements in an ArrayList by specifying their index, which starts at 0 for the first element and goes up to size() - 1 for the last element. Here's an example:
 

ArrayList fruits = new ArrayList();  fruits.add("Apple");  fruits.add("Banana");  fruits.add("Cherry");    String firstFruit = fruits.get(0); // Access the first element ("Apple")  String secondFruit = fruits.get(1); // Access the second element ("Banana")

 

Iterating through the ArrayList 

You can use loops, such as a for-each loop or a regular for loop, to iterate through all the elements in the ArrayList.
 

Using a For-Each Loop:  for (String fruit : fruits) {      System.out.println(fruit); // This will print each fruit one by one  }  Using a Regular For Loop:  for (int i = 0; i < fruits.size(); i++) {      String fruit = fruits.get(i);      System.out.println(fruit); // This will also print each fruit one by one  }

 

Checking for element existence 

You can check if an element exists in the ArrayList using the contains() method:
 

boolean containsBanana = fruits.contains("Banana");  if (containsBanana) {      System.out.println("The ArrayList contains 'Banana'.");  }

 

Getting the index of an Element 

To find the index of a specific element in the ArrayList, you can use the indexOf() method. It returns the index of the first occurrence of the element, or -1 if the element is not present:
 

int indexOfCherry = fruits.indexOf("Cherry");  if (indexOfCherry != -1) {      System.out.println("The index of 'Cherry' is: " + indexOfCherry);  } else {      System.out.println("'Cherry' is not found in the ArrayList.");  }

 

Remember that when accessing elements by index, be sure to check if the index is within the valid range (0 to size() - 1) to avoid IndexOutOfBoundsException errors. 

ArrayList methods 

Here are some common methods for working with ArrayLists in Java: 

Common ArrayList methods 

1) add(E element): Adds an element to the end of the ArrayList. 

2) add(int index, E element): Inserts an element at the specified index. 

3) get(int index): Retrieves the element at the given index. 

4) set(int index, E element): Replaces the element at the specified index with a new element. 

5) remove(int index): Removes and returns the element at the specified index. 

6) size(): Returns the number of elements in the ArrayList. 

7) isEmpty(): Checks if the ArrayList is empty. 

8) clear(): Removes all elements from the ArrayList. 

Iterating through an ArrayList 

You can iterate through an ArrayList using various loops or enhanced for-each loops. Here's an example using a for-each loop:
 

ArrayList fruits = new ArrayList();  fruits.add("Apple");  fruits.add("Banana");  fruits.add("Cherry");     for (String fruit : fruits) {      System.out.println(fruit);  }

 

You can also use a regular for loop with an index to access elements one by one. 

Sorting an ArrayList 

To sort an ArrayList, you can use the Collections.sort() method, which is a part of the java.util package. Make sure the elements in the ArrayList implement the Comparable interface or provide a custom Comparator for sorting. 

Here's an example of sorting an ArrayList of strings: 

 

import java.util.ArrayList;  import java.util.Collections;    ArrayList fruits = new ArrayList();  fruits.add("Cherry");  fruits.add("Apple");  fruits.add("Banana");    Collections.sort(fruits);   for (String fruit : fruits) {      System.out.println(fruit);  }

 

This code sorts the fruits ArrayList in natural order (lexicographically). If you want to sort in a custom order, you can provide a custom Comparator to the Collections.sort() method. 

These are some of the common ArrayList methods and ways to iterate through and sort an ArrayList in Java. ArrayLists are versatile data structures that offer various methods for manipulating and processing elements. 

ArrayList vs. Arrays 

ArrayLists and arrays are both used to store collections of elements in Java, but they have some key differences that make each suitable for different use cases. Here's a comparison between ArrayLists and arrays: 

ArrayList: 

1) Dynamic Sizing: ArrayLists can dynamically grow or shrink in size, which means you don't need to specify their size when creating them. This makes them more flexible. 

2) Automatic Resizing: When an ArrayList reaches its capacity, it automatically resizes itself, reallocating memory as needed. You don't have to manage this manually. 

3) Add and Remove Elements: Adding and removing elements from an ArrayList is easy, and the ArrayList takes care of resizing. 

4) Type Safety: You can use generics to ensure type safety. For example, ArrayList ensures that only integers are stored. 

5) Methods: ArrayLists provide methods for various operations like adding, removing, sorting, and checking for element existence. 

6) Iterating: You can easily iterate through an ArrayList using loops or iterators. 

Arrays  

1) Fixed size: Arrays have a fixed size, which means you need to specify the size when you create them. Once created, the size cannot be changed. 

2) Manual sizing: You have to manage the array size yourself. If you need more space, you must create a new array with a larger size and copy the elements from the old one. 

3) Efficiency: Arrays can be more memory and time-efficient in some cases because they don't have the overhead of dynamically resizing. 

4) Not type-safe: Arrays are not inherently type-safe. You can store elements of different types in the same array. 

5) No built-in methods: Arrays don't have built-in methods for common operations. You need to write custom code to add, remove, or sort elements. 

6) Iterating: Iterating through arrays is similar to ArrayLists, using loops or indices. 

 

 

When to use ArrayList?


 

ArrayLists are a dynamic and flexible data structure in Java, and they are suitable for a variety of use cases. You should consider using ArrayLists in the following situations: 

1) Dynamic sizing: When you need a collection that can grow or shrink dynamically as elements are added or removed. Unlike arrays, you don't need to specify the size in advance. 

2) Convenience: If you want to use a collection that provides built-in methods for adding, removing, and manipulating elements without writing custom code. 

3) Type safety: If you want to ensure type safety, you can use generics with ArrayLists. For example, you can create an ArrayList to store only integers. 

4) Collections framework: When working with Java's Collections Framework, ArrayList is a part of it and provides a consistent way to work with collections alongside other data structures like LinkedList, HashMap, and HashSet. 

5) Data retrieval and iteration: When you need to access elements by their index or iterate through the elements using loops, such as for-each or for loops. 

6) Avoiding manual memory management: If you want to avoid manual memory management and have the ArrayList automatically handle resizing as needed. 

7) Unknown or variable collection size: When the size of your collection is not known in advance, or when it might change over time. 

8) Working with lists: ArrayList is an excellent choice when you need list-like behavior, such as maintaining an ordered collection of elements. 

9) Ease of use: For quick and easy implementation of dynamic data structures, especially in situations where you don't need low-level memory control. 

10) Compatibility: When you need to work with libraries or APIs that expect collections as input or return values. ArrayList is widely supported in Java libraries and APIs. 

Conclusion 

ArrayLists in Java are a fundamental and flexible data structure that offers numerous advantages for managing collections of elements. They are part of the Java Collections Framework and provide a dynamic, resizable array-like structure, making them a versatile choice for a wide range of applications. 

Ready to elevate your web development skills? Join our Web Development Using Java Training today!