Java Scanner 输入陷阱与缓存模拟器数据解析实战

public static void main(String[] args) {
    Scanner in = new Scanner(System.in); // 用于读取单个令牌（如整数、单词）
    System.out.print("Enter number of cache blocks: ");
    int numBlocks = in.nextInt();
    System.out.print("Enter set associativity (1=direct mapped, 2=2-way, 4=4-way): ");
    int setAssoc = in.nextInt();
    System.out.print("Enter replacement policy (FIFO or LRU): ");
    String replacementPolicy = in.next();

    // 创建一个新的 Scanner 对象来读取整行输入，避免与 'in' 对象的冲突
    Scanner lineScanner = new Scanner(System.in); 
    System.out.println("Enter reference string (space-separated numbers):");
    String input = lineScanner.nextLine(); // 读取整个引用字符串行

    // 对读取到的字符串进行处理：去除首尾空白并按空格分割
    String[] references = input.trim().split(" ");
    int[] refs = new int[references.length];
    for (int i = 0; i < references.length; i++) {
        // 确保分割后的每个字符串都能被正确解析为整数
        if (!references[i].isEmpty()) { // 避免因连续空格导致空字符串解析错误
            refs[i] = Integer.parseInt(references[i]);
        }
    }

    cacheProject cache = new cacheProject(numBlocks, setAssoc, replacementPolicy);
    cache.simulate(refs);

    // 关闭 Scanner 资源，防止内存泄漏
    in.close();
    lineScanner.close();
}

package cacheProject;

import java.util.Scanner;
import java.util.ArrayList; // 引入ArrayList用于更灵活的LRU实现
import java.util.List;

public class cacheProject {

    private int numBlocks;
    private int setAssoc;
    private String replacementPolicy;

    // 缓存块的实际存储，这里使用List模拟，方便LRU操作
    // 注意：当前代码的LRU实现仍需完善，此处仅为示例结构
    private List<Integer> cacheContents; 

    public cacheProject(int numBlocks, int setAssoc, String replacementPolicy) {
        this.numBlocks = numBlocks;
        this.setAssoc = setAssoc; // 注意：此参数在当前simulate方法中未被完全利用
        this.replacementPolicy = replacementPolicy;
        this.cacheContents = new ArrayList<>(numBlocks); // 初始化缓存列表
    }

    public void simulate(int[] references) {
        int missRate = 0;
        int hits = 0;

        for (int block : references) {
            // 检查块是否在缓存中
            boolean inCache = cacheContents.contains(block);

            if (inCache) {
                hits++;
                // 如果是LRU策略，需要更新块的访问顺序
                if ("LRU".equals(replacementPolicy)) {
                    cacheContents.remove((Integer) block); // 移除旧位置
                    cacheContents.add(block);              // 添加到最新位置
                }
            } else {
                missRate++;
                // 如果缓存已满，根据策略移除块
                if (cacheContents.size() == numBlocks) {
                    if ("LRU".equals(replacementPolicy)) {
                        cacheContents.remove(0); // LRU：移除最不常用的（列表头部）
                    } else if ("FIFO".equals(replacementPolicy)) {
                        cacheContents.remove(0); // FIFO：移除最早进入的（列表头部）
                    }
                    // TODO: 对于其他策略或更复杂的set-associative，需要更复杂的逻辑
                }
                // 将新块添加到缓存
                cacheContents.add(block);
            }
        }

        System.out.println("Miss rate: " + (double) missRate / references.length);
        System.out.println("Hits: " + hits);
        System.out.println("Cache contents:");
        for (int i = 0; i < cacheContents.size(); i++) {
            System.out.print(cacheContents.get(i) + " ");
        }
        // 填充剩余的空块为0，以便与原始输出格式匹配（如果需要）
        for (int i = cacheContents.size(); i < numBlocks; i++) {
            System.out.print("0 ");
        }
        System.out.println();
    }

    // 原始的findLRUBlock方法逻辑不符合LRU定义，已在simulate中通过List操作简化
    // 真正的LRU需要追踪访问时间或维护一个有序列表。
    // 如果坚持使用数组，则需要额外的数组来存储每个块的上次访问时间戳。
    /*
    public int findLRUBlock(int[] cache) {
        // 此方法在当前LRU List实现中不再需要，或需要重写以适应数组+时间戳
        return -1; // 占位符
    }
    */

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.print("Enter number of cache blocks: ");
        int numBlocks = in.nextInt();
        System.out.print("Enter set associativity (1=direct mapped, 2=2-way, 4=4-way): ");
        int setAssoc = in.nextInt();
        System.out.print("Enter replacement policy (FIFO or LRU): ");
        String replacementPolicy = in.next();

        // 创建一个新的 Scanner 对象来读取整行输入，避免与 'in' 对象的冲突
        Scanner lineScanner = new Scanner(System.in); 
        System.out.println("Enter reference string (space-separated numbers):");
        String input = lineScanner.nextLine(); // 读取整个引用字符串行

        String[] referencesStr = input.trim().split(" ");
        // 过滤掉split可能产生的空字符串，例如用户输入了多个空格
        List<Integer> tempRefs = new ArrayList<>();
        for (String s : referencesStr) {
            if (!s.isEmpty()) {
                tempRefs.add(Integer.parseInt(s));
            }
        }
        int[] refs = tempRefs.stream().mapToInt(Integer::intValue).toArray();

        cacheProject cache = new cacheProject(numBlocks, setAssoc, replacementPolicy);
        cache.simulate(refs);

        // 关闭 Scanner 资源，防止内存泄漏
        in.close();
        lineScanner.close();
    }
}