AbstractCollection addAll() Method in Java with Examples

The addAll() method under the Collections Framework is essential for mass addition of elements from one collection to another and this method is implemented in the AbstractCollection class which is under java. It belongs to the util package, and acts as skeletal implementation of the Collection interface. In AbstractCollection, addAll() method is implemented by making a simple iteration of the specified collection and invoking the add() method for each element it contains. It implies that the behavior and efficiency of the addAll() operation depend directly upon the behavior of the add() operation.

Method Signature

Return Type: boolean: The method returns true/false; a boolean value. It returns true if the collection was changed, that is if one or more elements in the specified collection were successfully added to the set; returns false if the collection was not changed that can be due to several reasons including if the specified collection contained no elements or if the elements in the specified collection are already in the set and the set class does not allow for duplicate elements.

Collection: It indicates that the method accepts a collection of elements. Collection is the root interface in the Java Collections Framework, which means that addAll() can accept any type of collection (like List, Set, Queue, etc.).

<? extends E>: It is a bounded wildcard. It means that the collection can contain elements that are of type E or any subtype of E and this wildcard allows for flexibility. For example, if E is Number, the collection passed to addAll() could contain Integer, Double, or any other subclass of Number.

Example 1: Using ArrayList

In this example, we create an ArrayList abs1Strings to hold strings elements.

Filename: AbstractCollectionArrayListDemo.java

import java.util.AbstractCollection;
import java.util.ArrayList;
public class AbstractCollectionArrayListDemo {
    public static void main(String args[]) {
        // Creating an empty ArrayList for Strings
        AbstractCollection<String> abs1Strings = new ArrayList<>();
        // Adding elements into the String ArrayList
        abs1Strings.add("Apple");
        abs1Strings.add("Banana");
        abs1Strings.add("Cherry");
        // Displaying the String ArrayList
        System.out.println("AbstractCollection 1 (Strings): " + abs1Strings);
        // Creating an empty ArrayList for Integers
        AbstractCollection<Integer> abs1Integers = new ArrayList<>();
        // Adding elements into the Integer ArrayList
        abs1Integers.add(10);
        abs1Integers.add(20);
        abs1Integers.add(30);
        // Displaying the Integer ArrayList
        System.out.println("AbstractCollection 1 (Integers): " + abs1Integers);
        // Creating an empty ArrayList for Doubles
        AbstractCollection<Double> abs1Doubles = new ArrayList<>();
        // Adding elements into the Double ArrayList
        abs1Doubles.add(3.14);
        abs1Doubles.add(6.28);
        abs1Doubles.add(9.42);
        // Displaying the Double ArrayList
        System.out.println("AbstractCollection 1 (Doubles): " + abs1Doubles);
        // Creating another ArrayList for Strings
        AbstractCollection<String> abs2Strings = new ArrayList<>();
        // Appending elements from abs1Strings to abs2Strings using addAll()
        abs2Strings.addAll(abs1Strings);
        // Displaying the String ArrayList after using addAll()
        System.out.println("AbstractCollection 2 (Strings) after addAll: " + abs2Strings);
        // Creating another ArrayList for Integers
        AbstractCollection<Integer> abs2Integers = new ArrayList<>();
        // Appending elements from abs1Integers to abs2Integers using addAll()
        abs2Integers.addAll(abs1Integers);
        // Displaying the Integer ArrayList after using addAll()
        System.out.println("AbstractCollection 2 (Integers) after addAll: " + abs2Integers);
        // Creating another ArrayList for Doubles
        AbstractCollection<Double> abs2Doubles = new ArrayList<>();
        // Appending elements from abs1Doubles to abs2Doubles using addAll()
        abs2Doubles.addAll(abs1Doubles);
        // Displaying the Double ArrayList after using addAll()
        System.out.println("AbstractCollection 2 (Doubles) after addAll: " + abs2Doubles);
    }
}

Output:

AbstractCollection 1 (Strings): [Apple, Banana, Cherry]
AbstractCollection 1 (Integers): [10, 20, 30]
AbstractCollection 1 (Doubles): [3.14, 6.28, 9.42]
AbstractCollection 2 (Strings) after addAll: [Apple, Banana, Cherry]
AbstractCollection 2 (Integers) after addAll: [10, 20, 30]
AbstractCollection 2 (Doubles) after addAll: [3.14, 6.28, 9.42]

Example 2: Using HashSet

In this example, we create a HashSet abs1Strings to hold strings elements.

Filename: AbstractCollectionHashSetDemo.java

