Es la clase de implementación de List Interface. Permite duplicar objetos/elementos y además mantiene el orden de inserción. Puede obtener el elemento presente dentro de ArrayList por su índice, ahora necesita pasarlo al método de obtención (índice). Puede agregar los elementos a ArrayList usando el método add().
Sintaxis: Inicialización de ArrayList
ArrayList<Integer> gfg=new ArrayList<>();
Copiar elementos de un ArrayList a otro ArrayList
Hay dos enfoques: primero, solo necesita pasar la referencia de un ArrayList a otro y, en este caso, si cambia un valor o elemento de ArrayList, puede ver el mismo cambio en otro ArrayList. El segundo enfoque es donde creará duplicados reales, lo que significa que si cambia en un elemento ArrayList, entonces no se reflejará en el otro.
Enfoque 1: Uso del operador de asignación (=)
En este enfoque, simplemente asignaremos la primera referencia de ArrayList a la segunda, pero hay un aspecto importante a tener en cuenta aquí: no creamos un nuevo objeto, simplemente apuntamos la segunda ArrayList a la primera. Entonces, si realiza un cambio en el primer ArrayList, también se reflejará en el segundo porque está usando el mismo objeto. También podemos cambiar un valor de una ArrayList y podemos buscar lo mismo en la otra ya sea que se cambie o no.
Sintaxis:
ArrayList<Integer> gfg=new ArrayList<>(); ArrayList<Integer> gfg2=gfg;
A continuación se muestra la implementación del enunciado del problema anterior.
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
Enfoque 2: pasar el constructor
En este enfoque, simplemente pasaremos la primera ArrayList en el constructor de la segunda ArrayList. Al usar este enfoque, si cambiamos un elemento/valor de ArrayList, no afectará al otro, por lo que este es el enfoque en el que realmente creamos los duplicados. También podemos cambiar un valor de una ArrayList y podemos buscar lo mismo en la otra ya sea que se cambie o no.
Sintaxis:
ArrayList<Integer> gfg=new ArrayList<>(); ArrayList<Integer> gfg2=new ArrayList<>(gfg);
A continuación se muestra la implementación del enunciado del problema anterior:
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
Enfoque 3: Agregar uno por uno usando el método add()
En este enfoque, iteraremos sobre cada elemento del primer ArrayList y agregaremos ese elemento en el segundo ArrayList. Aquí, si cambia el primer elemento ArrayList, no cambiará los elementos del segundo ArrayList. También podemos cambiar un valor de una ArrayList y podemos buscar lo mismo en la otra ya sea que se cambie o no.
Sintaxis:
ArrayList<Integer> gfg=new ArrayList<>();
ArrayList<Integer> gfg2=new ArrayList<>();
for(Integer val: gfg){
gfg2.add(val);
}
A continuación se muestra la implementación del enunciado del problema anterior:
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
Enfoque 4: Usar el método addAll()
El método addAll() se usa para agregar todos los elementos de un ArrayList a otro ArrayList. Para esta implementación, tenemos que importar el paquete java.util.*.
Paso 1: declarar ArrayList 1 y agregarle los valores.
Paso 2: Cree otra ArrayList 2 con el mismo tipo.
Paso 3: Ahora, simplemente agregue los valores de un ArrayList a otro usando el método addAll(). Especifique ArrayList2.addAll(ArrayList1).
Paso 4: Ahora, imprime el 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]
Enfoque 5: Usar el método List.copyOf()
El método List.copyOf() se usa para agregar los elementos de un ArrayList a otro. Para usar este método, debemos importar el paquete java.util.List.* o java.util.* . Es un método de fábrica estático.
Paso 1: declarar ArrayList 1 y agregarle los valores.
Paso 2: Cree otra ArrayList 2 con el mismo tipo.
Paso 3: Ahora, simplemente agregue los valores de un ArrayList a otro usando el método List.copyOf(). Especifique List.copyOf(ArrayList1) en el constructor de ArrayList 2 recién creado.
Paso 4: Ahora, imprime el 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]
Complejidad de tiempo : O(N) donde N es el tamaño de ArrayList
Espacio Auxiliar: O(N)
Publicación traducida automáticamente
Artículo escrito por rajatagrawal5 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA