Algoritmo y Estructura de Datos II MATER

Algoritmo y Estructura de Datos II
MATERIAL DEL DOCENTE

(2012-II)
SEMANA 01 a SEMANA 03
ARREGLO DE OBJETOS
Juan José Flores Cueto

Juan José Rodríguez Vila
ESTRUCTURA DE DATOS: Arreglo de objetos
ESTRUCTURA DE DATOS - ARREGLOS
CONCEPTOS BÁSICOS
Definición:
Los arreglos, conocidos también como arrays, son estructuras de datos que permiten almacenar
más de un dato del mismo tipo a la vez. Es decir, un arreglo contiene un conjunto de datos, todos
del mismo tipo. Un arreglo puede almacenar un conjunto limitado de datos. Cada dato
perteneciente al arreglo se almacena en una posición y puede ser mostrado, modificado o
eliminado.
Ventajas:
 Los datos están almacenados en una sola estructura de datos siendo más fácil el acceso
a los mismos.
 Se utiliza un único nombre (nombre del arreglo) para referirse al conjunto de datos
almacenados en el arreglo. Esto nos permite reducir el uso de variables y constantes.
 Los arreglos permiten almacenar datos de entrada y datos utilizados durante el
procesamiento.
 Al igual que otras estructuras de datos (como las variables y constantes), los arreglos
tienen un tiempo de vida, por lo que pueden ser considerados como globales o locales.
Desventajas:
 Un arreglo no puede almacenar datos de diferente tipo. Se puede tener un arreglo de
números enteros, o un arreglo de cadenas, pero no se puede tener un arreglo que
contenga, por ejemplo, cadenas y números enteros a la vez.
 Dependiendo del tipo de arreglo, unidimensional o bidimensional, se necesitará uno o dos
índices para acceder a los datos almacenados en el arreglo.
 Antes de crear un arreglo es necesario conocer el número exacto de datos que se
necesitan almacenar (esto no es tan cierto ya que se pueden crear algoritmos que
permiten redimensionar los arreglos. También, existe una clase en Java, denominada
Vector, que pertenece al paquete java.util, que tiene métodos que permiten crear un
vector y redefinir su tamaño cada vez que sea necesario).
Pág. 2
ARREGLOS UNIDIMENSIONALES - VECTORES
Definición:
Los arreglos unidimensionales conocidos también como vectores o registros, son estructuras
de datos que permiten almacenar más de un dato del mismo tipo a la vez. Es decir, un vector
contiene un conjunto de datos, todos del mismo tipo, a los cuales se puede acceder a través de
un índice.
Representación gráfica:
A continuación se muestra la representación gráfica de un arreglo unidimensional llamado

nombre:
nombre
X0 X1 X2 ... X i-1 i
0 1 2 ... i -1
Donde:
nombre = Nombre del vector.

X0...X i -1 = Datos almacenados en el vector.
i = Tamaño del vector.
Declaración:
Para declarar un arreglo unidimensional es necesario, en primer lugar, definir un nombre. Para
definir un nombre de un arreglo unidimensional se siguen las mismas reglas utilizadas para la
definición de nombres de variables y constantes.
En segundo lugar, se debe determinar qué tipo de dato podrá almacenar el arreglo
unidimensional. Un arreglo unidimensional sólo puede almacenar datos del mismo tipo. Los tipos
Pág. 3
de datos válidos para declarar un arreglo unidimensional son los mismos tipos de datos válidos
definidos para declarar variables y constantes.
En general, para declarar un arreglo unidimensional se utiliza el siguiente formato:
En Java:
TipoDeDato arreglo[ ] ;
En Pseudocódigo y Diagrama de Flujo:
TipoDeDato[ ] arreglo;
Donde TipoDeDato debe ser un tipo de arreglo o tipo de dato válido y arreglo es el nombre
del arreglo unidimensional (puede existir más de un arreglo, los cuales serán separados por
comas).
Para declarar un arreglo unidimensional se utiliza sólo un corchete de apertura y cierre “[ ]” al final
del nombre del arreglo.
También se puede declarar un arreglo unidimensional colocando los corchetes de apertura y

cierre después del tipo de dato y no después del nombre del arreglo unidimensional, según se
muestra a continuación:
En Java:
TipoDeDato[ ] arreglo ;
En Pseudocodigo y Diagrama de Flujo:
TipoDeDato[ ] arreglo;
Pág. 4
Creación:
Para crear un arreglo unidimensional, es necesario que el arreglo unidimensional previamente

haya sido declarado, tal y como se explicó anteriormente.
Antes de crear un arreglo unidimensional se debe determinar cuál va ser el tamaño del mismo. Es
decir, cuál va a ser la cantidad total de datos que se podrá almacenar.
Para crear un arreglo unidimensional se utiliza el siguiente formato:
En Java:
arreglo = new TipoDeDato [tamaño] ;
En Pseudocodigo y Diagrama de Flujo:
CREAR arreglo[tamaño]
Donde TipoDeDato debe ser un tipo de arreglo unidimensional o tipo de dato válido y
arreglo es el nombre del arreglo.
El operador new nos permite crear un arreglo unidimensional. Cuando se crea un arreglo
unidimensional con el operador new, se debe indicar el tamaño, es decir cuántos datos podrá
almacenar.
Es importante mencionar que el tipo de dato utilizado para crear un arreglo unidimensional
deberá ser el mismo tipo de dato con el cual se declaró y que para crearlo es necesario
especificar un índice.
En Java, existe también una forma directa para declarar y crear arreglos unidimensionales,
utilizando el siguiente formato:
En Java:
TipoDeDato arreglo[ ] = new TipoDeDato [tamaño];
Pág. 5
Donde TipoDeDato debe ser un tipo de arreglo unidimensional o tipo de dato válido y
arreglo es el nombre del arreglo unidimensional.
Utilizando este formato se declara y crea el arreglo unidimensional en forma directa (esto es
conocido como “Definición de un arreglo”).
Inicialización:
Cuando se crea un arreglo unidimensional utilizando el operador new es recomendable, aunque

no necesario, inicializar todas las posiciones del mismo. Inicializar todas las posiciones de un
arreglo unidimensional significa asignar un valor a cada posición con la finalidad de evitar que se
produzca un error, si se intenta acceder a una posición del arreglo unidimensional que todavía no
contiene un dato.
Generalmente, los arreglos numéricos (tipo NUMERO) se inicializan con cero (0), los arreglos
lógicos (tipo LOGICO) o booleanos se inicializan con false, los arreglos de caracteres con ‘0’ y los
arreglos de objetos con null.
Ingreso de datos:
Después de crear un arreglo unidimensional, inicialice o no el arreglo unidimensional, se deberán

ingresar datos.
Es necesario que se ingresen datos a todas las posiciones del arreglo unidimensional. Si no se
ingresan datos a todas las posiciones del arreglo unidimensional deberá asegurarse de
inicializarlo o en su defecto de mantener un adecuado control de las posiciones que tienen datos
almacenados y aquellas que no. Recuerde que tratar de acceder a una posición que no tiene un
dato o que no ha sido inicializada, produce un error que ocasiona que se interrumpa la ejecución
del programa.
Pág. 6
ARREGLOS BIDIMENSIONALES - MATRICES
Definición:
Los arreglos bidimensionales conocidos también como matrices o tablas, son estructuras de
datos que permiten almacenar más de un dato del mismo tipo a la vez. Es decir, una matriz
contiene un conjunto de datos, todos del mismo tipo, a los cuales se puede acceder a través de
dos índices.
A continuación se muestra la representación gráfica de un arreglo bidimensional llamado nombre:
nombre
Columnas
0 1 2 j-1
0 X 0,0 X 0,1 X 0,2 … X 0,j -1
1 X 1,0
Filas 2 X 2,0
Donde:
nombre = Nombre de la matriz.

X0,0...Xi-1, j -1 = Datos almacenados en la matriz.
i-1 X i-1,0 X i-1,j -1 (i, j)
i*j = Tamaño de la matriz.
Es importante indicar que para declarar, crear, inicializar e ingresar datos en un arreglo
bidimensional o matriz se siguen las mismas reglas definidas para los arreglos unidimensionales
o vectores. La diferencia radica en el número de índices que se utilizarán.
Pág. 7
ARREGLOS EN PARALELO
Introducción:
Cuando se plantean soluciones a diversos problemas es necesario utilizar variables, vectores y

