Métodos principales de ArrayList en Java

En este artículo vamos a ver el uso y métodos principales de ArrayList en Java como una herramienta para facilitar y almacenar elementos. Podríamos definir un ArrayList en Java, que se encuentra en el paquete java.util, como un array dinámico que nos permite almacenar elementos, sin un tamaño limitado como podría ser un array.

Un ArrayList implementa la interfaz List lo que nos permite utilizar todos sus métodos.

Principales características de ArrayList

Vamos a enumerar las principales características de ArrayList:

• ArrayList puede contener elementos duplicados, podríamos decir que esta es la clase más importante.
• ArrayList tiene acceso aleatorio debido a que el array trabaja con una base de índices.
• Se mantiene el orden en la insercción.
• No permite uso de synchronized.
• El acceso a un ArrayList va a ser más lento que los accesos a LinkedList.
• Hay que tener en cuenta que no se permite crear ArrayList de tipos primitivos.
• ArrayList extiende de AbstractList e implementa la interfaz List.

ArrayList tiene la siguiente declaración en Java:

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable  

Constructores en ArrayList

Tenemos tres diferentes maneras de instanciar un ArrayList:

Construcción de un ArrayList vacío:

new ArrayList()

Creación de un ArrayList con un tamaño:

new ArrayList(int size)

Construcción de un ArrayList con el tipo del elemento:

ArrayList(Collection<? extends E> c)	

Métodos principales de un ArrayList

Método	Descripción
void add(int index, E element)	Permite añadir un elemento en un posición especifica
boolean addAll(Collection<? extends E> c)	Permite añadir una colección de elementos
boolean add(E e)	Permite añadir un elemento a un ArrayList
boolean addAll(int index, Collection<? extends E> c)	Permite añadir una colección de elementos a partir de una posición en un ArrayList
void clear()	Permite limpiar un ArraList
boolean isEmpty()	Devuelve TRUE si el ArrayList esta vacío
Iterator()	Nos devuelve un iterator sobre los elementos d ela lista
listIterator()	devuelve una lista de iteradores sobre los elementos del ArrayList
E get(int index)	Obtiene el elemento de la posición pasada por parámetro
void ensureCapacity(int requiredCapacity)
int lastIndexOf(Object o)	Devuelve el indíce de la última ocurrencia del elemento. Si el elemento no se encuentra devuelve -1.
Object[] toArray()	It is used to return an array containing all of the elements in this list in the correct order.
Object clone()	Permite realizar el clone de un ArrayList
<T> T[] toArray(T[] a)	Devuelve un array conteniendo todos los elementos de la lista en el orden correcto.
boolean contains(Object o)	Devuelve TRUE si el objeto pasado por parámetro existe
int indexOf(Object o)	Devuelve la posición o índice del objeto pasado por parámetro.
E remove(int index)	Elimina el elemento que ocupa la posición pasada por parámetro.
boolean remove(Object o)	Elimina la primera ocurrencia el elemento pasado por parámetro.
boolean removeAll(Collection<?> c)	Elimina todas las ocurrencias pasadas por parámetro
boolean removeIf(Predicate<? super E> filter)	Elimina todo los elementos que satisfacen el predicado pasado por parámetro
protected void removeRange(int fromIndex, int toIndex)	Elimina los elementos entre un rango pasado por parámetro
void replaceAll(UnaryOperator<E> operator)	Remplaza todos los elementos de la lista con los elementos especificados
void retainAll(Collection<?> c)	Retiene todos los elementos presentes en la colección pasada por parámetro.
E set(int index, E element)	Reemplaza el elemento pasado por parámetro en la posición indicada.
void sort(Comparator<? super E> c)	Permite la ordenación de los elementos de la lista en función del Comparator pasado por parámetro.
Spliterator<E> spliterator()	Nos permite crear un spliterator en la lista
int size()	Nos devuelve el tamaño de la lista
List<E> subList(int fromIndex, int toIndex)	Nos devuelve una sublista entre los valores pasados por parámetro
void trimToSize()	Recorta la capacidad de esta instancia de ArrayList para que tenga el tamaño actual de la lista

Ejemplos de Uso de ArrayList en Java

Construir un ArrayList

List<String> arraylist = new ArrayList(19);

Ejemplo añadir elementos en un ArrayList en Java

List listOfString = new ArrayList();
listOfString.add("hola");
listOfString.add("adios");

List auxListOfString = new ArrayList();
auxListOfString.addAll(listOfString);

Método para conocer si existe un elemento en un ArrayList en Java

List listOfString = new ArrayList();
listOfString.add("hola");

boolean containsHola = listOfString.contains("hola");

Ejemplo eliminar un elemento en un ArrayList en Java

Aplicaremos remove para eliminar un elemento de la lista. Remove devuelve true si se ha eliminado con éxito.

List listOfString = new ArrayList<String>();
listOfString.add("hola");

boolean removed = listOfString.remove("hola");

Obtener tamaño de un ArrayList

Para obtener el tamaño de un arrayList aplicaremos el método size().

  ArrayList<String> stringList = new ArrayList<String>();
  list.add("Hola");

  int totalSize = stringList.size();

Iterar sobre un ArrayList haciendo uso de Iterator

 public static void main(String args[]){  
  ArrayList<String> stringList = new ArrayList<String>();
  list.add("Hola");
  list.add("Adios");    
  list.add("Hi");    
  Iterator itr=stringList.iterator();//getting the Iterator  
  while(itr.hasNext()){
   System.out.println(itr.next());
  }  
//también se puede hacer con lambda
  stringList.forEach(str->System.out.println(str));

 }  
}  

