ARREGLOS

Vista previa del material en texto

ARREGLOS
Un array en Java es una estructura de datos que permite almacenar una colección de elementos, todos del mismo tipo, en una única variable.
Los elementos de un array están organizados secuencialmente en memoria, y se pueden acceder a través de índices numéricos, comenzando por el índice 0 para el primer elemento, 1 para el segundo, y así sucesivamente.
Los arreglos son objetos en Java y tienen un tamaño fijo una vez que son creados. Sin embargo, existen otras estructuras de datos como ArrayList que permiten agregar y eliminar elementos dinámicamente.
Ventajas de utilizar arrays:
· Permiten almacenar múltiples elementos del mismo tipo en una única variable.
· Facilitan la organización y el manejo de conjuntos de datos relacionados.
· Ofrecen un acceso rápido y eficiente a los elementos mediante índices numéricos.
· Mejoran la legibilidad y la estructura del código al agrupar datos relacionados.
Algunos de los métodos más comunes en los arreglos son:
· length: devuelve el número de elementos en el arreglo.
· sort: ordena los elementos del arreglo.
· fill: rellena el arreglo con un valor específico.
· toString: devuelve una representación en cadena del arreglo.
Creación de arrays en Java
Crear un array en Java implica tres pasos: declarar la variable del array, asignarle memoria y, opcionalmente, inicializar sus elementos. Veamos cada uno de estos pasos con ejemplos detallados.
a) Declaración de arrays
Para declarar un array, utilizamos la siguiente sintaxis: tipo_de_dato[] nombre_del_array;
Ejemplo:
int[] numeros; // Declarando un array de enteros llamado "numeros"
String[] palabras; // Declarando un array de cadenas llamado "palabras"
b) Asignación de memoria
Después de declarar el array, es necesario asignarle memoria, especificando su tamaño con la palabra clave new. La sintaxis es: nombre_del_array = new tipo_de_dato[tamaño];
Ejemplo:
numeros = new int[5]; // Asignando memoria para 5 elementos enteros en el array "numeros"
palabras = new String[3]; // Asignando memoria para 3 elementos de cadena en el array "palabras"
También podemos declarar y asignar memoria en una sola línea:
int[] numeros = new int[5]; // Declarando y asignando memoria al array "numeros"
String[] palabras = new String[3]; // Declarando y asignando memoria al array "palabras"
c) Inicialización de arrays
Podemos inicializar los elementos del array de varias maneras. A continuación, se presentan algunas de ellas:
1. Inicialización individual de elementos:
numeros[0] = 10; // Asignando el valor 10 al primer elemento del array "numeros"
numeros[1] = 20; // Asignando el valor 20 al segundo elemento
// ...
palabras[0] = "Hola"; // Asignando la cadena "Hola" al primer elemento del array "palabras"
palabras[1] = "Mundo"; // Asignando la cadena "Mundo" al segundo elemento
// ...
2. Inicialización durante la declaración:
int[] numeros = {1, 2, 3, 4, 5}; // Declarando, asignando memoria e inicializando el array "numeros" con valores
String[] palabras = {"Java", "Array", "Ejemplo"}; // Declarando, asignando memoria e inicializando el array "palabras" con cadenas
3. Inicialización usando bucles:
for (int i = 0; i < numeros.length; i++) {
 numeros[i] = i * 10; // Asignando valores múltiplos de 10 a los elementos del array "numeros"
}
for (int i = 0; i < palabras.length; i++) {
 palabras[i] = "Palabra " + (i + 1); // Asignando "Palabra 1", "Palabra 2", ... a los elementos del array "palabras"
}
La creación de un array en Java implica declarar la variable del array, asignarle memoria y, opcionalmente, inicializar sus elementos. La comprensión de estos pasos es fundamental para trabajar con arrays y organizar datos en nuestros programas de manera eficiente.
Tipos de arrays en Java
En Java, podemos crear arrays de diferentes tipos, como arrays de tipos primitivos, arrays de objetos y clases, y arrays multidimensionales.
A continuación, se presenta una descripción de cada uno de estos tipos, junto con ejemplos detallados.
a) Arrays de tipos primitivos
Los arrays de tipos primitivos permiten almacenar elementos de tipos básicos como int, double, char, boolean, etc.
Estos son algunos ejemplos:
int[] numeros = new int[5]; // Array de enteros
double[] precios = new double[3]; // Array de números decimales (double)
char[] letras = new char[10]; // Array de caracteres
boolean[] banderas = new boolean[2]; // Array de valores booleanos (verdadero/falso)
b) Arrays de objetos y clases
Los arrays de objetos y clases permiten almacenar elementos que son instancias de clases personalizadas o clases predefinidas de Java, como String, Integer, Double, etc.
Ejemplo – Array de objetos de la clase String:
String[] nombres = new String[4]; // Array de objetos de la clase String
nombres[0] = "Alice";
nombres[1] = "Bob";
nombres[2] = "Carol";
nombres[3] = "David";
Ejemplo – Array de objetos de una clase personalizada (Estudiante):
class Estudiante {
 String nombre;
 int edad;
 Estudiante(String nombre, int edad) {
 this.nombre = nombre;
 this.edad = edad;
 }
}
// Creación de un array de objetos de la clase Estudiante
Estudiante[] estudiantes = new Estudiante[3];
estudiantes[0] = new Estudiante("Juan", 20);
estudiantes[1] = new Estudiante("Ana", 22);
estudiantes[2] = new Estudiante("Luis", 19);
c) Arrays multidimensionales
Los arrays multidimensionales son arrays cuyos elementos son, a su vez, otros arrays. El caso más común es el array bidimensional, también conocido como matriz.
Ejemplo – Array bidimensional de enteros (matriz de enteros):
int[][] matriz = new int[3][4]; // Creación de una matriz de 3 filas y 4 columnas
// Inicialización de la matriz con valores
matriz[0][0] = 1;
matriz[0][1] = 2;
matriz[0][2] = 3;
matriz[0][3] = 4;
matriz[1][0] = 5;
// ...
// Inicialización de la matriz con bucles
for (int i = 0; i < matriz.length; i++) {
 for (int j = 0; j < matriz[i].length; j++) {
 matriz[i][j] = (i * matriz[i].length) + j + 1;
 }
}
Ejemplo – Array bidimensional de objetos de la clase String:
String[][] tablero = new String[3][3]; // Creación de un tablero de 3x3 para un juego de tres en raya
// Inicialización del tablero con guiones
for (int i = 0; i < tablero.length; i++) {
 for (int j = 0; j < tablero[i].length; j++) {
 tablero[i][j] = "-";
 }
}
// Imprimir el tablero en la consola
for (int i = 0; i < tablero.length; i++) {
 for (int j = 0; j < tablero[i].length; j++) {
 System.out.print(tablero[i][j] + " ");
 }
 System.out.println();
}
Este ejemplo crea un tablero de 3×3 para un juego de tres en raya utilizando un array bidimensional de objetos de la clase String. Luego, inicializa el tablero con guiones y lo imprime en la consola.
Acceso a elementos de un array en Java
Para acceder a los elementos de un array en Java, utilizamos índices numéricos. Los índices en un array comienzan en 0 para el primer elemento, 1 para el segundo y así sucesivamente hasta la longitud del array menos 1 para el último elemento.
A continuación, se muestran ejemplos de cómo acceder a los elementos de diferentes tipos de arrays.
a. Acceso a elementos de un array de tipos primitivos
int[] numeros = {10, 20, 30, 40, 50}; 
int primerNumero = numeros[0]; // Accediendo al primer elemento del array 
int segundoNumero = numeros[1]; // Accediendo al segundo elemento del array 
int ultimoNumero = numeros[numeros.length - 1]; // Accediendo al último elemento del array System.out.println("Primer número: " + primerNumero); System.out.println("Segundo número: " + segundoNumero); System.out.println("Último número: " + ultimoNumero);
b. Acceso a elementos de un array de objetos y clases
String[] nombres = {"Alice", "Bob", "Carol", "David"}; 
String primerNombre = nombres[0]; // Accediendo al primer elemento del array 
String segundoNombre = nombres[1]; // Accediendo al segundo elemento del array 
String ultimoNombre = nombres[nombres.length - 1]; // Accediendo al último elemento del array 
System.out.println("Primer nombre: " + primerNombre); System.out.println("Segundo nombre: " + segundoNombre);System.out.println("Último nombre: " + ultimoNombre)
c.  Acceso a elementos de un array multidimensional
int[][] matriz = {
 {1, 2, 3},
 {4, 5, 6},
 {7, 8, 9}
 };
 int primerElemento = matriz[0][0]; // Accediendo al primer elemento de la matriz
 int elementoCentral = matriz[1][1]; // Accediendo al elemento central de la matriz
 int ultimoElemento = matriz[matriz.length - 1][matriz[0].length - 1];
 System.out.println("Primer elemento: " + primerElemento);
 System.out.println("Elemento central: " + elementoCentral);
 System.out.println("Último elemento: " + ultimoElemento);
