How to properly use ObservableMap in Java

I'm currently developing a chat application and I want, in my GUI controllers, to have Observables Collections to be able to manage messages that I receive.

So, to be more specific I have this listener where I listen for new messages that comes from the server:

Listener for new Chats:

class ChatCustomManagerListener {   
   private static HashMap <Chat, ChatCustomMessageListener> chatsTable;

   /*
   * This is the event that gets triggered when new chat is created
   */
   public void chatCreated (Chat newChat) {
       ChatCustomMessageListener listener = new ChatCustomMessageListener();
       newChat.addListener (listener);
       chatsTable.put (newChat, listener);
    }
}

Listener for new Messages:

class ChatCustomMessageListener {
   private List <Message> messagesQueue;

   public ChatCustomMessageListener () {
      //QueuedLinkedList is my extension of LinkedList class
      //add() is made at the tail of List
      //get() returns the head of list
      messagesQueue = new QueuedLinkedList ();
    }
   /*
   * This is the event that gets triggered when a new message is received
   */
    public void processMessage (Chat chat, Message message) {
       messagesQueue.add (message);
    }
}

Now, In my GUI Controllers, I want to define an ObservableMap to look for ChatCustomManagerListener.chatsTable changes and for each Entry inside chatsTable, I want to have an ObservableList for ChatCustomMessageListener.messagesQueue

What I got so far, but not working is this:

    class ChatController {
       private ObservableMap  <Chat, ChatCustomMessageListener> chatsObserver;
       private LinkedList <ObservableList <Message>> messagesObservables;
       private LinkedList <List <Message>> messageData;

       private void initObservables () {
          chatsObserver = FXCollections.observableMap (ChatCustomManagerListener.getChats ());

        messageData   = new LinkedList <> ();
        messagesObservables = new LinkedList <> ();

        chatsObserver.forEach ((chat, messageListener) -> {
            messageData.add (messageListener.getMessagesQueue());
        });

        messageData.forEach ((queueOfMessages) -> {
            ObservableList <Message> observer = FXCollections.observableList (queueOfMessages);
            observer.addListener (new ListChangeListener <Message> () {

                @Override
                public void onChanged (javafx.collections.ListChangeListener.Change <? extends Message> c)                      
                    log.debug ("New message was received");
                }
            });
            messagesObservables.add (observer);
        });

        chatsObserver.addListener (new MapChangeListener <Chat, ChatCustomMessageListener> () {

            @Override
            public void onChanged (
                    javafx.collections.MapChangeListener.Change <? extends Chat, ? extends ChatCustomMessageListener> change) {
                //define what is done when a new chat is created
                log.debug ("New  chat was created");

            }

        });
}}

So what is the right way to define my Observables?

Copyright Notice：Content Author:「Alex Chihaia」，Reproduced under the CC 4.0 BY-SA copyright license with a link to the original source and this disclaimer.
Link to original article：https://stackoverflow.com/questions/40632364/how-to-properly-use-observablemap-in-java