Arraylist…

Tema 12
Avelino Gómez
Explicación detallada de ArrayList en Java
¿Qué es ArrayList?

La clase ArrayList en Java es un tipo de lista dinámica que permite almacenar elementos de forma similar a un array,
pero con la ventaja de que su tamaño puede cambiar a medida que se añaden o eliminan elementos. Se encuentra en el
paquete java.util. A diferencia de los arrays en Java, que tienen un tamaño fijo, el tamaño de un ArrayList puede
modificarse según sea necesario.

Sintaxis básica Para crear un ArrayList que almacene cadenas de texto (String), se utiliza el siguiente código:
import java.util.ArrayList; // Importar la clase ArrayList

ArrayList<String> cars = new ArrayList<String>(); // Crear un objeto ArrayList

Métodos de ArrayList
Agregar elementos (add): Para añadir elementos al ArrayList, se usa el método add(). Por ejemplo:

cars.add("Volvo");
cars.add("BMW");
Además, puedes especificar la posición en la que deseas agregar un elemento, indicando el índice:

cars.add(0, "Mazda"); // Inserta "Mazda" en la posición 0

Acceder a un elemento (get): Para acceder a un elemento específico en el ArrayList, se usa el método get(),
proporcionando el índice del elemento deseado:

String firstCar = cars.get(0); // Obtiene el primer elemento (índice 0)

Modificar un elemento (set): Puedes cambiar el valor de un elemento existente con el método set(), indicando el
índice y el nuevo valor:

cars.set(0, "Opel"); // Cambia el primer elemento a "Opel"

Eliminar un elemento (remove): Para eliminar un elemento de la lista, se usa remove(), pasando el índice del
elemento:

cars.remove(0); // Elimina el primer elemento

También es posible eliminar todos los elementos usando clear():

cars.clear(); // Vacía el ArrayList

Obtener el tamaño (size): Para conocer el número de elementos en el ArrayList, utiliza el método size():

int totalCars = cars.size();

Recorrer un ArrayList

Puedes recorrer un ArrayList con un bucle for tradicional o con un bucle for-each:

// Con bucle for tradicional

for (int i = 0; i < cars.size(); i++) {
System.out.println(cars.get(i));
}

// Con bucle for-each

for (String car : cars) {
System.out.println(car);
}

ArrayList con otros tipos de datos

Dado que ArrayList solo almacena objetos, no se pueden almacenar directamente tipos primitivos (como int o
double). En su lugar, se usan las clases envolventes (Integer para int, Double para double, etc.).

Ejemplo para almacenar números enteros:

ArrayList<Integer> myNumbers = new ArrayList<Integer>();

myNumbers.add(10);
myNumbers.add(20);
Ordenar un ArrayList

Puedes ordenar los elementos de un ArrayList usando la clase Collections y su método sort(). Por ejemplo:

import java.util.Collections; // Importar la clase Collections

// Ordenar un ArrayList de Strings

Collections.sort(cars);

// Ordenar un ArrayList de Integers

Collections.sort(myNumbers);

Ejemplos

Crear y manipular un ArrayList de coches:

import java.util.ArrayList;
import java.util.Collections;

public class Main {

public static void main(String[] args) {
ArrayList<String> cars = new ArrayList<String>();
cars.add("Volvo");
cars.add("BMW");
cars.add("Ford");
cars.add("Mazda");
 System.out.println("Lista original: " + cars);

// Agregar en una posición específica

cars.add(1, "Audi");

// Modificar un elemento
cars.set(0, "Tesla");

// Eliminar un elemento
cars.remove(3);

// Ordenar la lista
Collections.sort(cars);

// Imprimir el tamaño y elementos

System.out.println("Tamaño de la lista: " + cars.size());
System.out.println("Elementos ordenados: " + cars);
}
}

Este ejemplo muestra cómo agregar, modificar, eliminar, ordenar e imprimir los elementos de un ArrayList en Java.
Java LinkedList

La clase LinkedList es muy similar a ArrayList, pero tiene diferencias importantes en su implementación.

Ejemplo

// Importar la clase LinkedList

import java.util.LinkedList;

public class Main {

public static void main(String[] args) {
LinkedList<String> cars = new LinkedList<String>();
cars.add("Volvo");
cars.add("BMW");
cars.add("Ford");
cars.add("Mazda");
System.out.println(cars);
}
}

En este ejemplo, se crea una instancia de LinkedList para almacenar cadenas (en este caso, marcas de autos).
Luego, se agregan elementos a la lista y se imprimen.
Comparación entre ArrayList y LinkedList

La clase LinkedList es una colección que puede contener muchos objetos del mismo tipo, al igual que ArrayList.
Ambas clases implementan la interfaz List, lo que significa que se pueden realizar las mismas operaciones en ambas,
como agregar, cambiar, eliminar elementos y limpiar la lista. Sin embargo, su implementación interna es muy diferente.

Cómo funciona ArrayList

ArrayList usa un arreglo regular para almacenar sus elementos. Cuando se agrega un elemento, se coloca en el
arreglo. Si el arreglo no tiene suficiente espacio, se crea un nuevo arreglo más grande, se copian los elementos al nuevo
arreglo y se elimina el anterior.

Cómo funciona LinkedList

LinkedList almacena sus elementos en "contenedores". La lista tiene un enlace al primer contenedor y cada
contenedor tiene un enlace al siguiente en la lista. Cuando se agrega un elemento, se coloca en un nuevo contenedor y
ese contenedor se enlaza a uno de los otros contenedores existentes.

¿Cuándo usar cada uno?

● Usa un ArrayList cuando necesites almacenar y acceder a datos de manera eficiente.

● Usa un LinkedList cuando necesites manipular los datos (por ejemplo, agregar o eliminar elementos en
cualquier parte de la lista de manera eficiente).
Métodos de LinkedList
Explicación de Métodos

1. addFirst(): Este método permite agregar un elemento al principio de la lista.

2. addLast(): Agrega un elemento al final de la lista.
3. removeFirst(): Elimina el primer elemento de la lista.
4. removeLast(): Elimina el último elemento de la lista.
5. getFirst(): Devuelve el primer elemento de la lista.
6. getLast(): Devuelve el último elemento de la lista.

Diferencias clave

● Acceso aleatorio: ArrayList es más eficiente cuando se necesita acceder a elementos aleatorios, ya que utiliza
un arreglo interno.
● Manipulación de datos: LinkedList es más eficiente cuando se trata de agregar o eliminar elementos en
cualquier parte de la lista, ya que puede hacerlo rápidamente sin necesidad de mover otros elementos.
Listsorting
Otra clase útil del paquete java.util es la clase Collections, que incluye el método sort() para ordenar listas
alfabéticamente o numéricamente.

Ordenar un ArrayList de Strings alfabéticamente en orden ascendente:

import java.util.ArrayList;
import java.util.Collections; // Importar la clase Collections

public class Main {

public static void main(String[] args) {
ArrayList<String> cars = new ArrayList<String>();
cars.add("Volvo");
cars.add("BMW");
cars.add("Ford");
cars.add("Mazda");

Collections.sort(cars); // Ordenar los autos

for (String i : cars) {

System.out.println(i);
}
}
}

En este ejemplo, creamos una lista de cadenas (ArrayList<String>) que contiene nombres de marcas de autos.
Luego, usamos el método Collections.sort() para ordenar los elementos de la lista en orden alfabético
ascendente. Finalmente, imprimimos los elementos ordenados usando un bucle for-each.
Ordenar un ArrayList de enteros numéricamente en orden ascendente:

import java.util.ArrayList;
import java.util.Collections; // Importar la clase Collections

public class Main {

public static void main(String[] args) {
ArrayList<Integer> myNumbers = new ArrayList<Integer>();
myNumbers.add(33);
myNumbers.add(15);
myNumbers.add(20);
myNumbers.add(34);
myNumbers.add(8);
myNumbers.add(12);

Collections.sort(myNumbers); // Ordenar los números

for (int i : myNumbers) {

System.out.println(i);
}
}
}

En este caso, tenemos una lista de números enteros. Usamos Collections.sort() para ordenar la lista
numéricamente en orden ascendente, y luego imprimimos los números ordenados con un bucle for-each.
Invertir el orden

También puedes ordenar una lista en orden inverso, utilizando el método reverseOrder() de la clase Collections.

Ordenar un ArrayList de Strings alfabéticamente en orden descendente:

