Contenido del Curso
Fundamentos de Java
Fundamentos de Java
¿Qué Es un Array?
Arreglos
Almacenar información exclusivamente en variables no siempre es conveniente, ya que consumiría una cantidad significativa de memoria de pila y requeriría un número considerable de líneas de código.
La solución a este problema son los arreglos.
Exploremos la sintaxis básica para declarar un arreglo en Java:
Main
dataType[] arrayName = new dataType[capacity];
Podemos utilizar cualquier tipo de dato al declarar un arreglo, incluyendo int, float, char y más. Incluso es posible emplear tus propias clases personalizadas en las declaraciones de arreglos. El aprendizaje sobre cómo crear tus propias clases y sus objetos se abordará en un curso aparte de Java Extended.
Es obligatorio especificar el tamaño del arreglo entre corchetes ([]). Consideremos un ejemplo de cómo crear un arreglo de tipo int con un tamaño de 5:
Main
package com.example; public class Main { public static void main(String[] args) { // Declares a new int array with a length of 5 int[] intArray = new int[5]; // Prints the size of the array System.out.println(intArray.length); } }
Como habrás notado, utilizamos algo desconocido junto con la salida en consola. Esto se denomina propiedad del arreglo.
Los arreglos poseen sus propias propiedades.
Las propiedades se acceden utilizando la notación de punto (.) sobre el objeto correspondiente. En nuestro ejemplo, el arreglo intArray tiene propiedades y estamos utilizando una de ellas.
La propiedad .length devuelve el tamaño (longitud) del arreglo como un valor de tipo int. Esto también puede escribirse de otra manera:
Main
package com.example; public class Main { public static void main(String[] args) { // Declares a new int array with a length of 5 int[] intArray = new int[5]; // Declares a new int with the value of the array's size int length = intArray.length; // Prints the size of the array System.out.println(length); } }
Ahora, examinemos tres métodos y propiedades fundamentales para trabajar con arreglos:
Arrays.sort(array): ordena los elementos del arreglo en orden ascendente;Arrays.fill(array, value): asigna el valor especificado a todos los elementos del arreglo;Arrays.toString(array): convierte el arreglo en una representación de cadena, facilitando la visualización de sus elementos.
Main
package com.example; import java.util.Arrays; public class Main { public static void main(String[] args) { int[] array = {5, 2, 9, 1, 6}; // Sort the array Arrays.sort(array); System.out.println("Sorted array: " + Arrays.toString(array)); // Fill the array with the value 0 Arrays.fill(array, 0); System.out.println("Array after filling: " + Arrays.toString(array)); } }
Primero, ordena el arreglo en orden ascendente utilizando Arrays.sort() y muestra el arreglo ordenado usando Arrays.toString(), que convierte el arreglo en un formato de cadena legible. Luego, todos los elementos del arreglo son reemplazados por 0 utilizando Arrays.fill(), y el arreglo actualizado se imprime en el mismo formato legible.
¿Cómo acceder a datos específicos en un arreglo?
Los arreglos en Java están indexados. Cada elemento del arreglo se encuentra en su celda y se le asigna un ID único. La numeración de los elementos dentro del arreglo comienza en 0. Supongamos que tenemos un arreglo de números from zero to nine, por lo que contiene 10 elementos.
Veamos un diagrama que ilustra cómo se organizan los elementos dentro del arreglo:
Si tenemos un arreglo con 10 elementos, el primer elemento se almacenará en el índice 0 y el último en el índice 9, porque la indexación comienza desde cero.
La práctica siempre es mejor que solo la teoría, así que exploremos un ejemplo de cómo agregar y eliminar elementos de un arreglo utilizando índices:
Main
package com.example; public class Main { public static void main(String[] args) { // Declares a new int array with a length of 5 int[] intArray = new int[5]; // Fills the array with numbers from 1 to 5 intArray[0] = 1; intArray[1] = 2; intArray[2] = 3; intArray[3] = 4; intArray[4] = 5; // Prints the fourth element of the array System.out.println(intArray[3]); } }
Hemos llenado nuestro arreglo con elementos del uno al cinco especificando cada elemento con un índice. Sin embargo, este enfoque carece de elegancia y requiere muchas líneas de código. Veamos un método alternativo para declarar un arreglo que ya viene prellenado:
Main
package com.example; public class Main { public static void main(String[] args) { // Declares a new pre-filled int array with a length of 5 int[] intArray = {1, 2, 3, 4, 5}; // Prints the first element of the array System.out.println(intArray[0]); } }
Creamos un arreglo idéntico al que hicimos anteriormente, pero esta vez requirió menos líneas de código y se ve más elegante.
Es importante destacar que al utilizar esta notación de arreglo, los elementos deben estar encerrados entre llaves ({}) y separados por comas.
1. ¿Qué se imprimirá al ejecutar este código?
2. ¿Qué se imprimirá al ejecutar este código?
¡Gracias por tus comentarios!
