Java - Iterador (recorrido) o String que no se muestre

Saludos de un cobolero. No trabajo actualmente pero es poner en antecedentes de lo que me llega a costar esto.
Estoy haciendo la práctica en Java de una de las materias de la carrera, y hay uno de los métodos que me está trayendo de cabeza. La práctica consiste en un gestor de nevadas. Hay usuarios que se suscriben a las incidencias de 1 o más carreteras, y hay un método que muestra los mensajes de las carreteras a las que está suscrito ese usuario. El método es así:

public Iterador viewMessages(String userId)
throws EIException
{
User subbed = getUser(userId);
Iterador<UserRoad> sub = subbed.getUserRoad();
//ALGUN PASO INTERMEDIO, QUE NO SE CUAL PUEDE SER, Y GETINCIDENTS QUE TODAVÍA NO ESTÁ HECHO
Iterador<RoadMessage> incidents = alguna_estructura_de_clase_Road.getIncidents();
if (incidents == null) throw new EIException("There are no messages");

return incidents;
}

Tengo hecho el método getUserRoad:

public Iterador getUserRoad() throws EIException
{
if (usersRoad.estaVacio() == true)
{
throw new EIException("There are no messages");
}
else
{
return usersRoad.elements();
}
}

Por lo que ahora tengo que "sub" tiene un Iterador con los elementos de UserRoad. UserRoad únicamente almacena en su clase el RoadId, por lo que a la práctica tengo un listado de identificadores de carreteras en forma de iterador.
El problema viene de que la asociación que tiene los mensajes de las incidencias de las carreteras, roadsMessages, de clase RoadMessage, está definido como atributo en la clase Road, y por lo tanto he de tener algún_tipo_de_estructura_de_clase_Road.
Había pensado en dos posibles opciones:
1- crear un método para transformar el iterador usersRoad.elements en un string para ir buscando carretera por carretera en RoadMessage y ir añadiendo los mensajes a la salida. Todo esto en la clase principal, SnowManagerImpl, que es la que tienes los métodos que hay que implementar. El problema de esta opción es que debería pasar por toString y en el juego de pruebas no muestra un listado de las carreteras a las que está suscrito el usuario. No sé si habría otra forma de convertirlo en String sin necesidad que se mostrase (novato que es uno). Para que veais el juego de pruebas el argumento es el usuario que tiene una o más opciones, y los resultados son el código identificador del mensaje y el identificador del usuario que subió la incidencia entre paréntesis:

viewMessages(789012345)
Message920 (901234567)
Message720 (789012345)
Message725 (789012345)
Message525 (567890123)
Message969 (901234567)

2- crear un método para transformar el Iterador<UserRoad> en un Iterador<Road> (la clase Road tiene de atributos RoadId, Source, Destination así que no valdría poner un variable_que_contendria_roads.elements() = sub) y con ese iterador de Road, crear en la clase Road el método getIncidents accediendo a los registros de la clase RoadMessage con cada una de las carreteras del iterador de entrada. El problema de esta opción es que no he llegado a ver ningún método que tome como argumento un Iterador y saque un Iterador. Algo así como:

Public Iterador<Road> getRoadsSubscribed (Iterador<UserRoad> sub)

Por lo que llevo desde el viernes comiéndome la cabeza.
PD: La salida de viewMessages ha de ser Iterador, como ya habéis visto (que igualmente el toString de la clase RoadMessage ya se encargaría de hacer que saliese como justo aquí arriba en el juego de pruebas), ya que si ponen la definición del procedimiento en la plantilla es para cumplirla.

Demasiado complejo con los pocos datos que hay. No está claro qué es un Iterador ... pero se puede suponer que será igual que un Iterator ... (a no ser que sea requisito de la práctica, yo no los usaría, no hacen falta y complican)

Si no he entendido mal, un usuario se suscribe a los eventos de una serie de carreteras.
Esto significa que habrá colecciones de:
- Usuarios
- Carreteras
- Incidentes

Si es así, yo haría algo similar a esto:

- Clases para cada tipo de entidad:

public class Evento {
String Descripcion;
double pk;
}

public class Carretera {
private ArrayList<Evento> eventos;
public Iterador<Evento> getEventos() {
...
}
...
}

public class Usuario {
String userId;
private ArrayList<Carretera> suscripciones;
public Iterador<Carretera> getCarreteras() {
...
}
...
}

- Una clase estática que sirva de modelo. Contendrá las colecciones necesarias (aunque quizás en la fase en la que estás de la práctica no vayan a ser necesarias todas):

public class Model {
private static ArrayList<Usuario> usuarios;
private static ArrayList<Carretera> carreteras;
private static ArrayList<Evento> eventos;

public static Iterador<Usuario> getUsuarios() {
...
}
}

- Por último, para obtener los eventos por usuarios harías:

Iterador<Usuario> userIt = Model.getUsuarios();

while(userIt.hasNext()) {
Usuario user = userIt.next();
Iterador<Carretera> carreteraIt = user.getCarreteras();
while(carreteraIt.hasNext()) {
Carretera carretera = carreteraIt.next();
Iterador<Evento> eventoIt = carretera.getEventos();
while(eventoIt.hasNext()) {
Evento evento = eventoIt.next();
// Haz loque quieras con el evento ...
}
}
}
}

No hacía falta recorrer todos los usuarios, por algo el argumento de viewMessages es el id de UN usuario. Pero supongo que serviría si no fuera porque dado mi bajísimo nivel de Java me he quedado igual con esa clase estática con los tres contenedores.
Y sí, es un Iterator, lo que pasa que la materia en los apuntes iba aprovechando para crear sus propias librerias de TAD's (Tipos Abstractos de Datos), y no se puede cambiar el formato de retorno ya que en la plantilla vacía del código se muestra así.
Al final he hecho lo siguiente:

public Iterator viewMessages(String userId) throws EIException
{
UserRoad objeto = null;
Iterator<RoadMessage> incidentes = null;
User user = getUser(userId);
Iterator<UserRoad> sub = user.getUserRoad();
for ( Iterator<UserRoad> it = sub; it.haySiguiente(); )
{
objeto = it.siguiente();
incidentes = getSubRoads(objeto.roadId);
}
return incidentes;
}

public Iterator<RoadMessage> getSubRoads(String roadId) throws EIException
{
Road roadObject = null;
Iterator<RoadMessage> result = null;
roadObject = getRoad(roadId);
result = roadObject.getIncidents();
return result;
}

Y en la clase Road:

public Iterator getIncidents() throws EIException
{
if (messagesRoads.estaVacio() == true)
{
throw new EIException("There are no messages");
}
else
{
return messagesRoads.elements();
}
}