Java知识体系及聊天室程序

Java知识体系结构梳理如下：

1. 基础语法：Java的基本语法，包括数据类型、运算符、控制语句、数组等。

2. 面向对象编程：Java是一种面向对象的编程语言，需要掌握类、对象、继承、多态等概念。

3. 异常处理：Java提供了异常处理机制，需要掌握异常的分类、处理方式等。

4. 集合框架：Java提供了丰富的集合框架，包括List、Set、Map等，需要了解其特点和使用方法。

5. IO流：Java提供了文件读写和网络通信等IO流，需要掌握其使用方法。

6. 多线程：Java提供了多线程编程机制，需要掌握线程的创建、同步、互斥等概念。

7. 数据库编程：Java可以通过JDBC连接数据库，需要掌握SQL语句的编写和Java操作数据库的方法。

8. GUI编程：Java提供了Swing和AWT两种GUI库，需要掌握GUI组件的使用方法和事件处理机制。

9. 网络编程：Java提供了Socket和RMI两种网络编程方式，需要了解其使用方法和原理。

10. Web开发：Java可以用于Web开发，需要掌握Servlet、JSP、Spring、Struts等Web开发框架。

11. 安全编程：Java提供了安全编程的机制，包括加密、数字签名等，需要了解其使用方法和原理。

12. 性能调优：Java程序的性能调优是一个重要的话题，需要掌握优化技巧和工具的使用方法。

13. 设计模式：Java程序设计中常用的设计模式，包括单例模式、工厂模式、观察者模式等，需要了解其使用方法和原理。

14. 其他：Java还包括XML解析、Web服务、分布式计算等方面的知识，需要根据实际需求进行学习和掌握。

Java网络编程聊天室可以通过以下步骤实现发送文件功能：

1. 在聊天室客户端界面添加一个文件选择按钮，允许用户选择要发送的文件。

2. 当用户选择要发送的文件后，客户端将文件转换为字节数组，并向服务器发送一个包含文件名和字节数组的消息。

3. 服务器接收到消息后，将文件保存到指定的目录下，并向所有在线客户端广播一个包含文件名和文件路径的消息。

4. 在客户端界面上，接收到服务器广播的文件消息后，显示文件名和下载链接，用户可以点击链接下载文件。

下面是一个简单的Java代码示例：

聊天室客户端：

import java.awt.BorderLayout;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Base64;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

public class ChatClient extends JFrame {

    private static final long serialVersionUID = 1L;
    private JTextArea chatArea;
    private JButton fileButton;
    private JFileChooser fileChooser;
    private ExecutorService executor;
    private Socket socket;
    private OutputStream outputStream;
    private InputStream inputStream;
    private String userName;

    public ChatClient(String userName) {
        this.userName = userName;
        initComponents();
    }

