Chat em Java

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.String;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
import javax.swing.JOptionPane;

public class SimpleChat2
{
    public static void main(String[] args)
    {
        String hostt = null;
        int porrt;
        String portt = null;
        String a;
        Socket socket = new Socket();
      
      a = JOptionPane.showInputDialog(null,"Iniciar Como Cliente?");
      if (a.equals("sim"))
      {
          hostt = JOptionPane.showInputDialog(null,"Insira o host");
          portt = JOptionPane.showInputDialog(null,"Insira a porta");
          
          porrt = Integer.parseInt(portt);
          
          startClient(hostt,porrt);
          //non-static method startClient(int) cannot be referenced from a static context          
      }
      
      else 
      {
          
          portt = JOptionPane.showInputDialog(null,"Insira a porta");
          porrt = Integer.parseInt(portt);
          startServer(porrt);
          //
          //non-static method startServer(int) cannot be referenced from a static context
          //
      }
      
      
    }

    private static void  startClient(String host, int port)
    {
        
        
        try
        {
            Socket socket = new Socket();
            socket.connect(new InetSocketAddress(host, port));
            chat(socket);
        }
        catch (UnknownHostException e)
        {
            System.out.println("Host desconhecido");
            System.out.println("Host: " + host);
            System.out.println("Porta: " + port);
            System.exit(2);
        }
        catch (IOException e)
        {
            e.printStackTrace();
            System.exit(1);
        }
    }

    private static void startServer(int porta) 
    {
        try
        {
            ServerSocket socket = new ServerSocket(porta);
            System.out.println("Aguardando conexao...");
            Socket s = socket.accept();
            
            chat(s);
        } catch (IOException e)
        {
            System.out.println("Problemas na comunicação: ");
            e.printStackTrace();
            System.exit(1);
        }
    }

    private static void chat(Socket s) throws IOException
    {
        System.out.println("Conectado com " + s.getRemoteSocketAddress());
        listen(s.getInputStream());
        talk(s.getOutputStream());
    }

    /**
     * @param outputStream
     */
    private static void talk(OutputStream outputStream) throws IOException
    {
        DataOutputStream output = new DataOutputStream(outputStream);
        String line = "";
        while (!line.equals("EXIT"))
        {
            Scanner scan = new Scanner(System.in);        
            System.out.print(": ");
            line = scan.nextLine();
            output.writeInt(line.length());
            for (char ch : line.toCharArray())
                output.writeChar(ch);
            output.flush();
        }
    }

    /**
     * @param inputStream
     */
    private static  void listen(final InputStream inputStream)
    {        
        new Thread(new Runnable() {
            DataInputStream ds = new DataInputStream(inputStream);
            public void run() 
            {                
                try
                {
                    while (true)
                    {
                        int size = ds.readInt();
                        int cont = 0;
                        char[] chars = new char[size];
                        while (cont < size)
                        {
                            chars[cont] = ds.readChar();
                            cont = cont + 1;
                        }
                        
                        String str = new String(chars);
                        if (str.equals("EXIT"))
                        {
                            System.out.println("Conversa terminada.");
                            System.exit(0);
                        }
                        
                        System.out.println(str);
                    }
                } catch (IOException e)
                {
                }
            }
        }).start();
    }
}

package chat;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Vector;

public class ServidorSocket extends Thread {

	// Parte que controla as conexões por meio de threads.
	private static Vector CLIENTES;

	// socket deste cliente
	private Socket conexao;

	// nome deste cliente
	private String nomeCliente;
	// lista que armazena nome de CLIENTES
	private static List LISTA_DE_NOMES = new ArrayList();

	// construtor que recebe o socket deste cliente
	public ServidorSocket(Socket socket) {
		this.conexao = socket;
	}

	// testa se nomes são iguais, se for retorna true
	public boolean armazena(String newName) {

		// System.out.println(LISTA_DE_NOMES);
		for (int i = 0; i < LISTA_DE_NOMES.size(); i++) {
			if (LISTA_DE_NOMES.get(i).equals(newName))
				return true;
		}

		// adiciona na lista apenas se não existir
		LISTA_DE_NOMES.add(newName);
		return false;
	}

