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.