Arreglos (Vectores o Arrays)

Definición

En programación, un arreglo o vector (llamados en inglés arrays) es una zona de almacenamiento contiguo, que contiene una serie de elementos del mismo tipo. Desde el punto de vista lógico un arreglo se puede ver como un conjunto de elementos ordenados en fila (o filas y columnas si tuviera dos dimensiones).
Todo vector se compone de un determinado número de elementos. Cada elemento es referenciado por la posición que ocupa dentro del vector. Dichas posiciones son llamadas índice y siempre son correlativos.
Indexación base-cero (0): En este modo el primer elemento del vector será la componente cero ('0') del mismo, es decir, tendrá el índice '0'. En consecuencia, si el vector tiene 'n' componentes la última tendrá como índice el valor 'n-1'.

Para trabajar con vectores muchas veces es preciso recorrerlos. Esto se realiza por medio de bucles. El siguiente pseudocódigo muestra un algoritmo típico para recorrer un vector y aplicar una función 'f(...)' a cada una de las componentes del vector:

i = 0
mientras (i < longitud)
    #Se realiza alguna operación con el vector en la i-ésima posición
    f(v[i])
    i=i+1
fin_mientras

Lo habitual es que un vector tenga una cantidad fija de memoria asignada, aunque dependiendo del tipo de vector y del lenguaje de programación un vector podría tener una cantidad variable de datos. En este caso, se los denomina vectores dinámicos, en oposición, a los vectores con una cantidad fija de memoria asignada se los denomina vectores estáticos.

A continuacion les dejo, un programa para que vean con mas detalles el uso de un arreglo.

Detalles del programa:
Se crea un vector de 7 elementos. Y, se agrega un menu con las siguientes opciones

  1. Ingresar dato: Ingresa un elemento al arreglo.
  2. Ver arreglo: Imprime el contenido del arreglo
  3. Eliminar dato: elimina un dato del arreglo. El usuario escoge que dato desea eliminar; si el dato no existe se le envia un mensaje que el dato que desea eliminar no existe.
  4. Salir: Sale o termina la aplicacion

Ejemplo:
_ _ _ _ _ _ _
|_||_||_||_||_||_||_| ---> Arreglo limpio.

_ _ _ _ _ _ _
|W||_||_||_||_||_||_| ---> Se ingreso el dato: W

_ _ _ _ _ _ _
|W||I||_||_||_||_||_| ---> Se ingreso el dato: I

_ _ _ _ _ _ _
|W||I||K||_||_||_||_| ---> Se ingreso el dato: K

_ _ _ _ _ _ _
|W||I||K||I||_||_||_| ---> Se ingreso el dato: I

_ _ _ _ _ _ _
|W||I||_||I||_||_||_| ---> Se elimino el dato: K

Se ordena... quedando asi:

_ _ _ _ _ _ _
|W||I||I||_||_||_||_|

_ _ _ _ _ _ _
|W||I||I||S||_||_||_| ---> Se ingreso el dato: S

El programa consta de tres clases: Principal(Contiene el método principal main), GetSet y Presentacion.

Clase: Principal

public class Principal {
public static void main(String args[])
{
int opt = 3;
Presentacion objPresent = new Presentacion();
GetSet objGetSet = new GetSet();

objGetSet.clean();
do
{
opt = objPresent.menu();

switch (opt)
{
case 1:
objGetSet.getValues();
break;
case 2:
objGetSet.delete();
break;
case 3:
objGetSet.watch();
break;
case 4:
System.exit(0);
break;
default:
System.out.println("La opción no es valida. Intente lo nuevamente.");
}
}while(opt < 5);

}
}

Clase: Presentacion

import java.io.*;

public class Presentacion {

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int opt;

public int menu()
{
System.out.println("\nPor favor... Escoja una opcion: ");

System.out.println("1. Insertar");
System.out.println("2. Eliminar");
System.out.println("3. Ver");
System.out.println("4. Salir");

try
{
opt = Integer.parseInt(br.readLine());
}
catch(IOException err)
{
System.out.print("Error entrada/salida; "+err.toString());
}
return opt;
}

public void presentacion()
{
System.out.println("\t\t\tWWW.KUBUNTU-ES.ORG");
System.out.println("\t\t\tEJEMPLO ARREGLOS JAVA");
System.out.println("\n\t\t\tELABORADO POR:");
System.out.println("\t\t\t\tmandrake");
}
}

Clase: GetSet

import java.io.*;

public class GetSet {

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
<strong> /*DECLARACION Y CREACION DEL ARREGLO*/</strong>
String[] my_array = new String[7];

<strong> /*DECLARACION DE VARIABLES*/</strong>
int index = 0;
int index7 = 0;
int end = 10;

<strong> /*METODO QUE LIMPIA EL ARREGLO.*/</strong>
public void clean()
{
int index5;

<strong> /* LIMPIANDO EL ARREGLO */</strong>
for(index5 = 0;index5<my_array.length;index5++)
{
my_array[index5] = " ";
}
}
<strong> /*METODO QUE AGREGA LOS VALORES AL ARREGLO*/
/*   - ORDENA*/
/*   - OBTIENE ESPACIO*/
/*   - AGREGA DATO AL ARREGLO*/</strong>
public void getValues()
{
int index6 = 0;
int subindice = 10;

<strong>/* ORDENANDO */</strong>
do
{
{
try
{

if(my_array[index6].equals(" "))
{
my_array[index6] = my_array[index6+1];
my_array[index6+1] = " ";
}

}
catch(NullPointerException err)
{
System.out.println("Excepcion por puntero nulo. "
+"\nNo puede eliminar nada puesto que el arreglo"
+"\nesta vacío. "+err.toString());
}
}
index6++;
}while(index6 < my_array.length-1);

<strong>/* OBTENIENDO EL ESPACIO EN EL CUAL GUARDAR EL DATO */</strong>

for(index7 = 0;index7<my_array.length;index7++)
{
if(my_array[index7].equals(" "))
{
subindice = index7;
index7 = end;
}
}
<strong>
/* AGREGANDO EL DATO POR EL USUARIO */</strong>
if(subindice < my_array.length)
{
try
{
System.out.println("Escriba el dato a ingresar.");
my_array[subindice] = br.readLine();
}
catch(IOException err)
{
System.out.println("Error Entrada/Salida. "+err.toString());
}
}
else
{
System.out.println("EL ARREGLO ESTA LLENO!!!");
}
}

<strong> /*METODO QUE IMPRIME EL ARREGLO*/
/*   - ORDENA*/
/*   - IMPRIME*/</strong>
public void watch()
{
int index1;
int index4 = 0;

<strong> /* ORDENANDO */</strong>
do
{
{
try
{

if(my_array[index4].equals(" "))
{
my_array[index4] = my_array[index4+1];
my_array[index4+1] = " ";
}

}
catch(NullPointerException err)
{
System.out.println("Excepcion por puntero nulo. "
+"\nNo puede eliminar nada puesto que el arreglo"
+"\nesta vacío. "+err.toString());
}
}
index4++;
}while(index4 < my_array.length-1);
<strong>
/* IMPRIMIENDO */</strong>
for(index1 = 0; index1 < my_array.length; index1++)
{
System.out.print(my_array[index1]);
}

}

<strong> /*METODO QUE ELIMINA UN DATO DEL ARREGLO*/</strong>
public void delete()
{
String dato = "";
int index2 = 0;

try
{
System.out.println("Ingrese el dato a eliminar");
dato = br.readLine();

do
{
{
try
{
if(my_array[index2].equals(dato))
{
my_array[index2] = (" ");
System.out.println("Se ha eliminado el dato correctamente");
}
else
{
System.out.println("El dato ingresado no existe en el arreglo");
}

}
catch(NullPointerException err)
{
System.out.println("Excepcion por puntero nulo. "
+"\nNo puede eliminar nada puesto que el arreglo"
+"\nesta vacio. "+err.toString());
}
}
index2++;
}while(index2 < my_array.length);
}
catch(IOException err)
{
System.out.println("Error Entrada/Salida. "+err.toString());
}
}
}

Espero este ejemplo les ayude en algo. Saludos y suerte!
Aparte les dejo un enlace a la pagina de mi amigo Sero; que contiene http://jonaalvarez.blogspot.com/2009/12/recopilatorio-de-15-practicos.ht...

Aportado por : mandrake0219
Fecha aporte: 14/11/2009