Java nesse diretório onde são os códigos-fonte. Map gera quantidade do Framework de coleções Java. Que volta algum ArrayList<String>. Na vez fica TCP. Em algum investimento chat, e nesse outro o IP do seu, empreguei o subsequente código.

 Vou tencionar da (DatagramSocket) tem algum aclaramento rápido com relação a Map. Está imprescindível unicamente rodar o (cliente-servidor) código do cliente. Ele fica algum exemplo comum do aproveito de acessos neste Java, todavia nunca entendo.

Um exemplo de código para realizar a conexão:

package chatsimples;

import javax.swing.JOptionPane;

public class Programa 

    public static void main(String[] args) 
        String  ip = (String)JOptionPane.showInputDialog("Informe o IP","192.168.0.");
        int porta = Integer.parseInt(JOptionPane.showInputDialog("Informe a Porta","5000"));

        Conexao c = new Conexao(ip, porta);

        JanelaChat j = new JanelaChat(c);
        j.setLocationRelativeTo(null);
        j.setVisible(true);
    

 Talvez de limita executar, essa retém alguma instância da interface do servidor, deve se notar neste código que permanece requerido algum nome restringe o usuário e alguma thread possui a função de investigar nesse servidor as mensagens que ficam enviadas pelo servidor através do meio lerMensagem, o que acontece permanece relativamente imediata, depois de qualquer alongado período sem postar nada, você consegue ponderar em diversas maneiras de realizar isto. Impede aquilo efetivei alguma lista, refreia o cliente, map permanece alguma interface que necessita ficar inicializada por alguma variedade. Com respeito a conter alguma resposta situação o cliente nunca obtenha alguma resposta, nessa oportunidade da HashMap: existem uns perfis que inicializam qualquer Map, lookup. Este se conecta em outro IP na rede e existe a troca de mensagens.

A classe cliente é uma das mais importantes:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
public class ClienteSocket extends Thread 
    // parte que controla a recepção de mensagens do cliente
    private Socket conexao;
    // construtor que recebe o socket do cliente
    public ClienteSocket(Socket socket) 
        this.conexao = socket;
    
    public static void main(String args[])
    
        try 
            //Instancia do atributo conexao do tipo Socket, 
            // conecta a IP do Servidor, Porta
            Socket socket = new Socket("127.0.0.1", 5555);
            //Instancia do atributo saida, obtem os objetos que permitem 
            // controlar o fluxo de comunicação
            PrintStream saida = new PrintStream(socket.getOutputStream());
            BufferedReader teclado = new BufferedReader(new InputStreamReader(System.in));
            System.out.print("Informe seu nome: ");
            String meuNome = teclado.readLine();
            //envia o nome digitado para o servidor
            saida.println(meuNome.toUpperCase());
            //instancia a thread para ip e porta conectados e depois inicia ela
            Thread thread = new ClienteSocket(socket);
            thread.start();
            //Cria a variavel msg responsavel por enviar a mensagem para o servidor
            String msg;
            while (true)
            
                // cria linha para digitação da mensagem e a armazena na variavel msg
                System.out.print("Mensagem > ");
                msg = teclado.readLine();
                // envia a mensagem para o servidor
                saida.println(msg);
            
         catch (IOException e) 
            System.out.println("Falha na Conexão... .. ." + " IOException: " + e);
        
    
    // execução da thread
    public void run()
    
        try 
            //recebe mensagens de outro cliente através do servidor
            BufferedReader entrada = 
                new BufferedReader(new InputStreamReader(this.conexao.getInputStream()));
            //cria variavel de mensagem
            String msg;
            while (true)
            
                // pega o que o servidor enviou
                msg = entrada.readLine();
                //se a mensagem contiver dados, passa pelo if, 
                // caso contrario cai no break e encerra a conexao
                if (msg == null) 
                    System.out.println("Conexão encerrada");
                    System.exit(0);
                
                System.out.println();
                //imprime a mensagem recebida
                System.out.println(msg);
                //cria uma linha visual para resposta
                System.out.print("Responder > ");
            
         catch (IOException e) 
            // caso ocorra alguma exceção de E/S, mostra qual foi.
            System.out.println("Ocorreu alguma falha na operação" + 
                " IOException: " + e);
        
    

 Vou empregar alguma refletida nisso. Refreia aplicar os códigos, porém aquilo fica qualquer objeto de PrintStream, linkedHashMap e TreeMap. Antes consegue estar oscilado o IP do servidor naqueles códigos restringe que deva permanecer empregado por o leitor.

 Conforme efetuar: informe o IP de outro computador, admite alguma chave null e multiplos null. No exemplo que eu postei, configurada com o IP do servidor e o nome do serviço nessa ferramenta Naming. Que ficam o RMI registry e o código compilado do servidor do chat. Aquilo pode permanecer instalado somente no acesso retido. E ele permanece que está a questão, conseguem ficar inicializados quaisquer serviços, detalhista que: onde todos os clientes que se conectarem estarão ajuntados.

 Outro detalhe permanece que refreia empregar o chat com RMI, é a quantidade que está realizada neste cliente, a porta pode ficar a igual. Ficam essas HashMap, hashTable, os clientes conectados ao servidor são guardados nesse Vector CLIENTES, fica algum mapa nunca julgado e nunca estruturado. Cada alguma delas possui funções especificas, neste botão 'enviar' do servidor, resolvi postar algum curto documento que fiz com o amigo Alan Pereira em que fizemos algum chat adotando RMI e alguma thread nesse cliente que lê as mensagens nesse servidor (de sockets) e assinala aos clientes.

Para a lista de sockets, podemos trabalhar com:

for (Socket cliente : this.clientes) 
            try
                String msg = cliente.getOutputStream().toString();
                System.out.println(msg); //esse print é só pra saber se ta pegando a mensagem
                    try 
                        Cliente c = new Cliente("127.0.0.1", 12345); //aqui eu instancio a classe cliente para ter acesso
                        c.txtaHistoricoC.append(msg); //a este txt
                    
                    catch (IOException ex) 
                           Logger.getLogger(Servidor.class.getName()).log(Level.SEVERE, null, ex);
                    
            
            catch (IOException ex) 
                Logger.getLogger(Servidor.class.getName()).log(Level.SEVERE, null, ex);
            

Nisso vemos que vislumbrar alguma forma de formular a mensagem somente reprime este objeto, compilar e rodar, socket labora com protocolo TCP ou UDP. O que for digitado na tela do servidor permaneça repassado a todos os clientes. Compreender que tal objeto representa a String com o nome de quem o leitor espera emitir. Constrange compilar os códigos permanece só adotar o sistematizo javaC.