Obtener la longitud de un array
Para obtener la longitud de un array (es decir, la cantidad de elementos que contiene), utilizamos la propiedad length.
Ejemplo:
int[] numeros = {10, 20, 30, 40, 50};
int longitud = numeros.length; // Obteniendo la longitud del array "numeros"
System.out.println("La longitud del array 'numeros' es: " + longitud);
Para obtener la longitud de un array multidimensional, aplicamos la propiedad length a las dimensiones correspondientes.
Ejemplo:
int[][] matriz = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }; 
int filas = matriz.length; // Obteniendo el número de filas de la matriz 
int columnas = matriz[0].length; // Obteniendo el número de columnas de la matriz System.out.println("La matriz tiene " + filas + " filas y " + columnas + " columnas.");
Este ejemplo muestra cómo obtener la cantidad de filas y columnas en una matriz (array bidimensional) utilizando la propiedad length. En este caso, la matriz tiene 3 filas y 3 columnas
Manipulación de Arrays en Java
En esta sección, veremos cómo manipular arrays en Java a través de diversos ejemplos prácticos y bien documentados.
Recorrido de arrays usando bucles (for, for-each, while)
· Bucle for:
int[] numeros = {1, 2, 3, 4, 5};
 for (int i = 0; i < numeros.length; i++) {
 System.out.println("Elemento en el índice " + i + ": " + numeros[i]);
 }
