Practica de Listas (Programación II) Netbeans

Universidad Mariano Gálvez de Guatemala
Harvi Vinicio España Sologaistoa
Ingeniería en Sistemas Plan Sábado, Sección “A”
“Práctica de listas”
Programación II
Ing. Luis Alejandro Sosa Escobar

1) Un cine de un pueblo pequeño nos propone hacer una aplicación para
controlar las personas de una cola de un cine en los grandes estrenos de
películas. Un conjunto de personas espera la cola para sacar una entrada,
tendremos que calcular la entrada según la edad de la persona (mínimo 5
años). La edad de las personas se genera aleatoriamente entre 5 y 60 años.
Os recomiendo realizar un método en el main para generar Personas en la
cola. Al final, deberemos mostrar la cantidad total recaudada. El número de
personas de la cola se elige al azar entre 0 y 50.
Código fuente:
Primer paquete (ColaParaCine):
Clase Persona:
package ColaParaCine;
public class Persona {
private int edad;
public Persona(int edad){
this.edad=edad;
public int getEdad() {
return edad;
public void setEdad(int edad) {
this.edad = edad;
}
Clase Main (principal):
import cola.ColaDinamica;
public class Main {
public static void main(String[] args) {
//Constantes
final double ENTRADA_5_10_ANIOS=1;
final double ENTRADA_11_17_ANIOS=2.5;
final double ENTRADA_18_ANIOS=3.5;
ColaDinamica<Persona> colaCine = new ColaDinamica<>();
rellenarCola(colaCine);
double cantidadRecaudada = 0;
Persona p;
while (!colaCine.isEmpty()){
p = colaCine.dequeue();
if(p.getEdad()<=5 && p.getEdad()<=10){
cantidadRecaudada+=ENTRADA_5_10_ANIOS;
}else if (p.getEdad()<=11 && p.getEdad()<=17){
cantidadRecaudada+=ENTRADA_11_17_ANIOS;
}else{
cantidadRecaudada+=ENTRADA_18_ANIOS;
System.out.println("Se ha recaudado " +cantidadRecaudada);
public static void rellenarCola(ColaDinamica<Persona> cola){
int numPersonas = Metodos.generaNumeroAleatorio(0, 50);
System.out.println("Se van a generar "+numPersonas+" personas");
Persona p;
int edad;
for (int i = 0; i < numPersonas; i++){
edad = Metodos.generaNumeroAleatorio(5, 60);
p = new Persona(edad);
System.out.println("Se ha generado una persona con
"+p.getEdad()+"años");
cola.enqueue(p);
Clase Metodos:
public class Metodos {
public static int generaNumeroAleatorio(int minimo, int maximo) {
int num = (int) Math.floor(Math.random() * (minimo - (maximo + 1)) + (maximo

+ 1));
return num;
}
public static double generaNumeroRealAleatorio(double minimo, double maximo)
{
double num = Math.rint(Math.floor(Math.random() * (minimo - ((maximo * 100)

+ 1)) + ((maximo * 100) + 1))) / 100;
return num;
Segundo paquete (cola):
Clase ColaDinamica:
package cola;
public class ColaDinamica<T> {
//Atributos
private Nodo<T> primero;
private Nodo<T> ultimo;
private int tamanio;
public ColaDinamica() {
primero = null;
ultimo = null;
tamanio = 0;
public boolean isEmpty() {
return primero == null;
public int size() {
return tamanio;
public T primero() {
if (isEmpty()) {
return null;
return primero.getElemento();
public T dequeue() {
if (isEmpty()) {
return null;
T elemento = primero.getElemento();
Nodo<T> aux = primero.getSiguiente();
primero = null;
primero = aux;
tamanio--;
if (isEmpty()) {
ultimo = null;
return elemento;
public T enqueue(T elemento) {
Nodo<T> aux = new Nodo(elemento, null);
if (isEmpty()) {
primero = aux;
ultimo = aux;
} else {
if (size() == 1) {
primero.setSiguiente(aux);
} else {
ultimo.setSiguiente(aux);
ultimo = aux;
tamanio++;
return aux.getElemento();
public String toString() {
if (isEmpty()) {
return "La lista esta vacia";
} else {
String cadena = "";
Nodo<T> aux = primero;

while (aux != null) {
cadena += aux;
aux = aux.getSiguiente();
return cadena;
Clase Nodo:
package cola;
public class Nodo<T> {
//Atributos
private T elemento;
private Nodo<T> siguiente; //Apunta al siguiente nodo
//Contructor
public Nodo(T elemento, Nodo<T> siguiente){
this.elemento = elemento;
this.siguiente = siguiente;
//Metodos
public T getElemento() {
return elemento;
public void setElemento(T elemento) {
this.elemento = elemento;
public Nodo<T> getSiguiente() {
return siguiente;
public void setSiguiente(Nodo<T> siguiente) {
@Override
public String toString() {
return elemento+"\n";
Ejecución:
Zip en Drive:
https://drive.google.com/file/d/1G5ORQ3q5gnhnhMI8C4hlNlR_FbTSSGYb/view?u
sp=sharing
2) Realiza el ejercicio anterior pero el lugar de usar una lista enlazada, usar la
clase ArrayList. Usa un iterador para recorrer el ArrayList. Usa la misma clase
Persona del ejercicio anterior.
Código fuente:
Clase Persona:
package ColaParaCineArrayList;
public class Persona {
private int edad;
public Persona(int edad){
this.edad=edad;
public int getEdad() {
return edad;
public void setEdad(int edad) {
this.edad = edad;
}
package ColaParaCineArrayList;
import java.util.ArrayList;
import java.util.Iterator;
public class Main {
ArrayList<Persona> cola = new ArrayList<>();
generarCola(cola);
double recaudacion;
double recaudacionTotal=0;
Persona espectadorActual;
int edadActual;
//Creamos el iterator
Iterator<Persona> it=cola.iterator();
//Recorremos la cola
while(it.hasNext()){
espectadorActual=it.next();
edadActual=espectadorActual.getEdad();
//Comprobamosla edad
if(edadActual>=5 && edadActual<=10){ recaudacion=1; }else

if(edadActual>=11 && edadActual<=17){
recaudacion=2.5;
}else{
recaudacion=3.5;
recaudacionTotal+=recaudacion;
System.out.println("Una persona de "+edadActual+" años se le ha cobrado "

+recaudacion);
//Mostramos el resultado
System.out.println("La recaudación es de "+recaudacionTotal);

}
public static void generarCola(ArrayList<Persona> cola){
int numeroPersonas=generaNumeroAleatorio(1,50);
System.out.println("Se van a generar "+numeroPersonas+" personas");
for(int i=0;i<numeroPersonas;i++){
cola.add(new Persona(generaNumeroAleatorio(5, 60)));
public static int generaNumeroAleatorio(int minimo, int maximo){
int num=(int)Math.floor(Math.random()*(minimo-(maximo+1))+(maximo+1));
return num;
}
Ejecución:
Zip en Drive:
https://drive.google.com/file/d/10nCoAx2R9zILrN8Je9kLDFChJ3-
g0WkG/view?usp=sharing
3) Un supermercado nos pide que hagamos una pequeña aplicación que
almacene los productos pasados por el escáner.
La aplicación debe almacenar Productos (clase), cada producto al crearse
contiene una cantidad, un precio (estos dos generados aleatoriamente). El
nombre del producto será básico (producto1, producto2, producto3, etc.).
Calcular el precio total de una lista de entre 1 y 8 productos (aleatorio).
Mostrar un ticket con todo lo vendido y el precio final como se hacen en los
supermercados.
Código fuente:
Clase Producto:
package SuperMercado;
import java.text.DecimalFormat;
public class Producto {
private int cantidad;
private double precio;
public Producto(int cantidad, double precio){
this.cantidad=cantidad;
this.precio=precio;
public int getCantidad() {
return cantidad;
}
public double getPrecio() {
return precio;
public double precioFinal(){
DecimalFormat df=new DecimalFormat("#,##");
return Double.parseDouble(df.format(this.precio * this.cantidad));
public class Main {
ListaEnlazada<Producto> productos=new ListaEnlazada<>();

generarProductos(productos);
String ticket=" Cantidad Precio Total\n";
double precioTotal=0;
Producto productoActual;
for(int i=0;!productos.estaVacia();i++){
productoActual=productos.devolverYBorrarPrimero();
precioTotal+=productoActual.precioFinal();
ticket+="Producto"+(i+1)+"\t"+productoActual.getCantidad()+
"\t"+productoActual.getPrecio()+
"\t"+productoActual.precioFinal()+"\n";
ticket+="Precio final\t\t\t"+precioTotal;
System.out.println(ticket);
public static void generarProductos(ListaEnlazada<Producto> lista){

int numeroPersonas=Metodos.generaNumeroAleatorio(1,8);
int cantidad;
double precio;
cantidad=Metodos.generaNumeroAleatorio(1,10);;
precio=Metodos.generaNumeroRealAleatorio(0.05, 50);
lista.insertarUltimo(new Producto(cantidad, precio));
Clase Metodos:
public static int generaNumeroAleatorio(int minimo, int maximo) {
int num = (int) Math.floor(Math.random() * (minimo - (maximo + 1)) + (maximo

+ 1));
return num;
public static double generaNumeroRealAleatorio(double minimo, double maximo)

{
double num = Math.rint(Math.floor(Math.random() * (minimo - ((maximo * 100)

+ 1)) + ((maximo * 100) + 1))) / 100;
return num;
Clase ListaEnlazada:
public class ListaEnlazada<T>{
//Atributos
public ListaEnlazada(){
listaVacia();
}
private void listaVacia(){
primero = null;
public boolean estaVacia(){
public void insertarPrimero(T t){
Nodo<T> nuevo = new Nodo<>(t);
if (!estaVacia()){
nuevo.setSiguiente(primero);
primero=nuevo;
public void insertarUltimo(T t){

Nodo<T> aux = new Nodo<>(t);
Nodo<T> rec_aux;
if (estaVacia()) {
insertarPrimero(t);
}else {
rec_aux = primero;
while(rec_aux.getSiguiente() != null){
rec_aux=rec_aux.getSiguiente();
rec_aux.setSiguiente(aux);
public void quitarPrimero(){
Nodo<T> aux;
if (!estaVacia()){
aux=primero;
primero = primero.getSiguiente();
aux=null;
}
}
public void quitarUltimo(){
Nodo<T> aux=primero;
if(aux.getSiguiente()==null)
listaVacia();
if(!estaVacia()) {
aux=primero;
while(aux.getSiguiente().getSiguiente() != null){
aux=aux.getSiguiente();
aux.setSiguiente(null);
public T devolverUltimo(){
T elemen = null;
Nodo<T> aux;
if (!estaVacia()){
aux = primero;
while(aux.getSiguiente() != null){
elemen = aux.getDato();
return elemen;
public T devolverPrimero(){
T elemen = null;
if (!estaVacia()){
elemen = primero.getDato();
return elemen;
public int cuantosElementos(){
Nodo<T> aux;
int numElementos=0;
aux = primero;
while(aux != null){
numElementos++;
return numElementos;
public T devolverDato(int pos){
int cont=0;
T dato=null;
if(pos<0 || pos>=cuantosElementos()){
System.out.println("La posicion insertada no es correcta");
}else{
while(aux!=null){
if (pos == cont){
dato=aux.getDato();
cont++;
}
return dato;
public Nodo<T> devolverNodo(int pos){
int cont=0;
}else{
while(aux!=null){
if (pos == cont){
return aux;
cont++;
}
}
return aux;
public void introducirDato(int pos, T dato){
Nodo<T> auxDato=null;
Nodo<T> anterior=primero;
int contador=0;
if(pos<0 || pos>cuantosElementos()){
}else{
if(pos==0){
insertarPrimero(dato);
}else if(pos==cuantosElementos()){
insertarUltimo(dato);
}else{
while(aux!=null){
if (pos == contador){
auxDato=new Nodo<>(dato, aux);
anterior.setSiguiente(auxDato);
anterior=aux;
contador++;
public void modificarDato(int pos, T dato){
int cont=0;
}else{
while(aux!=null){
if (pos == cont){
aux.setDato(dato);
cont++;
public void borraPosicion(int pos){
Nodo<T> anterior=null;
int contador=0;
}else{
while(aux!=null){
if (anterior==null){
}else {
anterior.setSiguiente(aux.getSiguiente());
aux=null;
}else{
anterior=aux;
contador++;
public T devolverYBorrarPrimero(){
T dato=devolverPrimero();
quitarPrimero();
return dato;
public int indexOf (T t){
if (estaVacia()){
return -1;
}else{
int contador=0;
boolean encontrado=false;
while(aux!=null && !encontrado){
if(t.equals(aux.getDato())){
encontrado=true;
}else{
contador++;
if(encontrado){
return contador;
}else{
return -1;
public int indexOf (T t, int pos){

Nodo<T> aux;
if (estaVacia()){
return -1;
}else{
int contador=pos;
aux=devolverNodo(pos);
encontrado=true;
}else{
contador++;
if(encontrado){
return contador;
}else{
return -1;
}
}
public boolean datoExistente(T t){
boolean existe=false;
while(aux!=null && !existe){
if(aux.getDato().equals(t)){
existe=true;
return existe;
public void mostrar(){
System.out.println("Contenido de la lista");
System.out.println("---------------------");
while(aux!=null){
System.out.println(aux.getDato());
@Override
public String toString(){
String contenido="";
while(aux!=null){
contenido=aux.getDato()+"\n";
return contenido;
}
}
Clase Nodos:
private T dato;
private Nodo<T> siguiente;
public Nodo(){
siguiente=null;
public Nodo(T p){
siguiente=null;
dato = p;
public Nodo(T t, Nodo<T> siguiente){
this.siguiente=siguiente;
dato = t;
}
public T getDato() {
return dato;
public void setDato(T dato) {
this.dato = dato;
return siguiente;
}
Ejecución:
Zip en Drive:
https://drive.google.com/file/d/1BUOQpys0AoQceFk3eVvevdAUoP_sdD0e/view?u
sp=sharing
4) Realiza el ejercicio anterior pero el lugar de usar una lista enlazada, usar la
clase ArrayList. Usa un iterador para recorrer el ArrayList.
Código fuente:
Clase Producto:
package SuperMercadoArrayList;
import java.text.DecimalFormat;
public class Producto {
private int cantidad;
private double precio;
public Producto(int cantidad, double precio){
this.cantidad=cantidad;
this.precio=precio;
public int getCantidad() {
return cantidad;
public double getPrecio() {

return precio;
public double precioFinal(){
DecimalFormat df=new DecimalFormat("#,##");
return Double.parseDouble(df.format(this.precio * this.cantidad));
import java.util.*;
import java.util.Iterator;
public class Main {
ArrayList<Producto> productos=new ArrayList<>();
generarProductos(productos);
String ticket=" Cantidad Precio Total\n";
double precioTotal=0;
Producto productoActual;
Iterator<Producto> it=productos.iterator();
for(int i=0;it.hasNext();i++){
productoActual= it.next();
precioTotal+=productoActual.precioFinal();
ticket+="Producto"+(i+1)+"\t"+productoActual.getCantidad()
+"\t"+productoActual.getPrecio()
+"\t"+productoActual.precioFinal()+"\n";
ticket+="Precio final\t\t\t"+precioTotal;
System.out.println(ticket);
public static void generarProductos(ArrayList<Producto> lista){

int numeroPersonas=Metodos.generaNumeroAleatorio(1,8);
int cantidad;
double precio;
cantidad=Metodos.generaNumeroAleatorio(1,10);
precio=Metodos.generaNumeroRealAleatorio(0.05, 50);
lista.add(new Producto(cantidad, precio));
Clase Métodos:
return num;
}
public static double generaNumeroRealAleatorio(double minimo, double
maximo){
double num=Math.rint(Math.floor(Math.random()*(minimo-
((maximo*100)+1))+((maximo*100)+1)))/100;
return num;
Ejecución:
Zip en Drive:
https://drive.google.com/file/d/17eQ4lk__EW7qEmM6TRBOI--
GYTRe0C6R/view?usp=sharing
5) Un amigo funcionario nos pide que le hagamos un informe para sus informes.
Debemos gestionar informes que están formados de un código numérico y
una tarea que pueden ser ADMINISTRATIVO, EMPRESARIAL y
PERSONAL. Debe comprobarse que la tarea es alguna de estas.
Nuestro amigo quiere que seamos capaz de agregar y eliminar informes en
forma de pila (el último en entrar es el primero en salir). Agrega 10 informes
y muestra su contenido, elimina todo el contenido y agrega de nuevo 5
informes.
Código fuente:
Clase InformeAEP:
package Informe;
public class InformeAEP {

private final String[] tareas={"administrativo", "empresarial", "personal"};
private int codigo;

private String tarea;
public InformeAEP(int codigo,int indiceTarea){

this.codigo= codigo;
this.tarea= this.tareas[indiceTarea];
}
public int getCodigo() {

return codigo;
}
public void setCodigo(int codigo) {

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

return tarea;
}
public void setTarea(String tarea) {

this.tarea = tarea;
}
public String[] getTareas(){

return tareas;
}
@Override
return "El informe con codigo "+codigo+" tiene la tarea de "+tarea;
}
}
package Informe;
public class Main {

ListaEnlazada<InformeAEP> informes=new ListaEnlazada<>();
//Se agregan 10 informes

for(int i=1;i<=10;i++){
informes.insertarUltimo(new InformeAEP(i,
Metodos.generaNumeroAleatorio(0,2)));
}
System.out.println("Primeros diez informes agregados: ");
ListaEnlazada<InformeAEP> aux=new ListaEnlazada<>();
while(!informes.estaVacia()){
aux.insertarUltimo(informes.devolverUltimo());
informes.quitarUltimo();
System.out.println(aux.devolverUltimo());
}
informes = aux;
}
System.out.println("\n***Informes eliminados***\n");
for(int i=1;i<=5;i++){
informes.insertarUltimo(new InformeAEP(i,
Metodos.generaNumeroAleatorio(0,2)));
}
System.out.println("Ultimos 5 informes agregados: ");

aux=new ListaEnlazada<>();
aux.insertarUltimo(informes.devolverUltimo());
System.out.println(aux.devolverUltimo());
}
informes = aux;
aux=null;
}
}
Clase Metodos:
package Informe;

return num;
}
}
Clase ListaEnlazada:
package Informe;
public class ListaEnlazada<T>{
//Atributos
//Constructor
public ListaEnlazada(){
listaVacia();
}
private void listaVacia(){

primero = null;
}
public boolean estaVacia(){

}
public void insertarPrimero(T t){

Nodo<T> nuevo = new Nodo<>(t);
if (!estaVacia()){
nuevo.setSiguiente(primero);
}
primero=nuevo;
public void insertarUltimo(T t){
Nodo<T> aux = new Nodo<>(t);

Nodo<T> rec_aux;
if (estaVacia()) {
insertarPrimero(t);
}else {
rec_aux = primero;
while(rec_aux.getSiguiente() != null){
rec_aux=rec_aux.getSiguiente();
}
rec_aux.setSiguiente(aux);
}
}
public void quitarPrimero(){

Nodo<T> aux;
if (!estaVacia()){
aux=primero;
aux=null;
}
}
public void quitarUltimo(){

if(aux.getSiguiente()==null)
listaVacia();
if(!estaVacia()) {
aux=primero;
while(aux.getSiguiente().getSiguiente() != null){
}
aux.setSiguiente(null);
}
public T devolverUltimo(){
T elemen = null;
Nodo<T> aux;
if (!estaVacia()){
aux = primero;
while(aux.getSiguiente() != null){
}
elemen = aux.getDato();
}
return elemen;
}
public T devolverPrimero(){
T elemen = null;
if (!estaVacia()){
elemen = primero.getDato();
}
return elemen;
}
public int cuantosElementos(){

Nodo<T> aux;
int numElementos=0;
aux = primero;
while(aux != null){
numElementos++;
}
return numElementos;
public T devolverDato(int pos){

int cont=0;
T dato=null;
}else{
while(aux!=null){
if (pos == cont){
dato=aux.getDato();
}
cont++;
}
}
return dato;
public Nodo<T> devolverNodo(int pos){

int cont=0;
}else{
while(aux!=null){
if (pos == cont){
return aux;
}
cont++;
}
}
return aux;
public void introducirDato(int pos, T dato){

Nodo<T> auxDato=null;
Nodo<T> anterior=primero;
int contador=0;
if(pos<0 || pos>cuantosElementos()){
}else{
if(pos==0){
insertarPrimero(dato);
}else if(pos==cuantosElementos()){
insertarUltimo(dato);
}else{
while(aux!=null){
auxDato=new Nodo<>(dato, aux);
anterior.setSiguiente(auxDato);
}
anterior=aux;
contador++;
}
}
}
public void modificarDato(int pos, T dato){

int cont=0;
}else{
while(aux!=null){
if (pos == cont){
aux.setDato(dato);
}
cont++;
}
}
public void borraPosicion(int pos){

Nodo<T> anterior=null;
int contador=0;
}else{
while(aux!=null){
if (anterior==null){
}else {
anterior.setSiguiente(aux.getSiguiente());
}
aux=null;
}else{
anterior=aux;
contador++;
}
}
}
}
public T devolverYBorrarPrimero(){
T dato=devolverPrimero();
quitarPrimero();
return dato;
}
public int indexOf (T t){
if (estaVacia()){
return -1;
}else{
int contador=0;
encontrado=true;
}else{
contador++;
}
}
if(encontrado){
return contador;
}else{
return -1;
}
}
}
public int indexOf (T t, int pos){
Nodo<T> aux;
if (estaVacia()){
return -1;
}else{
int contador=pos;
aux=devolverNodo(pos);

encontrado=true;
}else{
contador++;
}
}
if(encontrado){
return contador;
}else{
return -1;
}
}
}
public boolean datoExistente(T t){
boolean existe=false;
while(aux!=null && !existe){
if(aux.getDato().equals(t)){
existe=true;
}
}
return existe;
}
public void mostrar(){

System.out.println("Contenido de la lista");
System.out.println("---------------------");
while(aux!=null){
System.out.println(aux.getDato());
}
@Override
String contenido="";
while(aux!=null){
contenido=aux.getDato()+"\n";
}
return contenido;
}
}
Clase Nodos:
package Informe;
private T dato;
private Nodo<T> siguiente;
public Nodo(){
siguiente=null;
}
public Nodo(T p){
siguiente=null;
dato = p;
}
public Nodo(T t, Nodo<T> siguiente){

this.siguiente=siguiente;
dato = t;
}
public T getDato() {
return dato;
}
public void setDato(T dato) {

this.dato = dato;
}

return siguiente;
}

}
}
Ejecución:
Zip en Drive:
https://drive.google.com/file/d/1lR-6-
pfYOzuxyzeO8XqWUrn3cRLrnCN4/view?usp=sharing

Practica de Listas (Programación II) Netbeans

Cargado por

Información del documento

Descripción original:

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

Practica de Listas (Programación II) Netbeans

Cargado por

Copyright:

Formatos disponibles

Universidad Mariano Gálvez de Guatemala

Harvi Vinicio España Sologaistoa

Ingeniería en Sistemas Plan Sábado, Sección “A”

Ing. Luis Alejandro Sosa Escobar

Primer paquete (ColaParaCine):

public class Persona {

private int edad;

public Persona(int edad){

public int getEdad() {

public void setEdad(int edad) {

public class Main {

public static void main(String[] args) {

final double ENTRADA_5_10_ANIOS=1;

final double ENTRADA_11_17_ANIOS=2.5;

final double ENTRADA_18_ANIOS=3.5;

ColaDinamica<Persona> colaCine = new ColaDinamica<>();

}else if (p.getEdad()<=11 && p.getEdad()<=17){

System.out.println("Se ha recaudado " +cantidadRecaudada);

public static void rellenarCola(ColaDinamica<Persona> cola){

int numPersonas = Metodos.generaNumeroAleatorio(0, 50);

System.out.println("Se van a generar "+numPersonas+" personas");

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

edad = Metodos.generaNumeroAleatorio(5, 60);

public class Metodos {

public static int generaNumeroAleatorio(int minimo, int maximo) {

int num = (int) Math.floor(Math.random() * (minimo - (maximo + 1)) + (maximo

double num = Math.rint(Math.floor(Math.random() * (minimo - ((maximo * 100)

Segundo paquete (cola):

public class ColaDinamica<T> {

private Nodo<T> primero;

private Nodo<T> ultimo;

private int tamanio;

public boolean isEmpty() {

return primero == null;

public int size() {

Nodo<T> aux = primero.getSiguiente();

public T enqueue(T elemento) {

Nodo<T> aux = new Nodo(elemento, null);

public String toString() {

return "La lista esta vacia";

String cadena = "";

Nodo<T> aux = primero;

public class Nodo<T> {

private Nodo<T> siguiente; //Apunta al siguiente nodo

public void setElemento(T elemento) {

public Nodo<T> getSiguiente() {

public void setSiguiente(Nodo<T> siguiente) {

public class Persona {

private int edad;

public Persona(int edad){

public int getEdad() {

public void setEdad(int edad) {

public class Main {

public static void main(String[] args) {

ArrayList<Persona> cola = new ArrayList<>();

if(edadActual>=5 && edadActual<=10){ recaudacion=1; }else

System.out.println("Una persona de "+edadActual+" años se le ha cobrado "

System.out.println("La recaudación es de "+recaudacionTotal);

public static void generarCola(ArrayList<Persona> cola){

System.out.println("Se van a generar "+numeroPersonas+" personas");

cola.add(new Persona(generaNumeroAleatorio(5, 60)));

public static int generaNumeroAleatorio(int minimo, int maximo){

public class Producto {