JAVAfx项目总结 && 算法题

一、长短链接

1、短连接

对于短链接，在写完这个项目的理解是这样的，对于发给后端的每一个请求都有一个新建socket，当完成前端和后端的通信或者断开时即可给这个socket关闭。还有写的过程中查询资料室知的一些知识点。

(1)短链接的优点

a.对于服务器的资源占用较少

b.相对长连接实现起来相对简单

c.服务器不需要记录用户端的状态

(2)短链接的缺点

a.会频繁的和后端建立链接，断开连接

b.延迟高，不利于实时通信

c.不适用于高并发，很消耗后端的CPU和内存

(3)短链接的应用场景

a.低频请求

b.无状态服务(包括静态资源请求下载，登录注册忘记密码)

c.高安全性要求(银行等交易场所，避免信息被盗窃)

以下就是短链接的基本实现代码

用户端

import java.io.*;

import java.net.Socket;

public class ShortConnectionClient {

    public static void main(String[] args) {

        String serverAddress = "localhost";

        int port = 8080;

        try {

            // 每次请求都创建新的Socket连接

            Socket socket = new Socket(serverAddress, port);

            // 获取输出流，向服务器发送数据

            PrintWriter out = new PrintWriter(socket.getOutputStream(), true);

            out.println("Hello Server!");

            // 获取输入流，读取服务器响应

            BufferedReader in = new BufferedReader(

                new InputStreamReader(socket.getInputStream()));

            String response = in.readLine();

            System.out.println("Server response: " + response);

            // 关闭连接

            socket.close();

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

}

后端接收

import java.io.*; import java.net.ServerSocket; import java.net.Socket;

public class ShortConnectionServer {     public static void main(String[] args) {         int port = 8080;                  try (ServerSocket serverSocket = new ServerSocket(port)) {             System.out.println("Server started on port " + port);                          while (true) {                 // 接受客户端连接（每次都是新的连接）                 Socket clientSocket = serverSocket.accept();                 System.out.println("Client connected: " + clientSocket.getInetAddress());                                  // 处理客户端请求                 handleClient(clientSocket);             }         } catch (IOException e) {             e.printStackTrace();         }     }          private static void handleClient(Socket clientSocket) {         try (             BufferedReader in = new BufferedReader(                 new InputStreamReader(clientSocket.getInputStream()));             PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)         ) {             // 读取客户端消息             String message = in.readLine();             System.out.println("Received from client: " + message);                          // 发送响应             out.println("Hello Client! Your message: " + message);                          // 关闭连接（短链接特点）             clientSocket.close();         } catch (IOException e) {             e.printStackTrace();         }     } }

观了别人写的代码后我自己又突然有了想法，是不是后端可以有多个端口，负责不同的业务，于是我进行了查询，以下便是我的理解。

后端多端口

对于后端多个端口，每个端口都有自己负责的业务，可以有短链接请求端口，长连接建立端口，以及资源等其他业务请求端口。

(1)优点

a.业务需求多样化

b.性能优化

c.安全性 && 隔离

2.长连接

对于长连接，我的理解是当用户登录之后进入了主界面时，长连接也要建立了，而建立长连接，则是通过前端和后端while循环来建立，源源不断的看是否有请求的传递。

(1)长连接的优点

a.减少连接建立和断开的开销

b.适合频繁通信的场景

c.保持会话状态

d.更快的响应速度

(2)长连接的缺点

a.占用服务器资源

b.需要心跳机制维护

c.网络环境适应性较

d.复杂性较高

(3)长连接的应用场景

a.实时通信(qq,微信这种聊天软件等)

b.高频短数据交互

c.数据库/缓存连接池

d.API网关/微服务通信

长连接基本代码实现

用户端

import java.io.*; import java.net.*; import java.util.concurrent.*;

public class LongConnectionClient {     private static final String HOST = "localhost";     private static final int PORT = 8888;     private static final ScheduledExecutorService scheduler =          Executors.newScheduledThreadPool(1);

    public static void main(String[] args) {         try {             Socket socket = new Socket(HOST, PORT);             socket.setSoTimeout(5000); // 设置读取超时                          PrintWriter out = new PrintWriter(socket.getOutputStream(), true);             BufferedReader in = new BufferedReader(                 new InputStreamReader(socket.getInputStream()));                          // 发送业务消息             for (int i = 0; i < 5; i++) {                 String message = "业务消息_" + i;                 out.println(message);                                  String response = in.readLine();                 System.out.println("收到响应：" + response);                                  Thread.sleep(2000);             }                          // 关闭连接             scheduler.shutdown();             socket.close();         } catch (Exception e) {             e.printStackTrace();         }     }

    private static void startHeartbeat(PrintWriter out) {         // 每10秒发送一次心跳         scheduler.scheduleAtFixedRate(() -> {             try {                 out.println("HEARTBEAT");                 System.out.println("发送心跳");             } catch (Exception e) {                 e.printStackTrace();             }         }, 0, 10, TimeUnit.SECONDS);     } }

服务器

import java.io.*; import java.net.*; import java.util.concurrent.*;

public class LongConnectionServer {     private static final int PORT = 8888;     private static final int MAX_THREADS = 100;     private static final ExecutorService threadPool = Executors.newFixedThreadPool(MAX_THREADS);

    public static void main(String[] args) {         try (ServerSocket serverSocket = new ServerSocket(PORT)) {             System.out.println("长连接服务端启动，监听端口：" + PORT);                          while (true) {                 Socket clientSocket = serverSocket.accept();                 // 设置读写超时时间（毫秒）                 clientSocket.setSoTimeout(30000);                 // 长连接线程                 threadPool.execute(new ClientHandler(clientSocket));             }         } catch (IOException e) {             e.printStackTrace();         }     }

    static class ClientHandler implements Runnable {         private final Socket socket;         private long lastHeartbeatTime;

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

        @Override         public void run() {             try (BufferedReader in = new BufferedReader(                     new InputStreamReader(socket.getInputStream()));                  PrintWriter out = new PrintWriter(                     socket.getOutputStream(), true)) {                                  System.out.println("客户端连接：" + socket.getRemoteSocketAddress());

                String inputLine;                 while ((inputLine = in.readLine()) != null) {                     // 心跳检测                     if ("HEARTBEAT".equals(inputLine)) {                         lastHeartbeatTime = System.currentTimeMillis();                         out.println("HEARTBEAT_ACK");                         continue;                     }                                          // 处理业务逻辑                     System.out.println("收到消息：" + inputLine);                     String response = "处理结果：" + inputLine;                     out.println(response);                                          // 检查连接是否超时（30秒无心跳）                     if (System.currentTimeMillis() – lastHeartbeatTime > 30000) {                         System.out.println("连接超时，关闭连接");                         break;                     }                 }             } catch (SocketTimeoutException e) {                 System.out.println("读取超时，关闭连接");             } catch (IOException e) {                 e.printStackTrace();             } finally {                 try {                     socket.close();                     System.out.println("连接关闭：" + socket.getRemoteSocketAddress());                 } catch (IOException e) {                     e.printStackTrace();                 }             }         }     } }

二、序列化

1.序列化是将对象转换为字节流的过程，以便存储或传输；

2.反序列化则是将字节流恢复为对象。它在分布式系统、数据持久化和网络通信中起着关键作用。

3. 序列化的核心作用

（1）对象持久化（存储到文件/数据库）

• 将内存中的对象保存到磁盘，程序重启后可恢复。

• 示例：游戏存档、用户会话保存。

（2）网络传输（跨进程/跨机器通信）

• 对象 → 字节流 → 网络传输 → 字节流 → 对象。

• 示例：RPC调用、微服务通信。

（3）深拷贝（Deep Copy）

• 通过序列化/反序列化实现对象的完全复制。

• 示例：避免Java的浅拷贝问题。

（4）跨语言数据交换

• 通用序列化格式（如JSON、Protocol Buffers）支持不同语言解析。

• 示例：Java服务与Python客户端通信。

4. 序列化的核心意义

（1）解决对象传输问题

• 网络只能传输字节流，序列化是对象传输的基础。

（2）实现分布式系统通信

• 微服务、RPC、消息队列（如Kafka）依赖序列化传递对象。

（3）保证数据一致性

• 序列化协议定义了数据的编码规则，避免解析错误。

（4）提高系统扩展性

• 通过版本兼容的序列化协议（如Protobuf），支持字段动态增减。

四、IO流

在项目中，IO流主要用于文件读写和网络数据传输，核心使用了以下类：

1. 字节流（Byte Streams）

FileInputStream`/`FileOutputStream     用于读写二进制文件（如图片、视频）。

// 读取文件   try (FileInputStream fis = new FileInputStream("file.bin")) {       byte[] buffer = new byte[1024];       int bytesRead;       while ((bytesRead = fis.read(buffer)) != -1) {           // 处理数据       }   }

  // 写入文件   try (FileOutputStream fos = new FileOutputStream("output.bin")) {       fos.write(dataBytes);   }

2. 字符流（Character Streams）

BufferedReader`/`BufferedWriter 

// 读取文本文件   try (BufferedReader br = new BufferedReader(new FileReader("config.txt"))) {       String line;       while ((line = br.readLine()) != null) {           System.out.println(line);       }   }

  // 写入文本文件   try (BufferedWriter bw = new BufferedWriter(new FileWriter("log.txt"))) {       bw.write("Log message");       bw.newLine();   }

3. 对象流（Object Streams）

ObjectInputStream`/`ObjectOutputStream   用于序列化和反序列化Java对象（如用户数据持久化）。

  // 序列化对象到文件   try (ObjectOutputStream oos = new ObjectOutputStream(           new FileOutputStream("user.dat"))) {       oos.writeObject(user);   }

  // 从文件反序列化对象   try (ObjectInputStream ois = new ObjectInputStream(           new FileInputStream("user.dat"))) {       User user = (User) ois.readObject();   }

4. 网络IO（Socket流）

Socket.getInputStream()`/`Socket.getOutputStream()   用于网络通信，结合`BufferedReader`和`PrintWriter`处理文本协议。

// 服务端读取客户端数据   try (BufferedReader in = new BufferedReader(           new InputStreamReader(socket.getInputStream()))) {       String message = in.readLine();   }

  // 客户端发送数据到服务端   try (PrintWriter out = new PrintWriter(           socket.getOutputStream(), true)) {       out.println("Hello Server!");   }

五、多线程在项目中的应用

多线程主要用于并发处理客户端请求和异步任务。

1. 线程池管理

ExecutorService   避免频繁创建/销毁线程，提升性能。

ExecutorService threadPool = Executors.newFixedThreadPool(10);   threadPool.execute(() -> {       // 处理客户端请求   });

2. 线程同步

synchronized`关键字   保护共享资源（如数据库连接池）。  

public synchronized void updateData() {       // 线程安全操作   }

六、文件分片上传/下载

通过IO流实现大文件的分块处理。

1. 文件分片上传

// 客户端分片发送 try (FileInputStream fis = new FileInputStream("large_file.zip");      BufferedInputStream bis = new BufferedInputStream(fis)) {     byte[] buffer = new byte[1024 * 1024]; // 1MB分片     int bytesRead;     while ((bytesRead = bis.read(buffer)) != -1) {         socket.getOutputStream().write(buffer, 0, bytesRead);     } }

2. 服务端分片接收

try (FileOutputStream fos = new FileOutputStream("received_file.zip");      BufferedOutputStream bos = new BufferedOutputStream(fos)) {     byte[] buffer = new byte[1024 * 1024];     int bytesRead;     while ((bytesRead = socket.getInputStream().read(buffer)) != -1) {         bos.write(buffer, 0, bytesRead);     } }

七、MySQL数据库操作

使用JDBC进行CRUD操作。

1. 数据库连接

String url = "jdbc:mysql://localhost:3306/mydb"; String user = "root"; String password = "123456"; try (Connection conn = DriverManager.getConnection(url, user, password)) {     // 执行SQL }

2. 查询数据

String sql = "SELECT * FROM users WHERE id = ?"; try (PreparedStatement stmt = conn.prepareStatement(sql)) {     stmt.setInt(1, 1001);     ResultSet rs = stmt.executeQuery();     while (rs.next()) {         String name = rs.getString("name");     } }

3. 插入/更新数据

String sql = "INSERT INTO users (name, age) VALUES (?, ?)"; try (PreparedStatement stmt = conn.prepareStatement(sql)) {     stmt.setString(1, "Alice");     stmt.setInt(2, 25);     stmt.executeUpdate(); }

总结

| 技术       | 在项目中的应用                                                     | |————-|——————————————————————| | IO流       | 文件读写、网络数据传输、对象序列                     | | 多线程    | 并发处理客户端请求任务执行                     | | 文件分片 | 大文件的上传与下载                                              | | MySQL   | 用户数据存储、查询和更新                                    | | JavaFX   | 构建图形界面，与后端Socket/数据库交互             |

通过结合这些技术，项目实现了：  

1.客户端与服务端的稳定通信（长短链接结合）    2.高效文件传输（分片处理）    3.数据持久化（MySQL + 序列化）    4.用户友好的图形界面（JavaFX）

一、算法题

1.

解题思路：正常的并查集，加一个map来实现string->int即可

#include <iostream>
#include <vector>
#include <stack>
#include <queue>
#include <climits>
#include <algorithm>
#include <map>
#define ll long long
using namespace std;

int n, m, p;

int find(int x, vector<int>& parent) {
if (parent[x] != x)
parent[x] = find(parent[x], parent);
return parent[x];
}

void setUnion(int a, int b, vector<int>& parent, vector<int>& rank) {
a = find(a,parent);
b = find(b,parent);

if (a == b)
return;

int x1 = min(a, b);
int x2 = max(a, b);
if (rank[x1] > rank[x2])
parent[x2] = x1;
else if (rank[x1] < rank[x2])
parent[x2] = x1;
else {
parent[x1] = x2;
rank[x2]++;
}

}

bool isConnect(int a, int b, vector<int>& parent) {
a = find(a, parent);
b = find(b, parent);
return a == b;
}

int main() {
cin >> n >> m;
vector<int>parent(n + 1, 0); // 节点的上一级
map<string,int> tt;
vector<int>rank(n + 1, 0); // 建立最小的树

for (int i = 1; i <= n; i++) { // 先指向自身
parent[i] = i;
string s; cin >> s;
tt[s] = i;
}

for (int i = 1; i <= m; i++) { // 建立亲戚关系
string a, b; cin >> a >> b;
int x1 = tt[a], x2 = tt[b];
setUnion(x1, x2, parent, rank);
}
cin >> p;
for (int i = 1; i <= p; i++) {
string a, b; cin >> a >> b;
int x1 = tt[a], x2 = tt[b];
if (isConnect(x1, x2, parent))
cout << "Yes." << endl;
else
cout << "No." << endl;
}

return 0;
}

 2.

解题思路： 并查集，限定了合并条件，根据题目的合并条件合成即可

#include <iostream>
#include <vector>
#include <stack>
#include <queue>
#include <climits>
#include <algorithm>
#include <map>
#define ll long long
using namespace std;

map<string, string> parent;

// 查找并返回name的最早祖先，并进行路径压缩
string findAncestor(string name) {
if (name != parent[name]) {
parent[name] = findAncestor(parent[name]);
}
return parent[name];
}

int main() {
char prefix;
string name;
string current_parent;

cin >> prefix;
while (prefix != '$') {
cin >> name;
if (prefix == '#') {
current_parent = name;
if (parent.find(name) == parent.end()) {
parent[name] = name; // 初始化父亲为自身
}
} else if (prefix == '+') {
parent[name] = current_parent;
} else if (prefix == '?') {
cout << name << ' ' << findAncestor(name) << endl;
}
cin >> prefix;
}

return 0;
}

3.

解题思路：把题目看成图，每个点都是顶点，距离都是权重，就可以用kruskal了。

#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>
#include <iomanip>
using namespace std;

struct Edge {
int u, v;
double w;
bool operator<(const Edge& other) const {
return w < other.w;
}
};

vector<Edge> edges;
vector<int> parent;
int S, P;
vector<pair<int, int>> d;

int find(int x) {
if (parent[x] != x) {
parent[x] = find(parent[x]);
}
return parent[x];
}

void unionset(int x, int y) {
int rootX = find(x);
int rootY = find(y);
if (rootX != rootY) {
parent[rootY] = rootX;
}
}

double kruskal() {

parent.resize(P + 1);
for (int i = 1; i <= P; i++) {
parent[i] = i;
}

sort(edges.begin(), edges.end());

double ans = 0.0;
int k = P – S;

for (const auto& edge : edges) {
if (find(edge.u) != find(edge.v)) {
unionset(edge.u, edge.v);
ans = edge.w;
k–;
if (k == 0) {
break;
}
}
}

return ans;
}

int main() {
cin >> S >> P;
d.resize(P + 1);

for (int i = 1; i <= P; i++) {
cin >> d[i].first >> d[i].second;
}

for (int i = 1; i <= P; i++) {
for (int j = i + 1; j <= P; j++) {
double dx = d[i].first – d[j].first;
double dy = d[i].second – d[j].second;
double dis = sqrt(dx * dx + dy * dy);
edges.push_back({ i, j, dis });
}
}

double ans = kruskal();

cout << fixed << setprecision(2) << ans << endl;

return 0;
}

 4.

解题思路:开始想了好久，发现N<=6,这个数量好像可以直接遍历所有的情况来讨论，但是对于面积的计算还是有点迷，就看了下别人的思路。让放下的油滴尽可能的扩大，相加所有的面积，每次枚举都取面积的最大值

#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <iomanip>

using namespace std;

double area(int N, const vector<pair<int, int>>& points, int left, int right, int bottom, int top) {
double max_total_area = 0.0;
vector<int> indices(N);
for (int i = 0; i < N; ++i) {
indices[i] = i;
}

do {
vector<double> radii(N, 0.0);
double total_area = 0.0;
for (int i = 0; i < N; ++i) {
int x = points[indices[i]].first;
int y = points[indices[i]].second;
double min_r = min({x – left, right – x, y – bottom, top – y});
for (int j = 0; j < i; ++j) {
int xj = points[indices[j]].first;
int yj = points[indices[j]].second;
double dx = x – xj;
double dy = y – yj;
double distance = sqrt(dx * dx + dy * dy);
min_r = min(min_r, distance – radii[j]);
if (min_r <= 0) break;
}
if (min_r > 0) {
radii[i] = min_r;
total_area += M_PI * min_r * min_r;
}
}
if (total_area > max_total_area) {
max_total_area = total_area;
}
} while (next_permutation(indices.begin(), indices.end()));

double area_rect = (right – left) * (top – bottom);
return area_rect – max_total_area;
}

int main() {
int N;
cin >> N;
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
int left = min(x1, x2);
int right = max(x1, x2);
int bottom = min(y1, y2);
int top = max(y1, y2);

vector<pair<int, int>> points(N);
for (int i = 0; i < N; ++i) {
cin >> points[i].first >> points[i].second;
}

sort(points.begin(), points.end());
double remaining_area = area(N, points, left, right, bottom, top);
cout << static_cast<int>(round(remaining_area)) << endl;

return 0;
}

5.

解题思路：第一次写这种题，我最开始就是直接用dfs来搜索，但是时间超限，然后我看了一下别人的思路，可以用个二维数组存储已经知道的每个的位置的最大值，当dfs到这个位置，直接从二维数组里取出来就行了，这个方法也是记忆化搜索

#include <iostream>
#include <vector>
#include <stack>
#include <queue>
#include <climits>
#include <algorithm>
#include <map>
#define ll long long
using namespace std;

// 定义四个方向
int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

// 全局变量存储矩阵和dp数组
vector<vector<int>> matrix;
vector<vector<int>> dp;
int R, C;

// DFS函数，返回从(x, y)出发的最长滑坡长度
int dfs(int x, int y) {
// 如果已经计算过，直接返回结果
if (dp[x][y] != -1) {
return dp[x][y];
}

// 初始化为1，因为至少可以滑到自己
dp[x][y] = 1;

// 遍历四个方向
for (int i = 0; i < 4; ++i) {
int newX = x + dirs[i][0];
int newY = y + dirs[i][1];
// 检查边界条件和高度是否下降
if (newX >= 0 && newX < R && newY >= 0 && newY < C && matrix[newX][newY] < matrix[x][y]) {
// 递归计算相邻点的最长滑坡长度，并更新当前点的dp值
dp[x][y] = max(dp[x][y], dfs(newX, newY) + 1);
}
}

return dp[x][y];
}

int main() {
// 读取行数和列数
cin >> R >> C;
matrix.assign(R, vector<int>(C));
for (int i = 0; i < R; ++i) {
for (int j = 0; j < C; ++j) {
cin >> matrix[i][j];
}
}

// 初始化dp数组为-1，表示未计算
dp.assign(R, vector<int>(C, -1));

// 遍历所有点，计算最长滑坡长度
int maxLength = 0;
for (int i = 0; i < R; ++i) {
for (int j = 0; j < C; ++j) {
if (dp[i][j] == -1) { // 如果尚未计算
dfs(i, j);
}
maxLength = max(maxLength, dp[i][j]);
}
}

// 输出结果
cout << maxLength << endl;

return 0;
}