En este ejemplo, utilizamos un bucle for para recorrer el array de números. La variable i representa el índice del elemento actual. Accedemos a cada elemento del array utilizando numeros[i].
· Bucle while:
int[] numeros = {1, 2, 3, 4, 5};
int i = 0;
 	while (i < numeros.length) {
 	System.out.println("Elemento en el índice " + i + ": " + numeros[i]);
 	i++;
 }
En este ejemplo, utilizamos un bucle while para recorrer el array de números. Es similar al bucle for, pero la estructura de control es ligeramente diferente.
Búsqueda y filtrado de elementos en un array
· Búsqueda de elementos:
int[] numeros = {10, 25, 32, 45, 18}; 
int numeroBuscado = 32; 
boolean encontrado = false; 
for (int numero : numeros) { 
if (numero == numeroBuscado) { 
encontrado = true; break; 
} 
} 
if (encontrado) { 
System.out.println("El número " + numeroBuscado + " está en el array."); 
} else { 
System.out.println("El número " + numeroBuscado + " no se encuentra en el array."); 
}
En este ejemplo, buscamos un número específico en el array. Si lo encontramos, cambiamos el valor de la variable booleana encontrado a true y salimos del bucle.
· Filtrado de elementos:
int[] numeros = {10, 25, 32, 45, 18}; 
int limite = 30; 
ArrayList<Integer> filtrados = new ArrayList<>(); 
for (int numero : numeros) { 
if (numero > limite) { 
filtrados.add(numero); 
} 
} 
System.out.println("Números mayores a " + limite + ": " + filtrados);
En este ejemplo, filtramos los números mayores a un límite específico utilizando un ArrayList para almacenar los elementos que cumplen con la condición.
Modificación y eliminación de elementos en un array
· Modificación de elementos:
int[] numeros = {1, 2, 3, 4, 5}; 
for (int i = 0; i < numeros.length; i++) { 
numeros[i] *= 2; 
} 
System.out.println("Array modificado: " + Arrays.toString(numeros)); 
En este ejemplo, modificamos cada elemento del array de números multiplicándolos por 2. Usamos un bucle for para acceder a cada elemento del array por su índice y actualizar su valor.
· Eliminación de elementos:
Dado que los arrays en Java tienen una longitud fija, no es posible eliminar directamente un elemento de un array. Sin embargo, podemos crear un nuevo array sin el elemento que deseamos eliminar. En este caso, utilizaremos un ArrayList como estructura intermedia para facilitar el proceso.
int[] numeros = {1, 2, 3, 4, 5}; 
int numeroAEliminar = 3; 
ArrayList<Integer> listaNumeros = new ArrayList<>(); 
for (int numero : numeros) { 
if (numero != numeroAEliminar) { 
listaNumeros.add(numero); 
} 
} 
int[] numerosActualizados = new int[listaNumeros.size()]; 
for (int i = 0; i < listaNumeros.size(); i++) { 
numerosActualizados[i] = listaNumeros.get(i); 
} 
System.out.println("Array original: " + Arrays.toString(numeros)); System.out.println("Array sin el número " + numeroAEliminar + ": " + Arrays.toString(numerosActualizados));
En este ejemplo, creamos un ArrayList para almacenar los elementos del array original, excepto el número que deseamos eliminar. Luego, creamos un nuevo array de la longitud correcta y copiamos los elementos del ArrayList en el nuevo array.
Ten en cuenta que este enfoque no es el más eficiente, especialmente para arrays grandes. Si necesitas trabajar con estructuras de datos dinámicas, es recomendable utilizar ArrayLists u otras colecciones en lugar de arrays.
Arrays y funciones en Java
En esta sección, exploraremos cómo utilizar arrays en combinación con funciones en Java a través de ejemplos prácticos y bien documentados.
· Pasar arrays como argumentos a funciones
public class ArrayFunctions { 
public static void main(String[] args) { 
int[] numeros = {1, 2, 3, 4, 5}; 
imprimirArray(numeros); 
} 
public static void imprimirArray(int[] array) { 
for (int numero : array) { 
System.out.print(numero + " "); 
} System.out.println(); 
} 
}
En este ejemplo, creamos una función llamada imprimirArray que recibe un array de enteros como argumento. Luego, llamamos a esta función desde el método main y le pasamos el array numeros. La función imprimirArray imprime cada elemento del array en una línea.
· Retornar arrays desde funciones
public class ArrayFunctions { 
public static void main(String[] args) { 
int[] numeros = {1, 2, 3, 4, 5}; 
int[] numerosDobles = duplicarElementos(numeros); System.out.println("Array original: " + Arrays.toString(numeros)); System.out.println("Array con elementos duplicados: " + Arrays.toString(numerosDobles)); 
} 
public static int[] duplicarElementos(int[] array) { 
int[] resultado = new int[array.length]; 
for (int i = 0; i < array.length; i++) { 
resultado[i] = array[i] * 2; 
} return resultado; 
} 
}
En este ejemplo, creamos una función llamada duplicarElementos que recibe un array de enteros y retorna un nuevo array con cada elemento duplicado.
Desde el método main, llamamos a esta función y le pasamos el array numeros. La función duplicarElementos crea un nuevo array llamado resultado, llena el array con los elementos duplicados y lo retorna.
· Ejemplo de función con arrays multidimensionales
public class ArrayFunctions { 
public static void main(String[] args) { 
int[][] matriz = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }; imprimirMatriz(matriz); 
} 
public static void imprimirMatriz(int[][] matriz) { 
for (int i = 0; i < matriz.length; i++) { 
for (int j = 0; j < matriz[i].length; j++) {
 System.out.print(matriz[i][j] + " "); } System.out.println(); 
} 
}
}
En este ejemplo, trabajamos con un array bidimensional, también conocido como matriz. Creamos una función llamada imprimirMatriz que recibe una matriz de enteros como argumento y la imprime en un formato tabular. Luego, llamamos a esta función desde el método main y le pasamos la matriz matriz.
Clases y métodos de utilidad para trabajar con Arrays
La clase java.util.Arrays proporciona varios métodos de utilidad que facilitan el manejo y la manipulación de arrays en Java.
A continuación, se presentan algunos ejemplos prácticos y bien documentados de cómo utilizar estos métodos en programas Java.
MétodotoString()
El método toString() se utiliza para convertir un array en una representación de cadena legible. Este método es útil cuando queremos imprimir o mostrar el contenido de un array.
Ejemplo:
import java.util.Arrays;
public class ArrayExample {
 public static void main(String[] args) {
 int[] numbers = {4, 7, 2, 8, 1};
 System.out.println("Array original: " + Arrays.toString(numbers));
 }
}
Método sort()
El método sort() se utiliza para ordenar elementos de un array en orden ascendente. Este método es útil cuando necesitamos organizar los datos de un array en un orden específico.
Ejemplo:
import java.util.Arrays;
public class ArrayExample {
 public static void main(String[] args) {
 int[] numbers = {4, 7, 2, 8, 1};
 Arrays.sort(numbers);
 System.out.println("Array ordenado: " + Arrays.toString(numbers));
 }
}
Método equals()
El método equals() se utiliza para comparar dos arrays y determinar si son iguales. Dos arrays son iguales si contienen el mismo número de elementos y todos los elementos correspondientes en los dos arrays son iguales.
Ejemplo:
import java.util.Arrays;
public class ArrayExample {
 public static void main(String[] args) {
 int[] array1 = {4, 7, 2, 8, 1};
 int[] array2 = {4, 7, 2, 8, 1};
 int[] array3 = {1, 2, 7, 4, 8};
 boolean isEqual = Arrays.equals(array1, array2);
 System.out.println("¿Son array1 y array2 iguales? " + isEqual);
 isEqual = Arrays.equals(array1, array3);
 System.out.println("¿Son array1 y array3 iguales? " + isEqual);
 }
}
Método fill()
El método fill() se utiliza para asignar un valor específico a todos los elementos de un array. Este método es útil cuando necesitamos inicializar un array con un valor predeterminado.
Ejemplo:
import java.util.Arrays;
public class ArrayExample {
 public static void main(String[] args) {
 int[] numbers = new int[5];
 Arrays.fill(numbers, 42);
 System.out.println("Array lleno de 42s: " + Arrays.toString(numbers));
 }
}
Método copyOf()
El método copyOf() se utiliza para crear una copia de un array con una longitud específica. Este método es útil cuando necesitamos duplicar un array o ajustar su tamaño.
Ejemplo:
import java.util.Arrays;
public class ArrayExample {
 public static void main(String[] args) {
 int[] originalArray = {4, 7, 2, 8, 1};
 int[] copiedArray = Arrays.copyOf(originalArray, originalArray.length);
 System.out.println("Copia del array original: " + Arrays.toString(copiedArray));
 }
}
Método binarySearch()
El método binarySearch() se utiliza para buscar un elemento en un array ordenado. Este método utiliza el algoritmo de búsqueda binaria, lo que significa que es muy eficiente en términos de tiempo de ejecución.
Devuelve el índice del elemento buscado si se encuentra, de lo contrario, devuelve un valor negativo.
Ejemplo:
import java.util.Arrays;
public class ArrayExample {
 public static void main(String[] args) {
 int[] numbers = {1, 2, 4, 7, 8};
 int target = 7;
 int index = Arrays.binarySearch(numbers, target);
 if (index >= 0) {
 System.out.println("Elemento " + target + " encontrado en el índice: " + index);
 } else {
 System.out.println("Elemento " + target + " no encontrado en el array.");
 }
 }
}
Método deepEquals()
El método deepEquals() se utiliza para comparar dos arrays multidimensionales y determinar si son iguales.
Dos arrays multidimensionales son iguales si contienen el mismo número de elementos en cada dimensión y todos los elementos correspondientes en los dos arrays son iguales.
Ejemplo:
import java.util.Arrays;
public class ArrayExample {
 public static void main(String[] args) {
 int[][] matrix1 = {{1, 2}, {3, 4}};
 int[][] matrix2 = {{1, 2}, {3, 4}};
 int[][] matrix3 = {{4, 3}, {2, 1}};
 boolean isEqual = Arrays.deepEquals(matrix1, matrix2);
 System.out.println("¿Son matrix1 y matrix2 iguales? " + isEqual);
 isEqual = Arrays.deepEquals(matrix1, matrix3);
 System.out.println("¿Son matrix1 y matrix3 iguales? " + isEqual);
 }
}
Método deepToString()
El método deepToString() se utiliza para convertir un array multidimensional en una representación de cadena legible. Este método es útil cuando queremos imprimir o mostrar el contenido de un array multidimensional.
Ejemplo:
import java.util.Arrays;
public class ArrayExample {
 public static void main(String[] args) {
 int[][] matrix = {{1, 2}, {3, 4}, {5, 6}};
 System.out.println("Array multidimensional: " + Arrays.deepToString(matrix));
 }
}
Estos ejemplos ilustran cómo los métodos de utilidad proporcionados por la clase java.util.Arrays pueden facilitar el trabajo con arrays en Java.
Familiarizarse con estos métodos y aplicarlos en situaciones adecuadas puede mejorar significativamente la eficiencia y la legibilidad de nuestros programas.
Arraylists: una alternativa dinámica a los Arrays
Los arrays en Java son estructuras de datos de tamaño fijo, lo que significa que una vez creados, no se pueden cambiar en tamaño. Aunque son útiles en muchos casos, a veces necesitamos estructuras de datos más flexibles y dinámicas.
Aquí es donde entran las ArrayLists, que son parte del framework de Colecciones de Java y ofrecen un enfoque más dinámico para manejar conjuntos de datos.
Introducción a las colecciones y la clase java.util.ArrayList
Java ofrece un conjunto de clases e interfaces predefinidas en su framework de Colecciones, que nos permite manejar grupos de objetos de manera eficiente y flexible.
Una de estas clases es ArrayList, que es una implementación de la interfaz List y proporciona una estructura de datos similar a un array, pero con capacidad para cambiar de tamaño de manera dinámica.
Creación y manipulación de ArrayLists
Para comenzar a utilizar ArrayLists en Java, primero debemos importar la clase java.util.ArrayList. Luego, podemos crear instancias de ArrayList y manipularlas utilizando sus métodos proporcionados.
import java.util.ArrayList;
public class EjemploArrayList {
 public static void main(String[] args) {
 // Creación de un ArrayList de Strings
 ArrayList<String> nombres = new ArrayList<>();
 // Añadir elementos al ArrayList
 nombres.add("Ana");
 nombres.add("Luis");
 nombres.add("Carlos");
 // Acceder a elementos del ArrayList
 String primerNombre = nombres.get(0); // Ana
 // Eliminar elementos del ArrayList
 nombres.remove(1); // Elimina "Luis"
 // Iterar sobre un ArrayList usando un bucle for-each
 for (String nombre : nombres) {
 System.out.println(nombre);
 }
 // Cambiar el valor de un elemento del ArrayList
 nombres.set(0, "Maria");
 // Obtener el tamaño de un ArrayList
 int tamaño = nombres.size(); // 2
 }
}
Comparación entre Arrays y ArrayLists en Java
Ambos arrays y ArrayLists tienen sus ventajas y desventajas. A continuación, se presentan algunas diferencias clave:
· Arrays:
· Tamaño fijo: útil cuando se conoce el número exacto de elementos.
· Rendimiento ligeramente mejor debido a la falta de métodos adicionales y administración de memoria.
· Puede contener tipos de datos primitivos.
· ArrayLists:
· Tamaño dinámico: útil cuando se desconoce el número exacto de elementos o cuando se requiere cambiar el tamaño.
· Rendimiento ligeramente inferior en comparación con los arrays debido a la administración adicional de memoria y métodos.
· No puede contener tipos de datos primitivos directamente (utilizar clases envolventes como Integer, Double, etc.).
En general, es importante considerar las necesidades específicas de nuestro proyecto al decidir entre usar arrays o ArrayLists. Si requerimos una estructura de datos de tamaño fijo y un rendimiento óptimo, los arrays pueden ser una opción adecuada.
Sin embargo, si necesitamos una estructura de datos más flexible que pueda cambiarde tamaño dinámicamente, las ArrayLists serán una mejor opción.