Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.Aprende Lista y ArrayList en Java | Estructuras de Datos Fundamentales en Java
Learn
Cursos
Learning Tracks
Popular Topics
Practice
Projects
Quizzes & Challenges
Quizzes
Challenges
/
Estructuras de Datos en Java

bookLista y ArrayList en Java

Comencemos nuestra introducción a la estructura de datos List. A continuación se muestra un diagrama de flujo que ilustra la Jerarquía de Colecciones y Listas. Puede parecer un diagrama grande y complejo, pero lo desglosaremos paso a paso.

En esta sección, se explorará un tipo específico de colección llamado listas. Se examinarán más de cerca los diferentes tipos de listas, incluyendo ArrayList, LinkedList y Stack.

Dado que todas las listas heredan de la interfaz List, es posible crear objetos utilizando la interfaz principal. Sin embargo, profundizaremos en ese tema más adelante.

Por ahora, se analizará el primer tipo de lista: ArrayList.

Arriba se muestra la sintaxis para crear un ArrayList<>. Hay una parte que podría no resultar familiar: el genérico. Más adelante se abordarán los genéricos y cómo crearlos.

Por ahora, solo recuerde que al crear un ArrayList, se debe especificar el tipo de dato dentro de los corchetes angulares. Además, tenga en cuenta que las listas no pueden trabajar con tipos de datos primitivos. En su lugar, se utilizan clases envoltorio.

A continuación, se creará una lista en código y se agregarán algunos objetos utilizando el método add().

Main.java

Main.java

copy

              
1234567891011121314

            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numberList = new ArrayList<>();
        numberList.add(10);
        numberList.add(15);
        numberList.add(5);
        System.out.println(numberList);
    }
}

Como puedes observar, el método add() es muy sencillo: simplemente agrega el valor especificado a la lista.

Además, ten en cuenta que es necesario importar List y ArrayList desde la biblioteca java.util. Sin embargo, si utilizas IntelliJ IDEA, este entorno importa automáticamente estas bibliotecas, por lo que no es necesario preocuparse por ello.

Ahora, veamos un ejemplo de cómo crear una lista con nuestro propio tipo de dato personalizado:

Main.java

Main.java

copy

              
1234567891011121314151617181920212223242526272829303132333435

            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        Dog bob = new Dog("Bob", 2);
        Dog ben = new Dog("Ben", 1);
        Dog brian = new Dog("Brian", 5);
        List<Dog> dogList = new ArrayList<>();
        dogList.add(bob);
        dogList.add(ben);
        dogList.add(brian);
        System.out.println(dogList);
    }
}

class Dog {
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Como puedes ver, creamos nuestra propia clase Dog y un ArrayList utilizando este tipo de dato. Al imprimir la lista, se mostraron todos los objetos almacenados en ella.

¿Qué sucede si tienes un array y necesitas convertirlo en una lista? Puedes hacerlo utilizando el método asList() de la clase Arrays.

Este método nos permite crear una lista que contiene los mismos elementos que el array original. Es especialmente útil cuando queremos aplicar métodos de lista a un array. La sintaxis es sencilla:

Arrays.asList(arrayName);

Y puedes utilizarlo directamente al inicializar una nueva lista, por ejemplo:

Main.java

Main.java

copy

              
12345678910111213141516171819202122232425262728293031323334

            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        Dog bob = new Dog("Bob", 2);
        Dog ben = new Dog("Ben", 1);
        Dog brian = new Dog("Brian", 5);
        Dog[] dogs = {bob, ben, brian};
        List<Dog> dogList = new ArrayList<>(Arrays.asList(dogs));
        System.out.println(dogList);
    }
}

class Dog {
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Así como se puede convertir un array en una lista, también es posible convertir una lista en un array utilizando el método toArray().

Métodos de ArrayList<>

Revisión de los métodos básicos de lista. Hasta ahora, se podrían haber reemplazado fácilmente las listas por arrays, pero aquí está la diferencia clave: los métodos.

El método add() es un método sobrecargado, lo que significa que tiene múltiples variantes. Una de ellas permite agregar un elemento en un índice específico.

Al insertar un elemento en el medio de una lista, todos los elementos a la derecha se desplazan una posición para dejar espacio al nuevo elemento.

Por ejemplo, si se agrega un elemento al inicio de la lista, todos los elementos existentes se desplazarán una posición a la derecha.

A continuación, se muestra un ejemplo:

Main.java

Main.java

copy

              
123456789101112131415161718

            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        for (int i = 0; i < 5; i++) { // Filling `numbers` list with 5 values
            numbers.add(i);
        }
        System.out.println("`numbers` before modifying: " + numbers);
        numbers.add(2, 10); // Adding 10 on the second index
        System.out.println("`numbers` after first modifying: " + numbers);
        numbers.add(0, 5);
        System.out.println("`numbers` after second modifying: " + numbers);
    }
}

