Arreglos

Almacenar información exclusivamente en variables no siempre resulta 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.

Examinemos la sintaxis básica para declarar un arreglo en Java:

Main.java


              1
            
dataType[] 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


              12345678910
            
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 nuevo con la salida en consola: una propiedad de arreglo.

Los arreglos tienen sus propias propiedades, a las que se accede utilizando 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 de tipo int. Esto también se puede escribir de otra manera:

Main.java


              123456789101112
            
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.java


              1234567891011121314151617
            
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 usando 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 tiene 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.java


              12345678910111213141516
            
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. Exploremos un método alternativo para declarar un arreglo que ya venga prellenado:

Main.java


              12345678910
            
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 resultó 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?

¿Todo estuvo claro?

¡Gracias por tus comentarios!

Sección 4. Capítulo 1

Pregunte a AI

Pregunte lo que quiera o pruebe una de las preguntas sugeridas para comenzar nuestra charla

Suggested prompts:

Can you explain how to access or change a specific element in an array?

What happens if I try to access an index that doesn't exist in the array?

Can you show more examples of using Arrays methods like sort or fill?

Desliza para mostrar el menú

Arreglos

La solución a este problema son los arreglos.

Examinemos la sintaxis básica para declarar un arreglo en Java:

Main.java


              1
            
dataType[] 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


              12345678910
            
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 nuevo con la salida en consola: una propiedad de arreglo.

Main.java


              123456789101112
            
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.java


              1234567891011121314151617
            
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));
    }
}

¿Cómo acceder a datos específicos en un arreglo?

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.java


              12345678910111213141516
            
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]);
    }
}

Main.java


              12345678910
            
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 resultó 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?

¿Todo estuvo claro?

¡Gracias por tus comentarios!

Sección 4. Capítulo 1

¿Qué Es un Array?

Arreglos

¿Cómo acceder a datos específicos en un arreglo?

1. ¿Qué se imprimirá al ejecutar este código?

2. ¿Qué se imprimirá al ejecutar este código?

¿Qué Es un Array?

Arreglos

¿Cómo acceder a datos específicos en un arreglo?

1. ¿Qué se imprimirá al ejecutar este código?

2. ¿Qué se imprimirá al ejecutar este código?