Arrays o arreglos en Java

Los arrays o arreglos en Java, agrupan valores del mismo tipo guardados en una misma variable y accesible a cada valor de forma independiente, pueden ser unidimensionales o multidimensionales, generalmente son usados cuando necesitamos utilizar muchas variables del mismo tipo y para manejar tantos datos se hace muy complicado, es mejor usar un arrays en Java.

Array o arreglo unidimensional

Un array (o arreglo) unidimensional costa de una fila, es decir que solo trabaja en una dimensión, un beneficio de usar los arrays en Java, es que si deseamos guardar distintos valores del mismo tipo pero en una sola variable lo podemos hacer con estos arrays, su aplicación dependerá del tipo de proyecto que deseamos hacer, por ejemplo si queremos guardar las calificaciones de un conjunto alumnos podríamos utilizar un array unidimensional para generar sus notas de aprobación, etc.

Sintaxis

tipo nombre[];

Cuando declaramos un array unidimensional y queremos recorrer este array para obtener un valor guardado debemos recorrer desde la posición 0, ya que los arrays unidimensionales va desde el 0 hasta la posición n-1 donde n es igual al tamaño de nuestro array o arreglo unidimensional de Java.

Inicializando un array unidimensional en Java

Los arreglos en la programación Java se puede inicializar usando el operador new para crear la instancia del array indicando el tamaño.

int calificaciones[]; //también puede ser valido int[] calificaciones;
calificaciones = new int[10]; // Es el tamaño del array
//Otra forma es declararlo todo a la vez
//int calificaciones[]=new int[10]

Los array unidimensionales se pueden inicializar las veces que queramos, pero debemos tomar en cuenta que cuando hacemos esto perdemos todo el contenido del array guardado.

int notas[]=new notas[42];
...
notas=new notas[31];

Asignación de valores en un array unidimensional en Java

Cuando queremos llenar el array unidimensional con valores , se pude realizar de varias maneras, se la pude hacer directamente cuando declaramos el array y asignarle un valor o declararlo posteriormente y lo pedemos llenar con lo valores que sean necesarios.

calificaciones[2]=68;
int calificaciones[] = {81, 21, 71};
int calificaciones[]= new int[] {81,21,71};//Es igual al anterior

Gracias a las estructuras de control repetitivas while, do while o for de Java podemos rellenar y obtener fácilmente los valores de un array unidimensional.

Un array unidimensional puede tomar los valores de otro array unidimensional, pero los dos array deben ser del mismo tipo.

int notas[];
int ejemplo[]=new int[10];
notas=ejemplo;

Ejemplo de un array (arreglo) unidimensional en Java

import java.util.Scanner;
/**
 *
 * @author Creatividad Codificada
 */
public class ArrayUnidimensional 
{
    
    public static void main(String[] args) 
{
    Scanner t = new Scanner (System.in);
    int dim;
    int notas[];
    
    
    // lee la dimesion del array
    System.out.print("DIGITE LA DIMESION DEL ARRAY NOTAS: ");
	dim=t.nextInt();
        notas = new int [dim];
	System.out.println("INTRODUZCA LOS VALORES DEL ARRAY");
	for (int k=0;k<dim;k++)
	{
		System.out.print("notas [ "+ k + "] = ");
		notas[k]=t.nextInt();
	}
        // Ordenamos el array
        int aux;
	for (int i=0;i<dim;i++)
		for (int j=0;j<dim-1;j++)
		{
			if (notas[j]>notas[j+1])
			{
				aux = notas[j];
				notas[j]=notas[j+1];
				notas[j+1]=aux;
			}
		}
        
        
/* Arrays.sort(notas) tambien ordena el array 
de forma ascendente, se debe usar import java.util.Arrays;
*/
        
        
        //Imprime en consola el array ordenado
	System.out.println("ARRAY ORDENADO");
	for (int k=0;k<dim;k++)
        System.out.println("notas [ " +k+ " ] = "+notas[k]);

    }
    
}

Resultado

DIGITE LA DIMESION DEL ARRAY NOTAS: 7
INTRODUZCA LOS VALORES DEL ARRAY
notas [ 0] = 78
notas [ 1] = 71
notas [ 2] = 88
notas [ 3] = 65
notas [ 4] = 45
notas [ 5] = 51
notas [ 6] = 16
ARRAY ORDENADO
notas [ 0 ] = 16
notas [ 1 ] = 45
notas [ 2 ] = 51
notas [ 3 ] = 65
notas [ 4 ] = 71
notas [ 5 ] = 78
notas [ 6 ] = 88

Array (arreglo) multidimensional en Java

Estos array tienen la característica de trabajar con dos o más dimensiones, esto quiere decir que puede haber un array que contenga otro array.

Para entender mejor imagínense un cubo de Ruby donde cada cuadradito almacena un elemento del array multidimensional y si hablamos de tamaño un cubo Ruby sería un array de 3x3x3.

Sintaxis

int notas[][];

Inicializar un array multidimensional en Java

En los array multidimensionales también usamos la instrucción “new” para crear una nuevo array y ademas indicar el tamaño.

notas = new int[3][12]; // inicializamos un array notas de 3x12

También podemos iniciar nuestro array multidimensional en Java creativamente.

int notas[][]=new int[5][]; // Asignamos un tamaño al primer array y el 
// array faltante se la puede asignar después 
notas[0]=new int[15]; // Array en la posición 0 tendrá 15 enteros
notas[1]=new int[12]; // Array en la posición 1 tendrá 12 enteros
notas[2]=new int[16]; // Array en la posición 2 tendrá 16 enteros
notas[3]=new int[25]; // Array en la posición 3 tendrá 25 enteros
notas[4]=new int[17]; // Array en la posición 4 tendrá 17 enteros