La forma en que los valores se desplazan al insertar un elemento puede visualizarse en la siguiente ilustración:

Recuperación de elementos

Evidentemente, si es posible agregar objetos a una lista en un índice específico, también se pueden recuperar objetos por su índice utilizando el método get(int index).

A continuación, se muestra un ejemplo:

Main.java

Main.java

copy

              
12345678910111213141516171819

            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        names.add("David");
        names.add("Eva");

        // Retrieving element by index
        String element = names.get(2);  // Retrieving the 3rd element (index starts from 0)
        System.out.println("The element at index 2 is: " + element);
    }
}

Eliminación de elementos

Se pueden agregar elementos, se pueden recuperar, pero ¿se pueden eliminar? ¡Por supuesto! Es posible eliminar elementos utilizando el método remove(int index).

Este método también está sobrecargado, lo que significa que existe otra forma de eliminar un elemento. Se puede usar el método remove(Object obj), que elimina la primera aparición del elemento especificado.

Ahora, imagina que tienes una lista grande con todos los estudiantes de nuestro curso. Sin embargo, un estudiante se comportó mal y fue expulsado. No conoces su índice exacto, por lo que necesitas eliminarlo por nombre. Pero hay un inconveniente: el código está un poco defectuoso y su nombre puede aparecer varias veces en la lista.

Escribamos un programa para eliminar todas las apariciones de este estudiante de la lista:

Main.java

Main.java

copy

              
123456789101112131415161718

            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Charlie", "David", "Eva", "Frank", "Grace", "Hank", "Ivy", "Jack", "Katherine", "Leo", "Mia", "Nathan", "Olivia", "Paul", "Quinn", "Rachel", "Sam", "Tom", "Ursula", "Victor", "Wendy", "Xander", "Yvonne", "Zack", "Bob", "Emily", "Bob", "Jake", "Isabel", "Liam", "Nora", "Bob", "Sophia", "Bob", "Daniel", "Gabrielle", "Mike"};
        // Expelled student: Bob
        List<String> students = new ArrayList<>(Arrays.asList(names));
        System.out.println("Is Bob present in the list? " + students.contains("Bob"));
        while (students.contains("Bob")) {
            students.remove("Bob");
        }
        System.out.println("Is Bob still present in the list after the removal operation? " + students.contains("Bob"));
    }
}

Es posible que hayas notado que utilizamos otro método de lista—contains(Object obj). Este método verifica si el elemento especificado está presente en la lista y devuelve true o false.

Al usar contains(), establecemos la condición para el ciclo while, lo que nos permite eliminar todas las apariciones de un estudiante como "Bob" de la lista.

Por cierto, puedes simplificar este proceso considerablemente utilizando el método removeAll(Collection<?> c):

Main.java

Main.java

copy

              
123456789101112131415161718

            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Charlie", "David", "Eva", "Frank", "Grace", "Hank", "Ivy", "Jack", "Katherine", "Leo", "Mia", "Nathan", "Olivia", "Paul", "Quinn", "Rachel", "Sam", "Tom", "Ursula", "Victor", "Wendy", "Xander", "Yvonne", "Zack", "Bob", "Emily", "Bob", "Jake", "Isabel", "Liam", "Nora", "Bob", "Sophia", "Bob", "Daniel", "Gabrielle", "Mike"};
        // Expelled student: Bob
        List<String> students = new ArrayList<>(Arrays.asList(names));
        System.out.println("Is Bob present in the list? " + students.contains("Bob"));
        List<String> expelledStudents = new ArrayList<>();
        expelledStudents.add("Bob");
        students.removeAll(expelledStudents);
        System.out.println("Is Bob still present in the list after the removal operation? " + students.contains("Bob"));
    }
}

El método removeAll() recibe una colección como parámetro, que contiene los valores que serán eliminados de la lista sobre la que se invoca el método.

En este enfoque, creamos una colección de estudiantes expulsados y agregamos "Bob" a ella. Esto hace que nuestro código sea fácilmente ampliable—simplemente puedes añadir más estudiantes problemáticos a la lista de expulsados con el tiempo.

Actualización de un valor por índice

Volvamos a los métodos de lista—ahora es el momento del método de actualización.

Dado que el método add() simplemente desplaza todos los elementos a la derecha al insertar un nuevo valor, necesitamos una forma diferente de actualizar un valor existente por índice.

