Design Walnut

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Walnut {
    // 存储每个用户的收入和支出数据
    private Map<Integer, Map<String, Double>> data = new HashMap<>(); 
    // 收入关键词集合
    private Set<String> earnPattern = Set.of("credit", "credited", "deposit", "deposited");
    // 支出关键词集合
    private Set<String> expendPattern = Set.of("debit", "debited", "withdraw", "withdrawal", "withdrawn"); 
    // 平均收入缓存
    private double avgEarnCache = 0.0; 
    // 平均支出缓存
    private double avgExpenCache = 0.0; 
    // 用户总数
    private int userCount = 0; 

    /**
     * 解析文本并更新用户的收入或支出
     *
     * @param userId 用户ID
     * @param text   输入的文本
     */
    public void parseText(int userId, String text) {
        boolean newUser = false;
        
        // 如果用户不存在，则初始化其收入和支出为0
        if (!data.containsKey(userId)) {
            Map<String, Double> userData = new HashMap<>();
            userData.put("earnings", 0.0);
            userData.put("expenses", 0.0);
            data.put(userId, userData);
            userCount++;
            newUser = true;
        }

        // 判断是收入还是支出
        int inOrOut = earnOrExpend(text);
        if (inOrOut < 0) {
            return;
        }

        // 获取金额
        double amount = findAmount(text);
        if (inOrOut == 0) { // 收入
            data.get(userId).put("earnings", data.get(userId).get("earnings") + amount);
            updateAverageUserEarnings(amount, newUser);
            if (newUser) {
                updateAverageUserExpenses(0.0, true); // 新用户时，支出初始化为0
            }
        } else { // 支出
            data.get(userId).put("expenses", data.get(userId).get("expenses") + amount);
            updateAverageUserExpenses(amount, newUser);
            if (newUser) {
                updateAverageUserEarnings(0.0, true); // 新用户时，收入初始化为0
            }
        }
    }

    /**
     * 获取用户的总收入
     *
     * @param userId 用户ID
     * @return 用户的总收入
     */
    public double getTotalUserEarnings(int userId) {
        if (!data.containsKey(userId)) {
            return 0.0;
        }
        return data.get(userId).get("earnings");
    }

    /**
     * 获取用户的总支出
     *
     * @param userId 用户ID
     * @return 用户的总支出
     */
    public double getTotalUserExpenses(int userId) {
        if (!data.containsKey(userId)) {
            return 0.0;
        }
        return data.get(userId).get("expenses");
    }

    /**
     * 获取所有用户的平均收入
     *
     * @return 平均收入
     */
    public double getAverageUserEarnings() {
        return avgEarnCache;
    }

    /**
     * 获取所有用户的平均支出
     *
     * @return 平均支出
     */
    public double getAverageUserExpenses() {
        return avgExpenCache;
    }

    /**
     * 更新所有用户的平均收入
     *
     * @param amount  本次收入
     * @param newUser 是否为新用户
     */
    private void updateAverageUserEarnings(double amount, boolean newUser) {
        if (!newUser) {
            avgEarnCache += amount / userCount;
            return;
        }
        avgEarnCache = avgEarnCache * ((double) (userCount - 1) / userCount) + amount / userCount;
    }

    /**
     * 更新所有用户的平均支出
     *
     * @param amount  本次支出
     * @param newUser 是否为新用户
     */
    private void updateAverageUserExpenses(double amount, boolean newUser) {
        if (!newUser) {
            avgExpenCache += amount / userCount;
            return;
        }
        avgExpenCache = avgExpenCache * ((double) (userCount - 1) / userCount) + amount / userCount;
    }

    /**
     * 判断文本是收入还是支出
     *
     * @param text 输入的文本
     * @return 0 表示收入，1 表示支出，-1 表示无效
     */
    private int earnOrExpend(String text) {
        // 使用Stream判断文本中是否包含收入或支出的关键词
        return Stream.of(text.split(" "))
                .anyMatch(earnPattern::contains) ? 0 :
                Stream.of(text.split(" "))
                        .anyMatch(expendPattern::contains) ? 1 : -1;
    }

    /**
     * 提取金额信息
     *
     * @param text 输入的文本
     * @return 提取的金额，如果无效则返回-1.0
     */
    private double findAmount(String text) {
        // 将文本转为字符流
        String amountStr = IntStream.range(0, text.length())
                .mapToObj(i -> text.charAt(i))
                .filter(c -> Character.isDigit(c) || c == '.') // 只保留数字和小数点
                .map(String::valueOf)
                .collect(Collectors.joining());

        if (amountStr.isEmpty()) return -1.0;

        // 处理小数点的位置
        int dotIndex = amountStr.indexOf('.');
        if (dotIndex != -1 && amountStr.indexOf('.', dotIndex + 1) != -1) {
            return -1.0; // 如果有多个小数点，则返回 -1.0
        }

        // 如果小数点在最前面，补充 "0."
        if (dotIndex == 0) {
            amountStr = "0" + amountStr;
        }

        try {
            double amount = Double.parseDouble(amountStr);
            if (amount > 1e9) return -1.0; // 如果金额过大，返回-1.0
            return amount;
        } catch (NumberFormatException e) {
            return -1.0; // 如果解析失败，返回-1.0
        }
    }
}