Llenado de un array multidimensional en Java

Los arrays multidimensionales en Java también se puede dar valores de forma directa y se la hace similar a los unidimensionales, solo se separa mediante llaves y comas.

int notas [][] = {{8,18,21},{15,17,11},{0,1,18}}; 

Para asignar o recuperar varios valores de un array multidimensional se usa comúnmente las estructuras de control repetitivas o iterativas while, do while o for.

Ejemplo de array multidimensional en Java

import java.util.Scanner;
/**
 *
 * @author Creatividad Codificada
 */
public class ArrayMultidimensional {

    //fondo verde para la consola
    public static final String ANSI_GREEN_BACKGROUND = "\u001B[42m";
    
    //fondo azul para la consola
    public static final String ANSI_BLUE_BACKGROUND = "\u001B[44m";
    
    //color azul para las letras de consola
    public static final String ANSI_BLUE = "\u001B[34m";
    
    //color blanco para las letras de consola
    public static final String ANSI_WHITE = "\u001B[37m";
    
    public static void main(String[] args) {
        
        Scanner en = new Scanner (System.in);
        byte dim = 3; // DIMENSION DE LA MATRIZ
        int aux = 0; 
        int matriz[][] = new int [dim][dim];
        System.out.println(ANSI_GREEN_BACKGROUND+"SUMA DE LA DIAGONAL PARA UNA MATRIZ CUADRADA");
        System.out.println("TECLEE LOS NÚMEROS DE LA MATRIZ");
        for(int i=0 ; i<matriz.length ; i++)
        {
            for(int j=0; j<matriz.length; j++)
            {
                System.out.print("matriz["+i+"]"+"["+j+"] = ");
                matriz[i][j]=en.nextInt();
            }
        }
        
        for(int k=0 ; k<matriz.length ; k++)
        {
            for(int l=0; l<matriz.length; l++)
            {
                if (k==l) 
                {
                    aux = aux + matriz[k][l];
                    System.out.print( ANSI_BLUE_BACKGROUND + ANSI_WHITE + matriz[k][l] + "\t");
                }
                else System.out.print( ANSI_GREEN_BACKGROUND + ANSI_BLUE + matriz[k][l] + "\t");
            }
            System.out.println();
        }
        System.out.println("LA SUMA DE LA DIAGONAL ES : "+aux);
        
    }
    
}

Resultado

SUMA DE LA DIAGONAL PARA UNA MATRIZ CUADRADA 
TECLEE LOS NÚMEROS DE LA MATRIZ
matriz[0][0] = 15
matriz[0][1] = 48
matriz[0][2] = 75
matriz[1][0] = 65
matriz[1][1] = 85
matriz[1][2] = 24
matriz[2][0] = 35
matriz[2][1] = 46
matriz[2][2] = 67
15	48	75	
65	85	24	
35	46	67	
LA SUMA DE LA DIAGONAL ES : 167

Longitud de un array

Para obtener la longitud de un array usamos el método length el cual nos devuelve la longitud del array unidimensional o multidimensional.

notas.length // tamaño del array 
notas[2].length // tamaño del elemento

La clase Arrays

Esta clase estática es muy útil cuando necesitamos obtener o realizar algunas operaciones específicas, si la deseamos usar se ubica dentro el paquete conocido como java.utils.

Existen muchos métodos útiles para nuestros programas, ya que su implementación es muy sencilla, a continuación se detallaran algunas.

Metodo fill

Este método de la clase Arrays nos permite rellenar todo el array de una dimensión con el valor que deseemos, debemos indicar el nombre del array y junto al valor que deseamos rellenar en todo el array, esto lo declaramos en los argumentos del método fill.

int notas[]=new int[10];
Arrays.fill(notas, 9); //Se llena todo el array con 9 

También se puede definir desde que índice hasta que índice queremos rellenar y con qué valor

Arrays.fill(notas,0,2,51);//Del elemento 0 al 2 sus valores cambiaran a 51

Método equals

Este método compara dos arrays o arreglos, en caso que sean exactamente iguales, el resultado sera “true” son exactamente iguales es decir deben tener el mismo tipo de dato, tamaño y sus valores deben ser iguales, en caso de no ser así nos devolverá falso (false), es muy útil para determinar si son iguales dos arrays (arreglos) de una forma mas sencilla.

Arrays.equals(array1 , array2)

Método sort

Nos da la posibilidad de ordenar nuestro array de forma ascendente

int v[]={10,6,7,12,1,4,9,11,8,3};
Arrays.sort(v);//Estará ordenado
Arrays.sort(v,2,8);//Ordena del segundo al octavo elemento del array

System.arraysCopy

Este método nos da la posibilidad de copiar un array en otro array, este método recibe cinco argumentos.

arraycopy(Object ob, int iniPos, Object destino, int destPos, int tamanio)

1. src – el array principal.
2. iniPos – Es la posición inicial para copiar del array principal.
3. destino – el array de destino.
4. destPos – posición inicial en los datos de destino.
5. tamanio – Es la cantidad de elementos a copiar.

int array1[]={0,5,8,9,11};
int array2[]={4,8,6,0,1,2,4,7,9,6};
System.arraycopy(array1, 0, array2, 0, array1.length);
for (int i=0;i<=9;i++){
System.out.print(array2[i]+" ");
} //Imprime 0 5 8 9 11 2 4 7 9 6