How to Add Elements to an Arraylist in Java Dynamically?

Java, being a versatile and widely-used programming language, provides several data structures to manage and manipulate collections of data. One of the most commonly used data structures is the ArrayList. The ArrayList is a part of the Java Collections Framework and provides dynamic resizing, making it a flexible choice for storing and managing elements. In this section, we will explore how to add elements to an ArrayList dynamically in Java.

ArrayList in Java

Before delving into dynamic element addition, let's understand the basics of ArrayList. An ArrayList is a resizable array implementation of the List interface. It allows us to add, remove, and access elements based on their index. Unlike arrays, ArrayLists can dynamically grow or shrink in size as elements are added or removed.

To use ArrayList in Java, you need to import the java.util package:

Here's how you can declare an ArrayList:

It creates an ArrayList capable of holding strings. The <String> is a generic type parameter, indicating the type of elements that the ArrayList will contain. Generics provide compile-time type safety.

Adding Elements to an ArrayList

1. Adding Elements One by One

The simplest way to add elements to an ArrayList is to use the add method. Here's an example:

AddOneByOne.java

import java.util.ArrayList;
public class AddOneByOne {
    public static void main(String[] args) {
        ArrayList<String> stringList = new ArrayList<>();
        stringList.add("Java");
        stringList.add("is");
        stringList.add("powerful");
        stringList.add("!");
        System.out.println(stringList);
    }
}

Output:

[Java, is, powerful, !]

The add method appends the specified element to the end of the ArrayList.

2. Adding Elements at a Specific Index

You can also add elements at a specific index using the add method:

AddAtIndex.java

import java.util.ArrayList;
public class AddAtIndex {
    public static void main(String[] args) {
        ArrayList<String> stringList = new ArrayList<>();
        stringList.add("Java");
        stringList.add("is");
        stringList.add("powerful");
        stringList.add("!");
        stringList.add(2, "and");
        System.out.println(stringList);
    }
} 

Output:

[Java, is, and, powerful, !]

This inserts the element "and" at index 2, shifting the existing elements to the right.

3. Adding Another Collection

If we have another collection, such as an array or another ArrayList, we can add all its elements to an ArrayList using the addAll method:

AddAnotherCollection.java

import java.util.ArrayList;
public class AddAnotherCollection {
    public static void main(String[] args) {
        ArrayList<String> stringList = new ArrayList<>();
        stringList.add("Java");
        stringList.add("is");
        stringList.add("powerful");
        stringList.add("!");
        ArrayList<String> anotherList = new ArrayList<>();
        anotherList.add("ArrayList");
        anotherList.add("can");
        anotherList.add("handle");
        anotherList.add("collections");
        stringList.addAll(anotherList);
        System.out.println(stringList);
    }
} 

Output:

[Java, is, and, powerful, !, ArrayList, can, handle, collections]

Dynamic Element Addition

Dynamic element addition refers to the scenario where elements are added to an ArrayList during runtime, based on user input or other dynamic conditions. Let's explore various ways to achieve dynamic addition:

1. User Input

UserInput.java

import java.util.ArrayList;
import java.util.Scanner;
public class UserInput {
    public static void main(String[] args) {
        ArrayList<String> stringList = new ArrayList<>();
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter a string to add to the list: ");
        String userInput = scanner.nextLine();
        stringList.add(userInput);
        System.out.println(stringList);
    }
} 

Output:

Enter a string to add to the list: manoj
[manoj]

This code snippet prompts the user to enter a string, and the entered string is then added to the ArrayList.

2. Looping for Multiple Additions

Using loops allows you to add multiple elements dynamically. For example, adding five integers to an ArrayList:

LoopingForMultipleAdditions.java

import java.util.ArrayList;
import java.util.Scanner;
public class LoopingForMultipleAdditions {
    public static void main(String[] args) {
        ArrayList<Integer> intList = new ArrayList<>();
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < 5; i++) {
            System.out.print("Enter an integer to add to the list: ");
            int userInput = scanner.nextInt();
            intList.add(userInput);
        }
        System.out.println(intList);
    }
}

Output:

[1, 2, 3, 4, 5]

The loop iterates five times, adding an integer to the ArrayList in each iteration.

3. Dynamic Size Determination

If we don't know the size of the ArrayList beforehand, we can dynamically determine it during runtime:

DynamicSizeDetermination.java

import java.util.ArrayList;
import java.util.Scanner;
public class DynamicSizeDetermination {
    public static void main(String[] args) {
        ArrayList<Double> doubleList = new ArrayList<>();
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter the number of elements to add: ");
        int size = scanner.nextInt();
        for (int i = 0; i < size; i++) {
            System.out.print("Enter a double to add to the list: ");
            double userInput = scanner.nextDouble();
            doubleList.add(userInput);
        }
        System.out.println(doubleList);
    }
} 

Output:

[1.5, 2.5, 3.5]

This example first asks the user for the number of elements they want to add and then uses a loop to add the specified number of elements to the ArrayList.

4. Adding Elements Based on a Condition

We might need to add elements based on certain conditions. Here's an example that adds even numbers to an ArrayList:

AddBasedOnCondition.java

import java.util.ArrayList;
public class AddBasedOnCondition {
    public static void main(String[] args) {
        ArrayList<Integer> evenList = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) {
                evenList.add(i);
            }
        }
        System.out.println(evenList);
    }
} 

Output:

[2, 4, 6, 8, 10]

The program adds even numbers from 1 to 10 to the ArrayList.

Adding elements to an ArrayList dynamically in Java provides flexibility and adaptability to changing requirements. Whether you are adding elements based on user input, conditions, or dynamic size determination, the ArrayList's dynamic nature makes it a powerful tool for managing collections of data.

Understanding these techniques will empower you to write more dynamic and responsive Java applications. Experiment with the examples provided and incorporate dynamic element addition into your Java programming repertoire.

Next TopicHow to Add Splash Screen in Java

← prev next →