Ahora bien, si el algoritmo requerie asignar un tamaño en tiempo de ejecucíon, o sea asignado por el usuario del programa, se debe seguir el siguiente esquema :

Declarar arreglo vacio id
Leer N
asignar a id el tamaño N

Ejemplo

int arr[ ];
System.out.print(" Ingrese el numero de datos : ");
int tam = Integer.parseInt(in.readLine( ));

arr = new int[tam];

El arreglo arr está preparado para almacenar tam elementos de tipo entero (int). El acceso a estos elementos se hace con el operador [ ] desde el elemento 0 hasta el tam - 1, cumpliendo cada posición con las mismas propiedades de las variables individuales.

arr[0] = 3;
arr[1] += arr[0]++;
:
--arr[tam - 1];

Número de elementos de un arreglo

Todos los arrreglos tienen una propiedad que retorna la longitud del arreglo. Esta propiedad se llama length y se accede a ella de la siguiente manera :

identificador.length

int arreglo[ ] = new int[20];

System.out.println("Longitud arreglo : " + arreglo.length);

int i;

/* Se asignaran los valores : 0, 10 , 20, 30 ,..., 180, 190. */

for(i = 0; i < arreglo.length; i++)
{
    arreglo[i] = i * 10; 
}

System.out.println("Datos  del arrreglo  : ");
System.out.println();

for(i =0; i <  arreglo.length; i++)
    System.out.println(arreglo[i]);

Inicialización

Para declarar e inicializar el arreglo con un conjunto de valores, se debe usar el siguiente esquema

tipo id[ ] = {cte1 , cte2 , .... , cte_n};

Ejemplo

int entry[ ] = { 0 , 7 , 23 , 44 , 87, 99 , 166 };

double nota[ ] = { 3.50 , 4.78 , 6.50 };

char letra[ ] = { 'a' , 'e' , 'i' , 'o' , 'u' };

boolean p[ ] = { false , false , true , false , true , false , true , true , false };

Paso de un arreglo como parámetro a un método

Un arreglo se pasa por referencia, o sea cumple con la propiedad que los valores pueden ser modificados dentro del método.

Ejemplo

void imp_arreglo(int arr[ ])
{
   for(int i = 0;  i <  arr.length; i++)
      System.out.print("\t" + arr[i]);
}

*nota : "\t" permite que los datos del arreglo sean tabulados por el método print.

A continuación un programa que inicializa tres arreglos y llama al método imp_arreglo.

class Tabul
{
    public static void main(String arg[ ])
    {
        System.out.println();
        int arr[ ] = { 2 , 5 , 689 , 8 , 6 };
        imp_arreglo(arr);
        System.out.println();
        
        int arr2[ ] = { 31 , 823 , 3 , 13 , 90 };
        imp_arreglo(arr2); 
        System.out.println(); 
        System.out.println();
    }
        
    public static void  imp_arreglo(int    arr[ ])
    {
        for(int i = 0;  i <  arr.length; i++)
            System.out.print("\t" + arr[i]);
    }

}

Salida del programa :

Lectura por teclado

La lectura es similar a la lectura de una variable cualquiera. Lo único que cambia es que la lectura está dentro de un ciclo for.

Ejemplo : Programa que lee un arreglo por teclado y calcula la media,varianza y desviación estándar.

import java.io.*;
class Estad1
{
    public static void main(String arg[ ]) throws IOException
    {
        BufferedReader in = new BufferedReader(new
            InputStreamReader(System.in));
        int tam;

        System.out.println("\n Pograma de estadistica\n");
        System.out.print(" Ingrese el numero de datos : ");
        tam = Integer.parseInt(in.readLine( ));
        System.out.println( );

        if(tam > 1)
        {
            int arreglo[ ] = new int[tam];
             
            /* Lectura del arreglo */

             for(int i = 0; i < arreglo.length; i++)
             {
                 System.out.print(" Ingrese elemento " + i + " : ");
                 arreglo[ i ] = Integer.parseInt(in.readLine());     
             }
            
            System.out.println("\n Resultados \n");
            
            double aux_media = media(arreglo);
            System.out.println(" media : " + aux_media);
            
            double aux_var = varianza(arreglo,aux_media);
            System.out.println(" varianza : " + aux_var);
            System.out.println(" desv. estandar : " + Math.sqrt(aux_var));
        }
        else
        {
            System.out.println("\n numero de elementos no valido!");    
        }
    
        System.out.println();
    }

    public static double media(int arr[ ])
    {
        double sum = 0.0;

        for(int i = 0; i < arr.length ; i++)
        {
            sum += arr[i];
        }

        return sum / arr.length;
    }    
    
    public static double varianza(int arr[ ], double media)
    {
        double sum = 0.0;

        for(int i = 0; i < arr.length ; i++)
        {
            sum += Math.pow(arr[i] - media, 2);
        }
        
        return sum / (arr.length - 1);
    }

}

ALGORITMOS BASADOS EN EL INTERCAMBIO DE POSICIONES

En un arreglo, una operación fundamental es poder intercambiar los valores de dos posiciones i y j , o sea dejar en la posicion i lo que habia en la posicion j y viceversa.

Para realizar esta operación, usamos el siguiente algoritmo :

    tmp <-- a[i]     /* guardamos en tmp el contenido de la posicion i */
    a[i] <-- a[j]    /* asignamos lo que hay en la posicion j, a lla posicion i */
    a[j] <-- tmp     /* rescatamos lo que había en la posición i (tmp), asignandolo a la posicion j */

El paso siguiente, es poder hacer a través de un ciclo iterativo un intercambio de posiciones de afuera hacia dentro.

Aquí la condición del ciclo, es que i tome un valor inicial de cero, j tome un valor inicial de a.length - 1, y que el ciclo se ejecute mientras i sea menor que j.

Ahora bien, para que el ciclo termine alguna vez, en cada iteración hay que incrementar la variable i, y decrementar la variable j.

Algoritmo de intercambio de afuera hacia dentro (invertir arreglo)

INICIO

    i <-- 0
    j <-- a.length - 1

    MIENTRAS(i > j) HACER

        tmp <-- a[i]
        a[i] <-- a[j]
        a[j] <-- tmp

        i <-- i + 1
        j <-- j - 1

    FIN MIENTRAS
FIN

Ahora bien, usando la idea del intercambio entre posiciones contiguas (i y j = i + 1), si se cumple la condición que a[i] es mayor que a[j], obtenemos un algoritmo para ordenar un arreglo en forma ascendente, o sea de menor a mayor.

INICIO
    PARA i <-- 0 HASTA i <-- a.length - 2 HACER
        SI (a[i] > a[i+1]) ENTONCES
            tmp <-- a[i]
            a[i] <-- a[j]
            a[j] <-- tmp
        FIN SI
    FIN PARA
FIN

Ahora bien, independientemente cual sea la configuración original del arreglo (puede estar inicialmente de mayor a menor), se puede ver fácilmente en una traza de este algoritmo, que es necesario repetirlo tantas veces como elementos tenga el arreglo, para asegurar el orden buscado.

INICIO
    PARA k <-- 0 HASTA k <-- a.length - 1 HACER
        PARA i <-- 0 HASTA i <-- a.length - 2 HACER
            SI (a[i] > a[i+1]) ENTONCES
                tmp <-- a[i]
                a[i] <-- a[j]
                a[j] <-- tmp
            FIN SI
        FIN PARA
    FIN PARA
FIN