Examen de Java resuelto: secretaría de matrícula con clases, TreeMap, LinkedHashSet, lista de espera con ArrayDeque y una excepción comprobada propia.
Actualizado el
Código de Examen Java Programación orientada a objetos Nivel examen Código probado

La secretaría de una pequeña facultad quiere una herramienta de consola para gestionar la matrícula en asignaturas optativas. Cada asignatura tiene un código y un número fijo de plazas. Los alumnos se matriculan hasta que la asignatura se llena. Quienes llegan después entran en una lista de espera, que se atiende estrictamente por orden de llegada. Cuando un alumno matriculado se da de baja, el primero de la lista de espera ocupa su plaza automáticamente.
Escribe un programa en Java (un único fichero, clase pública Main) con al menos estas piezas. Una clase Asignatura que encapsule sus alumnos matriculados y su lista de espera. Una clase Secretaria que guarde todas las asignaturas y las localice por código. Y una excepción comprobada MatriculaException que transporte el mensaje de error. Toda operación inválida debe señalarse lanzando esa excepción. El método main la captura, imprime el error y continúa con la orden siguiente.
Entrada. El programa lee órdenes de la entrada estándar, una por línea, hasta el fin de fichero. Los tokens se separan con uno o más espacios. Se ignoran los espacios al principio y al final, y las líneas en blanco se saltan sin producir salida. Los códigos y los nombres de alumno son un solo token y se distinguen mayúsculas de minúsculas. Las cuatro órdenes son ASIGNATURA codigo plazas, MATRICULA alumno codigo, BAJA alumno codigo e INFORME.
Salida. ASIGNATURA imprime OK asignatura codigo. MATRICULA imprime MATRICULADO alumno codigo si queda plaza; si no, imprime ESPERA alumno codigo #k, donde k es la posición en la lista de espera empezando en 1. BAJA imprime BAJA alumno codigo. Si el alumno ocupaba plaza y la espera no estaba vacía, añade una segunda línea ADMITIDO otro codigo. Un alumno en espera también puede darse de baja: sale de la cola y nadie es admitido.
INFORME imprime una línea por asignatura en orden alfabético de código: codigo n/plazas matriculados=a,b espera=c,d, donde n es el número de matriculados. Los matriculados aparecen en el orden en que obtuvieron su plaza y la espera en orden de cola. Una lista vacía se escribe -. Si no existe ninguna asignatura, INFORME imprime sin asignaturas. Una entrada vacía no produce salida.
Errores. Cada orden fallida imprime exactamente una línea ERROR mensaje y no modifica nada. Mensajes: orden mal formada (palabra clave desconocida o número de tokens incorrecto; INFORME no lleva argumentos); asignatura duplicada codigo; plazas incorrectas texto; asignatura desconocida codigo (en MATRICULA o BAJA); alumno ya figura en codigo (ya matriculado o en espera); y alumno no figura en codigo (en BAJA). Las plazas son válidas solo si el texto consta únicamente de dígitos decimales (sin signo + ni -), cabe en un int y vale al menos 1. La comprobación de duplicado va antes que la de plazas.
Entrada de ejemplo
ASIGNATURA PRG101 2
ASIGNATURA MAT201 1
MATRICULA ana PRG101
MATRICULA bruno PRG101
MATRICULA carla PRG101
MATRICULA dani PRG101
MATRICULA ana PRG101
MATRICULA eva FIS100
BAJA ana PRG101
INFORMESalida esperada
OK asignatura PRG101
OK asignatura MAT201
MATRICULADO ana PRG101
MATRICULADO bruno PRG101
ESPERA carla PRG101 #1
ESPERA dani PRG101 #2
ERROR ana ya figura en PRG101
ERROR asignatura desconocida FIS100
BAJA ana PRG101
ADMITIDO carla PRG101
MAT201 0/1 matriculados=- espera=-
PRG101 2/2 matriculados=bruno,carla espera=dani- Clase Asignatura: estado privado, colecciones adecuadas para matriculados (orden de llegada, sin duplicados) y lista de espera (FIFO), y admisión correcta al darse de baja
- 1,0
- Excepción comprobada propia MatriculaException con los mensajes exactos, validación de las plazas con NumberFormatException traducida y errores que nunca detienen el programa
- 0,75
- Clase Secretaria con un mapa ordenado de asignaturas, búsqueda que lanza la excepción y despacho de órdenes que valida el número de tokens
- 0,75
- Formato de salida exacto en todas las órdenes, incluidas las líneas de INFORME, el guion de las listas vacías y el tratamiento de las líneas en blanco
- 0,5
Pistas
Pista 1 · ¿Qué colección para cada tarea?
Los matriculados necesitan consultas de pertenencia rápidas, sin duplicados y con un orden estable para el informe. La lista de espera necesita añadir por el final y sacar por el principio. Las asignaturas deben salir ordenadas por código. Cada requisito encaja con una clase de java.util: LinkedHashSet, ArrayDeque y TreeMap. Declara los atributos con el tipo de la interfaz (Set, Deque, Map).
Pista 2 · ¿Dónde se detecta cada error?
Coloca cada regla en la clase dueña de los datos. «Ya figura» y «no figura» pertenecen a Asignatura; «asignatura desconocida» y «asignatura duplicada», a Secretaria. Declara throws MatriculaException en esos métodos y deja en main un único try/catch alrededor de la ejecución de una orden. Así, un error corta el resto de esa orden y no quedan cambios a medias.
Pista 3 · ¿Cómo sabe main si alguien ha sido admitido?
Haz que el método de baja devuelva el nombre del alumno admitido, o null si nadie sube. Intenta primero quitar al alumno del conjunto de matriculados; si lo consigues, saca la cabeza de la cola con pollFirst(). Si no, inténtalo en la cola. Si ambas cosas fallan, lanza la excepción. Para las plazas, valida primero que el texto sea solo dígitos y recuerda que Integer.parseInt lanza una NumberFormatException no comprobada si el número no cabe en un int.
Solución
Solución explicada
La solución separa tres responsabilidades. Asignatura conoce sus plazas y su cola; Secretaria conoce el conjunto de asignaturas; Main solo trocea líneas e imprime resultados. Todas las reglas de negocio señalan el fallo con MatriculaException, subclase de Exception, de modo que el compilador obliga a cada llamador a tratarla. Si ya has hecho el ejercicio del inventario con clases, TreeMap y excepciones, reconocerás el patrón. Aquí se combina con una cola FIFO y con la idea de que el modelo devuelve valores en lugar de imprimir.
import java.io.*;
import java.util.*;
public class Main {
static class MatriculaException extends Exception {
MatriculaException(String mensaje) {
super(mensaje);
}
}
static class Asignatura {
private final String codigo;
private final int plazas;
private final Set<String> matriculados = new LinkedHashSet<>();
private final Deque<String> espera = new ArrayDeque<>();
Asignatura(String codigo, int plazas) {
this.codigo = codigo;
this.plazas = plazas;
}
private boolean figura(String alumno) {
return matriculados.contains(alumno) || espera.contains(alumno);
}
// Devuelve 0 si obtiene plaza; si no, su posicion en la espera (desde 1).
int matricular(String alumno) throws MatriculaException {
if (figura(alumno)) {
throw new MatriculaException(alumno + " ya figura en " + codigo);
}
if (matriculados.size() < plazas) {
matriculados.add(alumno);
return 0;
}
espera.addLast(alumno);
return espera.size();
}
// Devuelve el alumno admitido desde la espera, o null si nadie sube.
String darDeBaja(String alumno) throws MatriculaException {
if (matriculados.remove(alumno)) {
String siguiente = espera.pollFirst();
if (siguiente != null) {
matriculados.add(siguiente);
}
return siguiente;
}
if (espera.remove(alumno)) {
return null;
}
throw new MatriculaException(alumno + " no figura en " + codigo);
}
String resumen() {
return codigo + " " + matriculados.size() + "/" + plazas
+ " matriculados=" + unir(matriculados) + " espera=" + unir(espera);
}
private static String unir(Collection<String> nombres) {
return nombres.isEmpty() ? "-" : String.join(",", nombres);
}
}
static class Secretaria {
private final Map<String, Asignatura> asignaturas = new TreeMap<>();
void crearAsignatura(String codigo, String textoPlazas) throws MatriculaException {
if (asignaturas.containsKey(codigo)) {
throw new MatriculaException("asignatura duplicada " + codigo);
}
if (!textoPlazas.matches("[0-9]+")) {
throw new MatriculaException("plazas incorrectas " + textoPlazas);
}
int plazas;
try {
plazas = Integer.parseInt(textoPlazas);
} catch (NumberFormatException e) {
throw new MatriculaException("plazas incorrectas " + textoPlazas);
}
if (plazas < 1) {
throw new MatriculaException("plazas incorrectas " + textoPlazas);
}
asignaturas.put(codigo, new Asignatura(codigo, plazas));
}
Asignatura buscar(String codigo) throws MatriculaException {
Asignatura asignatura = asignaturas.get(codigo);
if (asignatura == null) {
throw new MatriculaException("asignatura desconocida " + codigo);
}
return asignatura;
}
List<String> informe() {
if (asignaturas.isEmpty()) {
return List.of("sin asignaturas");
}
List<String> lineas = new ArrayList<>();
for (Asignatura asignatura : asignaturas.values()) {
lineas.add(asignatura.resumen());
}
return lineas;
}
}
private static void exigirTokens(String[] t, int cuantos) throws MatriculaException {
if (t.length != cuantos) {
throw new MatriculaException("orden mal formada");
}
}
static List<String> ejecutar(Secretaria secretaria, String[] t) throws MatriculaException {
return switch (t[0]) {
case "ASIGNATURA" -> {
exigirTokens(t, 3);
secretaria.crearAsignatura(t[1], t[2]);
yield List.of("OK asignatura " + t[1]);
}
case "MATRICULA" -> {
exigirTokens(t, 3);
int posicion = secretaria.buscar(t[2]).matricular(t[1]);
yield List.of(posicion == 0
? "MATRICULADO " + t[1] + " " + t[2]
: "ESPERA " + t[1] + " " + t[2] + " #" + posicion);
}
case "BAJA" -> {
exigirTokens(t, 3);
String admitido = secretaria.buscar(t[2]).darDeBaja(t[1]);
List<String> lineas = new ArrayList<>();
lineas.add("BAJA " + t[1] + " " + t[2]);
if (admitido != null) {
lineas.add("ADMITIDO " + admitido + " " + t[2]);
}
yield lineas;
}
case "INFORME" -> {
exigirTokens(t, 1);
yield secretaria.informe();
}
default -> throw new MatriculaException("orden mal formada");
};
}
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
Secretaria secretaria = new Secretaria();
StringBuilder salida = new StringBuilder();
String linea;
while ((linea = in.readLine()) != null) {
linea = linea.trim();
if (linea.isEmpty()) {
continue;
}
String[] tokens = linea.split("\\s+");
try {
for (String resultado : ejecutar(secretaria, tokens)) {
salida.append(resultado).append('\n');
}
} catch (MatriculaException e) {
salida.append("ERROR ").append(e.getMessage()).append('\n');
}
}
System.out.print(salida);
}
}MatriculaException extiende Exception, no RuntimeException, así que es comprobada. Todo método que puede fallar (matricular, darDeBaja, crearAsignatura, buscar, ejecutar) declara throws MatriculaException, y los caminos de error quedan visibles en las firmas. El mensaje se pasa a super(mensaje) y main lo recupera con getMessage(), sin necesidad de atributos adicionales.
En Asignatura todos los atributos son private, y codigo y plazas además final. matriculados es un LinkedHashSet: rechaza duplicados, responde a contains en tiempo constante esperado y se recorre en orden de inserción, que es justo el orden de obtención de plaza que pide INFORME. espera es un ArrayDeque usado como cola: addLast para entrar y pollFirst para atender. Un admitido se añade al final del conjunto; por eso en el ejemplo carla aparece detrás de bruno.
matricular comprueba la regla de duplicado contra ambas colecciones antes que nada, mediante figura. Después devuelve 0 si hay plaza o el nuevo tamaño de la cola, que es la posición contada desde 1. darDeBaja aprovecha que Set.remove devuelve un booleano. Si el alumno tenía plaza, la cabeza de la cola (posiblemente null) pasa a matriculados y se devuelve. Si no, se intenta espera.remove, y solo si ambos intentos fallan se lanza la excepción. El modelo nunca imprime: devuelve valores y ejecutar los convierte en texto.
Secretaria guarda las asignaturas en un TreeMap, por lo que informe() obtiene el orden alfabético sin esfuerzo. En la prueba «líneas en blanco, espacios y orden» se crea ZO900 antes que BI050, y aun así el informe lista primero BI050. crearAsignatura respeta el orden del enunciado: primero el duplicado, después el formato de las plazas. La expresión regular [0-9]+ rechaza +3, que Integer.parseInt sí aceptaría.
Un texto solo de dígitos puede seguir sin caber en un int: es el caso de 99999999999 en la prueba «mensajes de error». Ahí parseInt lanza la NumberFormatException no comprobada, que se captura y se relanza como nuestra excepción. El valor 0 sí se convierte bien, pero lo rechaza la condición plazas < 1. Los cuatro casos producen la misma línea ERROR plazas incorrectas seguida del texto original.
ejecutar es una expresión switch. Cada rama valida el número de tokens con exigirTokens, llama al modelo y entrega con yield una lista de líneas. Las palabras clave desconocidas caen en default, que lanza la excepción. Como la excepción interrumpe la rama antes de cualquier yield, no hay salida parcial. Por eso MATRICULA eva FIS100 en el ejemplo solo imprime la línea de error, e INFORME ya se rechaza como orden mal formada en lugar de producir un informe.
main recorta cada línea, salta las vacías, trocea con \\s+ (varios espacios cuentan como uno) y envuelve una sola orden en try/catch. La salida se acumula en un StringBuilder y se imprime una vez, de modo que la «entrada vacía» no imprime nada. La prueba «rotación de la lista de espera» recorre todos los caminos de darDeBaja: xia abandona la cola sin admitir a nadie y vuelve a entrar como #3; después tres bajas sucesivas admiten a yago, wen y xia en orden de cola, y la última baja vacía la asignatura.
Casos de prueba
| Caso | Entrada | Salida esperada | Salida real | Resultado |
|---|---|---|---|---|
| ejemplo del enunciado | ASIGNATURA PRG101 2
ASIGNATURA MAT201 1
MATRICULA ana PRG101
MATRICULA bruno PRG101
MATRICULA carla PRG101
MATRICULA dani PRG101
MATRICULA ana PRG101
MATRICULA eva FIS100
BAJA ana PRG101
INFORME | OK asignatura PRG101
OK asignatura MAT201
MATRICULADO ana PRG101
MATRICULADO bruno PRG101
ESPERA carla PRG101 #1
ESPERA dani PRG101 #2
ERROR ana ya figura en PRG101
ERROR asignatura desconocida FIS100
BAJA ana PRG101
ADMITIDO carla PRG101
MAT201 0/1 matriculados=- espera=-
PRG101 2/2 matriculados=bruno,carla espera=dani | OK asignatura PRG101
OK asignatura MAT201
MATRICULADO ana PRG101
MATRICULADO bruno PRG101
ESPERA carla PRG101 #1
ESPERA dani PRG101 #2
ERROR ana ya figura en PRG101
ERROR asignatura desconocida FIS100
BAJA ana PRG101
ADMITIDO carla PRG101
MAT201 0/1 matriculados=- espera=-
PRG101 2/2 matriculados=bruno,carla espera=dani | OK |
| entrada vacía | (vacía) | (vacía) | (vacía) | OK |
| informe sin asignaturas | INFORME | sin asignaturas | sin asignaturas | OK |
| mensajes de error | ASIGNATURA AI300 cero
ASIGNATURA AI300 0
ASIGNATURA AI300 +3
ASIGNATURA AI300 99999999999
ASIGNATURA AI300 1
ASIGNATURA AI300 3
MATRICULA ana
HOLA mundo
BAJA ana AI300
MATRICULA ana AI300
INFORME ya
INFORME | ERROR plazas incorrectas cero
ERROR plazas incorrectas 0
ERROR plazas incorrectas +3
ERROR plazas incorrectas 99999999999
OK asignatura AI300
ERROR asignatura duplicada AI300
ERROR orden mal formada
ERROR orden mal formada
ERROR ana no figura en AI300
MATRICULADO ana AI300
ERROR orden mal formada
AI300 1/1 matriculados=ana espera=- | ERROR plazas incorrectas cero
ERROR plazas incorrectas 0
ERROR plazas incorrectas +3
ERROR plazas incorrectas 99999999999
OK asignatura AI300
ERROR asignatura duplicada AI300
ERROR orden mal formada
ERROR orden mal formada
ERROR ana no figura en AI300
MATRICULADO ana AI300
ERROR orden mal formada
AI300 1/1 matriculados=ana espera=- | OK |
| rotación de la lista de espera | ASIGNATURA BD110 1
MATRICULA zoe BD110
MATRICULA yago BD110
MATRICULA xia BD110
MATRICULA wen BD110
BAJA xia BD110
MATRICULA xia BD110
BAJA zoe BD110
BAJA yago BD110
BAJA wen BD110
BAJA xia BD110
INFORME | OK asignatura BD110
MATRICULADO zoe BD110
ESPERA yago BD110 #1
ESPERA xia BD110 #2
ESPERA wen BD110 #3
BAJA xia BD110
ESPERA xia BD110 #3
BAJA zoe BD110
ADMITIDO yago BD110
BAJA yago BD110
ADMITIDO wen BD110
BAJA wen BD110
ADMITIDO xia BD110
BAJA xia BD110
BD110 0/1 matriculados=- espera=- | OK asignatura BD110
MATRICULADO zoe BD110
ESPERA yago BD110 #1
ESPERA xia BD110 #2
ESPERA wen BD110 #3
BAJA xia BD110
ESPERA xia BD110 #3
BAJA zoe BD110
ADMITIDO yago BD110
BAJA yago BD110
ADMITIDO wen BD110
BAJA wen BD110
ADMITIDO xia BD110
BAJA xia BD110
BD110 0/1 matriculados=- espera=- | OK |
| líneas en blanco, espacios y orden | ASIGNATURA ZO900 2
ASIGNATURA BI050 3
MATRICULA lee ZO900
MATRICULA lee BI050
MATRICULA kim BI050
INFORME | OK asignatura ZO900
OK asignatura BI050
MATRICULADO lee ZO900
MATRICULADO lee BI050
MATRICULADO kim BI050
BI050 2/3 matriculados=lee,kim espera=-
ZO900 1/2 matriculados=lee espera=- | OK asignatura ZO900
OK asignatura BI050
MATRICULADO lee ZO900
MATRICULADO lee BI050
MATRICULADO kim BI050
BI050 2/3 matriculados=lee,kim espera=-
ZO900 1/2 matriculados=lee espera=- | OK |
Salidas reales: código compilado con Java 21.0.12.1 (Temurin) y ejecutado en un contenedor aislado el 19 de noviembre de 2026.
Complejidad
Sea a el número de asignaturas y e la longitud de la lista de espera de una asignatura. buscar y crearAsignatura cuestan O(log a) por el TreeMap. En matricular, la consulta al conjunto es O(1) esperado, pero espera.contains es un recorrido lineal, O(e); entrar en la cola es O(1). darDeBaja cuesta O(1) esperado para un matriculado, más O(1) de pollFirst. Para un alumno en espera es O(e), porque ArrayDeque.remove(Object) busca y desplaza elementos.
INFORME visita cada asignatura y cada nombre una vez: O(a + total de nombres). La memoria es O(a + total de nombres), ya que cada alumno se guarda una sola vez por asignatura, en el conjunto o en la cola, nunca en ambos. Para un examen es más que suficiente. Si las listas de espera pudieran tener miles de alumnos, añadiríamos un HashSet espejo de la cola para que contains fuese O(1); la eliminación de un alumno del centro de la cola seguiría siendo lineal salvo que se cambie de estructura.
Errores típicos
- Usar un
ArrayListcon comprobaciones manuales de duplicado para los matriculados y olvidar la comprobación al admitir a alguien desde la espera. UnLinkedHashSetgarantiza la regla por construcción. - Usar
HashMapoHashSetesperando un orden estable. Su orden de iteración no está especificado y el INFORME puede salir en un orden distinto del exigido. - Fiarse solo de
Integer.parseInt: acepta+3, que el enunciado declara incorrecto, y lanza unaNumberFormatExceptionno comprobada anteceroo99999999999que, si no se captura, detiene el programa. - Admitir a alguien de la espera cuando se da de baja un alumno que estaba en espera. Solo liberar una plaza provoca una admisión.
- Imprimir dentro de
AsignaturaoSecretariaantes de que se lance la excepción. Quedan resultados a medio imprimir y el modelo queda acoplado a la consola. - Acceder a
tokens[2]sin comprobar antestokens.length. Una línea corta comoMATRICULA anaprovocaArrayIndexOutOfBoundsExceptionen lugar deorden mal formada.
Variantes
Limitar el número de asignaturas por alumno
Nueva regla: un alumno puede ocupar como mucho L plazas en total (las posiciones en espera no cuentan). Mantén en Secretaria un índice inverso Map<String, Integer> plazasPorAlumno. Increméntalo cuando matricular devuelva 0 o cuando alguien sea admitido, y decreméntalo cuando un matriculado se dé de baja. Comprueba el límite antes de modificar la asignatura y lanza MatriculaException("limite alcanzado alumno"). En una admisión debes decidir si se salta al alumno que ya está en el límite o se le deja en la cola: justifica en tu respuesta cuál de los dos comportamientos es más justo.
Exponer vistas de solo lectura en lugar de un resumen
El profesor puede pedir consultores como getMatriculados(). No devuelvas el conjunto interno, porque cualquiera podría saltarse las reglas modificándolo. Devuelve Collections.unmodifiableSet(matriculados) o una copia (List.copyOf(espera)). Cualquier intento de modificar la vista lanza UnsupportedOperationException y la encapsulación se mantiene. La misma idea de proteger el estado con constructores y visibilidad aparece en el ejercicio de herencia, constructores y super.
En los temarios
Los bloques que combina este ejercicio aparecen en temarios oficiales de la región. El temario de Programación de la Facultad de Ciencias de la UNAM incluye entre sus unidades «Creación de clases», «Datos estructurados» y «Manejo de errores». El programa de ISIS1209 de la Universidad de los Andes menciona el estudio de mecanismos de reutilización de clases, como la herencia, y de definición de contratos, como las interfaces.
La unidad de aprendizaje Paradigmas de Programación del IPN dedica un bloque a la Programación Orientada a Objetos. Son, por tanto, temarios en los que un ejercicio de este tipo encaja por temática, sin que ello signifique que alguna de estas universidades lo haya propuesto.
Artículo generado mediante AI.larebelion



Comentarios (0)
Todavía no hay comentarios. Puedes ser el primero.
Escribe un comentario