Universidad Nacional San Cristóbal de Huamanga

Facultad de Ingeniería de Minas Geología y Civil

Escuela Profesional de Ingeniería de Sistemas

TAREA ACADÉMICA n° 03
ArrayList

Jordy Julian Huamán Lozano

Código 27115801

Docente

MSc. Ing. Fredy Barrientos

Ayacucho – Perú

Agosto de 2020
Contenido:
DESARROLLO Y RESULTADOS 3

1.1 Desarrollo 3

1.1.1 Ejercicio primero 3

1.2 Resultados e interpretación 9

1.2.1 Ejercicio primero 9

1.3 Repositorio 12

CONCLUSIONES 14

2
 1 DESARROLLO Y RESULTADOS
1.1 Desarrollo

1.1.1 Ejercicio primero

Para el siguiente programa se de ArrayList se muestra una manera de controlar los

clientes que ingresan a un establecimiento:

● Creamos la clase cliente con sus atributos, su constructor y sus métodos set y get:

public class Cliente {

private String Nombre;
private String Apellido;
private String Fecha;
private String Hora;

public Cliente(String Nombre, String Apellido, String Fecha,

String Hora) {
this.Nombre = Nombre;
this.Apellido = Apellido;
this.Fecha = Fecha;
this.Hora = Hora;
}

public String getNombre() {

return Nombre;
}

public void setNombre(String Nombre) {

this.Nombre = Nombre;
}

public String getApellido() {

return Apellido;
}

public void setApellido(String Apellido) {

this.Apellido = Apellido;
}

public String getFecha() {

return Fecha;
}

public void setFecha(String Fecha) {

this.Fecha = Fecha;
}

public String getHora() {

return Hora;
}

public void setHora(String Hora) {

this.Hora = Hora;
}
}