matrices en forma simultánea para almacenar los datos. Es decir, en una solución se puede
utilizar algunas variables, un vector, dos vectores o muchos vectores. También, se puede utilizar
variables, un vector y una matriz, o dos vectores y una matriz. En términos generales se puede
afirmar que en una solución se utilizan variables, vectores y matrices en forma simultánea y en el
número que se necesiten. Esto va a depender de la complejidad y tipo de problema que se
necesite resolver.
Cuando en una solución se utiliza más de un arreglo y el orden en que se disponen los datos
entre los arreglos tiene un significado, se les denomina vectores paralelos.
Ejemplos:
En la siguiente Gráfica de Estructura de Datos se utiliza una variable y dos vectores en forma
simultánea (en paralelo). En la variable (numTrab) se almacena el número de trabajadores y con
este valor se crean los dos vectores (los arreglos en paralelo deben tener el mismo tamaño). En
uno de los vectores (nombre[ ]) se almacenan los nombres de todos los trabajadores y en el otro
vector (sueldo[ ]) se almacenan sus respectivos sueldos. Se puede observar que un dato
almacenado en una posición de un vector está relacionado con el dato almacenado en la misma
posición del otro vector.
Pág. 8
Dados los vectores:
nombre sueldo
0 “Danae” 1000
Datos del mismo
1
trabajador.
. .
: :
numTrab - 1
numTrab
(String) (double) ( int )
Donde numTrab permite almacenar el número de trabajadores.
La pregunta lógica que se pueden formular sería la siguiente: ¿por qué en vez de crear dos
vectores en paralelo no creamos una matriz con dos columnas?, y la respuesta sería que en una
matriz solo se pueden almacenar datos del mismo tipo, mientras que usando dos vectores en
paralelo se pueden almacenar datos de diferente tipo. En el planteamiento de la solución anterior
en uno de los vectores se almacenan datos de tipo TEXTO mientras que en el otro vector se
almacenan datos de tipo NUMERO.
En la siguiente Gráfica de Estructura de Datos se utiliza una variable y tres vectores en forma
simultánea (en paralelo). En la variable (numSoc) se almacena el número de socios de un club y
con este valor se crean los tres vectores. En uno de los vectores (nombre[ ]) se almacenan los
nombres de los socios, en otro de los vectores (sexo[ ]) se almacena el sexo de cada uno de los
socios y en el tercer vector (edad[ ]) sus respectivas edades. Como ejemplo, se puede observar,
que todos los datos del socio Rodrigo están almacenados en la posición cero de los vectores en
paralelo.
Pág. 9
Dados los vectores:
nombre sexo edad

0 “Rodrigo” M 12
Datos del mismo 1
socio.
2
. . .
: : :
numSoc - 1
numSoc
(String) (char) (int) ( int )
Donde numSoc permite almacenar el número de socios.
Finalmente, en la siguiente Gráfica de Estructura de Datos se utiliza una variable, un vector y una
matriz con dos columnas en forma simultánea (en paralelo).
Dados los vectores:
nombre precio
PC (0) PV (1)
. . .
: : :
numArt - 1
numArt
Donde: numArt permite almacenar el número de Artículos.

PC = Precio de compra.
PV = Precio de venta.
Pág. 10
ARREGLOS DE GRAN TAMAÑO
Un arreglo de gran tamaño es aquel que se crea con una capacidad mayor a la cantidad de datos
que va a almacenar. Los arreglos de gran tamaño se utilizan cuando no se puede determinar
desde un inicio cuál debe ser el tamaño con el que se debe crear un arreglo. Observe la siguiente
Gráfica de Estructuras de Datos:
Dado el vector:
codigo
9999
numAlu = 0
(long) ( int )
Donde numAlu indica el número de códigos de alumnos almacenados.
En la gráfica mostrada se especifica que el vector codigo[ ] se creará con un tamaño de 1000.
Tamaño suficiente para poder almacenar todos los códigos de los alumnos de un salón de clase
(se supone que en un salón de clase no habrá tal cantidad de alumnos). Para manejar los datos
almacenados en un arreglo de gran tamaño se necesita una variable que indica el tamaño lógico
Pág. 11
del arreglo. En este caso, la variable numTrab nos indicará el total de códigos de alumnos que se
han almacenado en el vector en un determinado momento. Al inicio, el valor de la variable
numAlu deberá ser cero (esto significa que cuando se inicia la ejecución de la aplicación no se
tiene almacenado ningún código de alumno). Esto también puede ser aplicado en arreglos en
paralelo. Observe e interprete la siguiente Gráfica de Estructuras de Datos:
Dados los vectores:
nombre sueldo
0 “Danae” 1000
. .
: :
99999
numTrab = 0
Donde numTrab indica el número de trabajadores cuyos datos se han almacenado.
Pág. 12
ARREGLO DE OBJETOS
Definición:
Un arreglo de objetos es una estructura de datos que permiten almacenar objetos del mismo
tipo en lugar de almacenar datos simples. Es decir, un arreglo de objetos contiene un conjunto de
objetos, todos del mismo tipo, a los cuales se puede acceder utilizando uno o dos índices. Es
importante considerar que se podrá acceder a los datos almacenados en los objetos utilizando los
métodos definidos en su clase.
A continuación se muestra la representación gráfica de un arreglo de objetos. Observe que un

arreglo de objetos almacena objetos, y los objetos a su vez almacenan datos y métodos, los
cuales han sido definidos en su clase:
“Danae”
1000.0
10
- setNombre ()
- getNombre ()
- setSueldo () datos
- getSueldo ()
- setCodigo () 10
- getCodigo ()
“Danae”
1000.0
0 1 2
( Empleado )
Pág. 13
A continuación se muestra un conjunto de arreglos en paralelo definidos para una determinada

solución en comparación con su equivalente en arreglo de objetos:
Analice ambos diagramas e intente estableces las diferencias.
Pág. 14
Problema 01
Etapa 01 – Descripción del problema

Enunciado:
Desarrolle una solución que permita almacenar el código, nombre y sueldo de todos los
empleados de una empresa textil teniendo en cuenta el Diagrama de Clase y la Gráfica de
Estructura de Datos mostrados. También desarrolle los métodos para agregar datos, mostrar
datos y buscar datos en base al código del empleado. Utilice dos clases para el desarrollo de la
solución.
Etapa 03 – Diseño de la lógica
 Nombre del Proyecto: ProyEmpleado1
 Diagrama de Clases:
Pág. 15
 Gráfica de Estructura de Datos:
datos
numEmp = 0
(Empleado) ( int )
Donde:
numEmp = Número de empleados de la empresa.
Etapa 04 – Desarrollo de la codificación
Clase Empleado
package domPro;
public class Empleado {
private long codigo;

private String nombre;
private double sueldo;
public Empleado(){
codigo = 0;
nombre = null;
sueldo = 0;
}
public long getCodigo() {

return codigo;
}
Pág. 16
Clase Empleado
public void setCodigo(long codigo) {

this.codigo = codigo;
}
public String getNombre() {

return nombre;
}
public void setNombre(String nombre) {

this.nombre = nombre;
}
public double getSueldo() {

return sueldo;
}
public void setSueldo(double sueldo) {

this.sueldo = sueldo;
}
}
Clase PrgEmpleado
package domApli;
import biblioteca.LE;
import domPro.Empleado;
public class PrgEmpleado {
public Empleado datos[];

private int numEmp;
public PrgEmpleado() {
datos = new Empleado[5];
numEmp = 0;
}
public void ingresarDatos() {

int rpta;
long codigo;
String nombre;
Pág. 17
Clase PrgEmpleado
double sueldo;
do {
codigo = LE.leerLong("Ingrese el código");
nombre = LE.leerString("Ingrese el nombre");
sueldo = LE.leerDouble("Ingrese el sueldo");
Empleado objEmp = new Empleado();

objEmp.setCodigo(codigo);
objEmp.setNombre(nombre);
objEmp.setSueldo(sueldo);
datos[numEmp] = objEmp;
numEmp++;
rpta = LE.mostrarPreguntaOpcion2("Desea continuar? ");

} while (rpta == 0);
}
public void mostrarDatos() {

String listaDatos = "";
for (int i = 0; i < numEmp; i++) {
listaDatos = listaDatos + datos[i].getCodigo() + " "
+ datos[i].getNombre() + " " + datos[i].getSueldo() + "\n";
}
LE.mostrarInformacion("Datos de los Empleados\n\n" + listaDatos);
}
public void mostrarDatosEmpleado() {

long codigo = LE.leerLong("Ingrese código a buscar");
int pos = -1;

if (datos[i].getCodigo() == codigo) {
pos = i;
}
}
if (pos > -1) {
LE.mostrarInformacion("Empleado " + datos[pos].getNombre()
+ "\nSueldo: " + datos[pos].getSueldo());
} else {
LE.mostrarInformacion("Código de empleado no existe");
}
}
Pág. 18
Clase PrgEmpleado
public static void main(String arg[]) {

PrgEmpleado x = new PrgEmpleado();
x.ingresarDatos();
x.mostrarDatos();
x.mostrarDatosEmpleado();
}
}
Observe y analice las siguientes líneas de codificación del método ingresarDatos ( ):
public void ingresarDatos ( ) {

int rpta ;
long codigo ;
String nombre ;
double sueldo ;
do {
codigo = LE.leerLong ( “Ingrese el código” ) ;
nombre = LE.leerString ( “Ingrese el nombre” ) ;
sueldo = LE.leerDouble ( “Ingrese el sueldo” ) ;
Empleado objEmp = new Empleado ( ) ;

objEmp.setCodigo ( codigo ) ;
objEmp.setNombre ( nombre ) ;
objEmp.setSueldo ( sueldo ) ;
datos [numEmp ] = objEmp ;

numEmp ++ ;
rpta = LE.mostrarPreguntaOpcion2 ( "Desea continuar? " ) ;

} while ( rpta == 0 ) ;
}
Pág. 19
Primero, se solicitan los datos del empleado, los cuales se almacenan en las variables codigo,
nombre y sueldo. Imagínese que se ingresan los datos de un empleado que tiene código 10, su
nombre es “Juan José” y su sueldo es 1000.00.
…
codigo = LE.leerLong ( "Ingrese el código" ) ;
nombre = LE.leerString ( "Ingrese el nombre" ) ;
sueldo = LE.leerDouble ( "Ingrese el sueldo" ) ;
Luego, se crea un objeto de la clase Empleado llamado objEmp:
…
…
Al crearse el objeto se ejecuta en forma automática el método constructor con el cual el objeto se
inicializa. La siguiente figura muestra una representación, en forma gráfica, de la creación del
objeto.
Pág. 20
Una vez creado el objeto objEmp se procede a almacenar los datos ingresados y almacenados
en las variables codigo, nombre y sueldo en el objeto objEmp. Para ello, utilizamos los métodos
setter, tal y como se muestra a continuación:
…
…
Ahora, el objeto objEmp contiene los datos ingresados, lo cual se representa en la figura
siguiente:
Pág. 21
Finalmente, el objeto objEmp de la clase Empleado se almacena en el arreglo de objetos llamado

