Ejemplo Practico De Arreglos

En este Caso realizaremos un programa que lleve las ventas de los empleados, ya sea las ventas totales, por quincena, o parciales de quincena almacenándolas en arreglos Unidimensionales, Bidimensionales y Multidimensionales respectivamente y adicional a eso la opción de almacenarlos en un arreglo de estructura junto con el nombre apellido y cédula del empleado. Este programa manejara las modalidades de Estático y Dinámico. Con las operaciones de agregar y eliminar.


package paquetePGA;

import javax.swing.JOptionPane;

public class Arreglos {
//Vector: 1 dimension

//Declaracion
int Pd=5;
double ventas[]= new double[Pd];

//Constructor
public Arreglos(){
}

//llenar
public void llenar(){
for (int i=0; i<Pd; i++){
ventas[i]=Double.parseDouble(JOptionPane.showInputDialog("Ingrese el total vendido por el empleado " + (i+1)));
}
}

//imprimir
public void imprimir(){
for (int i=0; i<Pd; i++){
JOptionPane.showMessageDialog(null, "El total vendido por el empleado "+(i+1)+" es de "+ventas[i]);
}
}

}

class Matriz extends Arreglos{
//Matriz: 2 Dimensiones

//Declaracion
int Sd=2;
double ventas[][];

//Constructor
public Matriz(){
this.Pd=3;
this.ventas=new double[Pd][Sd];
}

//llenar en 2D
public void llenar(){
for (int i=0; i<Pd; i++){
for (int j=0; j<Sd; j++){
ventas[i][j]=Double.parseDouble(JOptionPane.showInputDialog("Ingrese el total vendido por el Empleado " +(i+1)+ " en la quincena "+(j+1)));
}
}
}

//Imprimir en 2D
public void imprimir(){
for (int i=0; i<Pd; i++){
for (int j=0; j<Sd; j++){
JOptionPane.showMessageDialog(null, "El total vendido por el Empleado "+(i+1)+" en la quincena "+(j+1)+" es de "+ventas[i][j]);
}
}
}
}

class ArrMD extends Matriz{
//Arreglo Multidimensional: 3 o mas dimensiones

//Declaracion
int Td=2;
double ventas[][][];

//Constructor
public ArrMD(){
this.Pd=3;
this.Sd=2;
this.ventas=new double[Pd][Sd][Td];
}

//llenar en 3D
public void llenar(){
for (int i=0; i<Pd; i++){
for (int j=0; j<Sd; j++){
for (int k=0; k<Td; k++){
ventas[i][j][k]=Double.parseDouble(JOptionPane.showInputDialog("Ingrese el total vendido por el Empleado " +(i+1)+ " en el parcial "+(k+1)+" de la quincena "+(j+1)));
}
}
}
}

//Imprimir en 3D
public void imprimir(){
for (int i=0; i<Pd; i++){
for (int j=0; j<Sd; j++){
for (int k=0; k<Td; k++){
JOptionPane.showMessageDialog(null, "El total vendido por el Empleado "+(i+1)+" en el parcial "+(k+1)+" de la quincena "+(j+1)+" es de "+ventas[i][j][k]);
}
}
}
}
}

class ArrEst extends Arreglos{
//Arreglo de Estrucctura: Permite varios tipos de datos

//Declaracion
String nom[], ape[], ci[];
double ventas[];

//Constructor
public ArrEst(){
this.Pd=2;
this.nom=new String[Pd];
this.ape=new String[Pd];
this.ci=new String[Pd];
this.ventas=new double[Pd];
}

//llenar Est
public void llenar(){
for (int i=0; i<Pd; i++){
nom[i]=JOptionPane.showInputDialog("Ingrese el Nombre del Empleado " + (i+1));
ape[i]=JOptionPane.showInputDialog("Ingrese el Apellido del Empleado " + (i+1));
ci[i]=JOptionPane.showInputDialog("Ingrese la Cedula del Empleado " + (i+1));
ventas[i]=Double.parseDouble(JOptionPane.showInputDialog("Ingrese las Ventas del Empleado " + (i+1)));
}
}

//imprimir Est
public void imprimir(){
for (int i=0; i<Pd; i++){
JOptionPane.showMessageDialog( null, "El empleado "+nom[i]+" "+ape[i]+" de CI: "+ci[i]+" tuvo un total de ventas de "+ventas[i]);
}
}
}

class ArreglosD extends Arreglos {
//Vector: 1 dimension  ¡¡DINAMICO!!

//Declaracion
int Pd=Integer.parseInt(JOptionPane.showInputDialog("Ingrese Cantidad de Empleados"));
double ventas[]= new double[Pd];

//Constructor
public ArreglosD(){
}

//llenar
public void llenar(){
for (int i=0; i<Pd; i++){
ventas[i]=Double.parseDouble(JOptionPane.showInputDialog("Ingrese el total vendido por el empleado " + (i+1)));
}
}

//imprimir
public void imprimir(){
for (int i=0; i<Pd; i++){
JOptionPane.showMessageDialog(null, "El total vendido por el empleado "+(i+1)+" es de "+ventas[i]);
}
}

}

class MatrizD extends ArreglosD{
//Matriz: 2 Dimensiones  ¡¡DINAMICO!!

//Declaracion
int Sd=Integer.parseInt(JOptionPane.showInputDialog("Ingrese Cantidad de Quincenas"));
double ventas[][];

//Constructor
public MatrizD(){
this.ventas=new double[Pd][Sd];
}

//llenar en 2D
public void llenar(){
for (int i=0; i<Pd; i++){
for (int j=0; j<Sd; j++){
ventas[i][j]=Double.parseDouble(JOptionPane.showInputDialog("Ingrese el total vendido por el Empleado " +(i+1)+ " en la quincena "+(j+1)));
}
}
}

//Imprimir en 2D
public void imprimir(){
for (int i=0; i<Pd; i++){
for (int j=0; j<Sd; j++){
JOptionPane.showMessageDialog(null, "El total vendido por el Empleado "+(i+1)+" en la quincena "+(j+1)+" es de "+ventas[i][j]);
}
}
}
}

class ArrMDD extends MatrizD{
//Arreglo Multidimensional: 3 o mas dimensiones  ¡¡DINAMICO!!

//Declaracion
int Td=Integer.parseInt(JOptionPane.showInputDialog("Ingrese Cantidad de Parciales p/Quincena"));
double ventas[][][];

//Constructor
public ArrMDD(){
this.ventas=new double[Pd][Sd][Td];
}

//llenar en 3D
public void llenar(){
for (int i=0; i<Pd; i++){
for (int j=0; j<Sd; j++){
for (int k=0; k<Td; k++){
ventas[i][j][k]=Double.parseDouble(JOptionPane.showInputDialog("Ingrese el total vendido por el Empleado " +(i+1)+ " en el parcial "+(k+1)+" de la quincena "+(j+1)));
}
}
}
}

//Imprimir en 3D
public void imprimir(){
for (int i=0; i<Pd; i++){
for (int j=0; j<Sd; j++){
for (int k=0; k<Td; k++){
JOptionPane.showMessageDialog(null, "El total vendido por el Empleado "+(i+1)+" en el parcial "+(k+1)+" de la quincena "+(j+1)+" es de "+ventas[i][j][k]);
}
}
}
}
}

class ArrEstD extends ArreglosD{
//Arreglo de Estrucctura: Permite varios tipos de datos ¡¡DINAMICO!!

//Declaracion
String nom[], ape[], ci[];
double ventas[];

//Constructor
public ArrEstD(){
this.nom=new String[Pd];
this.ape=new String[Pd];
this.ci=new String[Pd];
this.ventas=new double[Pd];
}

//llenar Est
public void llenar(){
for (int i=0; i<Pd; i++){
nom[i]=JOptionPane.showInputDialog("Ingrese el Nombre del Empleado " + (i+1));
ape[i]=JOptionPane.showInputDialog("Ingrese el Apellido del Empleado " + (i+1));
ci[i]=JOptionPane.showInputDialog("Ingrese la Cedula del Empleado " + (i+1));
ventas[i]=Double.parseDouble(JOptionPane.showInputDialog("Ingrese las Ventas del Empleado " + (i+1)));
}
}

//imprimir Est
public void imprimir(){
for (int i=0; i<Pd; i++){
JOptionPane.showMessageDialog( null, "El empleado "+nom[i]+" "+ape[i]+" de CI: "+ci[i]+" tuvo un total de ventas de "+ventas[i]);
}
}
}

Vídeo Tutoriales

En los siguientes video Tutoriales presentaremos una vista sencilla de lo que son arreglos en código C debido a su similitud con el lenguaje Java. Ademas de explicación de codificación en el lenguaje Java

Arreglos en C.

Arreglos Bidimensionales en C 

Codigo de Arreglos en Java 

Arreglos Dinámicos

Un array dinámico tiene que ser redimensionado antes de poder ser utilizado mediante la instrucción Redimensionar. Dicha instrucción puede aparecer en cualquier parte del código donde la variable sea accesible. Así Redimensionar Ciudad(8) declara 8 variables que son Ciudad(1),    Ciudad(2), ..., Ciudad(8).

Al igual que en los arreglos estáticos dispone de 4 tipos según su amplitud o dimensiones.

Arreglos Estaticos

 Un array estático no puede ser redimensionado nunca. Un array dinámico habrá de redimensionarse al menos una vez (para poder ser usado), pero podrá modificarse tantas veces como se estime necesario, aunque el número de localizadores siempre tendrá que ser el mismo. Esto nos dota de flexibilidad para manejar datos: si teníamos 100 clientes y henos perdido 25 podremos no sólo borrar el nombre sino recortar espacios sobrantes, reagrupar, etc. En definitiva: ahorrar memoria.

Tipo de Arreglos:

Arreglos Unidimensionales

Arreglos Bidimensionales

Arreglos Multidimensionales

Arreglos De Estructura

Arreglos De Tipo Estructura

Se puede crear un arreglo de estructuras tal como se crea un arreglo de otro tipo. Los arreglos muy útiles para almacenar archivos de empleados, inventarios, o cualquier tipo de dato que se puede utilizar con la estructura.

Arreglos Multidimensional

En Java a diferencia de otros lenguajes, los arreglos multidimensionales son tratados como arreglos de arreglos. Esto implica que la creación e inicialización de arreglos de más de una dimensión, necesariamente deberá incluir llamados new para cada una de las dimensiones del arreglo

Arreglos Bidimensionales

Es un arreglo de arreglos, es decir, un arreglo unidimensional donde cada elemento es un arreglo.

Los arreglos bidimensionales son muy utilizados para el uso de matrices de datos, y poder recorrer los datos guardados dentro de este tipo de arreglos.

Arreglos Unidimensionales

Es una colección de datos del mismo tipo. Sirve para manejar un número “n” de elementos en común, ya sea de tipos definidos por el Lenguaje, (“int”, “float”, “String”, etc.) así como aquellos definidos por el programador.

Los arreglos en Java son dinámicos, pero no extensibles, lo cual significa que deben ser creados con el tamaño que tendrán hasta el final de su vida.

Arreglos

Los arreglos se pueden definir como objetos en los que podemos guardar mas de una variable, es decir, al tener un único arreglo, este puede guardar múltiples variables de acuerdo a su tamaño o capacidad, es importante recordar que las variables guardadas deben ser del mismo tipo, por ejemplo: Si tenemos un arreglo de tipo Numérico que puede almacenar 10 variables, solo podrá almacenar 10 números diferentes, no otras variables como caracteres o Strings.