import java.util.AbstractCollection;
import java.util.HashSet;
public class AbstractCollectionHashSetDemo {
    public static void main(String args[]) {
        // Creating an empty HashSet for Strings
        AbstractCollection<String> abs1Strings = new HashSet<>();
        // Adding elements into the String HashSet
        abs1Strings.add("Apple");
        abs1Strings.add("Banana");
        abs1Strings.add("Cherry");
        // Displaying the String HashSet
        System.out.println("AbstractCollection 1 (Strings): " + abs1Strings);
        // Creating an empty HashSet for Integers
        AbstractCollection<Integer> abs1Integers = new HashSet<>();
        // Adding elements into the Integer HashSet
        abs1Integers.add(10);
        abs1Integers.add(20);
        abs1Integers.add(30);
        // Displaying the Integer HashSet
        System.out.println("AbstractCollection 1 (Integers): " + abs1Integers);
        // Creating an empty HashSet for Doubles
        AbstractCollection<Double> abs1Doubles = new HashSet<>();
        // Adding elements into the Double HashSet
        abs1Doubles.add(3.14);
        abs1Doubles.add(6.28);
        abs1Doubles.add(9.42);
        // Displaying the Double HashSet
        System.out.println("AbstractCollection 1 (Doubles): " + abs1Doubles);
        // Creating another HashSet for Strings
        AbstractCollection<String> abs2Strings = new HashSet<>();
        // Merging elements from abs1Strings to abs2Strings using addAll()
        abs2Strings.addAll(abs1Strings);
        // Displaying the String HashSet after using addAll()
        System.out.println("AbstractCollection 2 (Strings) after addAll: " + abs2Strings);
        // Creating another HashSet for Integers
        AbstractCollection<Integer> abs2Integers = new HashSet<>();
        // Merging elements from abs1Integers to abs2Integers using addAll()
        abs2Integers.addAll(abs1Integers);
        // Displaying the Integer HashSet after using addAll()
        System.out.println("AbstractCollection 2 (Integers) after addAll: " + abs2Integers);
        // Creating another HashSet for Doubles
        AbstractCollection<Double> abs2Doubles = new HashSet<>();
        // Merging elements from abs1Doubles to abs2Doubles using addAll()
        abs2Doubles.addAll(abs1Doubles);
        // Displaying the Double HashSet after using addAll()
        System.out.println("AbstractCollection 2 (Doubles) after addAll: " + abs2Doubles);
    }
}

Output:

AbstractCollection 1 (Strings): [Apple, Cherry, Banana]
AbstractCollection 1 (Integers): [20, 10, 30]
AbstractCollection 1 (Doubles): [3.14, 6.28, 9.42]
AbstractCollection 2 (Strings) after addAll: [Apple, Cherry, Banana]
AbstractCollection 2 (Integers) after addAll: [20, 10, 30]
AbstractCollection 2 (Doubles) after addAll: [3.14, 6.28, 9.42]

Example 3: Using LinkedList

In this example, we create a LinkedList abs1Strings to hold strings elements.

Filename: AbstractCollectionLinkedListDemo.java

import java.util.AbstractCollection;
import java.util.LinkedList;
public class AbstractCollectionLinkedListDemo {
    public static void main(String args[]) {
        // Creating an empty LinkedList for Strings
        AbstractCollection<String> abs1Strings = new LinkedList<>();
        // Adding elements into the String LinkedList
        abs1Strings.add("Monday");
        abs1Strings.add("Tuesday");
        abs1Strings.add("Wednesday");
        // Displaying the String LinkedList
        System.out.println("AbstractCollection 1 (Strings): " + abs1Strings);
        // Creating an empty LinkedList for Integers
        AbstractCollection<Integer> abs1Integers = new LinkedList<>();
        // Adding elements into the Integer LinkedList
        abs1Integers.add(1);
        abs1Integers.add(2);
        abs1Integers.add(3);
        // Displaying the Integer LinkedList
        System.out.println("AbstractCollection 1 (Integers): " + abs1Integers);
        // Creating an empty LinkedList for Doubles
        AbstractCollection<Double> abs1Doubles = new LinkedList<>();
        // Adding elements into the Double LinkedList
        abs1Doubles.add(3.14);
        abs1Doubles.add(6.28);
        abs1Doubles.add(9.42);
        // Displaying the Double LinkedList
        System.out.println("AbstractCollection 1 (Doubles): " + abs1Doubles);
        // Creating another LinkedList for Strings
        AbstractCollection<String> abs2Strings = new LinkedList<>();
        // Appending elements from abs1Strings to abs2Strings using addAll()
        abs2Strings.addAll(abs1Strings);
        // Displaying the String LinkedList after using addAll()
        System.out.println("AbstractCollection 2 (Strings) after addAll: " + abs2Strings);
        // Creating another LinkedList for Integers
        AbstractCollection<Integer> abs2Integers = new LinkedList<>();
        // Appending elements from abs1Integers to abs2Integers using addAll()
        abs2Integers.addAll(abs1Integers);
        // Displaying the Integer LinkedList after using addAll()
        System.out.println("AbstractCollection 2 (Integers) after addAll: " + abs2Integers);
        // Creating another LinkedList for Doubles
        AbstractCollection<Double> abs2Doubles = new LinkedList<>();
        // Appending elements from abs1Doubles to abs2Doubles using addAll()
        abs2Doubles.addAll(abs1Doubles);
        // Displaying the Double LinkedList after using addAll()
        System.out.println("AbstractCollection 2 (Doubles) after addAll: " + abs2Doubles);
    }
}

Output:

AbstractCollection 1 (Strings): [Monday, Tuesday, Wednesday]
AbstractCollection 1 (Integers): [1, 2, 3]
AbstractCollection 1 (Doubles): [3.14, 6.28, 9.42]
AbstractCollection 2 (Strings) after addAll: [Monday, Tuesday, Wednesday]
AbstractCollection 2 (Integers) after addAll: [1, 2, 3]
AbstractCollection 2 (Doubles) after addAll: [3.14, 6.28, 9.42]

Applications

1. Data Processing and Aggregation

In data processing applications, you might need to aggregate data from multiple sources or stages of processing. The addAll() method simplifies this task by allowing you to combine the results into a single collection.

2. Concurrency and Parallel Processing

In concurrent or parallel processing scenarios, you may have multiple threads producing data concurrently. The addAll() method provides a thread-safe way to combine the data into a shared collection.

3. Data Migration and Integration

During data migration or integration tasks, you might need to transfer data between different systems or formats. The addAll() method facilitates this process by enabling you to merge data from various sources into a unified collection.

Next TopicChecking-if-two-words-are-present-in-a-string-in-java

← prev next →