datos (observe que el arreglo datos solo puede almacenar datos de tipo Empleado, es decir, solo
puede almacenar objeto de la clase Empleado).
datos
numEmp = 0
(Empleado) ( int )
Para almacenar el objeto objEmp en el arreglo datos utilizamos la siguiente sentencia:
…
…
Es decir, el objeto objEmp se almacena en el arreglo datos en la posición especificada por

numEmp (recuerde que un objeto contiene datos y una copia de los métodos especificados en la
clase a la que pertenece).
Finalmente, es necesario incrementar la variable numEmp con la finalidad que el próximo objeto
que se desee almacenar se almacene en la posición siguiente del arreglo.
Pág. 22
…
numEmp ++ ;
…
En resumen, para almacenar un objeto en un arreglo, hay que seguir los siguientes pasos:
1. Ingresar los datos a almacenar

2. Crear un objeto de la clase que se desea almacenar en un arreglo de objetos
3. Almacenar los datos ingresados en el objeto creado
4. Almacenar el objeto creado en el arreglo de objetos
5. Incrementar la variable que controla la posición donde se almacenará el siguiente objeto.
public void agregarDatos ( ) {

int rpta ;
long codigo ;
String nombre ;
double sueldo ;
do {
numEmp ++ ;

} while ( rpta == 0 ) ;
}
Pág. 23
Es posible codificar y utilizar un segundo método constructor de la clase Empleado el cual reciba
los datos necesarios para inicializar los atributos del objeto creado. Para ello, modifique la clase
Empleado agregando el método constructor (cuando existe más de un método constructor en una
clase se denomina sobrecarga de métodos constructores) que se muestra a continuación:
Clase Empleado
package domPro ;
private long codigo ;

private String nombre ;
private double sueldo ;
public Empleado ( ) {
codigo = 0 ;
nombre = null ;
sueldo = 0 ;
}
public Empleado ( long codigo, String nombre, double sueldo ) {

this.codigo = codigo ;
this.nombre = nombre ;
this.sueldo = sueldo ;
}
/* …
Incluir los métodos setter y getter
…
*/
Si se cuenta con un método constructor de la clase Empleado que reciba datos para que los
valores de los atributos sean inicializados se podría reducir las líneas de código utilizadas para
almacenar un objeto de la clase Empleado en el arreglo datos [ ]; y solo se utilizarían las
siguientes sentencias:
Pág. 24
public void ingresarDatos ( ) {

int rpta ;
long codigo ;
String nombre ;
double sueldo ;
do {
Empleado objEmp = new Empleado (codigo, nombre sueldo ) ;

numEmp ++ ;

} while ( rpta == 0 ) ;
}
Ahora, para poder mostrar los datos almacenados en un arreglo de objetos es necesario utilizar
los métodos getter. Imagínese que se han ingresado los códigos, nombres y sueldos de tres
empleados los cuales se muestran en la siguiente Gráfica de estructura de Datos:
datos
codigo = 10
0 nombre = “Juan José”
sueldo = 1000.00
codigo = 20
1 nombre = “Carmen”
sueldo = 2000.00
codigo = 30
2 nombre = “Danae”
sueldo = 3500.00
numEmp = 3
(Empleado) ( int )
Pág. 25
Si deseo recuperar el código del empleado almacenado en la posición 1 del arreglo de objetos
datos [ ] debería utilizar la siguiente sentencia:
…
int codigo = datos [ 1 ].getCodigo ( ) ;
…
Nombre del Ejecuta el

arreglo método
Especifica la
posición del arreglo
Observe que se ejecuta el método getCodigo( ) del objeto de la

clase Empleado almacenado en la posición 1 del arreglo datos[ ].
El valor que el método getCodigo( ) devuelve se almacena en la
variable entera codigo. Esto permite que la variable codigo
almacene el valor 20.
Si se desea recuperar todos los datos almacenados en el arreglo se podrá utilizar la estructura de
repetición for, tal y como se emplea en el método mostrarDatos( ) de la clase PrgEmpleado.
Finalmente, intente modificar la aplicación anterior e incluya un método que permita aumentar el
tamaño del arreglo, un método que permite ordenar por código los datos, un método para eliminar
datos y otro para modificar datos. También incluya un método menu( ) desde el cual se puedan
ejecutar los métodos creados.
Tenga presente que si incluye un método que permita eliminar datos (eliminarDatos ( )) y un
método que permita modificar datos (modificarDatos ( )) el criterio de búsqueda de datos será a
través del código el cual deberá ser único (los códigos no se pueden repetir). Para ello, deberá
crear un método que permita buscar un código (buscarCodigo ( )) y devuelva un valor -1 si el
código no es encontrado o un valor igual a la posición del arreglo donde fue encontrado el código.
De ser este el caso, el método ingresarDatos ( ) y el método mostrarDatosEmpleado ( ) deberán
modificarse para que puedan utilizar el método de búsqueda creado.
Pág. 26
Problema 02

Enunciado:
Desarrolle una solución que permita almacenar el código, nombre y la nota final de todos los
alumnos de un salón de clase teniendo en cuenta el Diagrama de Clase y la Gráfica de Estructura
de Datos mostrados. También desarrolle todos los métodos necesarios para actualizar y controlar
los datos almacenados. Utilice 2 clases para el desarrollo de la solución.
 Nombre del Proyecto: ProyAlumnos1
Pág. 27
datos
numAlu = 0
(Alumno) ( int )
Donde:
numAlu = Número de alumnos del salón de clase.
Clase Alumno
package domPro;
public class Alumno {

private double nota;
public Alumno(long codigo, String nombre, double nota) {

this.nota = nota;
}

return codigo;
}
Pág. 28
Clase Alumno
}