Ordenar un ArrayList en Java

A continuación vamos a crear una lista de números y se ordenaran por defecto al aplicar el método sort de menor a mayor:

 List<Integer> numberList=new ArrayList<Integer>();  
  numberList.add(11);  
  numberList.add(500);  
  numberList.add(59);  
  numberList.add(10);  
  Collections.sort(numberList);  
  numberList.forEach(number->System.out.println(number));

Salida:

10
11
59
500

Si quieres ver más información sobre como ordenar listas puedes echar un ojo a este artículo.

Maneras de recorrer un ArrayList en Java

Vamos a ver diferentes maneras de recorrer un ArrayList en Java. Hay que tener en cuenta que para recorrer un ArrayList en Java depende de si la versión de Java es anterior o poster a Java 8:

Vamos a ver varias formas de recorrer un ArrayList en Java:

• Haciendo uso de Iterator.
• Recorriendo con forEach.
• Haciendo uso de la interfaz ListIterator .
• Con un while.
• Con forEachRemaining().
• Haciendo uso de stream().

  public void iterateAnArrayList(){

    ArrayList<String> names=new ArrayList();
    names.add("Jose");
    names.add("Fran");
    names.add("Noel");
    names.add("Pablo");

    System.out.println("Con ListIterator");
    //Here, element iterates in reverse order
    ListIterator<String> namesIterator=names.listIterator(names.size());
    while(namesIterator.hasPrevious()) {
      String str=namesIterator.previous();
      System.out.println(str);
    }
    
    System.out.println("Con bucle For convencional:");
    for(int i=0;i<names.size();i++) {
      System.out.println(names.get(i));
    }

    System.out.println("Haciendo uso de ForEach");
    names.forEach(name->{ 
      System.out.println(name);
    });

    System.out.println("Con forEachRemaining():");
    Iterator<String> itr=names.iterator();
    itr.forEachRemaining(name-> System.out.println(name));
  
  
  System.out.println("Haciendo uso de stream()");
  names.stream().peek(name->System.out.println(name));
}

En el último caso en el que hemos usado «peek» dentro de un stream es un uso recomendado para debug. Por lo general, haremos uso de Map siempre que queramos realizar una modificación.

Ejemplo de retainAll() en un ArrayList

En este apartado vamos a ver un ejemplo de uso de retainAll().

El método de retainAll se usa para eliminar todos los elementos que no están contenidos en la colección que se pasa especificamente o mantiene todos los elementos con los que hace match de la lista pasada por parámetro.

Podemos tener las siguientes excepciones:

• ClassCastException: Si la clase de los elementos que se pasan son incompatibles.
• NullPointerException: SI la lista contiene algún elemento a null y la colección que se pasa por parámetro no lo permite, o también si la colección es null.

Vamos a ver un ejemplo de uso de retainAll en Java:

class arrayListExamples{  
 public void retainAllExample(){  
    ArrayList<String> names=new ArrayList();
    names.add("Jose");
    names.add("Fran");
    names.add("Noel");
    names.add("Pablo");
    ArrayList<String> names2=new ArrayList();
    names2.add("Pepe");
    names2.add("Pablo");  

    names.retainAll(names2);  

    Iterator iter=al.iterator();  
      
   while(iter.hasNext()){  
      System.out.println(iter.next());  
   }  
 }  
}  

Salida:

Pablo

Lo que hemos hecho con retainAll() en el ejemplo anterior es eliminar y mantener de la lista primera los elementos de la lista segunda.

replaceAll en un ArrayList en Java

El método replaceAll() en un arraylist se encarga de remplazar cada elemento de un arraylist con el resultado especificado por parámetro:

La sintaxis del método sería la siguiente:

arraylist.replaceAll(UnaryOperator<E> operator)

Vamos a ver un ejemplo de un arrayList en el que reemplazamos todos los elementos añadiendo uno:

class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbersAddOne = new ArrayList<>();

        numbersAddOne.add(1);
        numbersAddOne.add(2);
        numbersAddOne.add(3);
        System.out.println("ArrayList: " + numbersAddOne);

        numbersAddOne.replaceAll(e -> e + 1);;

        System.out.println("ArrayList after add one: " + numbersAddOne);
    }
}

Resultado:

ArrayList: [1, 2, 3]
ArrayList after add one: [2, 3, 4]

Big O Notation en un ArrayList

Cuando trabajamos con un ArrayList para obtener un elemento de una lista hay que tener en cuenta que el Big O Notation, es decir, la complejidad dependerá de la manera de acceder.

En función de la operación con un ArrayList su Big O Notation puede cambiar:

• Acceder a través del indice. Si accedemos a un elemento a través de su índice será O(1).
• Insertar o eliminar un elemento al principio: Si insertamos o eliminamos un elemento al principio de una lista tenemos que desplazar todos los elementos restantes por lo que su complejidad sería O(n) siendo n el tamaño de la lista.
• Insertar o eliminar entre el principio y el final: Su Big O Notation sería O(n). Ya que tenemos que recorrer y desplazar elementos.

Conclusión

En esta entrada sobre uso y métodos principales de ArrayList en Java, hemos visto los principales métodos de ArrayList como su aplicación. Conocer bien ArrayList nos evitará problemas o recorridos en la estructura innecesarios con lo que podremos optimizar nuestra aplicación.