一个简单的 Java 源码示例，展示了如何实现一个收藏文章的算法及数据库表结构的设计实现

源码资源网

一个简单的 Java 源码示例，展示了如何实现一个收藏文章的算法及数据库表结构的设计实现
一个简单的 Java 源码示例，展示了如何实现一个收藏文章的算法。这个示例中包含了用户、文章的类定义，以及如何实现收藏功能，并显示每个用户收藏的文章和每篇文章被哪些用户收藏过。
### 1. 定义用户和文章类

1. import java.util.ArrayList;
   
2. import java.util.HashMap;
   
3. import java.util.List;
   
4. import java.util.Map;
   
5. // 用户类
   
6. class User {
   
7.     private String username;
   
8.     private List<Article> favoriteArticles;
   
9.      public User(String username) {
   
10.         this.username = username;
    
11.         this.favoriteArticles = new ArrayList<>();
    
12.     }
    
13.      public String getUsername() {
    
14.         return username;
    
15.     }
    
16.      public void addFavoriteArticle(Article article) {
    
17.         if (!favoriteArticles.contains(article)) {
    
18.             favoriteArticles.add(article);
    
19.             article.addUser(this); // 同时将用户添加到文章的收藏用户列表
    
20.         }
    
21.     }
    
22.      public List<Article> getFavoriteArticles() {
    
23.         return favoriteArticles;
    
24.     }
    
25. }
    
26. // 文章类
    
27. class Article {
    
28.     private String title;
    
29.     private List<User> usersWhoFavorited;
    
30.      public Article(String title) {
    
31.         this.title = title;
    
32.         this.usersWhoFavorited = new ArrayList<>();
    
33.     }
    
34.      public String getTitle() {
    
35.         return title;
    
36.     }
    
37.      public void addUser(User user) {
    
38.         if (!usersWhoFavorited.contains(user)) {
    
39.             usersWhoFavorited.add(user);
    
40.         }
    
41.     }
    
42.      public List<User> getUsersWhoFavorited() {
    
43.         return usersWhoFavorited;
    
44.     }
    
45. }
    
46. 
    

复制代码

### 2. 主程序示例

1. public class Main {
   
2. public static void main(String[] args) {
   
3. // 创建用户
   
4. User user1 = new User("Alice");
   
5. User user2 = new User("Bob");
   
6. // 创建文章
   
7. Article article1 = new Article("Java Programming");
   
8. Article article2 = new Article("Data Structures");
   
9. // 用户收藏文章
   
10. user1.addFavoriteArticle(article1);
    
11. user1.addFavoriteArticle(article2);
    
12. user2.addFavoriteArticle(article1);
    
13. // 显示每个用户收藏的文章
    
14. System.out.println(user1.getUsername() + " 收藏的文章:");
    
15. for (Article article : user1.getFavoriteArticles()) {
    
16. System.out.println("- " + article.getTitle());
    
17. }
    
18. System.out.println(user2.getUsername() + " 收藏的文章:");
    
19. for (Article article : user2.getFavoriteArticles()) {
    
20. System.out.println("- " + article.getTitle());
    
21. }
    
22. // 显示每篇文章被哪些用户收藏过
    
23. System.out.println("\n文章收藏情况:");
    
24. for (Article article : new Article[]{article1, article2}) {
    
25. System.out.println(article.getTitle() + " 被以下用户收藏过:");
    
26. for (User user : article.getUsersWhoFavorited()) {
    
27. System.out.println("- " + user.getUsername());
    
28. }
    
29. }
    
30. }
    
31. }

复制代码

### 代码说明
1. **User 类**：代表用户，包含用户名和用户收藏的文章列表。 `addFavoriteArticle`  方法用于添加收藏的文章，并同时更新文章的收藏用户列表。
2. **Article 类**：代表文章，包含文章标题和收藏该文章的用户列表。 `addUser`  方法用于添加收藏该文章的用户。
3. **Main 类**：主程序示例，创建用户和文章，并演示如何进行收藏操作以及如何显示用户收藏的文章和文章的收藏情况。
### 使用方法
您可以将上述代码复制到 Java IDE 中，运行  `Main`  类以查看输出结果。根据需要，您可以扩展用户和文章的属性及方法，以满足特定需求。






根据上述 Java 源码，我们可以设计一个 MySQL 数据库表结构来存储用户、文章及其收藏关系。下面是一个可能的数据库设计方案：
### 数据库表结构
1. **用户表 (users)**
   -  `id`  (INT, 主键, 自增): 用户的唯一标识符
   -  `username`  (VARCHAR(255), 唯一): 用户名
sql
   CREATE TABLE users (
       id INT AUTO_INCREMENT PRIMARY KEY,
       username VARCHAR(255) NOT NULL UNIQUE
   );
2. **文章表 (articles)**
   -  `id`  (INT, 主键, 自增): 文章的唯一标识符
   -  `title`  (VARCHAR(255), 唯一): 文章标题
sql
   CREATE TABLE articles (
       id INT AUTO_INCREMENT PRIMARY KEY,
       title VARCHAR(255) NOT NULL UNIQUE
   );
3. **收藏表 (favorites)**
   -  `user_id`  (INT, 外键): 用户的唯一标识符，引用  `users`  表
   -  `article_id`  (INT, 外键): 文章的唯一标识符，引用  `articles`  表
   -  `PRIMARY KEY (user_id, article_id)` : 复合主键，确保同一用户不能重复收藏同一篇文章

1. sql
   
2.    CREATE TABLE favorites (
   
3.        user_id INT,
   
4.        article_id INT,
   
5.        PRIMARY KEY (user_id, article_id),
   
6.        FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
   
7.        FOREIGN KEY (article_id) REFERENCES articles(id) ON DELETE CASCADE
   
8.    );

复制代码

### 数据库表结构说明
1. **用户表 (users)**：存储用户信息，每个用户有一个唯一的  `id`  和  `username` 。
2. **文章表 (articles)**：存储文章信息，每篇文章有一个唯一的  `id`  和  `title` 。
3. **收藏表 (favorites)**：存储用户与文章之间的收藏关系。通过  `user_id`  和  `article_id`  形成复合主键，确保同一用户不能重复收藏同一篇文章。
### 示例 SQL 语句
以下是一些示例 SQL 语句，用于插入数据和查询收藏信息：
1. **插入用户**

1. sql
   
2.    INSERT INTO users (username) VALUES ('Alice'), ('Bob');

复制代码

2. **插入文章**

1. sql
   
2.    INSERT INTO articles (title) VALUES ('Java Programming'), ('Data Structures');

复制代码

3. **插入收藏关系**

1. sql
   
2.    INSERT INTO favorites (user_id, article_id) VALUES (1, 1), (1, 2), (2, 1);

复制代码

4. **查询用户收藏的文章**

1. sql
   
2.    SELECT u.username, a.title
   
3.    FROM favorites f
   
4.    JOIN users u ON f.user_id = u.id
   
5.    JOIN articles a ON f.article_id = a.id;

复制代码

5. **查询文章被哪些用户收藏过**

1. sql
   
2.    SELECT a.title, u.username
   
3.    FROM favorites f
   
4.    JOIN articles a ON f.article_id = a.id
   
5.    JOIN users u ON f.user_id = u.id;

复制代码

通过上述表结构和 SQL 语句，您可以在 MySQL 数据库中实现用户收藏文章的功能。