Come conservare i clienti in un elenco

Question

Sto facendo funzionare un server, e ho un arraylist di tipo client Quando un client si connette tramite serversocket.accept() passo il nuovo socket al costruttore ArrayLists. Questo è tutto dentro il costruttore

this.add(new Client(Socket client)); 

mio problema è quando un client si disconnette, si chiude il socket, ma non elimina il suo posto nella ArrayList, e spostare tutto giù uno. Quindi l'arraylist cresce costantemente.

Cosa posso fare/utilizzare per risolvere questo problema?

A volte eseguirò comandi che verranno eseguiti su tutti i client, motivo per cui memorizzo i client in un arraylist.

Esiste un'alternativa migliore per l'archiviazione dei client in un server?

Update 1

Le classi sono nelle fasi iniziali. Molto poco è stato implementato. Finora l'opzione HashMap suggerita nella risposta funziona meglio per me. Grazie per le vostre risposte

Answer 1

Interessante problema.

Dovresti usare la mappa di hash qui .. Aggiungi il client con oggetto come valore e usa un tasto. Ogni volta che lo scolleghi, rimuovilo dalla mappa.

Una buona domanda, quale potrebbe essere la chiave? può essere il riferimento all'oggetto (dipende dalla tua scelta) o qualsiasi cosa che sia unica rispetto all'oggetto client (ci deve essere qualcosa, altrimenti puoi generarlo facilmente).

Map<Integer,Client> clientMap = new HashMap<Integer,Client>(); 

Answer 2

È necessario rimuovere il client da ArrayList, gli elementi di resto nell'elenco rimescolano automaticamente verso l'alto lungo l'elenco.

//java.util.ArrayList.remove(Object) shifts any subsequent elements 
// to the left (subtracts one from their indices). 

Dire, se il Cliente è Client A e ArrayList è ArrayListA, allora si dovrebbe applicare

ArrayListA.remove(ClientA); 

Ma, il migliore approccio sarebbe quella di utilizzare HashMap per memorizzare le informazioni del cliente come accennato nella risposta di Danyal Sandeelo.

Answer 3

Se il client è la propria classe, allora si può provare questo:

public class Client { 

public final List<Client> clients; 

public Client(List<Client> clients, Socket socketClient) { 
    this.clients = clients; 
    clients.add(this); 
} 

public void disconnect() { 
    clients.remove(this); 
}} 



    List<Client> clients = new ArrayList<Client>(); 
    new Client(clients, new Socket()); 
    new Client(clients, new Socket()); 
    new Client(clients, new Socket()); 

Answer 4

Un sacco di ipotesi sono fatte, per esempio sto assumendo di avere un metodo disconnect() nella classe Client. Si prega di fornire maggiori dettagli se si desidera una soluzione più accurata.

Un modo per farlo potrebbe essere passare una richiamata al client in modo che rimuova se stessa dal ArrayList al termine.Molto approssimativa implementazione:

public class Callback { 
    private ArrayList<Client> clients; 

    public Callback(ArrayList<Client> clients) { 
     this.clients = clients; 
    } 

    public void remove(Client client) { 
     clients.remove(client); 
    } 
} 

poi passare il Callback quando si crea un'istanza della Client:

Callback callback = new Callback(list); 
list.add(new Client(socket, callback)); 

quindi chiamare il metodo della richiamata remove(). Se il Client ha un metodo disconnect(), allora al suo interno si può fare

public void disconnect() { 
    // bla bla 
    callback.remove(this); 
} 

In questo modo il Client può pulire dopo se stessa quando è necessario :)