# Java List: métodos y ámbitos de uso más importantes

Una Java List es sobre todo adecuada para escenarios en los que el **tamaño del conjunto de datos** no se conoce de antemano o puede cambiar con el tiempo. Te mostramos ejemplos concretos del uso de listas y qué operaciones puedes realizar con ellas.

## ¿Para qué sirven las listas de Java?

Las listas son una de las estructuras de datos básicas en la programación Java y tienen una amplia gama de aplicaciones. Contienen elementos en un **orden específico** que pueden añadirse, modificarse, borrarse o consultarse. Los objetos de una Java List pueden pertenecer a distintas clases. Además, es posible almacenar elementos duplicados o nulos. Las listas Java admiten clases y métodos genéricos, lo que garantiza la seguridad de tipos.

Las listas se utilizan en aplicaciones de bases de datos para almacenar y acceder a **grandes registros de consultas a bases de datos**. En las interfaces gráficas de usuario, las listas Java suelen utilizarse para mostrar una lista de elementos, por ejemplo, las opciones de un menú desplegable o los distintos artículos de una tienda online.

Las listas de Java también son indispensables en algoritmos y estructuras de datos. Se utilizan en la implementación de **algoritmos de ordenación, algoritmos de búsqueda o estructuras de pilas y colas**. En aplicaciones de red, las listas pueden ayudar a facilitar la gestión de conexiones y sockets.

## Los métodos de las listas de Java

Las listas de Java pertenecen a la interfaz collections y deben importarse desde el paquete **java.util**. Las clases de implementación incluyen [Java ArrayList](https://www.ionos.mx/digitalguide/paginas-web/desarrollo-web/java-arraylist/), LinkedList, Vector y Stack. Puedes declarar las distintas instancias de la lista de la siguiente manera:

```Java
List linkedList = new LinkedList(); // LinkedList
List arrayList = new ArrayList(); // ArrayList
List vecList = new Vector(); // Vector
List stackList = new Stack(); //Stack
```

He aquí algunos de los métodos más importantes utilizados en relación con las listas Java:

1. `int size()`: determina la cantidad de elementos en una lista.
2. `void add(int index, E element)`: agrega un elemento en una posición específica.
3. `boolean isEmpty()`: comprueba si la lista está vacía.
4. `void clear()`: elimina todos los elementos de la lista.
5. `boolean contains(Object o)`: devuelve el valor `true` si el objeto `o` está en la lista.
6. `boolean add(E e)`: agrega el elemento especificado al final de la lista.
7. `boolean remove(Object o)`: elimina la primera aparición de un elemento específico.
8. `E get(int index)`: devuelve el elemento en el índice indicado.
9. `E set(int index, E element)`: reemplaza o inserta un elemento en el índice especificado.
10. `Object[] toArray()`: devuelve un array con los elementos de la lista.
11. `List<E> subList(int fromIndex, int toIndex)`: captura todos los elementos dentro del intervalo definido.
12. `default void replaceAll(UnaryOperator<E> operator)`: método estándar en Java 8 que aplica [operadores de Java](https://www.ionos.mx/digitalguide/paginas-web/desarrollo-web/operadores-java/ "Operador de Java") a cada elemento y sustituye el resultado por dicho elemento.

## Casos comunes de uso de las listas Java

A continuación, mostramos los usos más comunes de una lista Java. Estos incluyen **conversiones** de arrays a listas y viceversa, así como ordenar, recuperar o cambiar elementos.

### Convertir un array en una lista

Para convertir un array, puedes hacer un bucle a través de una lista y utilizar el método `.add()` para añadir los elementos al array uno a uno.

```Java
import java.util.*;
    public class ArrayToList{
      public static void main(String args[]){
      // Creating Array
      String[] colors={"blue","green","red","yellow"};
      System.out.println("Array: "+Arrays.toString(colors));
      //Converting Array to List
      List<String> list=new ArrayList<String>();
      for(String color: colors){
        list.add(color);
      }
      System.out.println("List: "+list);
      }
    }
```

Esto da este resultado:

```Java
Array: [blue, green, red, yellow]
List: [blue, green, red, yellow]
```

### Convertir una lista en un array

Una lista puede convertirse en un array con el método `toArray()`:

```Java
import java.util.*;
    public class ListToArray{
      public static void main(String args[]){
       List<String> days = new ArrayList<String>();
       days.add("Monday");
       days.add("Tuesday");
       days.add("Wednesday");
       days.add("Thursday");
       days.add("Friday");
       days.add("Saturday");
       days.add("Sunday");
       // Converting ArrayList to Array
       String[] array = days.toArray(new String[days.size()]);
       System.out.println("Array: "+Arrays.toString(array));
       System.out.println("List: "+days);
      }
    }
```

En el resultado vemos que el contenido del array y de la lista son idénticos:

```Java
Array: [Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday]
List: [Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday]
```

### Recuperar y modificar elementos de una lista Java

Con el método `get()` se puede acceder a un elemento en un índice concreto, mientras que con `set()` se **puede intercambiar y añadir** un objeto en una posición deseada.

```Java
import java.util.*;
    public class ListExample{
      public static void main(String args[]){
      // Creating a List
      List<String> letters=new ArrayList<String>();
      // Adding elements
      letters.add("a");
      letters.add("b");
      letters.add("c");
      // get()
      System.out.println("Element at index 1: "+letters.get(1));
      // set()
      letters.set(2, "d");
      for(String letter: letters)
      System.out.println(letter);
      }
    }
```

Como en Java se empieza a contar por el índice 0, obtenemos el siguiente resultado:

```Java
Element at index 1: b
a
b
d
```

### Ordenar una lista

Para ordenar una lista Java, podemos utilizar el método `.sort()` de la clase collections. Recorremos la lista mediante un bucle y mostramos los elementos por orden en la consola:

```Java
import java.util.*;
    class SortArrayList{
      public static void main(String args[]){
      // Creating a list of numbers
      List<Integer> numbers=new ArrayList<Integer>();
      numbers.add(4);
      numbers.add(57);
      numbers.add(92);
      numbers.add(26);
      // Sorting
      Collections.sort(numbers);
      for(Integer number: numbers)
        System.out.println(number);
      }
    }
```

Los números de la lista Java aparecen en la pantalla en orden ascendente:

```Java
4
26
57
92
```


This is a markdown version of: [https://www.ionos.mx/digitalguide/paginas-web/desarrollo-web/java-list/](https://www.ionos.mx/digitalguide/paginas-web/desarrollo-web/java-list/) for AI/LLM consumption.