import java.util.ArrayList;
import java.util.Collections; // Importar la clase Collections

public class Main {

public static void main(String[] args) {
ArrayList<String> cars = new ArrayList<String>();
cars.add("Volvo");
cars.add("BMW");
cars.add("Ford");
cars.add("Mazda");

Collections.sort(cars, Collections.reverseOrder()); // Ordenar en orden inverso

for (String i : cars) {

System.out.println(i);
}
}
}

Aquí, usamos Collections.sort() junto con Collections.reverseOrder() para ordenar la lista de cadenas
en orden alfabético descendente.
Ordenar un ArrayList de enteros numéricamente en orden descendente:

import java.util.ArrayList;
import java.util.Collections; // Importar la clase Collections

public class Main {

public static void main(String[] args) {
ArrayList<Integer> myNumbers = new ArrayList<Integer>();
myNumbers.add(33);
myNumbers.add(15);
myNumbers.add(20);
myNumbers.add(34);
myNumbers.add(8);
myNumbers.add(12);

Collections.sort(myNumbers, Collections.reverseOrder()); // Ordenar en orden inverso

for (int i : myNumbers) {

System.out.println(i);
}
}
}

En este ejemplo, usamos Collections.sort() junto con Collections.reverseOrder() para ordenar la lista de
enteros en orden numérico descendente.
ArrayList vs. LinkedList: Ambos son tipos de listas en Java, pero ArrayList está basado en un arreglo
dinámico, mientras que LinkedList utiliza nodos conectados entre sí. Dependiendo del uso, uno puede ser más
eficiente que el otro para determinadas operaciones (por ejemplo, insertar o eliminar elementos al principio de la lista es
más eficiente en un LinkedList).

Métodos de Collections: La clase Collections ofrece varios métodos útiles para manipular listas. El método
sort() organiza los elementos en orden ascendente, mientras que reverseOrder() invierte ese orden para un
orden descendente. Estos métodos son muy útiles cuando se necesita organizar los elementos de una lista según
criterios específicos.

Ordenar cadenas y números: En Java, ordenar cadenas y números es sencillo gracias a estos métodos de
Collections. El orden alfabético en cadenas y el orden numérico en enteros son el comportamiento predeterminado
al usar sort().

Cuándo usar:

● ArrayList es ideal cuando necesitas acceso rápido y frecuente a elementos por su índice. Es más eficiente
para obtener datos aleatorios.
● LinkedList es más adecuado cuando necesitas insertar o eliminar elementos frecuentemente en cualquier
parte de la lista.

Este enfoque te permite organizar las colecciones de manera eficiente, ya sea en orden ascendente o descendente,
según tus necesidades.
¿Qué es un HashMap?
Un HashMap en Java es una estructura de datos que almacena elementos como pares clave-valor. A diferencia de un
ArrayList, donde los elementos se acceden por un índice numérico, en un HashMap los elementos se acceden
utilizando una clave (que puede ser de cualquier tipo de objeto) y están asociados a un valor.

Método put(): El método put() se usa para agregar un par clave-valor al HashMap. Si la clave ya existe, el valor
asociado a esa clave se actualizará.

Método get(): Para recuperar el valor asociado con una clave en el HashMap, se utiliza el método get(). Si la
clave no existe, el método devuelve null.

Iteración sobre el HashMap: Existen varias formas de recorrer los elementos de un HashMap: puedes iterar solo
sobre las claves usando keySet(), sobre los valores con values(), o sobre ambos (clave y valor) utilizando
keySet() y el método get().

Clases envolventes (Wrapper Classes): Los tipos primitivos como int no pueden ser utilizados directamente como
claves o valores en un HashMap. En su lugar, debes usar las clases envolventes como Integer para int, Double
para double, Character para char, entre otras.
HashMap almacena los elementos en pares de clave/valor, y puedes acceder a ellos mediante un índice de otro tipo,
como por ejemplo un String.

En un HashMap, un objeto se utiliza como clave (índice) para acceder a otro objeto (valor). Se pueden almacenar
diferentes tipos de datos: claves de tipo String y valores de tipo Integer, o claves y valores del mismo tipo, como
claves de tipo String y valores de tipo String.

Crear un HashMap