return nombre;
}

}
public double getNota() {

return nota;
}
public void setNota(double nota) {

this.nota = nota;
}
}
Clase PrgAlumno
package domApli;
import java.awt.Color;
import domPro.Alumno;
public class PrgAlumno {
public Alumno datos[];

private int numAlu;
public PrgAlumno() {
datos = new Alumno[5];
numAlu = 0;
}

PrgAlumno x = new PrgAlumno();
x.menu();
}
Pág. 29
Clase PrgAlumno
public void menu() {

int opc;
String opciones1 = "************MENU PRINCIPAL ************\n"
+ "-------------------------------------\n"
+ "[1] Ingreso de Datos \n" + "[0] Finalizar \n"
+ "-------------------------------------\n"
+ "Elija opción deseada:\n";

+ "-------------------------------------\n"
+ "[1] Ingreso de datos \n" + "[2] Mostrar datos \n"
+ "[3] Mostrar datos de un alumno \n"
+ "[4] Modificar datos \n" + "[5] Eliminar datos \n"
+ "[6] Ordenar datos \n" + "[0] Finalizar \n"
+ "-------------------------------------\n"
boolean acceso = false;

String opciones = opciones1;
do {
opc = LE.leerInt(opciones);
switch (opc) {
case 1:
ingresarDatos();
acceso = true;
opciones = opciones2;
break;
case 2:
if (acceso) {
mostrarDatos();
} else {
LE.mostrarError("La opción ingresada no es válida");
}
break;
case 3:
if (acceso) {
mostrarDatosAlumno();
} else {
}
break;
Pág. 30
Clase PrgAlumno
case 4:
if (acceso) {
modificarDatos();
} else {
}
break;
case 5:
if (acceso) {
eliminarDatos();
if (numAlu == 0) {
acceso = false;
}
} else {
}
break;
case 6:
if (acceso) {
ordenarDatos();
mostrarDatos();
} else {
}
break;
case 0:
break;
default:
}
} while (opc != 0);

int rpta, pos;
long codigo;
String nombre;
double nota;
Pág. 31
Clase PrgAlumno
do {
if (datos.length == numAlu) {
aumentar();
}
do {
codigo = LE.leerLong("Ingrese el código del alumno");
pos = buscarCodigo(codigo);
if (pos != -1) {
LE.mostrarInformacion("El código ingresado ya existe!.., verifique\n\n");
}
} while (pos != -1);
nombre = LE.leerString("Ingrese el nombre del alumno");

nota = LE.leerDouble("Ingrese la nota del alumno");
Alumno objAlu = new Alumno(codigo, nombre, nota);
datos[numAlu] = objAlu;
numAlu++;

}

for (int i = 0; i < numAlu; i++) {
listaDatos += datos[i].getCodigo() + " " + datos[i].getNombre()
+ " " + datos[i].getNota() + "\n";
}
LE.mostrarInformacion("Datos de los alumnos",
"Codigo - Nombre - Notas", listaDatos, " - Aceptar - ", Color.cyan);
}
public void mostrarDatosAlumno() {

long codigo = LE
.leerLong("Ingrese el código del alumno cuyos datos deseas mostrar");
int pos = buscarCodigo(codigo);
if (pos > -1) {
Pág. 32
Clase PrgAlumno
LE.mostrarInformacion("El nombre del alumno es "

+ datos[pos].getNombre() + " y tiene "
+ datos[pos].getNota() + " de nota");
} else {
LE.mostrarInformacion("El código del alumno no existe");
}
}
public void modificarDatos() {

long codigo = LE
.leerLong("Ingrese el código del alumno cuyos datos deseas modificar");
if (pos > -1) {

int rpta = LE.mostrarPreguntaOpcion2("Está usted"
+ " seguro que desea modificar los datos del alumno "
+ datos[pos].getNombre() + " cuya nota es "
+ datos[pos].getNota());
if (rpta == 0) {
String nombre = LE.leerString("Ingrese el nombre del alumno");
double nota = LE.leerDouble("Ingrese la nota del alumno");
datos[pos].setNombre(nombre);
datos[pos].setNota(nota);
}
} else {
}
}
public void eliminarDatos() {

long codigo = LE
.leerLong("Ingrese el código del alumno cuyos datos deseas eliminar");
if (pos > -1) {
int rpta = LE.mostrarPreguntaOpcion2("Está usted"

+ " seguro que desea eliminar los datos del alumno "
+ datos[pos].getNombre() + " cuya nota es "
+ datos[pos].getNota());
if (rpta == 0) {
Pág. 33
Clase PrgAlumno
for (int i = pos; i < numAlu - 1; i++) {

datos[i] = datos[i + 1];
}
numAlu--;
}
} else {
}
}
public void ordenarDatos() {

for (int i = 0; i < numAlu - 1; i++) {
for (int j = i + 1; j < numAlu; j++) {
if (datos[i].getCodigo() > datos[j].getCodigo()) {
Alumno tmp = datos[i];
datos[i] = datos[j];
datos[j] = tmp;
}
}
}
}
public int buscarCodigo(long codigo) {

if (codigo == datos[i].getCodigo()) {
return i;
}
}
return -1;
}
public void aumentar() {

Alumno datosTmp[] = new Alumno[datos.length + 5];
datosTmp[i] = datos[i];
}
datos = datosTmp;
}
Pág. 34
Modelo Vista Controlador
El Modelo Vista Controlador (MVC) es un patrón de arquitectura de software que separa

los datos de una aplicación, la interfaz gráfica de usuario, y la lógica de control en
tres componentes distintos.
 Modelo: Esta es la representación específica de la información con la cual el sistema opera.

En resumen, el modelo se limita a lo relativo de la vista y su controlador facilitando las
presentaciones visuales complejas. El sistema también puede operar con más datos no
relativos a la presentación, haciendo uso integrado de otras lógicas de negocio y de datos
afines con el sistema modelado.
 Vista: Este presenta el modelo en un formato adecuado para interactuar, usualmente
la interfaz de usuario.
 Controlador: Este responde a eventos, usualmente acciones del usuario, e invoca
peticiones al modelo y, probablemente, a la vista.
Pág. 35
Problema 03

Enunciado:
Desarrolle una solución que permita almacenar el código, nombre y sueldo de todos los
empleados de una empresa textil teniendo en cuenta el Diagrama de Clase y la Gráfica de
Estructura de Datos mostrados. También desarrolle los métodos para agregar datos, mostrar
datos y buscar datos en base al código del empleado. Utilice 3 clases para el desarrollo de la
solución (MVC).
Pág. 36
datos
numEmp = 0
(Empleado) ( int )
Donde:
Clase Empleado
package modelo;

private double sueldo;
public Empleado(){
codigo = 0;
nombre = null;
sueldo = 0;
}
public Empleado(long codigo, String nombre, double sueldo){

Pág. 37
Clase Empleado

return codigo;
}

}

return nombre;
}

}

return sueldo;
}

}
}
Clase ArregloEmpleado
package controlador;
import modelo.Empleado;
public class ArregloEmpleado {

Empleado datos[];
int numEmp;
public ArregloEmpleado() {
numEmp = 0;
}
Pág. 38
public int agregarDatos(long codigo, String nombre, double sueldo) {
if (pos != -1) {
return -1;
} else {
if (numEmp == datos.length) {
aumentar();
}
Empleado objEmp = new Empleado(codigo, nombre, sueldo);
numEmp++;
return 0;
}
}
public String obtenerDatos() {

listaDatos = listaDatos + "Codigo-->" + datos[i].getCodigo()
+ " " + "Nombre-->" + datos[i].getNombre() + " "
+ "Sueldo-->" + datos[i].getSueldo() + "\n";
}
return listaDatos;
}
public String obtenerDatosEmpleado(long codigo) {

listaDatos = "Informacion Encontrada : \n" + "Codigo-->"
+ datos[i].getCodigo() + " " + "Nombre-->"
+ datos[i].getNombre() + " " + "Sueldo-->"
+ datos[i].getSueldo();
return listaDatos;
}
}
return listaDatos;
}

return i;
}
}
return -1;
Pág. 39
}

Empleado datosTmp[] = new Empleado[datos.length + 3];
}
datos = datosTmp;
}
}
Clase PrgEmpleado
package vista;
import controlador.ArregloEmpleado;
public class PrgEmpleado {
ArregloEmpleado objArray;
public PrgEmpleado() {
objArray = new ArregloEmpleado();
}

int rpta;
long codigo;
String nombre;
double sueldo;
do {
sueldo = LE.leerDouble("Ingrese el sueldo");
objArray.agregarDatos(codigo, nombre, sueldo);

}

String listaDatos = objArray.obtenerDatos();
Pág. 40
Clase PrgEmpleado
if (listaDatos != "") {
LE.mostrarInformacion("Datos de los Empleados\n\n" + listaDatos);

} else {
LE.mostrarInformacion("No existen datos registrados");
}
}
public void mostrarDatosEmpleado() {

long codigo = LE
.leerLong("Ingrese el código del empleado cuyos datos deseas mostrar");
String listaDatos = objArray.obtenerDatosEmpleado(codigo);
LE.mostrarInformacion("Datos del Empleado\n\n" + listaDatos);
} else {
LE.mostrarInformacion("Código de empleado no existe");
}
}

PrgEmpleado x = new PrgEmpleado();
x.ingresarDatos();
x.mostrarDatos();
x.mostrarDatosEmpleado();
}
}
Observe la declaración del atributo datos [ ] de la clase ArregloEmpleado:

Empleado datos[];
int numEmp;
numEmp = 0;
}
Pág. 41
Reflexione las implicancias de declarar al atributo datos [ ] sin el modificador de acceso public.
Por otro lado, es importante mencionar sobre la necesidad de aumentar el tamaño del arreglo de
objetos cuando se ingresen más datos de los que se pueden almacenar. Analice la modificación
en el método agregarDatos ( ) y la codificación del método aumentar ( ).

if (pos != -1) {
return -1;
} else {
aumentar();
}
numEmp++;
return 0;
}
}
public void aumentar ( ) {
Empleado datosTmp [ ] = new Empleado [ datos.length + 5 ] ;
for ( int i = 0 ; i < numEmp ; i++ ) {

datosTmp [i] = datos [i] ;
}
datos = datosTmp ;
}
Cada vez que se ingresen más datos de los que se pueden almacenar se ejecutará él método
aumentar ( ) para permitir el ingresar y almacenamiento de los datos de cinco empleados más. El
Pág. 42
método aumentar ( ) también puede ser codificado utilizando el método ArrayCopy de la clase
System de Java.
public void aumentar ( ) {
Empleado datosTmp [ ] = new Empleado [ datos.length + 5 ] ;

System.ArrayCopy ( datos, 0, datosTmp, datos.length ) ;
datos = datosTmp ;
También, podemos extender la codificación de la clase ArregloEmpleado desarrollando los

métodos modificarDatos ( ), ordenarCodigo ( ) y eliminarDatos ( ), tal y como se muestra a
continuación:
public void modificarDatos ( int pos, String nombre, double sueldo ) {

datos [pos].setNombre ( nombre ) ;
datos [pos].setSueldo ( sueldo ) ;
}
public void eliminarDatos ( int pos ) {

if ( pos != -1 ) {
for ( int i = pos ; i < numEmp ; i++ ) {
datos[i] = datos[i + 1] ;
}
}
numEmp -- ;
}
public void ordenarCodigo ( ) {

for ( int i = 0 ; i < numEmp - 1 ; i++ ) {
for ( int j = i + 1 ; j < numEmp ; j++ ) {
// Mayor por ser en forma ascendente

if ( datos[i].getCodigo ( ) > datos[j].getCodigo ( ) ) {
// Intercambio
Empleado tmp = datos[i] ;
datos[i] = datos[j] ;
datos[j] = tmp ;
}
}
}
}
Pág. 43
Una pregunte que sería importante formularse estaría referida a la forma en que se podría o
debería utilizarse los métodos modificarDatos ( ), eliminarDatos ( ) y ordenarDatos ( ) desde la
clase PrgEmpleado. ¿Cuál es su opinión al respecto?
También, deberá analizar la codificación del método eliminarDatos ( ) y determinar la parte en la

que existe un error. Debate las implicancias del mismo.
Pág. 44
Problema 04

Enunciado:
Desarrolle una solución que permita almacenar el código, nombre y la nota final de todos los
alumnos de un salón de clase teniendo en cuenta el Diagrama de Clase y la Gráfica de Estructura
de Datos mostrados. También, desarrolle todos los métodos necesarios para actualizar y
controlar los datos almacenados. Utilice 3 clases para el desarrollo de la solución (MVC).
 Nombre del Proyecto: ProyAlumnos2
 Diagrama de Paquetes:
vista controlador modelo
biblioteca
Pág. 45
 Diagrama de clases:
datos
numAlu = 0
(Alumno) ( int )
Donde:
numAlu = Número de alumnos del salón de clase.
Pág. 46
Clase Alumno
package modelo;
public class Alumno {

private double nota;
public Alumno(){
codigo = 0;
nombre = null;
nota = 0;
}
public Alumno(long codigo, String nombre, double nota){

this.nota = nota;
}

return codigo;
}

}

