聊天室案例（简易版）

 聊天室客户端：

import java.io.*;
import java.net.Socket;
import java.util.Scanner;

/**
 * 聊天室客户端
 * @author  JaneLee
 */
public class Client {
    /*
    import java.net.Socket; 套接字
    Socket封装了TCP协议的通讯细节，使得我们可以和远端计算机建立链接并利用两条流的读写完成网络交互。
     */
    private Socket socket;
    /**
     * 构造方法，用于初始化客户端
     */
    public Client(){
        try {
            /*
            实例化Socket就是连接服务端的过程
            参数1：服务端的地址信息
            参数2：服务端打开的服务端口
            通过地址可以找到网络上的服务端计算机，通过端口可以链接到该机器上运行到服务端应用程序
            如果服务端无响应则实例化Socket时会抛出异常
             */
            //localhost代表本地IP，也可使用127.0.0.1同样是表示本机IP。
            System.out.println("正在连接服务端...");
            socket = new Socket("localhost",8888);
            System.out.println("与服务端建立连接！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public  void Start(){
        try {
            ServerHandler serverHandler = new ServerHandler();
            Thread t = new Thread(serverHandler);
            t.setDaemon(true);
            t.start();
            /*
            Socket提供的方法：
            OutputStream   getOutputStream（）
            该方法会返回一个字节输出流，通过流写出的字节会通过网络发送给远端计算机对于客户端这边而言，远端计算机就是服务端。
             */
            OutputStream out = socket.getOutputStream();
            OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");
            BufferedWriter bw = new BufferedWriter(osw);
            PrintWriter pw = new PrintWriter(bw,true);
            Scanner scan = new Scanner(System.in);
            System.out.println("请输入：");
            while (true) {
                String line = scan.nextLine();
                if ("exit".equals(line)){
                    break;
                }
                pw.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                //最终关掉socket，与服务端断开连接
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        Client client = new Client();
        client.Start();
    }
    class ServerHandler implements Runnable{
        @Override
        public void run() {
            //通过socket
            try {
                BufferedReader br = new BufferedReader(
                        new InputStreamReader(
                                socket.getInputStream(),"UTF-8"
                        )
                );
                String line;
                //循环读取服务器发送过来的消息并输出到控制台
                while ((line = br.readLine())!=null){
                    System.out.println(line);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

聊天室服务端：

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

/**
 *聊天室服务端
 * @author  JaneLee
 */
public class Server {
    private ServerSocket server;
//    private PrintWriter[] allout = {};//用来存放所有客户的输出流，用来广播消息
    private List<PrintWriter> allout = new ArrayList<>();
    /**
     * 构造方法，用来初始化服务端
     */
    public Server(){
        try {
            /*
             ServerSocket试运行在服务端的，作用是通过打开的服务端口等待客户端的链接，
             一旦客户端通过这个端口与服务器连接时， ServerSocket就会创建一个Socket与该客户端交互
             */
            System.out.println("正在启动服务端...");
            server = new ServerSocket(8888);
            System.out.println("服务端启动完毕!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public void start(){
        try {
            /*
             ServerSocket的方法：
             Socket accept（）
             该方法是一个阻塞方法，调用程序就“卡住了”。此时等待客户端的连接。一旦一个客户端通过8888端口服务端建立连接时，
             该方法立即返回一个Socket实例，通过这个Socket就可以与客户端进行交互了
             */
            while(true) {
                System.out.println("等待客户端连接...");
                Socket socket = server.accept();
                System.out.println("客户端已连接！");
                for (int i = 0; i < allout.size(); i++) {
                    allout.get(i).println(socket.getInetAddress().getHostAddress()+"上线了！");
                }
                //启动一个线程处理该客户端的交互
                ClientHandler clientHandler = new ClientHandler(socket);
                Thread t = new Thread(clientHandler);
                t.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
     Server server = new Server();
     server.start();
    }
    private class  ClientHandler implements Runnable{
        private  Socket socket;
        private String host;//获取该客户的ip地址
        public  ClientHandler (Socket socket){
            this.socket = socket;
            //通过socket获取远端计算机地址信息
            host = socket.getInetAddress().getHostAddress();
        }
        public void run(){
            PrintWriter pw = null;
            try {
              /*
            socket提供的方法：
            InputStream getInputStream（）
            该方法获取字节输入流用于读取远端计算机发送活来的字节。对于服务端这边而言远端计算机就是客户端。
             */
                InputStream in = socket.getInputStream();
                InputStreamReader isr = new InputStreamReader(in,"UTF-8");
                BufferedReader br = new BufferedReader(isr);
                //通过Socket获取输出流给客户端发消息使用
                pw = new PrintWriter(
                        new BufferedWriter(
                                new OutputStreamWriter(socket.getOutputStream(),"UTF-8")
                        ),true
                );
                //将当前客户端的输出流存入共享数组allout中
//                synchronized (Server.this) {
//                    //1.对allout扩容
//                    allout = Arrays.copyOf(allout, allout.length + 1);
//                    //2.将当前输出流存入数组
//                    allout[allout.length - 1] = pw;
//                }
//                System.out.println(host+"上线了，当前在线人数"+allout.length);
                String  line;
                while ((line = br.readLine())!=null) {
                    final String message = host+"说"+line;
                    System.out.println(message);
//                    synchronized (Server.this) {
//                        //将消息回复给所有客户端
//                        for (int i = 0; i < allout.length; i++) {
//                            allout[i].println(host + "说:" + line);
//                        }
//                    }
                    allout.forEach(
                            out->out.println(message)
                    );
                }
            } catch (IOException e) {
                for (int i = 0; i < allout.size(); i++) {
                    allout.get(i).println(socket.getInetAddress().getHostAddress()+"下线了！");
                }
            } finally {
                //处理客户端断开连接后的操作
//                synchronized (Server.this) {
//                    for (int i = 0; i < allout.length; i++) {
//                        if (allout[i] == pw) {
//                            allout[i] = allout[allout.length - 1];
//                            allout = Arrays.copyOf(allout, allout.length - 1);
//                            break;
//                        }
//                    }
//                }
//                System.out.println(host+"下线了，当前在线人数"+allout.length);
                allout.remove(pw);
                System.out.println(host+"下线了，当前在线人数"+allout.size());
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}