El método set(int index, Object value) hace exactamente eso:

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> example = new ArrayList<>();
        for (int i = 1; i <= 5; i++) {
            example.add(i);
        }
        System.out.println("List before modification: " + example);
        example.set(2, 28);
        System.out.println("List after modification: " + example);
    }
}

Es bastante sencillo—reemplazamos el elemento en el segundo índice con el número 28.

Otros métodos

Ya has revisado los métodos más comunes, pero existen muchos más. Como se utilizan rara vez, no nos centraremos en cada uno de ellos.

En su lugar, puedes encontrar todos los métodos que necesites—junto con la documentación completa y explicaciones detalladas—abriendo la clase ArrayList en IntelliJ IDEA.

Para hacerlo, simplemente importa la librería ArrayList, mantén presionada la Command key (Ctrl en Windows) y haz clic en ArrayList. Esto te mostrará todos los campos y métodos disponibles en la clase, ayudándote a explorar cualquier método que puedas haber pasado por alto.

1. ¿Qué método podemos usar para agregar un elemento por índice?

2. ¿Qué método podemos usar para obtener un elemento por índice?

3. ¿Qué método podemos utilizar para eliminar la primera aparición de un elemento?

4. ¿Qué método podemos utilizar para reemplazar un elemento por índice?

5. ¿Qué método podemos utilizar para comprobar la presencia de un elemento?

6. ¿Podemos crear una lista a partir de un arreglo?

7. ¿Cómo podemos crear una lista a partir de un arreglo?

question mark

¿Qué método podemos usar para agregar un elemento por índice?

Select the correct answer

question mark

¿Qué método podemos usar para obtener un elemento por índice?

Select the correct answer

question mark

¿Qué método podemos utilizar para eliminar la primera aparición de un elemento?

Select the correct answer

question mark

¿Qué método podemos utilizar para reemplazar un elemento por índice?

Select the correct answer

question mark

¿Qué método podemos utilizar para comprobar la presencia de un elemento?

Select the correct answer

question mark

¿Podemos crear una lista a partir de un arreglo?

Select the correct answer

question mark

¿Cómo podemos crear una lista a partir de un arreglo?

Select the correct answer

¿Todo estuvo claro?

¿Cómo podemos mejorarlo?

¡Gracias por tus comentarios!

Sección 1. Capítulo 2

Pregunte a AI

expand

Pregunte a AI

ChatGPT

Pregunte lo que quiera o pruebe una de las preguntas sugeridas para comenzar nuestra charla

bookLista y ArrayList en Java

Desliza para mostrar el menú

Comencemos nuestra introducción a la estructura de datos List. A continuación se muestra un diagrama de flujo que ilustra la Jerarquía de Colecciones y Listas. Puede parecer un diagrama grande y complejo, pero lo desglosaremos paso a paso.

En esta sección, se explorará un tipo específico de colección llamado listas. Se examinarán más de cerca los diferentes tipos de listas, incluyendo ArrayList, LinkedList y Stack.

Dado que todas las listas heredan de la interfaz List, es posible crear objetos utilizando la interfaz principal. Sin embargo, profundizaremos en ese tema más adelante.

Por ahora, se analizará el primer tipo de lista: ArrayList.

Arriba se muestra la sintaxis para crear un ArrayList<>. Hay una parte que podría no resultar familiar: el genérico. Más adelante se abordarán los genéricos y cómo crearlos.

Por ahora, solo recuerde que al crear un ArrayList, se debe especificar el tipo de dato dentro de los corchetes angulares. Además, tenga en cuenta que las listas no pueden trabajar con tipos de datos primitivos. En su lugar, se utilizan clases envoltorio.

A continuación, se creará una lista en código y se agregarán algunos objetos utilizando el método add().

Main.java

Main.java

copy

              
1234567891011121314

            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numberList = new ArrayList<>();
        numberList.add(10);
        numberList.add(15);
        numberList.add(5);
        System.out.println(numberList);
    }
}

Como puedes observar, el método add() es muy sencillo: simplemente agrega el valor especificado a la lista.

Además, ten en cuenta que es necesario importar List y ArrayList desde la biblioteca java.util. Sin embargo, si utilizas IntelliJ IDEA, este entorno importa automáticamente estas bibliotecas, por lo que no es necesario preocuparse por ello.

Ahora, veamos un ejemplo de cómo crear una lista con nuestro propio tipo de dato personalizado:

Main.java

Main.java

copy

              
1234567891011121314151617181920212223242526272829303132333435

            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        Dog bob = new Dog("Bob", 2);
        Dog ben = new Dog("Ben", 1);
        Dog brian = new Dog("Brian", 5);
        List<Dog> dogList = new ArrayList<>();
        dogList.add(bob);
        dogList.add(ben);
        dogList.add(brian);
        System.out.println(dogList);
    }
}