return nombre;
}

}
public double getNota() {

return nota;
}
public void setNota(double nota) {

this.nota = nota;
}
}
Pág. 47
Clase ArregloAlumno
import modelo.Alumno;
public class ArregloAlumno {

Alumno datos[];
int numAlu;
public ArregloAlumno() {
numAlu = 0;
datos = new Alumno[5];
}
public int agregarDatos(long codigo, String nombre, double nota) {

if (pos != -1) {
return -1;
} else {
if (numAlu == datos.length) {
aumentar();
}
Alumno objAlu = new Alumno(codigo, nombre, nota);
datos[numAlu] = objAlu;
numAlu++;
return 0;
}
}

listaDatos = listaDatos + datos[i].getCodigo() + " \t"
+ datos[i].getNombre() + " \t" + datos[i].getNota() + " \n";
}
return listaDatos;
}
public String obtenerDatosAlumno(long codigo) {

listaDatos = "\nCodigo: " + datos[i].getCodigo() + "\nNombre: "
+ datos[i].getNombre() + "\nNota: "
Pág. 48
Clase ArregloAlumno
+ datos[i].getNota();
return listaDatos;
}
}
return listaDatos;
}
public void modificarDatos(int pos, String nombre, double nota) {
datos[pos].setNombre(nombre);
datos[pos].setNota(nota);
}
public void eliminarDatos(int pos) {

if (pos > -1) {
for (int i = pos; i < numAlu - 1; i++) {
}
numAlu--;
}
}

for (int i = 0; i < numAlu - 1; i++) {
for (int j = i + 1; j < numAlu; j++) {
Alumno tmp = datos[i];
datos[j] = tmp;
}
}
}
}

return i;
}
}
return -1;
}

Alumno datosTmp[] = new Alumno[datos.length + 3];
Pág. 49
Clase ArregloAlumno

}
datos = datosTmp;
}
public int getNumAlu() {

return numAlu;
}
Clase PrgAlumno
package vista;
import controlador.ArregloAlumno;
public class PrgAlumno {
ArregloAlumno objArray;
public PrgAlumno() {
objArray = new ArregloAlumno();
}

PrgAlumno x = new PrgAlumno();
x.menu();
}
public void menu() {

int opc;
+ "-------------------------------------\n"
+ "[1] Ingreso de Datos \n" + "[0] Finalizar \n"
+ "-------------------------------------\n"
Pág. 50
Clase PrgAlumno

+ "-------------------------------------\n"
+ "[1] Ingreso de datos \n" + "[2] Mostrar datos \n"
+ "[3] Mostrar datos de un alumno \n"
+ "[4] Modificar datos \n" + "[5] Eliminar datos \n"
+ "[6] Ordenar datos \n" + "[0] Finalizar \n"
+ "-------------------------------------\n"
boolean acceso = false;

String opciones = opciones1;
do {
opc = LE.leerInt(opciones);
switch (opc) {
case 1:
ingresarDatos();
acceso = true;
break;
case 2:
if (acceso) {
mostrarDatos();
} else {
}
break;
case 3:
if (acceso) {
mostrarDatosAlumno();
} else {
}
break;
case 4:
if (acceso) {
modificarDatos();
} else {
}
break;
Pág. 51
Clase PrgAlumno
case 5:
if (acceso) {
eliminarDatos();
if (objArray.getNumAlu() == 0) {
acceso = false;
}
} else {
}
break;
case 6:
if (acceso) {
ordenarDatos();
mostrarDatos();
} else {
}
break;
case 0:
break;
default:
}
} while (opc != 0);

int rpta;
ong codigo;
String nombre;
double nota;
do {
nota = LE.leerDouble("Ingrese la nota");
objArray.agregarDatos(codigo, nombre, nota);

}
Pág. 52
Clase PrgAlumno

LE.mostrarInformacion("Datos de los alumnos","Código Nombre
Notas",listaDatos, "Ok", Color.cyan);
} else {
LE.mostrarInformacion("No existen datos registrados");
}
}
public void mostrarDatosAlumno() {

long codigo = LE
.leerLong("Ingrese el código del alumno cuyos datos deseas mostrar");
String listaDatos = objArray.obtenerDatosAlumno(codigo);
LE.mostrarInformacion("Datos del alumno\n" + listaDatos);
} else {
LE.mostrarInformacion("Código de alumno no existe");
}
}
public void modificarDatos() {

long codigo = LE
.leerLong("Ingrese el código del alumno cuyos datos deseas modificar");
int pos = objArray.buscarCodigo(codigo);
if (pos > -1) {

int rpta = LE
.mostrarPreguntaOpcion2("Está usted seguro que desea modificar "
+ "los datos del siguiente alumno?\n"
+ objArray.obtenerDatosAlumno(codigo));
if (rpta == 0) {
String nombre = LE.leerString("Ingrese el nombre del alumno");
double nota = LE.leerDouble("Ingrese la nota del alumno");
objArray.modificarDatos(pos, nombre, nota);
}
} else {
}
}
Pág. 53
Clase PrgAlumno
public void eliminarDatos() {

long codigo = LE
.leerLong("Ingrese el código del alumno cuyos datos deseas eliminar");
int pos = objArray.buscarCodigo(codigo);
if (pos > -1) {

int rpta = LE
.mostrarPreguntaOpcion2("Está usted seguro que desea eliminar "
+ "los datos del siguiente alumno?\n"
+ objArray.obtenerDatosAlumno(codigo));
if (rpta == 0) {
objArray.eliminarDatos(pos);
}
} else {
}
}

objArray.ordenarDatos();
}
Pág. 54
Problema 05

Enunciado:
Desarrolle una solución que permita almacenar el código, el nombre y el sueldo de cada uno de
los empleados de una empresa utilizando arreglo de objetos. También, desarrolle algunos
métodos para manejar los datos almacenados. Utilice el lenguaje de programación Java para la
codificación de la solución y el paquete javax.swing para crear la GUI.
Etapa 02 – Definición de la solución.
 Resultado Deseado:
Almacenar y manipular los datos de los empleados de una empresa.
 Datos Necesarios:
Código, nombre y sueldo de los empleados.
 Procesamiento:
Se ingresarán los datos de los empleados y se almacenarán en un arreglo de objetos. Se
desarrollarán métodos para poder manipular los datos almacenados.

 Diagrama de Paquetes:
swing
(from javax)
event
Vista controlador modelo
biblioteca
(from java)
Pág. 55
 Diseño de la Interfaz Gráfica de Usuario (GUI):
Pág. 56
datos
numEmp = 0
(Empleado) ( int )
Donde:
Etapa 04- Desarrollo de la Codificación
Clase Empleado
package modelo;

long codigo;
String nombre;
double sueldo;
public Empleado() {
codigo = 0;
nombre = "";
sueldo = 0;
}
public Empleado(long codigo, String nombre, double sueldo) {

Pág. 57
Clase Empleado

return codigo;
}

}

return nombre;
}

}

return sueldo;
}

}
import modelo.Empleado;

Empleado datos[];
int numEmp;
Pág. 58
numEmp = 0;
}

if (pos != -1) {
return -1;
} else {
aumentar();
}

numEmp++;
return 0;
}
}

listaDatos = listaDatos + "Codigo-->" + datos[i].getCodigo()
+ " " + "Nombre-->" + datos[i].getNombre() + " "
+ "Sueldo-->" + datos[i].getSueldo() + "\n";
}
return listaDatos;
}
public int eliminarDatos(long codigo) {

if (pos == -1) {
return -1;
} else {
for (int i = pos; i < numEmp - 1; i++) {
}
numEmp--;
return 0;
}
}

