What Is an Array?
Desliza para mostrar el menú
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 muchas líneas de código.
La solución a este problema son los arreglos.
Un arreglo es un contenedor que puede almacenar una cantidad fija de objetos del mismo tipo.
Exploración de la sintaxis básica para declarar un arreglo en Java:
Main.java
1dataType[] arrayName = new dataType[capacity];
Podemos utilizar cualquier tipo de dato al declarar un arreglo, incluyendo int, float, char y más.
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.java
12345678910package 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 nuevo con la salida en consola: una propiedad de arreglo.
Los arreglos tienen sus propias propiedades, a las que se accede usando la notación de punto (.). En nuestro ejemplo, el arreglo intArray utiliza una de estas propiedades. La propiedad .length devuelve el tamaño del arreglo como un valor int. Esto también se puede escribir de otra manera:
Main.java
123456789101112package 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.
Estos métodos provienen de la clase utilitaria java.util.Arrays. Para utilizarlos, tu código debe importar esta clase al principio.
Main.java
1234567891011121314151617package 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 usando Arrays.sort() y muestra el arreglo ordenado utilizando Arrays.toString(), que convierte el arreglo en un formato de cadena legible. Luego, todos los elementos del arreglo son reemplazados por 0 usando Arrays.fill(), y el arreglo actualizado se imprime en el mismo formato legible.
array es simplemente un nombre de ejemplo para el arreglo. Puedes nombrar el arreglo como desees, según los requisitos de la tarea o tus preferencias.
¿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 del cero al nueve, 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.
En programación, los arreglos utilizan indexación basada en cero, lo que significa que el primer elemento está en la posición 0. La fórmula N-1 ayuda a calcular la posición de un elemento en el arreglo, donde N es el número del elemento (comenzando desde 1) y N-1 es su índice en el arreglo.
La práctica siempre es mejor que solo la teoría, así que aquí tienes un ejemplo de cómo agregar y eliminar elementos de un arreglo usando índices:
Main.java
12345678910111213141516package 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. Exploremos un método alternativo para declarar un arreglo que ya viene prellenado:
Main.java
12345678910package 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 notar que al usar esta notación de arreglo, los elementos deben estar encerrados entre llaves ({}) y separados por comas.
Al declarar un arreglo de esta manera, no especificamos su tamaño explícitamente. El compilador determina automáticamente la longitud requerida del arreglo según los elementos proporcionados y lo llena en consecuencia.
1. ¿Qué se imprimirá al ejecutar este código?
2. ¿Qué se imprimirá al ejecutar este código?
¡Gracias por tus comentarios!
Pregunte a AI
Pregunte a AI
Pregunte lo que quiera o pruebe una de las preguntas sugeridas para comenzar nuestra charla
