Design Twitter

import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;

/**
 * Your Twitter object will be instantiated and called as such:
 * Twitter obj = new Twitter();
 * obj.postTweet(userId,tweetId);
 * List<Integer> param_2 = obj.getNewsFeed(userId);
 * obj.follow(followerId,followeeId);
 * obj.unfollow(followerId,followeeId);
 */
public class Twitter {

    private static final AtomicInteger timeStamp = new AtomicInteger(0);
    private final Map<Integer, User> userMap;

    // 推文类
    private static class Tweet {
        private final int id;
        private final int time;
        private final Tweet next;

        private Tweet(int id, int time, Tweet next) {
            this.id = id;
            this.time = time;
            this.next = next;
        }

        // 使用 Builder 构建 Tweet
        public static class Builder {
            private int id;
            private int time;
            private Tweet next;

            public Builder id(int id) {
                this.id = id;
                return this;
            }

            public Builder time(int time) {
                this.time = time;
                return this;
            }

            public Builder next(Tweet next) {
                this.next = next;
                return this;
            }

            public Tweet build() {
                return new Tweet(id, time, next);
            }
        }
    }

    // 用户类
    private static class User {
        private final int id;
        private final Set<Integer> followed;
        private Tweet tweetHead;

        public User(int id) {
            this.id = id;
            this.followed = new HashSet<>();
            follow(id); // 自己默认关注自己
        }

        public void follow(int userId) {
            followed.add(userId);
        }

        public void unfollow(int userId) {
            if (userId != this.id) {
                followed.remove(userId);
            }
        }

        public void post(int tweetId) {
            tweetHead = new Tweet.Builder()
                    .id(tweetId)
                    .time(timeStamp.getAndIncrement())
                    .next(tweetHead)
                    .build();
        }
    }

    public Twitter() {
        this.userMap = new HashMap<>();
    }

    private User getOrCreateUser(int userId) {
        return userMap.computeIfAbsent(userId, User::new);
    }

    public void postTweet(int userId, int tweetId) {
        getOrCreateUser(userId).post(tweetId);
    }

    public List<Integer> getNewsFeed(int userId) {
        if (!userMap.containsKey(userId)) {
            return Collections.emptyList();
        }

        // 获取用户自己和其关注用户的所有推文头
        List<Tweet> tweets = userMap.get(userId).followed.stream()
                .map(userMap::get)
                .filter(Objects::nonNull)
                .map(user -> user.tweetHead)
                .filter(Objects::nonNull)
                .collect(Collectors.toList());

        // 使用优先队列（最大堆）获取最近的 10 条推文
        PriorityQueue<Tweet> maxHeap = new PriorityQueue<>(
                Comparator.comparingInt((Tweet t) -> t.time).reversed());
        maxHeap.addAll(tweets);

        List<Integer> result = new ArrayList<>();
        while (!maxHeap.isEmpty() && result.size() < 10) {
            Tweet top = maxHeap.poll();
            result.add(top.id);
            if (top.next != null) {
                maxHeap.add(top.next);
            }
        }
        return result;
    }

    public void follow(int followerId, int followeeId) {
        getOrCreateUser(followerId).follow(followeeId);
        getOrCreateUser(followeeId); // 确保被关注用户存在
    }

    public void unfollow(int followerId, int followeeId) {
        User follower = userMap.get(followerId);
        if (follower != null) {
            follower.unfollow(followeeId);
        }
    }
}