class Dog {
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Como puedes ver, creamos nuestra propia clase Dog y un ArrayList utilizando este tipo de dato. Al imprimir la lista, se mostraron todos los objetos almacenados en ella.

¿Qué sucede si tienes un array y necesitas convertirlo en una lista? Puedes hacerlo utilizando el método asList() de la clase Arrays.

Este método nos permite crear una lista que contiene los mismos elementos que el array original. Es especialmente útil cuando queremos aplicar métodos de lista a un array. La sintaxis es sencilla:

Arrays.asList(arrayName);

Y puedes utilizarlo directamente al inicializar una nueva lista, por ejemplo:

Main.java

Main.java

copy

              
12345678910111213141516171819202122232425262728293031323334

            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        Dog bob = new Dog("Bob", 2);
        Dog ben = new Dog("Ben", 1);
        Dog brian = new Dog("Brian", 5);
        Dog[] dogs = {bob, ben, brian};
        List<Dog> dogList = new ArrayList<>(Arrays.asList(dogs));
        System.out.println(dogList);
    }
}

class Dog {
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Así como se puede convertir un array en una lista, también es posible convertir una lista en un array utilizando el método toArray().

Métodos de ArrayList<>

Revisión de los métodos básicos de lista. Hasta ahora, se podrían haber reemplazado fácilmente las listas por arrays, pero aquí está la diferencia clave: los métodos.

El método add() es un método sobrecargado, lo que significa que tiene múltiples variantes. Una de ellas permite agregar un elemento en un índice específico.

Al insertar un elemento en el medio de una lista, todos los elementos a la derecha se desplazan una posición para dejar espacio al nuevo elemento.

Por ejemplo, si se agrega un elemento al inicio de la lista, todos los elementos existentes se desplazarán una posición a la derecha.

A continuación, se muestra un ejemplo:

Main.java

Main.java

copy

              
123456789101112131415161718

            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        for (int i = 0; i < 5; i++) { // Filling `numbers` list with 5 values
            numbers.add(i);
        }
        System.out.println("`numbers` before modifying: " + numbers);
        numbers.add(2, 10); // Adding 10 on the second index
        System.out.println("`numbers` after first modifying: " + numbers);
        numbers.add(0, 5);
        System.out.println("`numbers` after second modifying: " + numbers);
    }
}

La forma en que los valores se desplazan al insertar un elemento puede visualizarse en la siguiente ilustración:

Recuperación de elementos

Evidentemente, si es posible agregar objetos a una lista en un índice específico, también se pueden recuperar objetos por su índice utilizando el método get(int index).

A continuación, se muestra un ejemplo:

Main.java

Main.java

copy

              
12345678910111213141516171819

            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        names.add("David");
        names.add("Eva");

        // Retrieving element by index
        String element = names.get(2);  // Retrieving the 3rd element (index starts from 0)
        System.out.println("The element at index 2 is: " + element);
    }
}

Eliminación de elementos

Se pueden agregar elementos, se pueden recuperar, pero ¿se pueden eliminar? ¡Por supuesto! Es posible eliminar elementos utilizando el método remove(int index).

Este método también está sobrecargado, lo que significa que existe otra forma de eliminar un elemento. Se puede usar el método remove(Object obj), que elimina la primera aparición del elemento especificado.

Ahora, imagina que tienes una lista grande con todos los estudiantes de nuestro curso. Sin embargo, un estudiante se comportó mal y fue expulsado. No conoces su índice exacto, por lo que necesitas eliminarlo por nombre. Pero hay un inconveniente: el código está un poco defectuoso y su nombre puede aparecer varias veces en la lista.

Escribamos un programa para eliminar todas las apariciones de este estudiante de la lista:

Main.java

Main.java

copy

              
123456789101112131415161718

            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Charlie", "David", "Eva", "Frank", "Grace", "Hank", "Ivy", "Jack", "Katherine", "Leo", "Mia", "Nathan", "Olivia", "Paul", "Quinn", "Rachel", "Sam", "Tom", "Ursula", "Victor", "Wendy", "Xander", "Yvonne", "Zack", "Bob", "Emily", "Bob", "Jake", "Isabel", "Liam", "Nora", "Bob", "Sophia", "Bob", "Daniel", "Gabrielle", "Mike"};
        // Expelled student: Bob
        List<String> students = new ArrayList<>(Arrays.asList(names));
        System.out.println("Is Bob present in the list? " + students.contains("Bob"));
        while (students.contains("Bob")) {
            students.remove("Bob");
        }
        System.out.println("Is Bob still present in the list after the removal operation? " + students.contains("Bob"));
    }
}

Es posible que hayas notado que utilizamos otro método de lista—contains(Object obj). Este método verifica si el elemento especificado está presente en la lista y devuelve true o false.

Al usar contains(), establecemos la condición para el ciclo while, lo que nos permite eliminar todas las apariciones de un estudiante como "Bob" de la lista.

Por cierto, puedes simplificar este proceso considerablemente utilizando el método removeAll(Collection<?> c):

Main.java

Main.java

copy

              
123456789101112131415161718

            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Charlie", "David", "Eva", "Frank", "Grace", "Hank", "Ivy", "Jack", "Katherine", "Leo", "Mia", "Nathan", "Olivia", "Paul", "Quinn", "Rachel", "Sam", "Tom", "Ursula", "Victor", "Wendy", "Xander", "Yvonne", "Zack", "Bob", "Emily", "Bob", "Jake", "Isabel", "Liam", "Nora", "Bob", "Sophia", "Bob", "Daniel", "Gabrielle", "Mike"};
        // Expelled student: Bob
        List<String> students = new ArrayList<>(Arrays.asList(names));
        System.out.println("Is Bob present in the list? " + students.contains("Bob"));
        List<String> expelledStudents = new ArrayList<>();
        expelledStudents.add("Bob");
        students.removeAll(expelledStudents);
        System.out.println("Is Bob still present in the list after the removal operation? " + students.contains("Bob"));
    }
}

El método removeAll() recibe una colección como parámetro, que contiene los valores que serán eliminados de la lista sobre la que se invoca el método.

En este enfoque, creamos una colección de estudiantes expulsados y agregamos "Bob" a ella. Esto hace que nuestro código sea fácilmente ampliable—simplemente puedes añadir más estudiantes problemáticos a la lista de expulsados con el tiempo.

Actualización de un valor por índice

Volvamos a los métodos de lista—ahora es el momento del método de actualización.

Dado que el método add() simplemente desplaza todos los elementos a la derecha al insertar un nuevo valor, necesitamos una forma diferente de actualizar un valor existente por índice.

El método set(int index, Object value) hace exactamente eso:

Main.java

Main.java

copy

              
12345678910111213141516

            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> example = new ArrayList<>();
        for (int i = 1; i <= 5; i++) {
            example.add(i);
        }
        System.out.println("List before modification: " + example);
        example.set(2, 28);
        System.out.println("List after modification: " + example);
    }
}

Es bastante sencillo—reemplazamos el elemento en el segundo índice con el número 28.

Otros métodos

Ya has revisado los métodos más comunes, pero existen muchos más. Como se utilizan rara vez, no nos centraremos en cada uno de ellos.

En su lugar, puedes encontrar todos los métodos que necesites—junto con la documentación completa y explicaciones detalladas—abriendo la clase ArrayList en IntelliJ IDEA.

Para hacerlo, simplemente importa la librería ArrayList, mantén presionada la Command key (Ctrl en Windows) y haz clic en ArrayList. Esto te mostrará todos los campos y métodos disponibles en la clase, ayudándote a explorar cualquier método que puedas haber pasado por alto.

1. ¿Qué método podemos usar para agregar un elemento por índice?

2. ¿Qué método podemos usar para obtener un elemento por índice?

3. ¿Qué método podemos utilizar para eliminar la primera aparición de un elemento?

4. ¿Qué método podemos utilizar para reemplazar un elemento por índice?

5. ¿Qué método podemos utilizar para comprobar la presencia de un elemento?

6. ¿Podemos crear una lista a partir de un arreglo?

7. ¿Cómo podemos crear una lista a partir de un arreglo?

question mark

¿Qué método podemos usar para agregar un elemento por índice?

Select the correct answer

question mark

¿Qué método podemos usar para obtener un elemento por índice?

Select the correct answer

question mark

¿Qué método podemos utilizar para eliminar la primera aparición de un elemento?

Select the correct answer

question mark

¿Qué método podemos utilizar para reemplazar un elemento por índice?

Select the correct answer

question mark

¿Qué método podemos utilizar para comprobar la presencia de un elemento?

Select the correct answer

question mark

¿Podemos crear una lista a partir de un arreglo?

Select the correct answer

question mark

¿Cómo podemos crear una lista a partir de un arreglo?

Select the correct answer

¿Todo estuvo claro?

¿Cómo podemos mejorarlo?

¡Gracias por tus comentarios!

Sección 1. Capítulo 2
some-alt