Para crear un HashMap que almacene claves de tipo String y valores de tipo String, usamos el siguiente código:

import java.util.HashMap; // Importar la clase HashMap

HashMap<String, String> capitalCities = new HashMap<String, String>();

Aquí, hemos creado un HashMap llamado capitalCities que almacenará pares clave/valor, donde tanto la clave
como el valor son cadenas de texto.
Agregar elementos a un HashMap

El HashMap tiene varios métodos útiles. Para agregar elementos, se utiliza el método put(). Por ejemplo, para
agregar países y sus respectivas capitales:

import java.util.HashMap;

public class Main {

public static void main(String[] args) {
HashMap<String, String> capitalCities = new HashMap<String, String>();

// Agregar claves y valores (País, Ciudad)

capitalCities.put("England", "London");
capitalCities.put("Germany", "Berlin");
capitalCities.put("Norway", "Oslo");
capitalCities.put("USA", "Washington DC");

System.out.println(capitalCities);
}
}

En este código, se agregan pares clave/valor donde la clave es el nombre del país y el valor es su capital.
Acceder a un elemento

Para acceder a un valor en un HashMap, se usa el método get() y se hace referencia a su clave. Por ejemplo:

capitalCities.get("England");

Este código devolverá el valor asociado a la clave "England", que en este caso es "London".

Eliminar un elemento

Para eliminar un elemento, se usa el método remove() y se hace referencia a la clave que deseas eliminar:

capitalCities.remove("England");

Este código eliminará la entrada con la clave "England" y su valor asociado.

Para eliminar todos los elementos del HashMap, se puede usar el método clear():

capitalCities.clear();
Obtener el tamaño del HashMap

Si deseas saber cuántos elementos hay en un HashMap, puedes usar el método size():

capitalCities.size();

Este código devuelve la cantidad de pares clave/valor en el HashMap.

Recorrer un HashMap

Puedes recorrer los elementos de un HashMap utilizando un bucle for-each. Hay diferentes maneras de hacerlo
dependiendo de lo que quieras acceder (solo claves, solo valores, o ambos).

● Imprimir solo las claves:

for (String i : capitalCities.keySet()) {

System.out.println(i);
}

● Imprimir solo los valores:

for (String i : capitalCities.values()) {

System.out.println(i);
}
 ● Imprimir claves y valores:

for (String i : capitalCities.keySet()) {

System.out.println("key: " + i + " value: " + capitalCities.get(i));
}

Uso de otros tipos

Las claves y los valores de un HashMap son objetos. En los ejemplos anteriores, hemos usado objetos de tipo String.
Sin embargo, puedes usar otros tipos de datos, como int, pero debes especificar una clase envolvente (wrapper
class), como Integer para int. Para otros tipos primitivos, se usan clases envolventes como: Boolean para
boolean, Character para char, Double para double, etc.

Ejemplo: Crear un HashMap con claves de tipo String y valores de tipo Integer:
import java.util.HashMap;

public class Main {

public static void main(String[] args) {

HashMap<String, Integer> people = new HashMap<String, Integer>();

// Agregar claves y valores (Nombre, Edad)

people.put("John", 32);
people.put("Steve", 30);
En este ejemplo, el HashMap people almacena
people.put("Angie", 33); claves de tipo String (nombres de personas) y
valores de tipo Integer (edades).
for (String i : people.keySet()) {
System.out.println("key: " + i + " value: " + people.get(i));
}
}
}
¿Qué es un HashSet?
Un HashSet es una colección de elementos donde todos los elementos son únicos. No puedes agregar elementos
duplicados a un HashSet, y no importa el orden en que se agreguen o se recuperen los elementos. Esto lo convierte en
una buena opción cuando necesitas almacenar elementos sin duplicados y no te importa el orden de esos elementos.