    private void initComponents() {
        setTitle("Chat Client");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setSize(400, 400);

        chatArea = new JTextArea();
        JScrollPane scrollPane = new JScrollPane(chatArea);
        add(scrollPane, BorderLayout.CENTER);

        JPanel panel = new JPanel();
        fileButton = new JButton("Send File");
        fileChooser = new JFileChooser();
        fileButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                int returnVal = fileChooser.showOpenDialog(ChatClient.this);
                if (returnVal == JFileChooser.APPROVE_OPTION) {
                    File file = fileChooser.getSelectedFile();
                    try {
                        sendFile(file);
                    } catch (IOException ex) {
                        ex.printStackTrace();
                    }
                }
            }
        });
        panel.add(fileButton);
        add(panel, BorderLayout.SOUTH);

        setVisible(true);

        executor = Executors.newFixedThreadPool(2);
        executor.execute(new ReceiveMessageTask());
        executor.execute(new SendMessageTask());
    }

    private void sendFile(File file) throws IOException {
        byte[] fileBytes = Files.readAllBytes(file.toPath());
        String fileName = file.getName();
        String fileData = Base64.getEncoder().encodeToString(fileBytes);
        String message = "FILE " + fileName + " " + fileData;
        outputStream.write(message.getBytes());
        outputStream.flush();
    }

    private void receiveFile(String fileName, String fileData) throws IOException {
        Path filePath = Paths.get("received", fileName);
        byte[] fileBytes = Base64.getDecoder().decode(fileData);
        Files.write(filePath, fileBytes);
        String message = "FILE " + fileName + " " + filePath.toAbsolutePath();
        broadcastMessage(message);
    }

    private void broadcastMessage(String message) throws IOException {
        outputStream.write(message.getBytes());
        outputStream.flush();
    }

    private class ReceiveMessageTask implements Runnable {
        public void run() {
            try {
                socket = new Socket("localhost", 8000);
                outputStream = socket.getOutputStream();
                inputStream = socket.getInputStream();
                String message = "JOIN " + userName;
                outputStream.write(message.getBytes());
                outputStream.flush();
                while (true) {
                    byte[] buffer = new byte[1024];
                    int len = inputStream.read(buffer);
                    if (len > 0) {
                        String msg = new String(buffer, 0, len);
                        if (msg.startsWith("FILE ")) {
                            String[] parts = msg.split(" ");
                            String fileName = parts[1];
                            String fileData = parts[2];
                            receiveFile(fileName, fileData);
                        } else {
                            chatArea.append(msg + "\n");
                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private class SendMessageTask implements Runnable {
        public void run() {
            try {
                while (true) {
                    String message = System.console().readLine();
                    if (message != null && !message.isEmpty()) {
                        if (message.startsWith("/")) {
                            if (message.startsWith("/quit")) {
                                outputStream.write("QUIT".getBytes());
                                outputStream.flush();
                                executor.shutdownNow();
                                break;
                            }
                        } else {
                            message = "CHAT " + message;
                            outputStream.write(message.getBytes());
                            outputStream.flush();
                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                new ChatClient("User1");
            }
        });
    }

}

聊天室服务器：

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

public class ChatServer {

    private List<ClientHandler> clients = new ArrayList<>();

    public void start() {
        try {
            ServerSocket serverSocket = new ServerSocket(8000);
            System.out.println("Server started on port 8000.");
            while (true) {
                Socket socket = serverSocket.accept();
                ClientHandler client = new ClientHandler(socket);
                clients.add(client);
                System.out.println("New client joined: " + client.getName());
                broadcastMessage(client.getName() + " joined the chat.");
                client.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void broadcastMessage(String message) {
        for (ClientHandler client : clients) {
            client.sendMessage(message);
        }
    }

    private class ClientHandler extends Thread {

        private Socket socket;
        private String name;
        private InputStream inputStream;
        private OutputStream outputStream;

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

        public String getName() {
            return name;
        }

        public void run() {
            try {
                inputStream = socket.getInputStream();
                outputStream = socket.getOutputStream();
                byte[] buffer = new byte[1024];
                int len = inputStream.read(buffer);
                if (len > 0) {
                    String message = new String(buffer, 0, len);
                    if (message.startsWith("JOIN ")) {
                        name = message.substring(5).trim();
                        sendMessage("Welcome to the chat, " + name + "!");
                        broadcastMessage(name + " joined the chat.");
                    }
                }
                while (true) {
                    len = inputStream.read(buffer);
                    if (len > 0) {
                        String message = new String(buffer, 0, len);
                        if (message.startsWith("CHAT ")) {
                            message = name + ": " + message.substring(5);
                            broadcastMessage(message);
                        } else if (message.startsWith("FILE ")) {
                            String[] parts = message.split(" ");
                            String fileName = parts[1];
                            String fileData = parts[2];
                            broadcastMessage("FILE " + fileName + " " + socket.getInetAddress().getHostAddress());
                        } else if (message.startsWith("QUIT")) {
                            broadcastMessage(name + " left the chat.");
                            break;
                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    socket.close();
                    clients.remove(this);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        public void sendMessage(String message) throws IOException {
            outputStream.write(message.getBytes());
            outputStream.flush();
        }

    }

    public static void main(String[] args) {
        new ChatServer().start();
    }

}