{"id":199,"date":"2026-10-01T17:53:01","date_gmt":"2026-10-01T17:53:01","guid":{"rendered":"https:\/\/java.nosoyia.es\/?page_id=199"},"modified":"2026-10-01T17:53:01","modified_gmt":"2026-10-01T17:53:01","slug":"arraylist","status":"publish","type":"page","link":"https:\/\/java.nosoyia.es\/?page_id=199","title":{"rendered":"ArrayList"},"content":{"rendered":"\n
\n
\n

Correspondencia en Python —><\/p>\n<\/div>\n\n\n\n

\n
\"\"<\/a><\/figure>\n<\/div>\n<\/div>\n\n\n\n

Los ArrayList son un tipo de estructura de datos con algunas caracter\u00edsticas comunes con la estructura List.<\/p>\n\n\n\n

    \n
  • Ambos son una estructura ordenada de elementos del mismo tipo.<\/li>\n\n\n\n
  • Comienzan por el elemento 0<\/li>\n\n\n\n
  • Pueden tener elementos repetidos.<\/li>\n\n\n\n
  • El contenido de cada uno de sus elementos, puede ser modificado.<\/li>\n\n\n\n
  • Puede haber ArraysList de dos o m\u00e1s dimensiones. Incluso cada una de sus dimensiones, puede tener diferente cantidad de elementos.<\/li>\n<\/ul>\n\n\n\n

    Entre otras muchas diferencias tenemos:<\/p>\n\n\n\n

      \n
    • Su tama\u00f1o puede variar, ya que se pueden a\u00f1adir y eliminar elementos.<\/li>\n\n\n\n
    • Sus \u00edndices se encierran entre par\u00e9ntesis.<\/li>\n\n\n\n
    • Los m\u00e9todos y funciones que se les aplican son casi todos distintos.<\/li>\n<\/ul>\n\n\n\n
      import java.util.ArrayList;\n\npublic class Prueba {\n    public static void main(String[] args) {\n        ArrayList<Integer> medidas= new ArrayList<Integer>();\n        medidas.add(40);\n        medidas.add(30);\n        medidas.add(20);\n        System.out.println("Las medidas de equipaje admitido son:");\n        System.out.println("Alto: "+medidas.get(0) +". Largo:"+medidas.get(1) +". Ancho: "+medidas.get(2));\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
      Resultado:\n\nLas medidas de equipaje admitido son:\nAlto: 40. Largo:30. Ancho: 20<\/code><\/pre><\/div>\n\n\n\n
      En este ejemplo, hemos declarado el ArrayList (su tama\u00f1o ser\u00e1 0 por defecto), a continuaci\u00f3n hemos a\u00f1adido 3 elementos. Si entre los par\u00e9ntesis de la declaraci\u00f3n indicamos un n\u00famero entero, establecemos que el ArrayList tendr\u00e1 un tama\u00f1o inicial de ese entero, aunque inicialmente todos sus elementos tendr\u00e1n un valor \u00abnull\u00bb.<\/p>\n\n\n\n
      Tambi\u00e9n podemos declarar e inicializar a la vez sus primeros elementos, aunque la forma de hacerlo es diferente al ejemplo anterior, y debemos de importar un par de m\u00e9todos m\u00e1s de java.util<\/p>\n\n\n\n
      import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.List;\n\npublic class Prueba {\n    public static void main(String[] args) {\n        List<Integer> medidas = new ArrayList<>(Arrays.asList(40,30,20));\n\n        System.out.println("Las medidas de equipaje admitido son:");\n        System.out.println("Alto: "+medidas.get(0) +". Largo:"+medidas.get(1) +". Ancho: "+medidas.get(2));\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
      Resultado:\n\nLas medidas de equipaje admitido son:\nAlto: 40. Largo:30. Ancho: 20<\/code><\/pre><\/div>\n\n\n\n
      Seg\u00fan el tipo de dato que contengan, la forma de declararlo es diferente, puede ser:<\/p>\n\n\n\n
        \n
      • ArrayList<Integer> si contiene datos tipo int<\/li>\n\n\n\n
      • ArrayList<String> si va a contener cadenas.<\/li>\n\n\n\n
      • ArrayList<Double> para tipos double.<\/li>\n\n\n\n
      • ArrayList<Float> para tipos float.<\/li>\n\n\n\n
      • ArrayList<Boolean> para tipo boolean<\/li>\n\n\n\n
      • ArrayList<nombre_clase> si va a contener objetos de una clase.<\/li>\n<\/ul>\n\n\n\n
        Veamos otro ejemplo. A diferencia de con Array (que deb\u00edamos pasarlos previamente todos a una cadena), podemos imprimir directamente todos los elementos que contiene un ArrayList.<\/p>\n\n\n\n
        import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.List;\n\npublic class Prueba {\n    public static void main(String[] args) {\n        List<String> medidas = new ArrayList<>(Arrays.asList("Cristiano", "Messi", "Joaqu\u00edn", "Morata", "Pedri"));\n\n        System.out.println(medidas);\n        \n    }\n}<\/code><\/pre><\/div>\n\n\n\n
        Resultado:\n[Cristiano, Messi, Joaqu\u00edn, Morata, Pedri]<\/code><\/pre><\/div>\n\n\n\n
        Los ArrayList comienzan con el primer elemento con \u00edndice 0. Podemos dar un nuevo valor a cualquier elemento simplemente asign\u00e1ndole el nuevo valor.<\/p>\n\n\n\n
        import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.List;\n\npublic class Prueba {\n    public static void main(String[] args) {\n        List<String> jugadores = new ArrayList<>(Arrays.asList("Cristiano", "Messi", "Joaqu\u00edn", "Morata", "Pedri"));\n        System.out.println("Mi jugador preferido es "+jugadores.get(0));\n        System.out.println("El m\u00e1ximo goleador es "+jugadores.get(2));\n        jugadores.set(1,"Cucurella");\n        System.out.print(jugadores);\n    }<\/code><\/pre><\/div>\n\n\n\n
        Resultado:\n\nMi jugador preferido es Cristiano\nEl m\u00e1ximo goleador es Joaqu\u00edn\n[Cristiano, Cucurella, Joaqu\u00edn, Morata, Pedri]<\/code><\/pre><\/div>\n\n\n\n
        Vemos que para acceder a los elementos de un ArrayList se utiliza el m\u00e9todo .get(posici\u00f3n)<\/mark><\/em><\/strong> que nos da el valor del elemento contenido en dicha posici\u00f3n.<\/p>\n\n\n\n
        Tambi\u00e9n vemos que para variar el valor de un determinado elemento usamos el m\u00e9todo .set (posici\u00f3n,nuevo_valor)<\/mark><\/em><\/strong>, que cambia el valor del elemento que se encuentre en esa posici\u00f3n por el nuevo valor.<\/p>\n\n\n\n
        El m\u00e9todo .add(nuevo_elemento)<\/mark><\/em><\/strong> nos a\u00f1ade un nuevo elemento al final del ArrayList y el m\u00e9todo .size( )<\/mark><\/em><\/strong> nos facilita el total de elementos que contiene.<\/p>\n\n\n\n
        import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.List;\n\npublic class Prueba {\n    public static void main(String[] args) {\n        List<String> jugadores = new ArrayList<>(Arrays.asList("Cristiano", "Messi", "Joaqu\u00edn", "Morata", "Pedri"));\n        jugadores.add("Casillas");\n        System.out.println(jugadores);\n        int total_elementos=jugadores.size();\n        System.out.println("El total de jugadores es: "+total_elementos);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
        Resultado:\n\n[Cristiano, Messi, Joaqu\u00edn, Morata, Pedri, Casillas]\nEl total de jugadores es: 6<\/code><\/pre><\/div>\n\n\n\n
        Tambi\u00e9n podemos insertar un elemento en una determinada posici\u00f3n con el m\u00e9todo .add (posici\u00f3n, nuevo_elemento)<\/mark><\/em><\/strong><\/p>\n\n\n\n
        import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.List;\n\npublic class Prueba {\n    public static void main(String[] args) {\n        List<String> jugadores = new ArrayList<>(Arrays.asList("Cristiano", "Messi", "Joaqu\u00edn", "Morata", "Pedri"));\n        jugadores.add(2,"Pedri");\n        System.out.println(jugadores);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
        Resultado:\n[Cristiano, Messi, Pedri, Joaqu\u00edn, Morata, Pedri]<\/code><\/pre><\/div>\n\n\n\n
        Con el m\u00e9todo .remove(\u00edndice)<\/mark><\/em><\/strong> eliminamos el elemento que se encuentre en la posici\u00f3n del \u00edndice indicada; y con .remove(valor)<\/mark><\/em><\/strong> eliminamos el primer elemento de la lista que posea el valor indicado.<\/p>\n\n\n\n
        import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.List;\n\npublic class Prueba {\n    public static void main(String[] args) {\n        List<String> jugadores = new ArrayList<>(Arrays.asList("Cristiano", "Messi", "Joaqu\u00edn", "Morata", "Pedri","Cristiano"));\n        jugadores.add(2,"Pedri");\n        System.out.println(jugadores);\n        jugadores.remove(1);\n        jugadores.remove("Cristiano");\n        \/\/jugadores.removeIf(jugador ->jugador.startsWith("C"));\n        System.out.println(jugadores);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
        Resultado:\n\n[Cristiano, Messi, Pedri, Joaqu\u00edn, Morata, Pedri, Cristiano]\n[Pedri, Joaqu\u00edn, Morata, Pedri, Cristiano]<\/code><\/pre><\/div>\n\n\n\n
        Con .removeIf( elemento -> condici\u00f3n)<\/mark><\/em><\/strong> eliminamos todos los elementos del ArrayList que cumpla una determinada condici\u00f3n. En el siguiente ejemplo, eliminamos todos los elementos que comiencen por \u00abCri\u00bb<\/p>\n\n\n\n
        import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.List;\n\npublic class Prueba {\n    public static void main(String[] args) {\n        List<String> jugadores = new ArrayList<>(Arrays.asList("Cristiano", "Messi", "Joaqu\u00edn", "Morata", "Pedri","Cristiano"));\n        jugadores.add(2,"Pedri");\n        jugadores.removeIf(jugador ->jugador.startsWith("Cri"));\n        System.out.println(jugadores);\n    }<\/code><\/pre><\/div>\n\n\n\n
        [Messi, Pedri, Joaqu\u00edn, Morata, Pedri]<\/code><\/pre><\/div>\n\n\n\n
        Otro ejemplo. Ahora eliminamos todos los n\u00fameros mayores que 100.<\/p>\n\n\n\n
        public class Prueba2 {\n    public static void main(String[] args) {\n        List<Integer> mis_numeros = new ArrayList<>(Arrays.asList(3,44,32,401,178));\n        mis_numeros.removeIf(numero -> numero>100);\n        System.out.println(mis_numeros);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
        Resultado:\n\n[3, 44, 32]<\/code><\/pre><\/div>\n\n\n\n
        A partir de un ArrayList podemos obtener otro ArrayList extra\u00eddo de una porci\u00f3n del primero. El m\u00e9todo a aplicar es .subList(inicio,fin)<\/mark><\/em><\/strong> con el cual obtendremos un segmento de ArrayList que se inicia en el elemento inicio y finaliza en el elemento fin (que no estar\u00e1 inclu\u00eddo).<\/p>\n\n\n\n
        En los siguientes ejemplos, nos hemos ayudado en algunos de ellos de la variable \u00abfin\u00bb que hemos declarado para conocer el tama\u00f1o del ArrayList y poder a\u00f1adirlo como margen superior del segmento. Debemos de tener en cuenta que el elemento fin no va a estar incluido.<\/p>\n\n\n\n
        import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.List;\n\npublic class Prueba2 {\n    public static void main(String[] args) {\n        List<Integer> mis_numeros = new ArrayList<>(Arrays.asList(1,3,5,7,11,13,17,19,23,29));\n        int fin=mis_numeros.size(); \/\/tama\u00f1o del ArrayList.\n        List<Integer> segmento_1 = mis_numeros.subList(2, (fin-2));\n        List<Integer> segmento_2 = mis_numeros.subList(0, 6);\n        List<Integer> segmento_3 = mis_numeros.subList(3, fin);\n        List<Integer> segmento_4 = mis_numeros.subList(2, 7);\n        System.out.println(segmento_1);\n        System.out.println(segmento_2);\n        System.out.println(segmento_3);\n        System.out.println(segmento_4);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
        Resultado:\n\n[5, 7, 11, 13, 17, 19]\n[1, 3, 5, 7, 11, 13]\n[7, 11, 13, 17, 19, 23, 29]\n[5, 7, 11, 13, 17]<\/code><\/pre><\/div>\n\n\n\n
        Tratar un String como un ArrayList.<\/mark><\/em><\/strong> Para muchas operaciones podemos trabajar con un dato tipo String como si fuese un ArrayList.<\/p>\n\n\n\n
        public class Prueba3 {\n    public static void main(String[] args) {\n        String texto = "Hola, soy una cadena y tambi\u00e9n un ArrayList.";\n        int tamanyo=texto.length();\n        String segmento_1=texto.substring(0,6);\n        String segmento_2=texto.substring(14,21);\n        String nuevo_texto="";\n        String excluidos="aeiou";\n        for (int k=0; k<tamanyo; k+=1){\n            char letra=texto.charAt(k);\n            if (excluidos.indexOf(letra) == -1){\n               nuevo_texto=nuevo_texto+letra;\n            }\n        }\n        System.out.println("La cadena tiene "+tamanyo+" caracteres.");\n        System.out.println(segmento_1+segmento_2);\n        System.out.println(nuevo_texto);\n\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
        Resultado:\n\nLa cadena tiene 44 caracteres.\nHola, cadena \nHl, sy n cdn y tmb\u00e9n n ArryLst.<\/code><\/pre><\/div>\n\n\n\n
        Primer hemos averiguado el tama\u00f1o del String. Luego hemos extra\u00eddos dos segmentos de dicho String y los hemos sumado. A continuaci\u00f3n lo hemos recorrido para extraerles los caracteres que estaban incluidos en otro String.<\/p>\n\n\n\n
        Con el m\u00e9todo .split(\u00abseparador\u00bb)<\/mark><\/em><\/strong> podemos obtener un ArrayList de Strings a partir de un String inicial. El par\u00e1metro separador (que ir\u00e1 siempre entre comillas) indica el punto en que se divide cada uno de los segmentos de ArrayList que pasar\u00e1n al nuevo. Si el separador es un espacio en blanco, debemos de indicar el espacio en blanco entre las comillas.<\/p>\n\n\n\n
        import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.List;\n\npublic class Prueba3 {\n    public static void main(String[] args) {\n        String texto = "Este verano est\u00e1 siendo muy caluroso";\n        List<String> pasar_List = Arrays.asList(texto.split(" "));\n        ArrayList<String> mi_lista = new ArrayList<>(pasar_List);\n        System.out.println(mi_lista);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
        Resultado:\n\n[Este, verano, est\u00e1, siendo, muy, caluroso]<\/code><\/pre><\/div>\n\n\n\n
        Podemos a\u00f1adir un par\u00e1metro adicional al m\u00e9todo .split que indique el n\u00famero m\u00e1ximo de segmentos<\/mark><\/em><\/strong> que debe de extraer:<\/p>\n\n\n\n
        import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.List;\n\npublic class Prueba3 {\n    public static void main(String[] args) {\n        String texto = "Este verano est\u00e1 siendo muy caluroso";\n        List<String> pasar_List = Arrays.asList(texto.split(" ",3));\n        ArrayList<String> mi_lista = new ArrayList<>(pasar_List);\n        System.out.println(mi_lista);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
        Resultado:\n[Este, verano, est\u00e1 siendo muy caluroso]<\/code><\/pre><\/div>\n\n\n\n
        El m\u00e9todo contrario es String.join(\u00abdelimitador\u00bb,ArrayList) <\/mark><\/em><\/strong>que toma un ArrayList de String y forma a partir del mismo un \u00fanico String que tendr\u00e1 como separador el delimitador indicado entre comillas como primer par\u00e1metro.<\/p>\n\n\n\n
        import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.List;\n\npublic class Prueba3 {\n    public static void main(String[] args) {\n        List<String> mi_lista = new ArrayList<>(Arrays.asList("Este", "verano", "est\u00e1", "siendo", "muy", "caluroso"));\n        String mi_frase = String.join(" ",mi_lista);\n        System.out.println(mi_frase);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
        Resultado:\n\nEste verano est\u00e1 siendo muy caluroso<\/code><\/pre><\/div>\n\n\n\n
        Para vaciar un ArrayList la forma m\u00e1s eficiente es utilizar el m\u00e9todo .clear( )<\/mark><\/em><\/strong><\/p>\n\n\n\n
        import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.List;\n\npublic class Prueba2 {\n    public static void main(String[] args) {\n        List<Integer> mis_numeros = new ArrayList<>(Arrays.asList(1,3,5,7,11));\n        System.out.println(mis_numeros);\n        mis_numeros.clear();\n        System.out.println(mis_numeros);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
        Resultado:\n\n[1, 3, 5, 7, 11]\n[]<\/code><\/pre><\/div>\n\n\n\n
        El m\u00e9todo .addAll(otro_ArrayList)<\/mark><\/em><\/strong> permite a\u00f1adir todos los elementos del ArrayList que figura como par\u00e1metro al ArrayList original.<\/p>\n\n\n\n
        import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.List;\n\npublic class Prueba2 {\n    public static void main(String[] args) {\n        List<Integer> mis_numeros = new ArrayList<>(Arrays.asList(1,3,5,7,11));\n        List<Integer> tus_numeros = new ArrayList<>(Arrays.asList(18,32,143));\n        List<Integer> total_numeros = new ArrayList<>();\n        total_numeros.addAll(mis_numeros);\n        total_numeros.addAll(tus_numeros);\n\n        System.out.println(mis_numeros);\n        System.out.println(tus_numeros);\n        System.out.println(total_numeros);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
        Resultado:\n\n[1, 3, 5, 7, 11]\n[18, 32, 143]\n[1, 3, 5, 7, 11, 18, 32, 143]<\/code><\/pre><\/div>\n\n\n\n
        Es posible que debamos recorrer todos los elementos de un ArrayList por diversas circunstancias. Por ejemplo, para sumar todos sus elementos, saber sus elementos son mayores (o menores) que un valor determinado…<\/p>\n\n\n\n
        En el siguiente ejemplo, recorremos el ArrayList y sumamos todos sus elementos:<\/p>\n\n\n\n
        import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.List;\n\npublic class Prueba {\n    public static void main(String[] args) {\n        List<Double> mis_numeros = new ArrayList<>(Arrays.asList(13.4,3.87,5.0,7.0,11.0));\n        double suma=0;\n        for (double numero : mis_numeros){\n            suma=suma+numero;\n        }\n        double total=Math.round(suma * 100.0) \/ 100.0;\n        System.out.println("Todos los n\u00fameros suman: "+total);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
        Resultado:\n\nTodos los n\u00fameros suman: 40.27<\/code><\/pre><\/div>\n\n\n\n
        Si queremos saber las veces que aparece un determinado elemento en un ArrayList, podemos utilizar el m\u00e9todo Collections.frequency(ArrayList, elemento)<\/mark><\/em>:<\/strong><\/p>\n\n\n\n
        import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.Collections;\nimport java.util.List;\n\npublic class Prueba {\n    public static void main(String[] args) {\n        List<Double> mis_numeros = new ArrayList<>(Arrays.asList(5.3,3.87,5.3,7.0,11.0,5.3));\n        int repeticiones= Collections.frequency(mis_numeros,5.3);\n        System.out.println("El n\u00famero 5.3 aparece "+repeticiones+" veces.");\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
        Resultado:\n\nEl n\u00famero 5.3 aparece 3 veces.<\/code><\/pre><\/div>\n\n\n\n
        El m\u00e9todo Collections.max(ArrayList)<\/mark><\/em><\/strong> nos permite obtener el valor m\u00e1ximo contenido en un ArrayList:<\/p>\n\n\n\n
        import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.Collections;\nimport java.util.List;\n\npublic class Prueba {\n    public static void main(String[] args) {\n        List<Double> mis_numeros = new ArrayList<>(Arrays.asList(5.3,3.87,5.3,7.0,11.0,5.3));\n        double el_maximo= Collections.max(mis_numeros);\n        System.out.println("El n\u00famero mayor es el: "+ el_maximo);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
        Resultado:\n\nEl n\u00famero mayor es el: 11.0<\/code><\/pre><\/div>\n\n\n\n
        De la misma manera el m\u00e9todo Collections.min(ArrayList)<\/mark><\/em><\/strong> nos devuelve el m\u00ednimo valor de un ArrayList:<\/p>\n\n\n\n
        import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.Collections;\nimport java.util.List;\n\npublic class Prueba {\n    public static void main(String[] args) {\n        List<Double> mis_numeros = new ArrayList<>(Arrays.asList(5.3,3.87,5.3,7.0,11.0,5.3));\n        double el_minimo= Collections.min(mis_numeros);\n        System.out.println("El n\u00famero menor es el: "+ el_minimo);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
        Resultado:\n\nEl n\u00famero menor es el: 3.87<\/code><\/pre><\/div>\n\n\n\n
        Estos dos m\u00e9todos anteriores aplicados a ArrayList de String, tomar\u00eda como valores m\u00e1ximos y m\u00ednimos los c\u00f3digos ASCII del primer (o siguientes) caracteres de cada String.<\/p>\n\n\n\n
        Debemos de tener en cuenta que los caracteres en may\u00fasculas tienen un c\u00f3digo ASCII menor que los que est\u00e1n en min\u00fasculas, de ah\u00ed se explica el resultado del siguiente c\u00f3digo.<\/p>\n\n\n\n
        import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.Collections;\nimport java.util.List;\n\npublic class Prueba {\n    public static void main(String[] args) {\n        List<String> mis_palabras = new ArrayList<>(Arrays.asList("Tomate","pera","calabaza","Calabaza","mel\u00f3n","Zanahoria"));\n        String el_maximo= Collections.max(mis_palabras);\n        System.out.println(mis_palabras);\n        System.out.println("La palabra mayor es el: "+ el_maximo);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
        Resultado:\n\n[Tomate, pera, calabaza, Calabaza, mel\u00f3n, Zanahoria]\nLa palabra mayor es el: pera\n<\/code><\/pre><\/div>\n\n\n\n
        El m\u00e9todo Collections.reverse(ArrayList)<\/mark><\/em><\/strong> permite invertir completamente el orden de los elementos de un ArrayList:<\/p>\n\n\n\n
        import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.Collections;\nimport java.util.List;\n\npublic class Prueba {\n    public static void main(String[] args) {\n        List<String> mis_palabras = new ArrayList<>(Arrays.asList("Tomate","pera","calabaza","Calabaza","mel\u00f3n","Zanahoria"));\n        System.out.println(mis_palabras);\n        Collections.reverse(mis_palabras);\n        System.out.println(mis_palabras);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
        Resultado:\n\n[Tomate, pera, calabaza, Calabaza, mel\u00f3n, Zanahoria]\n[Zanahoria, mel\u00f3n, Calabaza, calabaza, pera, Tomate]<\/code><\/pre><\/div>\n\n\n\n
        Collections.sort(ArrayList)<\/mark><\/em><\/strong> ordenar\u00e1 un ArrayList en orden ascendente num\u00e9rico o en orden ascendente por c\u00f3digo ASCII<\/p>\n\n\n\n
        import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.Collections;\nimport java.util.List;\n\npublic class Prueba {\n    public static void main(String[] args) {\n        List<String> mis_palabras = new ArrayList<>(Arrays.asList("Tomate","pera","calabaza","Calabaza","mel\u00f3n","Zanahoria"));\n        System.out.println(mis_palabras);\n        Collections.sort(mis_palabras);\n        System.out.println(mis_palabras);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
        Resultado:\n\n[Tomate, pera, calabaza, Calabaza, mel\u00f3n, Zanahoria]\n[Calabaza, Tomate, Zanahoria, calabaza, mel\u00f3n, pera]<\/code><\/pre><\/div>\n\n\n\n
        Collections.binarySearch(ArrayList, elemento)<\/mark><\/em><\/strong><\/code> Este m\u00e9todo permite obtener la posici\u00f3n que ocupa un determinado elemento en un ArrayList. <\/p>\n\n\n\n
        Si el elemento no est\u00e1 en el ArrayList dar\u00e1 un resultado negativo.<\/p>\n\n\n\n
        import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.Collections;\nimport java.util.List;\n\npublic class Prueba {\n    public static void main(String[] args) {\n        List<String> mis_palabras = new ArrayList<>(Arrays.asList("Tomate","mel\u00f3n","pera","pi\u00f1a","calabaza","Calabaza","Zanahoria"));\n        System.out.println(mis_palabras);\n        int posicion=Collections.binarySearch(mis_palabras, "mel\u00f3n");\n        System.out.println("La palabra 'mel\u00f3n' est\u00e1 en la posici\u00f3n "+posicion);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
        Resultado:\n\n[Tomate, mel\u00f3n, pera, pi\u00f1a, calabaza, Calabaza, Zanahoria]\nLa palabra 'mel\u00f3n' est\u00e1 en la posici\u00f3n 1<\/code><\/pre><\/div>\n\n\n\n
        Interesante es el m\u00e9todo Collections.shuffle(ArrayList) <\/mark><\/em><\/strong>que ordena todos los elementos del ArrayList de forma aleatoria.<\/p>\n\n\n\n
        import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.Collections;\nimport java.util.List;\n\npublic class Prueba {\n    public static void main(String[] args) {\n        List<Integer> mis_numeros = new ArrayList<>(Arrays.asList(1,2,3,4,5,6,7,8,9,10));\n        System.out.println(mis_numeros);\n        Collections.shuffle(mis_numeros);\n        System.out.println(mis_numeros);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
        Posible resultado:\n\n[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n[6, 1, 5, 8, 9, 3, 4, 7, 2, 10]<\/code><\/pre><\/div>\n\n\n\n
        Con el m\u00e9todo Collections.fill(ArrayList, elemento)<\/mark><\/em><\/strong> reemplazamos todos los elementos de la lista con el elemento que se indica como par\u00e1metro.<\/p>\n\n\n\n
        import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.Collections;\nimport java.util.List;\n\npublic class Prueba {\n    public static void main(String[] args) {\n        List<Integer> mis_numeros = new ArrayList<>(Arrays.asList(1,2,3,4,5,6,7,8,9,10));\n        System.out.println(mis_numeros);\n        Collections.fill(mis_numeros, 0);\n        System.out.println(mis_numeros);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
        Resultado:\n\n[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]<\/code><\/pre><\/div>\n\n\n\n
        El m\u00e9todo Collections.copy(destino,origen)<\/mark><\/em><\/strong> copia todos los elementos del ArrayList origen en el nuevo ArrayList destino. Es indispensable que el ArrayList destino tenga el mismo tama\u00f1o (o mayor) que el ArrayList origen. Cada uno de los elementos de origen es copiado a su elemento correspondiente del destino. Veamos un ejemplo:<\/p>\n\n\n\n
        import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.Collections;\nimport java.util.List;\n\npublic class Prueba {\n    public static void main(String[] args) {\n        List<Integer> mis_numeros = new ArrayList<>(Arrays.asList(1,2,3,4,5,6,7,8,9,10));\n        List<Integer> nuevos_numeros = new ArrayList<>(Arrays.asList(new Integer[mis_numeros.size()]));\n\n        nuevos_numeros.add(787);\n        nuevos_numeros.add(583);\n        System.out.println(mis_numeros);\n        System.out.println(nuevos_numeros);\n        Collections.copy(nuevos_numeros,mis_numeros);\n        System.out.println(nuevos_numeros);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
        Resultado:\n\n[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n[null, null, null, null, null, null, null, null, null, null, 787, 583]\n[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 787, 583]<\/code><\/pre><\/div>\n\n\n\n
        El m\u00e9todo Collections.replaceAll(ArrayList,valor_antes,valor_despu\u00e9s)<\/mark><\/em><\/strong> nos facilita cambiar todas las apariciones en el ArrayList de un determinado valor (valor_antes) y cambiarlo por un nuevo valor (valor_despu\u00e9s):<\/p>\n\n\n\n
        import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.Collections;\nimport java.util.List;\n\npublic class Prueba2 {\n    public static void main(String[] args) {\n        List<Integer> mis_numeros = new ArrayList<>(Arrays.asList(1,1,173,824,1,3,5,7,11));\n        System.out.println(mis_numeros);\n        Collections.replaceAll(mis_numeros,1,0);\n        System.out.println(mis_numeros);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
        Resultado:\n\n[1, 1, 173, 824, 1, 3, 5, 7, 11]\n[0, 0, 173, 824, 0, 3, 5, 7, 11]<\/code><\/pre><\/div>\n\n\n\n
        Inicio<\/a><\/td>Comandos Java<\/a><\/td>Bloques de c\u00f3digo.<\/a><\/td><\/tr>
        Comentar c\u00f3digo<\/a><\/td>System.out.print<\/a><\/td>Scanner (System.in)<\/a><\/td><\/tr>
        Captura de errores<\/a><\/td>String<\/a><\/td>Datos  Num\u00e9ricos<\/a><\/td><\/tr>
        Elementos aleatorios<\/a><\/td>Datos Fecha\/hora<\/a><\/td>Constantes<\/a><\/td><\/tr>
        Bucles for<\/a><\/td>Bucles while<\/a><\/td>Bloque if<\/a><\/td><\/tr>
        Arrays<\/a><\/td>ArrayList<\/a><\/td>switch case<\/a><\/td><\/tr>
        HashSet<\/a><\/td>HashMap<\/a><\/td>M\u00e9todos.<\/a><\/td><\/tr>
        Clases<\/a><\/td>Archivos<\/a><\/td>Entorno gr\u00e1fico Swing<\/a><\/td><\/tr>
        JFrame (Ventanas)<\/a><\/td>Componentes b\u00e1sicos.<\/a><\/td><\/td><\/tr><\/tbody><\/table><\/figure>\n","protected":false},"excerpt":{"rendered":"
        Correspondencia en Python —> Los ArrayList son un tipo de estructura de datos con algunas caracter\u00edsticas comunes con la estructura List. Entre otras muchas diferencias tenemos: En este ejemplo, hemos declarado el ArrayList (su tama\u00f1o ser\u00e1 0 por defecto), a continuaci\u00f3n hemos a\u00f1adido 3 elementos. Si entre los par\u00e9ntesis de la declaraci\u00f3n indicamos un n\u00famero […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-199","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=\/wp\/v2\/pages\/199","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=199"}],"version-history":[{"count":22,"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=\/wp\/v2\/pages\/199\/revisions"}],"predecessor-version":[{"id":223,"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=\/wp\/v2\/pages\/199\/revisions\/223"}],"wp:attachment":[{"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=199"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}