1. Método add(): El método add() se usa para agregar elementos a un HashSet. Si intentas agregar un
elemento que ya existe, el conjunto no lo agregará, garantizando que todos los elementos sean únicos.
2. Método contains(): Este método se utiliza para verificar si un elemento ya está presente en el HashSet.
Devuelve true si el elemento existe y false si no.
3. Método remove(): Para eliminar un elemento de un HashSet, se utiliza el método remove(). Si el elemento no
existe en el conjunto, el conjunto no cambiará.
4. Recorrer un HashSet: Puedes recorrer los elementos de un HashSet con un bucle for-each, lo que te permite
acceder a cada elemento sin necesidad de preocuparte por los índices, ya que un HashSet no tiene un orden
específico.
5. Uso de clases envolventes: Aunque en los ejemplos se utilizan cadenas de texto (String), puedes utilizar
otros tipos, como Integer o Double, pero debes asegurarte de usar las clases envolventes correspondientes
para tipos primitivos (como int o double), ya que los tipos primitivos no pueden ser almacenados directamente
en un HashSet.
Un HashSet es una colección de elementos donde cada elemento es único, es decir, no se permiten duplicados. Esta
clase se encuentra en el paquete java.util y es parte de la estructura de datos de Java.

Crear un HashSet

Para crear un HashSet que almacene cadenas de texto (String), se utiliza la siguiente sintaxis:

import java.util.HashSet; // Importar la clase HashSet

HashSet<String> cars = new HashSet<String>();

En este caso, hemos creado un HashSet llamado cars que almacenará elementos de tipo String.

Agregar Elementos La clase HashSet tiene varios métodos útiles. Para agregar elementos a un HashSet, se utiliza el
método add(). Aquí tienes un ejemplo:
import java.util.HashSet;

public class Main {

public static void main(String[] args) {
HashSet<String> cars = new HashSet<String>();
cars.add("Volvo");
cars.add("BMW");
cars.add("Ford");
cars.add("BMW"); // Intento de agregar duplicado
cars.add("Mazda");
System.out.println(cars);
}
}
Nota: En este ejemplo, aunque "BMW" se agrega dos veces, solo aparecerá una vez en el HashSet, porque los
elementos en un conjunto (Set) deben ser únicos.

Verificar si un Elemento Existe

Para verificar si un elemento existe en el HashSet, se utiliza el método contains():

cars.contains("Mazda"); // Devuelve true si "Mazda" está en el HashSet

Eliminar un Elemento

Para eliminar un elemento, se usa el método remove():

cars.remove("Volvo"); // Elimina "Volvo" del HashSet

Si deseas eliminar todos los elementos, puedes usar el método clear():

cars.clear(); // Elimina todos los elementos del HashSet

Tamaño del HashSet

Para saber cuántos elementos hay en un HashSet, se utiliza el método size():

cars.size(); // Devuelve el número de elementos en el HashSet

Recorrer un HashSet

Puedes recorrer los elementos de un HashSet utilizando un bucle for-each:

for (String i : cars) {

System.out.println(i); // Imprime cada elemento del HashSet
}

Uso de Otros Tipos

Los elementos en un HashSet son objetos. En los ejemplos anteriores, se utilizaron elementos de tipo String, que
son objetos en Java (no tipos primitivos). Si quieres usar otros tipos como int, debes usar la clase envolvente
correspondiente, como Integer. Para otros tipos primitivos, se usan las siguientes clases envolventes:

● Boolean para boolean

● Character para char
● Double para double
Ejemplo: Crear un HashSet con objetos de tipo Integer:

import java.util.HashSet;

public class Main {

public static void main(String[] args) {

// Crear un HashSet que almacene enteros

HashSet<Integer> numbers = new HashSet<Integer>();

// Agregar valores al HashSet

numbers.add(4);
numbers.add(7);
numbers.add(8);

// Mostrar cuáles números entre 1 y 10 están en el HashSet

for (int i = 1; i <= 10; i++) {
if (numbers.contains(i)) {
System.out.println(i + " fue encontrado en el conjunto.");
} else {
System.out.println(i + " no fue encontrado en el conjunto.");
}
}
}
}
¿Qué es un Iterator? Un Iterator es una herramienta muy útil en Java para recorrer elementos de una
colección (como listas o conjuntos). El iterador proporciona métodos para obtener el siguiente elemento (next()),
verificar si hay más elementos (hasNext()), y eliminar elementos (remove()) durante el recorrido. Esto lo convierte en
un mecanismo versátil para recorrer y modificar colecciones de manera controlada.

1. Métodos principales de un Iterator:

○ hasNext(): Devuelve true si hay más elementos en la colección que no se han procesado aún, y false
si no queda ningún elemento.
○ next(): Devuelve el siguiente elemento de la colección. Si no hay más elementos (cuando hasNext()
devuelve false), intentarlo causará una excepción NoSuchElementException.
○ remove(): Elimina el último elemento devuelto por el iterador de la colección. Este método solo se puede
llamar después de invocar next().
2. Ventajas del Iterator:
○ Seguridad al modificar colecciones: Si necesitas modificar una colección mientras la recorres, un Iterator
es mucho más seguro que otros bucles (como for-each), ya que maneja internamente los problemas que
podrían surgir de modificar el tamaño de la colección mientras se recorre.
○ Recorrido uniforme: Al utilizar Iterator, puedes recorrer cualquier tipo de colección (listas, conjuntos,
etc.) de manera uniforme sin importar su implementación interna o el orden de los elementos.
3. Importante Consideración sobre la Eliminación de Elementos: Intentar modificar la colección (agregar o
eliminar elementos) mientras la recorres con un bucle for o for-each generará excepciones de concurrencia. El
Iterator soluciona este problema permitiendo modificaciones seguras a través del método remove().
Un Iterator (Iterador) es un objeto que se utiliza para recorrer colecciones, como ArrayList y HashSet. Se llama
"iterador" porque "iterar" es el término técnico para hacer un recorrido a través de los elementos de una colección.

Para usar un Iterator, es necesario importarlo desde el paquete java.util.

Obtener un Iterator El método iterator() se usa para obtener un Iterator para cualquier colección. A continuación,
te muestro un ejemplo de cómo crear un Iterator para recorrer una colección:
// Importar las clases ArrayList y Iterator
import java.util.ArrayList;
import java.util.Iterator;

public class Main {

public static void main(String[] args) {

// Crear una colección

ArrayList<String> cars = new ArrayList<String>();
cars.add("Volvo");
cars.add("BMW");
cars.add("Ford");
cars.add("Mazda");

// Obtener el iterador
Iterator<String> it = cars.iterator();

// Imprimir el primer elemento

System.out.println(it.next());
}}
En este ejemplo, creamos un ArrayList llamado cars, añadimos algunos elementos a la lista y luego obtenemos un
Iterator con el método iterator(). Después usamos el método next() para imprimir el primer elemento de la
colección.

Recorrer una Colección

Para recorrer todos los elementos de una colección, se utilizan los métodos hasNext() y next() del Iterator:

● hasNext(): Verifica si hay más elementos para recorrer en la colección.

● next(): Devuelve el siguiente elemento de la colección.

A continuación, te muestro cómo recorrer todos los elementos de la colección:

while (it.hasNext()) {
System.out.println(it.next());
}

Este código imprimirá todos los elementos de la colección uno por uno, ya que hasNext() verifica si hay más
elementos y, si es así, next() devuelve el siguiente elemento.

Eliminar Elementos de una Colección

Los Iterators están diseñados para facilitar la modificación de las colecciones mientras se recorre la colección. El
método remove() puede eliminar elementos de la colección mientras se itera sobre ella.
Ejemplo: Usar un iterador para eliminar números menores que 10 de una colección:

import java.util.ArrayList;
import java.util.Iterator;

public class Main {

public static void main(String[] args) {
ArrayList<Integer> numbers = new ArrayList<Integer>();
numbers.add(12);
numbers.add(8);
numbers.add(2);
numbers.add(23);

Iterator<Integer> it = numbers.iterator();
while (it.hasNext()) {
Integer i = it.next();
if (i < 10) {
it.remove(); // Eliminar elementos menores que 10
}
}
System.out.println(numbers); // Imprime la lista actualizada
}
}

Nota: Si intentas eliminar elementos utilizando un bucle for o un bucle for-each mientras recorres la colección, esto
no funcionará correctamente. Esto se debe a que la colección está cambiando de tamaño mientras se intenta recorrer, lo
que puede generar errores. Por eso, se recomienda usar un Iterator cuando necesites modificar la colección durante el
recorrido.
¿Qué son las Clases Wrapper?
Las Clases Wrapper permiten tratar los tipos primitivos de Java como objetos. Esto es necesario porque muchas de las
colecciones en Java, como ArrayList, requieren que los elementos sean objetos. Por ejemplo, no puedes almacenar
valores primitivos como int en una lista, pero puedes usar la clase Integer para almacenar valores enteros como
objetos.