for (int i = 0; i < numEmp - 1; i++) {
for (int j = i + 1; j < numEmp; j++) {
Pág. 59

Empleado tmp = datos[i];
datos[j] = tmp;
}
}
}
}
public String obtenerDatosEmpleado(long codigo) {

listaDatos = "Informacion Encontrada : \n" + "Codigo-->"
+ datos[i].getCodigo() + " " + "Nombre-->"
+ datos[i].getNombre() + " " + "Sueldo-->"
+ datos[i].getSueldo();
return listaDatos;
}
}
return "Datos no encontrados";
}

return i;
}
}
return -1;
}

Empleado datosTmp[] = new Empleado[datos.length + 3];
}
datos = datosTmp;
}
}
Pág. 60
Clase GUIEmpleado
package vista;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import controlador.ArregloEmpleado;
public class GUIEmpleado extends JFrame implements ActionListener,

WindowListener {
ArregloEmpleado objArray;
JLabel lblTitulo, lblCodigo, lblNombre, lblSueldo;

JTextField txtCodigo, txtNombre, txtSueldo;
JButton btnAgregar, btnMostrar, btnEliminar, btnOrdenar, btnBuscar;
JTextArea txaResultados;
JScrollPane scpResultados;
public GUIEmpleado() {
// Creo el objeto
objArray = new ArregloEmpleado();
// Construcción de la GUI
getContentPane().setLayout(null);
// Etiqueta lblTitulo
lblTitulo = new JLabel("DATOS DE EMPLEADOS");
lblTitulo.setBounds(50, 20, 200, 30);
getContentPane().add(lblTitulo);
// Etiqueta lblCodigo
lblNombre = new JLabel("Codigo :");
lblNombre.setBounds(50, 60, 50, 30);
getContentPane().add(lblNombre);
// Etiqueta lblNombre
lblNombre = new JLabel("Nombre :");
lblNombre.setBounds(50, 85, 60, 30);
getContentPane().add(lblNombre);
Pág. 61
Clase GUIEmpleado
// Etiqueta lblSueldos
lblSueldo = new JLabel("Sueldo :");
lblSueldo.setBounds(50, 110, 50, 30);
getContentPane().add(lblSueldo);
// Etiqueta txtCodigo
txtCodigo = new JTextField();
txtCodigo.setBounds(110, 65, 50, 20);
getContentPane().add(txtCodigo);
// Etiqueta txtNombre
txtNombre = new JTextField();
txtNombre.setBounds(110, 90, 100, 20);
getContentPane().add(txtNombre);
// Etiqueta txtSueldo
txtSueldo = new JTextField();
txtSueldo.setBounds(110, 115, 50, 20);
getContentPane().add(txtSueldo);
// Boton Agregar
btnAgregar = new JButton("Agregar");
btnAgregar.setBounds(370, 65, 130, 25);
btnAgregar.addActionListener(this);
getContentPane().add(btnAgregar);
// Boton Mostrar
btnMostrar = new JButton("Mostrar");
btnMostrar.setBounds(370, 90, 130, 25);
btnMostrar.addActionListener(this);
getContentPane().add(btnMostrar);
// Boton Eliminar
btnEliminar = new JButton("Eliminar");
btnEliminar.setBounds(370, 115, 130, 25);
btnEliminar.addActionListener(this);
getContentPane().add(btnEliminar);
// Boton Ordenar
btnOrdenar = new JButton("Ordenar Codigo");
btnOrdenar.setBounds(370, 140, 130, 25);
btnOrdenar.addActionListener(this);
getContentPane().add(btnOrdenar);
Pág. 62
Clase GUIEmpleado
// Boton Buscar
btnBuscar = new JButton("Buscar");
btnBuscar.setBounds(370, 165, 130, 25);
btnBuscar.addActionListener(this);
getContentPane().add(btnBuscar);
// Caja de texto de multiples lineas : TextArea

txaResultados = new JTextArea();
txaResultados.setBounds(50, 180, 310, 150);
txaResultados.setFont(new Font("arial", Font.ITALIC, 12));
txaResultados.setBackground(Color.LIGHT_GRAY);
// ScrollPane para multiples Datos en JTextArea

scpResultados = new JScrollPane(txaResultados);
scpResultados.setBounds(50, 180, 310, 150);
getContentPane().add(scpResultados);
this.addWindowListener(this);
this.setTitle("Empresa TALENTOS");
this.setSize(550, 400);
this.setLocationRelativeTo(null);
this.setVisible(true);
}
public void actionPerformed(ActionEvent e) {
if (e.getSource() == btnAgregar) {
// Evalua si hay datos en los txtArea
if (txtCodigo.getText().equalsIgnoreCase("")
|| txtNombre.getText().equalsIgnoreCase("")
|| txtSueldo.getText().equalsIgnoreCase("")) {
LE.mostrarError("Ingrese los datos solicitados!");
} else {
long codigo = Long.parseLong(txtCodigo.getText());

String nombre = txtNombre.getText();
double sueldo = Double.parseDouble(txtSueldo.getText());
int respuesta = objArray.agregarDatos(codigo, nombre, sueldo);
if (respuesta == -1) {
LE.mostrarError("El código ingresado ya existe");
}
limpiarCajas();
txaResultados.setText("");
}
Pág. 63
Clase GUIEmpleado
if (e.getSource() == btnMostrar) {
mostrarDatos();
}
if (e.getSource() == btnEliminar) {
long codigo = LE.leerLong("Ingrese el código del empleado cuyos datos deseas
eliminar");
int temp = objArray.eliminarDatos(codigo);

if (temp == 0) {
LE.mostrarInformacion("Datos del empleado eliminados correctamente");
mostrarDatos();
} else {
LE.mostrarError("El código no existe o no hay datos almacenados actualmente");
mostrarDatos();
}
}
if (e.getSource() == btnOrdenar) {
objArray.ordenarDatos();
mostrarDatos();
}
if (e.getSource() == btnBuscar) {
long codigo = LE.leerLong("Ingrese código para buscar");
String listaDatos = objArray.obtenerDatosEmpleado(codigo);
if (listaDatos == null) {
LE.mostrarInformacion("Código no encontrado");
} else {
txaResultados.append(listaDatos);
}
}
}
public static void main(String[] args) {

GUIEmpleado x = new GUIEmpleado();
}
public void limpiarCajas() {

txtCodigo.setText("");
txtNombre.setText("");
txtSueldo.setText("");
}
Pág. 64
Clase GUIEmpleado

txaResultados.append(listaDatos);
}
public void windowOpened(WindowEvent we) {

}
public void windowClosing(WindowEvent we) {

System.exit(0);
}
public void windowClosed(WindowEvent we) {

}
public void windowIconified(WindowEvent we) {

}
public void windowDeiconified(WindowEvent we) {

}
public void windowActivated(WindowEvent we) {

}
public void windowDeactivated(WindowEvent we) {

}
}
Pág. 65
Problema 06

Enunciado:
Implemente una Interfaz Gráfica de Usuario (GUI) utilizando componentes del paquete java.awt
para la clase PrgArreglo, la cual se denominará FrmArreglo y estará almacenada en el paquete
gui de tal forma que se pueda utilizar todos los métodos creados para la clase Arreglo.

Pág. 66
Clase FrmArreglo
package gui;
import java.awt.Frame;
import java.awt.Dimension;
import javax.swing.JLabel;
import java.awt.Rectangle;
import java.awt.Label;
import java.awt.TextField;
import java.awt.ScrollPane;
import java.awt.TextArea;
import java.awt.Button;
import java.awt.Dialog;
import javax.swing.JOptionPane;
import javax.swing.text.AbstractDocument.LeafElement;
import java.awt.BorderLayout;
import java.awt.SystemColor;
import domApli.Arreglo;
public class FrmArreglo extends Frame {
Arreglo objA = new Arreglo ( ) ;
private static final long serialVersionUID = 1L;

private Label lblCodigo = null;
private Label lblNombre = null;
private Label lblSueldo = null;
private TextField txtCodigo = null;
private TextField txtNombre = null;
private TextField txtSueldo = null;
private TextArea txASalida = null;
private Button btnIngresar = null;
private Button btnMostrar = null;
private Button btnOrdenar = null;
private Button btnModificar = null;
private Button btnBuscar = null;
private Button btnEliminar = null;
private Button btnSalir = null;
Pág. 67
Clase FrmArreglo
public FrmArreglo( ) {
super ( );
initialize( );
}
private void initialize( ) {
lblSueldo = new Label( );

lblSueldo.setBounds(new Rectangle(56, 138, 67, 23));
lblSueldo.setForeground(SystemColor.activeCaptionText);
lblSueldo.setText("Sueldo");
lblNombre = new Label( );

lblNombre.setBounds(new Rectangle(56, 104, 67, 23));
lblNombre.setForeground(SystemColor.activeCaptionText);
lblNombre.setText("Nombre");
lblCodigo = new Label( );

lblCodigo.setBounds(new Rectangle(56, 70, 67, 23));
lblCodigo.setForeground(SystemColor.activeCaptionText);
lblCodigo.setText("Codigo");
this.setLayout(null);
this.setBackground(SystemColor.desktop);
this.setTitle("FrmArreglo");
this.add(lblCodigo, null);
this.add(lblNombre, null);
this.add(lblSueldo, null);
this.add(getTxtCodigo(), null);
this.add(getTxtNombre(), null);
this.add(getTxtSueldo(), null);
this.add(getTxASalida(), null);
this.add(getBtnIngresar(), null);
this.add(getBtnMostrar(), null);
this.add(getBtnOrdenar(), null);
this.add(getBtnModificar(), null);
this.add(getBtnEliminar(), null);
this.add(getBtnSalir(), null);
this.add(getBtnBuscar(), null);
}
Pág. 68
Clase FrmArreglo
private TextField getTxtCodigo( ) {
if ( txtCodigo == null) {
txtCodigo = new TextField ( );
txtCodigo.setBounds(new Rectangle(127, 70, 174, 23));
}
return txtCodigo;
}
private TextField getTxtNombre( ) {
if (txtNombre == null) {
txtNombre = new TextField ( );
txtNombre.setBounds(new Rectangle(127, 105, 174,
23));
}
return txtNombre;
}
private TextField getTxtSueldo( ) {
if (txtSueldo == null) {
txtSueldo = new TextField ( );
txtSueldo.setBounds(new Rectangle(127, 140, 174, 23));
}
return txtSueldo;
}
private TextArea getTxASalida( ) {
if ( txASalida == null ) {
txASalida = new TextArea ( );
txASalida.setBounds(new Rectangle(49, 185, 377, 212));
}
return txASalida;
}
private Button getBtnIngresar( ) {
if (btnIngresar == null) {
btnIngresar = new Button ( );
btnIngresar.setBounds(new Rectangle(466, 76, 98, 35));
btnIngresar.setLabel("Ingresar");
btnIngresar.addActionListener(new
java.awt.event.ActionListener() {
Pág. 69
Clase FrmArreglo
public void actionPerformed(java.awt.event.ActionEvent

e) {
ingresar();
}
});
}
return btnIngresar;
}
private Button getBtnMostrar( ) {
if (btnMostrar == null) {
btnMostrar = new Button ( );
btnMostrar.setBounds(new Rectangle(466, 123, 98, 35));
btnMostrar.setLabel("Mostrar");
btnMostrar.addActionListener(new
public void actionPerformed(java.awt.event.ActionEvent e) {

mostrar();
}
});
}
return btnMostrar;
}
private Button getBtnOrdenar( ) {
if (btnOrdenar == null) {
btnOrdenar = new Button ( );
btnOrdenar.setBounds(new Rectangle(466, 217, 98,
35));
btnOrdenar.setLabel("Ordenar");
btnOrdenar.addActionListener(new
ordenar();
}
});
}
return btnOrdenar;
}
Pág. 70
Clase FrmArreglo
private Button getBtnModificar( ) {
if (btnModificar == null) {
btnModificar = new Button ( );
btnModificar.setBounds(new Rectangle(466, 264, 98,
35));
btnModificar.setLabel("Modificar");
btnModificar.addActionListener(new

modificar();
}
});
}
return btnModificar;
}
private Button getBtnBuscar( ) {
if (btnBuscar == null) {
btnBuscar = new Button ( );
btnBuscar.setLabel("Buscar");
btnBuscar.setBounds(new Rectangle(466, 170, 98, 35));
btnBuscar.addActionListener(new
public void actionPerformed(java.awt.event.ActionEvent
e) {
buscar();
}
});
}
return btnBuscar;
}
private Button getBtnEliminar( ) {
if (btnEliminar == null) {
btnEliminar = new Button ( );
btnEliminar.setBounds(new Rectangle(466, 311, 98,
35));
btnEliminar.setLabel("Eliminar");
btnEliminar.addActionListener(new
Pág. 71
Clase FrmArreglo

eliminar();
}
});
}
return btnEliminar;
}
private Button getBtnSalir( ) {

if (btnSalir == null) {
btnSalir = new Button ( );
btnSalir.setBounds(new Rectangle(466, 358, 98, 35));
btnSalir.setLabel("Salir");
btnSalir.addActionListener(new
salir();
}
});
}
return btnSalir;
}
void ingresar( ){
int codigo= Integer.parseInt(txtCodigo.getText());

String nombre = txtNombre.getText();
double sueldo= Double.parseDouble(txtSueldo.getText());
objA.agregarDatos(codigo, nombre, sueldo);
limpiar();
}
void mostrar( ){
txASalida.setText("Código Nombre
Sueldo\n"+objA.mostrarDatos());
}
void buscar( ){
int cod=LE.leerInt("ingresa el codigo a buscar");

int pos=objA.buscarXCodigo(cod);
Pág. 72
Clase FrmArreglo
if ( pos > 0 ) {
LE.mostrarInformacion ( "Empleado
"+objA.objE[pos].getNombre()+ "\n Sueldo: "
+objA.objE[pos].getSueldo()) ;
mostrar();
} else {
LE.mostrarInformacion ("Código de empleado no existe") ;
}
}
void ordenar( ){
objA.ordenarXCodigo();
void modificar(){
int cod=LE.leerInt("Ingresa el codigo a modificar:");
if ( pos > 0 ) {
String nombreTemp= LE.leerString("Ingresa nuevo
nombre:");
double sueldoTemp= LE.leerDouble("Ingresa nuevo

sueldo:");
objA.modificarDatos(pos,nombreTemp,sueldoTemp);
mostrar();
} else {
LE.mostrarError("El código a modificar no existe") ;
}
void eliminar( ){
int cod=LE.leerInt("Ingresa el codigo a eliminar:");
if ( pos > 0 ) {
objA.eliminarDatos(pos);
mostrar();
} else {
Pág. 73
Clase FrmArreglo
LE.mostrarError("El código a eliminar no existe") ;

}
}
void salir(){
System.exit(0);
}
void limpiar(){
txtCodigo.requestFocus();
}
}
Pág. 74
Problema 07

Enunciado:
Modifique la Interfaz Gráfica de Usuario (GUI) creada en el problema anterior denominada

FrmArreglo de tal forma que utilice componentes javax.swing.
Pág. 75
Clase FrmArreglo
package gui;
import java.awt.BorderLayout;
import javax.swing.JPanel;
import javax.swing.JFrame;
import java.awt.Dimension;
import javax.swing.JTextField;
import java.awt.Rectangle;
import javax.swing.BorderFactory;
import javax.swing.border.TitledBorder;
import java.awt.Font;
import javax.swing.JTextArea;
import java.awt.GridBagLayout;
import java.awt.GridLayout;
import javax.swing.JButton;
import javax.swing.ImageIcon;
import java.awt.event.KeyEvent;
import javax.swing.JScrollPane;
import domApli.Arreglo;
import javax.swing.JOptionPane;
public class FrmArreglo extends JFrame {
Arreglo objA = new Arreglo ( ) ;

private static final long serialVersionUID = 1L;
private JPanel jContentPane = null;
private JTextField txtCodigo = null;
private JTextField txtNombre = null;
private JTextField txtSueldo = null;
private JTextArea txASalida = null;
private JPanel pnlDatos = null;
private JPanel pnlBotones = null;
private JButton btnIngresar = null;
private JButton btnMostrar = null;
private JButton btnBuscar = null;
private JButton btnOrdenar = null;
private JButton btnModificar = null;
private JButton btnEliminar = null;
private JButton btnSalir = null;
private JScrollPane jScrollPane = null;
private JOptionPane op = null;
Pág. 76
Clase FrmArreglo
public FrmArreglo ( ) {
super( );
initialize( );
}
private void initialize ( ) {

this.setContentPane(getJContentPane());
this.setTitle("FrmArreglo");
}
private JPanel getJContentPane( ) {

if (jContentPane == null) {
jContentPane = new JPanel( );
jContentPane.setLayout(null);
jContentPane.add(getPnlDatos(), null);
jContentPane.add(getPnlBotones(), null);
jContentPane.add(getJScrollPane(), null);
}
return jContentPane;
}
private JTextField getTxtCodigo( ) {

if (txtCodigo == null) {
txtCodigo = new JTextField ( );
. txtCodigo.setBorder(BorderFactory.createTitledBorder
(null, "Ingrese codigo:",
TitledBorder.DEFAULT_JUSTIFICATION,
TitledBorder.DEFAULT_POSITION, new Font("Dialog",
Font.BOLD, 12), new Color(51, 51, 51)));
}
return txtCodigo;
}
private JTextField getTxtNombre( ) {

if (txtNombre == null) {
txtNombre = new JTextField ( );
txtNombre.setBorder(BorderFactory.createTitledBorder(null,
"Ingrese nombre:",TitledBorder.DEFAULT_JUSTIFICATION,
}
return txtNombre;
}
Pág. 77
Clase FrmArreglo
private JTextField getTxtSueldo( ) {

if (txtSueldo == null) {
txtSueldo = new JTextField ( );
txtSueldo.setBorder(BorderFactory.createTitledBorder(null,
"Ingrese sueldo:",
}
return txtSueldo;
}
private JTextArea getTxASalida( ) {

if (txASalida == null) {
txASalida = new JTextArea();
}
return txASalida;
}
private JPanel getPnlDatos( ) {

if (pnlDatos == null) {
GridLayout gridLayout = new GridLayout ( );
gridLayout.setRows(1);
gridLayout.setColumns(3);
pnlDatos = new JPanel();
pnlDatos.setBounds(new Rectangle(3, 3, 457, 47));
pnlDatos.setLayout(gridLayout);
pnlDatos.add(getTxtCodigo(), null);
pnlDatos.add(getTxtNombre(), null);
pnlDatos.add(getTxtSueldo(), null);
}
return pnlDatos;
}
private JPanel getPnlBotones( ) {

if (pnlBotones == null) {
GridLayout gridLayout1 = new GridLayout ( );
gridLayout1.setRows(7);
pnlBotones = new JPanel();
pnlBotones.setLayout(gridLayout1);
pnlBotones.setBounds(new Rectangle(309, 50, 150, 298));
pnlBotones.add(getBtnIngresar(), null);
pnlBotones.add(getBtnMostrar(), null);
Pág. 78
Clase FrmArreglo
pnlBotones.add(getBtnBuscar(), null);
pnlBotones.add(getBtnOrdenar(), null);
pnlBotones.add(getBtnModificar(), null);
pnlBotones.add(getBtnEliminar(), null);
pnlBotones.add(getBtnSalir(), null);
}
return pnlBotones;
}
private JButton getBtnIngresar ( ) {

if (btnIngresar == null) {
btnIngresar = new JButton ( );
btnIngresar.setText("Ingresar");
btnIngresar.setIcon(new ImageIcon("Add.png"));
btnIngresar.addActionListener(new
public void actionPerformed(java.awt.event.ActionEvent e)
{
ingresar();
}
});
}
return btnIngresar;
}
private JButton getBtnMostrar ( ) {

if (btnMostrar == null) {
btnMostrar = new JButton ( );
btnMostrar.setName("");
btnMostrar.setIcon(new ImageIcon("Window.png"));
btnMostrar.setText("Mostrar");
btnMostrar.addActionListener(new
{
mostrar( );
}
});
}
return btnMostrar;
}
Pág. 79
Clase FrmArreglo
private JButton getBtnBuscar ( ) {

if (btnBuscar == null) {
btnBuscar = new JButton ( );
btnBuscar.setText("Buscar");
btnBuscar.setIcon(new ImageIcon("Search.png"));
btnBuscar.setMnemonic(KeyEvent.VK_UNDEFINED);
btnBuscar.addActionListener(new
{
buscar();
}
});
}
return btnBuscar;
}
private JButton getBtnOrdenar ( ) {

if (btnOrdenar == null) {
btnOrdenar = new JButton ( );
btnOrdenar.setText("Ordenar");
btnOrdenar.setIcon(new ImageIcon("Template.png"));
btnOrdenar.addActionListener(new
{
ordenar();
}
});
}
return btnOrdenar;
}
private JButton getBtnModificar ( ) {

if (btnModificar == null) {
btnModificar = new JButton ( );
btnModificar.setText("Modificar");
btnModificar.setIcon(new ImageIcon("Edit.png"));
btnModificar.addActionListener(new
{
modificar();
}
});
}
Pág. 80
Clase FrmArreglo
return btnModificar;
}
private JButton getBtnEliminar ( ) {

if (btnEliminar == null) {
btnEliminar = new JButton ( );
btnEliminar.setText("Eliminar");
btnEliminar.setIcon(new ImageIcon("Close.png"));
btnEliminar.addActionListener(new
{
eliminar();
}
});
}
return btnEliminar;
}
private JButton getBtnSalir ( ) {

if (btnSalir == null) {
btnSalir = new JButton ( );
btnSalir.setText("Salir");
btnSalir.setIcon(new ImageIcon("Back.png"));
btnSalir.addActionListener(new
{
salir();
}
});
}
return btnSalir;
}
private JScrollPane getJScrollPane ( ) {

if (jScrollPane == null) {
jScrollPane = new JScrollPane ( );
jScrollPane.setBounds(new Rectangle(3, 54, 304, 289));
jScrollPane.setBorder(BorderFactory.createTitledBorder(null,
"Los datos a mostrar son:",
jScrollPane.setViewportView(getTxASalida());
Pág. 81
Clase FrmArreglo
}
return jScrollPane;
}
private JOptionPane getOp ( ) {

if (op == null) {
op = new JOptionPane();
}
return op;
}
void ingresar ( ){
int codigo= Integer.parseInt(txtCodigo.getText( ) );
String nombre = txtNombre.getText( );
double sueldo= Double.parseDouble(txtSueldo.getText( ));
objA.agregarDatos(codigo, nombre, sueldo);

limpiar();
}
void mostrar ( ){
txASalida.setText("Código Nombre
Sueldo\n"+objA.mostrarDatos( ));
}
void buscar ( ){
int cod=Integer.parseInt(op.showInputDialog("Ingresa el código a
buscar"));
if ( pos >= 0 ) {
op.showMessageDialog(this, "Empleado
"+objA.objE[pos].getNombre( )+ "\n Sueldo: "
+objA.objE[pos].getSueldo( ));
mostrar( );
} else {
op.showMessageDialog(this, "Código de empleado no existe") ;
}
}
void ordenar ( ){
objA.ordenarXCodigo( );
}
Pág. 82
Clase FrmArreglo
void modificar ( ){
int cod=Integer.parseInt(op.showInputDialog("Ingresa el código a
modificar"));
if ( pos >= 0 ) {
String nombreTemp= LE.leerString("Ingresa nuevo
nombre:");
double sueldoTemp= LE.leerDouble("Ingresa nuevo
sueldo:");
objA.modificarDatos(pos,nombreTemp,sueldoTemp);
mostrar();
} else {
op.showMessageDialog(this, "El código a modificar no
existe");
}
}
void eliminar ( ){
int cod=Integer.parseInt(op.showInputDialog("Ingresa el codigo a
eliminar:"));
if ( pos >= 0 ) {
objA.eliminarDatos(pos);
mostrar();
} else {
op.showMessageDialog(this,"El código a eliminar no
existe") ;
}
}
void salir ( ){
System.exit(0);
}
void limpiar ( ){
txtCodigo.requestFocus();
}
Pág. 83

Algoritmo y Estructura de Datos II MATER

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Algoritmo y Estructura de Datos II MATER

Cargado por

Copyright:

Formatos disponibles

Algoritmo y Estructura de Datos II

MATERIAL DEL DOCENTE

Juan José Flores Cueto

ESTRUCTURA DE DATOS - ARREGLOS

ARREGLOS UNIDIMENSIONALES - VECTORES

A continuación se muestra la representación gráfica de un arreglo unidimensional llamado

nombre = Nombre del vector.

i = Tamaño del vector.

En general, para declarar un arreglo unidimensional se utiliza el siguiente formato:

En Pseudocódigo y Diagrama de Flujo:

También se puede declarar un arreglo unidimensional colocando los corchetes de apertura y

En Pseudocodigo y Diagrama de Flujo:

Para crear un arreglo unidimensional, es necesario que el arreglo unidimensional previamente

Para crear un arreglo unidimensional se utiliza el siguiente formato:

arreglo = new TipoDeDato [tamaño] ;

En Pseudocodigo y Diagrama de Flujo:

TipoDeDato arreglo[ ] = new TipoDeDato [tamaño];

Cuando se crea un arreglo unidimensional utilizando el operador new es recomendable, aunque

Después de crear un arreglo unidimensional, inicialice o no el arreglo unidimensional, se deberán

ARREGLOS BIDIMENSIONALES - MATRICES

A continuación se muestra la representación gráfica de un arreglo bidimensional llamado nombre:

0 X 0,0 X 0,1 X 0,2 … X 0,j -1

nombre = Nombre de la matriz.

i*j = Tamaño de la matriz.

Cuando se plantean soluciones a diversos problemas es necesario utilizar variables, vectores y

Dados los vectores:

Donde numTrab permite almacenar el número de trabajadores.

Dados los vectores:

nombre sexo edad

(String) (char) (int) ( int )

Donde numSoc permite almacenar el número de socios.

Dados los vectores:

Donde: numArt permite almacenar el número de Artículos.

ARREGLOS DE GRAN TAMAÑO

Donde numAlu indica el número de códigos de alumnos almacenados.

Dados los vectores:

(String) (double) ( int )

Donde numTrab indica el número de trabajadores cuyos datos se han almacenado.

A continuación se muestra la representación gráfica de un arreglo de objetos. Observe que un

A continuación se muestra un conjunto de arreglos en paralelo definidos para una determinada

Analice ambos diagramas e intente estableces las diferencias.

Etapa 01 – Descripción del problema

Etapa 03 – Diseño de la lógica

 Nombre del Proyecto: ProyEmpleado1

 Gráfica de Estructura de Datos:

numEmp = Número de empleados de la empresa.

Etapa 04 – Desarrollo de la codificación

public class Empleado {

private long codigo;

public long getCodigo() {

public void setCodigo(long codigo) {

public String getNombre() {

public void setNombre(String nombre) {

public double getSueldo() {

public void setSueldo(double sueldo) {

public class PrgEmpleado {

public Empleado datos[];

public void ingresarDatos() {

Empleado objEmp = new Empleado();

rpta = LE.mostrarPreguntaOpcion2("Desea continuar? ");

public void mostrarDatos() {

public void mostrarDatosEmpleado() {

for (int i = 0; i < numEmp; i++) {

public static void main(String arg[]) {

String opciones2 = "MENU PRINCIPAL \n"