	// remove da lista os CLIENTES que já deixaram o chat
	public void remove(String oldName) {
		for (int i = 0; i < LISTA_DE_NOMES.size(); i++) {
			if (LISTA_DE_NOMES.get(i).equals(oldName))
				LISTA_DE_NOMES.remove(oldName);
		}
	}

	public static void main(String args[]) {

		// instancia o vetor de CLIENTES conectados
		CLIENTES = new Vector();
		try {

			// cria um socket que fica escutando a porta 5555.
			ServerSocket server = new ServerSocket(1500);
			System.out.println("ServidorSocket rodando na porta 5555");

			// Loop principal.
			while (true) {

				// aguarda algum cliente se conectar.
				// A execução do servidor fica bloqueada na chamada do método
				// accept da
				// classe ServerSocket até que algum cliente se conecte ao
				// servidor.
				// O próprio método desbloqueia e retorna com um objeto da
				// classe Socket
				Socket conexao = server.accept();

				// cria uma nova thread para tratar essa conexão
				Thread t = new ServidorSocket(conexao);
				t.start();
				// voltando ao loop, esperando mais alguém se conectar.
			}
		} catch (IOException e) {

			// caso ocorra alguma excessão de E/S, mostre qual foi.
			System.out.println("IOException: " + e);
		}
	}

	// execução da thread
	public void run() {
		try {

			// objetos que permitem controlar fluxo de comunicação que vem do
			// cliente
			BufferedReader entrada = new BufferedReader(new InputStreamReader(
					this.conexao.getInputStream()));
			PrintStream saida = new PrintStream(this.conexao.getOutputStream());

			// recebe o nome do cliente
			this.nomeCliente = entrada.readLine();

			// chamada ao metodo que testa nomes iguais
			if (armazena(this.nomeCliente)) {
				saida.println("Este nome ja existe! Conecte novamente com outro Nome.");
				CLIENTES.add(saida);

				// fecha a conexao com este cliente
				this.conexao.close();
				return;
			} else {

				// mostra o nome do cliente conectado ao servidor
				System.out.println(this.nomeCliente
						+ " : Conectado ao Servidor!");
			}

			// igual a null encerra a execução
			if (this.nomeCliente == null) {
				return;
			}

			// adiciona os dados de saida do cliente no objeto CLIENTES
			CLIENTES.add(saida);

			// recebe a mensagem do cliente
			String msg = entrada.readLine();

			// Verificar se linha é null (conexão encerrada)
			// Se não for nula, mostra a troca de mensagens entre os CLIENTES
			while (msg != null && !(msg.trim().equals(""))) {

				// reenvia a linha para todos os CLIENTES conectados
				sendToAll(saida, " escreveu: ", msg);

				// espera por uma nova linha.
				msg = entrada.readLine();
			}

			// se cliente enviar linha em branco, mostra a saida no servidor
			System.out.println(this.nomeCliente + " saiu do bate-papo!");

			// se cliente enviar linha em branco, servidor envia mensagem de
			// saida do chat aos CLIENTES conectados
			sendToAll(saida, " saiu", " do bate-papo!");

			// remove nome da lista
			remove(this.nomeCliente);

			// exclui atributos setados ao cliente
			CLIENTES.remove(saida);

			// fecha a conexao com este cliente
			this.conexao.close();
		} catch (IOException e) {

			// Caso ocorra alguma excessão de E/S, mostre qual foi.
			System.out.println("Falha na Conexao... .. ." + " IOException: "
					+ e);
		}
	}

	// enviar uma mensagem para todos, menos para o próprio
	public void sendToAll(PrintStream saida, String acao, String msg)
			throws IOException {
		Enumeration e = CLIENTES.elements();
		while (e.hasMoreElements()) {

			// obtém o fluxo de saída de um dos CLIENTES
			PrintStream chat = (PrintStream) e.nextElement();

			// envia para todos, menos para o próprio usuário
			if (chat != saida) {
				chat.println(this.nomeCliente + acao + msg);
			}
		}
	}
}

package chat;

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", 8010);

			// 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("Digite 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 Conexao... .. ." + " 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 uma Falha... .. ." + " IOException: "
					+ e);
		}
	}
}