1.单线程模式：
创建服务端：
第一步，准备地址和端口；第二步，创建一个ServerSocket对象；
第三步，等待客户端连接；最后一步，数据接收和发送。

public class SingleThreadServer {
    public static void main(String[] args) {
        //1. 准备地址和端口
        int port  = 1314;
        try {
            //2. ServerSocket
            ServerSocket serverSocket = new ServerSocket(port);
            //3. 等待客户端连接
            Socket client = serverSocket.accept();
            //4. 数据接收和发送
            //4.1 接收
            InputStream in = client.getInputStream();
            Scanner scanner = new Scanner(in);
            System.out.println("客户端说："+scanner.nextLine());
            //4.2 发送
            OutputStream out = client.getOutputStream();
            PrintStream printStream = new PrintStream(out);
            printStream.println("欢迎，欢迎");
            printStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

创建客户端：
第一步，准备服务端地址和端口号；第二步，创建客户端Socket连接服务器，
最后一步，数据传输（数据的发送和接收）。

public class SingleThreadClient {
    public static void main(String[] args) {
        //1. 服务端地址，端口号
        String ip = "127.0.0.1";//本机IP地址
        int port = 1314;
        try {
            //2.Socket
            Socket client = new Socket(ip,port);
            //3.数据传输（键盘输入，输出到显示屏）
            //3.1 发送数据
            OutputStream out = client.getOutputStream();
            PrintStream printStream = new PrintStream(out);
            printStream.println("服务器，我来了");
            printStream.flush();
            //3.2 接收数据
            InputStream in = client.getInputStream();
            Scanner scanner = new Scanner(in);
            System.out.println("来自服务端的数据："+scanner.nextLine());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

结果如下：


2.多线程模式：
上面的Server和Client只是进行了简单的通信操作：服务器端接收到客户端连接之后，服务器端向客户端输出一个字符串，而客户端也只是读取服务器端的字符串后就退出了。
实际应用中的客户端则可能需要和服务器端保持长时间通信，即服务器端需要不断地读取客户端数据，并向客户端写入数据；客户端也不需要不断地读取服务器端数据，并向服务器端写入数据。
创建服务端：
首先创建一个与客户端交互的任务处理；

public class ClientHandler implements Runnable {
    //储存所有注册的客户端
    private static final Map<String, Socket> socketMap = new ConcurrentHashMap<>();
    private final Socket client;
    private String name;

    public ClientHandler(Socket client) {
        this.client = client;
    }

    @Override
    public void run() {
        try {
            //获取客户端输入流
            InputStream in = this.client.getInputStream();
            Scanner scanner = new Scanner(in);
            while (true) {
                String line = scanner.nextLine();
                if (line.startsWith("register:")) {
                    String[] segments = line.split(";");
                    if (segments.length == 2 && segments[0].equals("register")) {
                        String name = segments[1];
                        register(name);
                    }
                    continue;
                }
                if (line.startsWith("groupChat:")) {
                    String[] segments = line.split(":");
                    if (segments.length == 2 && segments[0].equals("groupChat")) {
                        String message = segments[1];
                        groupChat(message);
                    }
                    continue;
                }
                if (line.startsWith("privateChat:")) {
                    String[] segments = line.split(":");
                    if (segments.length == 3 && segments[0].equals("privateChat")) {
                        String name = segments[1];
                        String message = segments[2];
                        privateChat(name, message);
                    }
                    continue;
                }
                if (line.equalsIgnoreCase("bye")) {
                    quitChat();
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void quitChat() {
        socketMap.remove(this.name);
        System.out.println(this.name + "下线了");
        printOnlineClient();
    }

    private void privateChat(String name, String message) {
        Socket socket = socketMap.get(name);
        if (socket != null) {
            sendMessage(socket, this.name + " 说:" + message);
        }
    }

    private void groupChat(String message) {
        for(Map.Entry<String,Socket> entry:socketMap.entrySet()) {
            Socket socket = entry.getValue();
            if (socket == this.client) {
                continue;
            }
            sendMessage(socket, this.name + "说：" + message);
        }
    }

    private void register(String name) {
        this.name = name;
        socketMap.put(name,this.client);
        System.out.println(name + "注册到系统中");
        sendMessage(this.client, "欢迎，" + name + "注册成功");
        printOnlineClient();
    }
    //打印当前在线客户人数
    private void printOnlineClient() {
        System.out.println("当前在线的客户端有：" + socketMap.size() + "个，名称列表如下：");
        for(String name:socketMap.keySet()) {//keySet()取得所有的key信息
            System.out.println(name);
        }
    }
    //发指定消息到客户端
    private void sendMessage(Socket client, String s) {
        try {
            OutputStream out = client.getOutputStream();
            PrintStream printStream = new PrintStream(out);
            printStream.println(s);
            printStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

创建服务端主程序。

public class MultiThreadServer {
    public static void main(String[] args) {
        int port = 1314;
        final ExecutorService executorService = Executors.newFixedThreadPool(2 * Runtime.getRuntime().availableProcessors());
        try {
            ServerSocket serverSocket = new ServerSocket(port);
            System.out.println("服务端启动，运行在：" + serverSocket.getLocalSocketAddress());
            while (true) {
                final Socket socket = serverSocket.accept();
                System.out.println("客户端连接，来自：" + socket.getRemoteSocketAddress());
                executorService.execute(new ClientHandler(socket));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }
    }
}

创建客户端：
首先创建一个读取服务端信息线程；

public class ReadDataFromServerThread extends Thread{
    private Socket client;

    public ReadDataFromServerThread(Socket client) {
        this.client = client;
    }

    @Override
    public void run() {
        try {
            InputStream in = client.getInputStream();
            Scanner scanner = new Scanner(in);
            while (true) {
                try {
                    String message = scanner.nextLine();
                    System.out.println("来自服务端>" +
                            message);
                }catch (NoSuchElementException e) {
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

再创建一个发送信息给服务端的线程；

public class WriteDataToServerThread extends Thread{
    private Socket client;

    public WriteDataToServerThread(Socket client) {
        this.client = client;
    }

    @Override
    public void run() {
        try {
            OutputStream out = client.getOutputStream();
            PrintStream printStream = new PrintStream(out);
            Scanner scanner = new Scanner(System.in);
            while (true) {
                System.out.print("请输入>");
                String message = scanner.nextLine();
                printStream.println(message);
                printStream.flush();
                if(message.equals("bye")){
                    break;
                }
            }
            this.client.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

最后客户端主程序。

public class MultiThreadClient {
    public static void main(String[] args) {
        String ip = "127.0.0.1";//本机IP地址
        int port = 1314;
        try {
            final Socket socket = new Socket(ip,port);
            new WriteDataToServerThread(socket).start();
            new ReadDataFromServerThread(socket).start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

先启动服务端，再启动多个客户端。
结果如下：