Métodos Clave de las Clases Wrapper:

○ Métodos Value(): Cada clase Wrapper tiene métodos como intValue(), byteValue(),
shortValue(), etc., que permiten extraer el valor primitivo encapsulado en el objeto Wrapper.
○ Método toString(): Este método convierte el valor del Wrapper en una cadena de texto. Es útil cuando
necesitas representar el valor como un String.

¿Por qué usar Clases Wrapper?

○ Las clases Wrapper permiten almacenar tipos primitivos en colecciones que solo aceptan objetos.
○ Son útiles cuando necesitas métodos adicionales para trabajar con los valores primitivos, como convertir el
valor en una cadena (toString()) o obtener el valor primitivo (intValue()).

Conversión entre Tipos Primitivos y Objetos: Las clases Wrapper permiten la conversión fluida entre los tipos
primitivos y sus equivalentes como objetos. Esta conversión es necesaria para trabajar con colecciones, y también
facilita la manipulación de datos primitivos cuando se necesitan métodos adicionales.
Uso de Clases Wrapper
A veces, debes usar las clases Wrapper. Por ejemplo, al trabajar con colecciones como ArrayList, donde no se
pueden usar tipos primitivos. Solo se pueden almacenar objetos en una lista, no valores primitivos:

Ejemplo:

ArrayList<int> myNumbers = new ArrayList<int>(); // Incorrecto

ArrayList<Integer> myNumbers = new ArrayList<Integer>(); // Correcto

En este caso, no puedes usar int directamente, pero puedes usar la clase Integer, que es el Wrapper
correspondiente.

Creación de Objetos Wrapper

Para crear un objeto Wrapper, usas la clase Wrapper en lugar del tipo primitivo. Una vez creado, puedes obtener el valor
del objeto Wrapper como si fuera un tipo primitivo, por ejemplo, imprimiendo el objeto directamente.

Ejemplo:

public class Main {

public static void main(String[] args) {
Integer myInt = 5;
Double myDouble = 5.99;
Character myChar = 'A';
 System.out.println(myInt); // Imprime: 5
System.out.println(myDouble); // Imprime: 5.99
System.out.println(myChar); // Imprime: A
}
}

Métodos para Obtener el Valor del Objeto Wrapper

Dado que ahora estás trabajando con objetos, puedes usar ciertos métodos para obtener información sobre el objeto
específico. Por ejemplo, para obtener el valor que encapsula el objeto Wrapper, puedes utilizar métodos como
intValue(), byteValue(), shortValue(), longValue(), floatValue(), doubleValue(), charValue(), y
booleanValue().

Ejemplo:

public class Main {

public static void main(String[] args) {
Integer myInt = 5;
Double myDouble = 5.99;
Character myChar = 'A';
System.out.println(myInt.intValue()); // Imprime: 5
System.out.println(myDouble.doubleValue()); // Imprime: 5.99
System.out.println(myChar.charValue()); // Imprime: A
}
}
Este ejemplo produce el mismo resultado que el anterior, pero esta vez utilizando los métodos específicos para obtener
el valor primitivo encapsulado en el Wrapper.

Método toString()

Otro método útil es el toString(), que se usa para convertir los objetos Wrapper en cadenas de texto. Esto es
especialmente útil cuando necesitas trabajar con representaciones de texto de los valores.

Ejemplo:

public class Main {

public static void main(String[] args) {
Integer myInt = 100;
String myString = myInt.toString(); // Convierte el Integer en String
System.out.println(myString.length()); // Imprime la longitud de la cadena: 3
}
}

En este ejemplo, el Integer se convierte en un String, y luego se imprime la longitud de la cadena resultante, que es
3 (la cantidad de caracteres de "100").
Clases Wrapper en Java

Las Clases Wrapper en Java proporcionan una forma de utilizar tipos de datos primitivos (como int, boolean, etc.)
como objetos. Esto es importante porque, en ciertos contextos, como cuando trabajas con colecciones, solo puedes
usar objetos, no tipos primitivos. Las clases Wrapper permiten envolver estos tipos primitivos en objetos.

A continuación, se muestra una tabla que indica el tipo de dato primitivo y su clase Wrapper correspondiente: