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]);
}
}
}
martes, 17 de julio de 2012
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
sábado, 14 de julio de 2012
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 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.
Suscribirse a:
Entradas (Atom)