It is the implementation class of List Interface. It allows duplicated objects/elements and as well as maintains the insertion order. You can get the element present inside the ArrayList by the index of it now you need to pass it into the getting (index) method. You can add the elements into ArrayList using the add() method.
Syntax: ArrayList Initialization
ArrayList<Integer> gfg=new ArrayList<>();
Copying Elements of one ArrayList to another ArrayList
There are two approaches first you actually just need to pass the reference of one ArrayList to another and in this case, if you change in one ArrayList value or element then you can see the same change in another ArrayList. The second approach is where you will create actual duplicates means if you change in one ArrayList Element then it will not reflect in the other one.
Approach 1: Using the assignment operator(=)
In this approach, we will simply assign the first ArrayList reference to the second but there is one important aspect to look at here we did not create a new object we simply pointed the second ArrayList to the first one. So if you make a change in the first ArrayList it will reflect in the second one also because you are using the same object. We can also change one value of one ArrayList and can look for the same in the other one whether it is changed or not.
Syntax:
ArrayList<Integer> gfg=new ArrayList<>(); ArrayList<Integer> gfg2=gfg;
Below is the implementation of the above problem statement.
Java
// Java Program for copying one ArrayList to another import java.io.*; import java.util.ArrayList; class GFG { public static void main(String[] args) { // creation of ArrayList of Integers ArrayList<Integer> gfg = new ArrayList<>(); // adding elements to first ArrayList gfg.add( 10 ); gfg.add( 21 ); gfg.add( 22 ); gfg.add( 35 ); // Assigning the first reference to second ArrayList<Integer> gfg2 = gfg; // Iterating over second ArrayList System.out.println( "-----Iterating over the second ArrayList----" ); for (Integer value : gfg2) { System.out.println(value); } // here we changed the third element to 23 // we changed in second list and you can // see the same change in the first Arraylist gfg2.set( 2 , 23 ); System.out.println( "third element of first list =" + gfg.get( 2 )); System.out.println( "third element of second list =" + gfg2.get( 2 )); } } |
-----Iterating over the second ArrayList---- 10 21 22 35 third element of first list =23 third element of second list =23
Approach 2: Passing in the constructor
In this approach, we will simply pass the first ArrayList in the second ArrayList’s constructor. By using this approach if we change one ArrayList element/value it will not affect the other one, so this is the approach where we actually created the duplicates. We can also change one value of one ArrayList and can look for the same in the other one whether it is changed or not.
Syntax :
ArrayList<Integer> gfg=new ArrayList<>(); ArrayList<Integer> gfg2=new ArrayList<>(gfg);
Below is the implementation of the above problem statement:
Java
// Java Program for copying one ArrayList to another import java.io.*; import java.util.ArrayList; class GFG { public static void main(String[] args) { // creation of ArrayList of Integers ArrayList<Integer> gfg = new ArrayList<>(); // adding elements to first ArrayList gfg.add( 10 ); gfg.add( 21 ); gfg.add( 22 ); gfg.add( 35 ); // passing in the constructor ArrayList<Integer> gfg2 = new ArrayList<>(gfg); // Iterating over second ArrayList System.out.println( "-----Iterating over the second ArrayList----" ); for (Integer value : gfg2) { System.out.println(value); } // here we changed the third element to 23 // we changed in second list and you can // here we will not see the same change in the first gfg2.set( 2 , 23 ); System.out.println( "third element of first list =" + gfg.get( 2 )); System.out.println( "third element of second list =" + gfg2.get( 2 )); } } |
-----Iterating over the second ArrayList---- 10 21 22 35 third element of first list =22 third element of second list =23
Approach 3: Adding one by one using add() method
In this approach, we will iterate over each element of the first ArrayList and add that element in the second ArrayList. Here if you change first ArrayList element then it will not change the elements of the second ArrayList. We can also change one value of one ArrayList and can look for the same in the other one whether it is changed or not.
Syntax :
ArrayList<Integer> gfg=new ArrayList<>(); ArrayList<Integer> gfg2=new ArrayList<>(); for(Integer val: gfg){ gfg2.add(val); }
Below is the implementation of the above problem statement:
Java
// Java Program for copying one ArrayList to another import java.io.*; import java.util.ArrayList; class GFG { public static void main(String[] args) { // creation of ArrayList of Integers ArrayList<Integer> gfg = new ArrayList<>(); // adding elements to first ArrayList gfg.add( 10 ); gfg.add( 21 ); gfg.add( 22 ); gfg.add( 35 ); ArrayList<Integer> gfg2 = new ArrayList<>(); // adding element to the second ArrayList // by iterating over one by one for (Integer value : gfg) { gfg2.add(value); } // Iterating over second ArrayList System.out.println( "-----Iterating over the second ArrayList----" ); for (Integer value : gfg2) { System.out.println(value); } // here we changed the third element to 23 // we changed in second list // here we will not see the same change in the first gfg2.set( 2 , 23 ); System.out.println( "third element of first list =" + gfg.get( 2 )); System.out.println( "third element of second list =" + gfg2.get( 2 )); } } |
-----Iterating over the second ArrayList---- 10 21 22 35 third element of first list =22 third element of second list =23
Approach 4: Using addAll() method
The addAll() method is used to add all the elements from one ArrayList to another ArrayList. For this implementation, we have to import the package java.util.*.
Step 1: Declare the ArrayList 1 and add the values to it.
Step 2: Create another ArrayList 2 with the same type.
Step 3: Now, simply add the values from one ArrayList to another by using the method addAll(). Specify ArrayList2.addAll(ArrayList1).
Step 4: Now, print the ArrayList 2.
Java
import java.util.*; class GFG { public static void main(String[] args) { ArrayList<String> AL1 = new ArrayList<>(); AL1.add( "geeks" ); AL1.add( "forgeeks" ); AL1.add( "learning" ); AL1.add( "platform" ); ArrayList<String> AL2 = new ArrayList<>(); AL2.addAll(AL1); System.out.println( "Original ArrayList : " + AL1); System.out.println( "Copied ArrayList : " + AL2); } } |
Original ArrayList : [geeks, forgeeks, learning, platform] Copied ArrayList : [geeks, forgeeks, learning, platform]
Approach 5 : Using List.copyOf() method
List.copyOf() method is used to add the elements of one ArrayList to another. To use this method, we have to import the package java.util.List.* or java.util.* . It is a static factory method.
Step 1: Declare the ArrayList 1 and add the values to it.
Step 2: Create another ArrayList 2 with the same type.
Step 3: Now, simply add the values from one ArrayList to another by using the method List.copyOf(). Specify List.copyOf(ArrayList1) in the constructor of newly created ArrayList 2.
Step 4: Now, print the ArrayList 2.
Java
import java.util.*; class GFG { public static void main(String[] args) { ArrayList<String> AL1 = new ArrayList<>(); AL1.add( "geeks" ); AL1.add( "forgeeks" ); AL1.add( "learning" ); AL1.add( "platform" ); ArrayList<String> AL2 = new ArrayList<>(List.copyOf(AL1)); System.out.println( "Original ArrayList : " + AL1); System.out.println( "Copied Arraylist : " + AL2); } } |
Original ArrayList : [geeks, forgeeks, learning, platform] Copied Arraylist : [geeks, forgeeks, learning, platform]
Time complexity: O(N) where N is the size of ArrayList
Auxiliary Space: O(N)
Approach 6 : Using clone() method
In java, clone() method is used to copy an entire object values without any side effects to the objects.
Step 1: Declare the ArrayList 1 and add the values to it.
Step 2: Create another ArrayList 2 with the same type.
Step 3: Now, simply add the values from one ArrayList to another by using the method object.clone(). Specify reference type before the clone() method for type casting.
Step 4: Now, print the ArrayList 2.
Java
/*package whatever //do not write package name here */ import java.util.*; import java.io.*; class GFG { public static void main (String[] args) { ArrayList<String> AL1 = new ArrayList<>(); AL1.add( "geeks" ); AL1.add( "forgeeks" ); AL1.add( "learning" ); AL1.add( "platform" ); ArrayList<String> AL2= new ArrayList<>(); AL2 = (ArrayList)AL1.clone(); System.out.println( "Original ArrayList : " + AL1); System.out.println( "Copied Arraylist : " + AL2); } } |
Output :
Original ArrayList : [geeks, forgeeks, learning, platform]
Copied Arraylist : [geeks, forgeeks, learning, platform]