3
● Declaramos los parámetros, las variables globales y los métodos para visualizar
una tabla donde se mostrar los datos ingresados:
public class PanelPrincipalControlCliente extends
javax.swing.JPanel {

//Permite eliminar e insertar elementos en tiempo constante

public static LinkedList contenedor1 = new LinkedList();
public static LinkedList contenedor2 = new LinkedList();
public static LinkedList contenedor3 = new LinkedList();
public String buscar;

//Damos forma a las tablas de ingreso de datos, en espera y

finalización
private DefaultTableModel modeloIngreso, modeloAtencion,
modeloFinClientes;
int contador = 0;

public PanelPrincipalControlCliente() {
initComponents();

//Metodos para mostrar las diferentes tablas

MostrarTablaIngreso();
MostrarTablaAtencion();
MostrarTablaFinCliente();
}

public void MostrarTablaIngreso() {

String datosIngreso[][] = {};
String columnaIngreso[] = {"NOMBRE", "APELLIDO", "FECHA",
"HORA DE INGRESO"};
modeloIngreso = new DefaultTableModel(datosIngreso,
columnaIngreso);
tablaEnEspera.setModel(modeloIngreso);
}

public void MostrarTablaAtencion() {

String datosEspera[][] = {};
String columnaEspera[] = {"NOMBRE", "APELLIDO", "FECHA",
"HORA DE ATENCIÓN"};
modeloAtencion = new DefaultTableModel(datosEspera,
columnaEspera);
tablaAtención.setModel(modeloAtencion);
}

private void MostrarTablaFinCliente() {

String datosFin[][] = {};
String columnaFin[] = {"NOMBRE", "APELLIDO", "FECHA",
"HORA DE FINALIZACIÓN"};
modeloFinClientes = new DefaultTableModel(datosFin,
columnaFin);
tablaAtendidos.setModel(modeloFinClientes);
}

4
 También implementaremos los métodos para ingresar, buscar por nombre o
apellido, poner en atención, y dar por finalizada la atención de los clientes, al
igual que un método para mostrar estos datos ingresados en las tablas
generadas anteriormente:

private void ingresar() {

//Declaramos las locales
String nombre, apellido, fecha, hora;

//Capturamos los datos ingresados

String ingresarNom, ingresarAp, ingresarfecha,
ingresarhora, a = "";
ingresarNom = txtNombre.getText();
ingresarAp = txtApellido.getText();
ingresarfecha = txtFecha.getText();
ingresarhora = txtHora.getText();
if (ingresarNom.equals(a) || ingresarAp.equals(a) ||
ingresarfecha.equals(a) || ingresarhora.equals(a)) {
JOptionPane.showMessageDialog(null, "Debe rellenar
todos los datos antes!!");

} else {
nombre = txtNombre.getText();
apellido = txtApellido.getText();
fecha = txtFecha.getText();
hora = txtHora.getText();

//Instamos dentro de la clase Cliente

Cliente clienteIngresado = new Cliente(nombre,
apellido, fecha, hora);
contenedor1.add(clienteIngresado);

//Limpiamos los cuadros de ingreso de datos

limpiarCuadros();

//Limpizamos la tabla de clientes ingresados para una

mejor presentación
LimpiarTablaIngreso();
}

//Metodo para mostrar los clientes ingresados

private void mostrarClienteIngreso() {
//Declaramos una variable de tipo Cliente
Cliente clientI;
for (int i = 0; i < contenedor1.size(); i++) {
clientI = (Cliente) contenedor1.get(i);
modeloIngreso.insertRow(contador, new Object[]{});
modeloIngreso.setValueAt(clientI.getNombre(),
contador, 0);
modeloIngreso.setValueAt(clientI.getApellido(),
contador, 1);
modeloIngreso.setValueAt(clientI.getFecha(),
contador, 2);
modeloIngreso.setValueAt(clientI.getHora(), contador,
3);
}

5
 }

//Metodo para buscar un campo

private void buscar() {
String buscar;

//Hacemos queu buscar capte el valor ingresao en el

cuadro de búsqueda
//El método trim() elimina los espacios antes y despues
del texto
buscar = txtBuscar.getText().trim();
Cliente c;
for (int i = 0; i < contenedor1.size(); i++) {
c = (Cliente) contenedor1.get(i);
//Condicionamos que si el texto ingresado es igual al
nombre o apeellido
//devuelva en los mismo cuadros ingreso de datos el
dato guardado anteriormente
if (buscar.equalsIgnoreCase(c.getNombre()) ||
buscar.equalsIgnoreCase(c.getApellido())) {
txtNombre.setText(c.getNombre());
txtApellido.setText(c.getApellido());
txtFecha.setText(c.getFecha());
txtHora.setText(c.getHora());

private void ponerEnAtencion() {

//declaramos las variables locales
String nombreAten, apellidoAten, fechaAten, horaAten;

String ingresarNom, ingresarAp, ingresarfecha,

ingresarhora, a = "";
ingresarNom = txtNombre.getText();
ingresarAp = txtApellido.getText();
ingresarfecha = txtFecha.getText();
ingresarhora = txtHora.getText();
if (ingresarNom.equals(a) || ingresarAp.equals(a) ||
ingresarfecha.equals(a) || ingresarhora.equals(a)) {
JOptionPane.showMessageDialog(null, "Debe rellenar
todos los datos antes!!");

} else {
//Leemos nuevamente con la hora de atencion
nombreAten = txtNombre.getText();
apellidoAten = txtApellido.getText();
fechaAten = txtFecha.getText();
horaAten = txtHora.getText();

//Ingresamos dentro de otra clase de tipo Cliente

Cliente clienteEnAtencion = new Cliente(nombreAten,
apellidoAten, fechaAten, horaAten);
contenedor2.add(clienteEnAtencion);

//Limpiamos cuadros de entrada

limpiarCuadros();

6
 //Limpizamos la tabla de clientes en atención para
una mejor presentación
LimpiarTablaEnAtención();
}
}

private void mostrarClientesEnAtención() {

//Declaramos una variable de tipo Cliente
Cliente clientEnAt;
//Hacemos el recorrido de los valores ingresados desde la
pocisión 0
//hasta el máxixo de tamaño que tenga nuestro contenedor
2
for (int i = 0; i < contenedor2.size(); i++) {
clientEnAt = (Cliente) contenedor2.get(i);
//Le asignamos a cada fila de la tabla en atención
modeloAtencion.insertRow(contador, new Object[]{});
modeloAtencion.setValueAt(clientEnAt.getNombre(),
contador, 0);
modeloAtencion.setValueAt(clientEnAt.getApellido(),
contador, 1);
modeloAtencion.setValueAt(clientEnAt.getFecha(),
contador, 2);
modeloAtencion.setValueAt(clientEnAt.getHora(),
contador, 3);

}
}

private void clientesAtendidos() {

//Declaramos las locales
String nombreFin, apellidofFin, fechafin, horaFin;

//HAcemos una nueva captura de los datos con la hora

cambiada
//para la dinalización de la atemción
String ingresarNom, ingresarAp, ingresarfecha,
ingresarhora ,a = "";
ingresarNom = txtNombre.getText();
ingresarAp = txtApellido.getText();
ingresarfecha = txtFecha.getText();
ingresarhora = txtHora.getText();
if (ingresarNom.equals(a) || ingresarAp.equals(a) ||
ingresarfecha.equals(a) || ingresarhora.equals(a)) {
JOptionPane.showMessageDialog(null, "Debe rellenar
todos los datos antes!!");

} else {
nombreFin = txtNombre.getText();
apellidofFin = txtApellido.getText();
fechafin = txtFecha.getText();
horaFin = txtHora.getText();

//Instanciamos una nueva clase

Cliente clienteAtendido = new Cliente(nombreFin,
apellidofFin, fechafin, horaFin);
contenedor3.add(clienteAtendido);

//Limpiamos los cuadros

limpiarCuadros();

7
 //Limpizamos la tabla de clientes atendidos para una
mejor presentación
limpiarTablaClientesAtendidos();
}
}

private void mostrarClientesAtendidos() {

//Declaramos una variable de tipo Cliente
Cliente clientAten;
//Hacemos el recorrido de los valores ingresados desde la
pocisión 0
//hasta el máxixo de tamaño que tenga nuestro contenedor
3
for (int i = 0; i < contenedor3.size(); i++) {
clientAten = (Cliente) contenedor3.get(i);
//Le asignamos a cada fila de la tabla en atención
modeloFinClientes.insertRow(contador, new
Object[]{});
modeloFinClientes.setValueAt(clientAten.getNombre(),
contador, 0);

modeloFinClientes.setValueAt(clientAten.getApellido(), contador,
1);
modeloFinClientes.setValueAt(clientAten.getFecha(),
contador, 2);
modeloFinClientes.setValueAt(clientAten.getHora(),
contador, 3);

}
}

//Método para limpiar cuadros entrada de texto

private void limpiarCuadros() {
//Limpiamos los cuadros de ingreso de datos
txtNombre.setText("");
txtApellido.setText("");
txtHora.setText("");
}

//Método para limpiar la tabla de ingreso

private void LimpiarTablaIngreso() {
//setRowCount devuelve la tabla en null
modeloIngreso.setRowCount(0);
}

//Método para limpiara la tabla de clientes en atención

private void LimpiarTablaEnAtención() {
modeloAtencion.setRowCount(0);
}

//Método para limpiar la tabla de clientes atendidos

private void limpiarTablaClientesAtendidos() {
modeloFinClientes.setRowCount(0);
}

8
  Además, este código está implementado en un panel (Ilustración 1.1):

Ilustración 1.1: Panel para la GUI del primer ejercicio.

1.2 Resultados e interpretación

1.2.1 Ejercicio primero

Al ejecutar nuestro se obtiene el siguiente resultado (Ilustración 1.2):

Ilustración 1.2: GUI ejecutado del primero ejercicio.

9
Interpretación: Este programa tiene 4 apartados:

 Entrada de datos de clientes, donde se ingresará el nombre, apellido, la fecha

con formado día/mes/año y la hora con formato hora/minutos donde nos
muestra un mensaje si no rellenamos los datos requeridos (Ilustración 1.3):

Ilustración 1.3: Ingreso de datos en la GUI.

 Botones de operaciones ingreso y mostrar clientes, donde uno puede

poner a los clientes en espera cuando los ingresas, o ponerlos en atención o
ponerlos en lista de clientes atendidos. Estos botones solo funcionan si los
cuadros de ingreso de datos están rellenados, caso contrario mostrara un aviso,
que diga que deben ser rellenados. Luego cada botón de mostrar permite
visualizar los datos ingresados anteriormente a cada apartado respectivamente
(Ilustración 1.4):

10
 Ilustración 1.4: Mensaje para llenar los datos requeridos de la GUI.

 Botón de búsqueda, el cual nos permite buscar a los clientes que ingresamos
anteriormente, por nombre o por apellido y ponerlos en lista de atención o lista
de atendidos, para ello se tiene que cambiar la hora cuando se quiere ponerlos
en atención o en lista de atendidos (Ilustración 1.6). Mostrará los datos en la
misma caja de cuadros de ingreso, esto gracias al método setText(), si no lo
encuentra no mostrará nada (Ilustración 1.5):

Ilustración 1.5: Búsqueda del cliente “Juan”.

11
 Ilustración 1.6: Cambiado hora para ingreso a atención del cliente Oscar.

 Tablas de datos, que nos permite visualizar a los clientes ingresados, puestos en
atención o lista de atendidos (Clientes finalizados) (Ilustración 1.7).

Ilustración 1.7: Clientes que están siendo atendidos.

1.3 Repositorio

El programa está implementado en un paquete llamado TA03 (Ilustración 1.8):

12
Ilustración 1.8: Subida exitosa al repositorio del paquete TA0.

13
 2 CONCLUSIONES
 Se logró conocer el funcionamiento de un AraryList y este nos indica que para
instanciar las variables de un arreglo primero tenemos que generar una clase sin
el método main.
 Se utilizó correctamente los métodos del ArrayList implementado, como el
método constructor, los métodos get y set que nos captan y devuelven,
respectivamente, un valor establecido o ingresado.

14