帮我用Java实现一个程序并给我完整的代码（1）通过随机数产生一个指令序列，共320条指令。指令的地址按下述原则生成： ①50%的指令是顺序执行的； ②50%的指令是均匀分布在前地址部分； ③50%的指令是均匀分布在后地址部分。 具体的实施方法是： ①在 [0，319] 的指令之间随即选取一起点m; ②顺序执行一条指令，即执行地址为m+1的指令； ③在前地址[0，m+1]中随机选取一条指令并执行，该指令的地址为m′； ④顺序执行一条指令，其地址为 m′+ 1； ⑤在后地址[m′+ 2，319]中随机选取一条指令并执行； ⑥重复上述步骤①-⑤，直到执行320次指令。 （2）将指令序列变换为页地址流 设：①页面大小为1k； ②用户内存容量为4页到32页； ③用户虚存容量为32k。 在用户虚存中，按每k存放10条指令排在虚存地址，即320条指令在虚存中的存放方式为： 第0条-第9条指令为第0页（对应虚存地址为[0，9]）； 第10条-第19条指令为第一页（对应虚存地址为[10，19]）； … … 第310条~第319条指令为第31页（对应虚地址为[310，319]）。 按以上方式，用户指令可组成32页。

以下是Java代码实现：

import java.util.Random;

public class MemorySimulation {

    private static final int INSTRUCTION_COUNT = 320; // 指令总数
    private static final int PAGE_SIZE = 1024; // 页面大小
    private static final int MIN_USER_MEMORY_PAGES = 4; // 用户内存最小页面数
    private static final int MAX_USER_MEMORY_PAGES = 32; // 用户内存最大页面数
    private static final int VIRTUAL_MEMORY_SIZE = 32 * 1024; // 虚拟内存大小

    private static final Random random = new Random();

    public static void main(String[] args) {
        int[] instructions = generateInstructions(); // 生成指令序列
        int[] pageAddresses = transformToPageAddresses(instructions); // 将指令序列转换为页地址流
        int userMemoryPageCount = random.nextInt(MAX_USER_MEMORY_PAGES - MIN_USER_MEMORY_PAGES + 1) + MIN_USER_MEMORY_PAGES; // 随机选择用户内存页面数
        int[] userMemory = new int[userMemoryPageCount * PAGE_SIZE]; // 用户内存
        int[] virtualMemory = new int[VIRTUAL_MEMORY_SIZE]; // 虚拟内存

        int pageFaultCount = executeInstructions(pageAddresses, userMemory, virtualMemory); // 执行指令序列并统计缺页数
        System.out.println("执行指令序列完毕，缺页次数为：" + pageFaultCount);
    }

    /**
     * 生成指令序列
     */
    private static int[] generateInstructions() {
        int[] instructions = new int[INSTRUCTION_COUNT];
        int m = random.nextInt(INSTRUCTION_COUNT); // 随机选择起始指令
        int index = 0;
        while (index < INSTRUCTION_COUNT) {
            instructions[index++] = m;
            m = (m + 1) % INSTRUCTION_COUNT;
            instructions[index++] = m;
            m = random.nextInt(m + 1);
            instructions[index++] = m;
            m = (m + 1) % INSTRUCTION_COUNT;
            instructions[index++] = m;
            m = random.nextInt(INSTRUCTION_COUNT - m - 1) + m + 1;
            instructions[index++] = m;
        }
        return instructions;
    }

    /**
     * 将指令序列转换为页地址流
     */
    private static int[] transformToPageAddresses(int[] instructions) {
        int[] pageAddresses = new int[instructions.length];
        for (int i = 0; i < instructions.length; i++) {
            pageAddresses[i] = instructions[i] / PAGE_SIZE;
        }
        return pageAddresses;
    }

    /**
     * 执行指令序列并统计缺页数
     */
    private static int executeInstructions(int[] pageAddresses, int[] userMemory, int[] virtualMemory) {
        int pageFaultCount = 0;
        for (int i = 0; i < pageAddresses.length; i++) {
            int page = pageAddresses[i];
            int physicalAddress = findPhysicalAddress(page, userMemory, virtualMemory); // 查找物理地址
            if (physicalAddress == -1) { // 缺页中断
                pageFaultCount++;
                loadPage(page, userMemory, virtualMemory); // 装入页面
                physicalAddress = findPhysicalAddress(page, userMemory, virtualMemory); // 再次查找物理地址
            }
            // 执行指令
            System.out.println("执行指令，物理地址为：" + physicalAddress);
        }
        return pageFaultCount;
    }

    /**
     * 查找页对应的物理地址
     */
    private static int findPhysicalAddress(int page, int[] userMemory, int[] virtualMemory) {
        // 在用户内存中查找
        int userMemoryIndex = page * PAGE_SIZE;
        if (userMemoryIndex < userMemory.length) {
            return userMemoryIndex + random.nextInt(PAGE_SIZE);
        }
        // 在虚拟内存中查找
        int virtualMemoryIndex = page * PAGE_SIZE;
        if (virtualMemoryIndex < virtualMemory.length) {
            loadPage(page, userMemory, virtualMemory); // 装入页面
            return userMemoryIndex + random.nextInt(PAGE_SIZE);
        }
        return -1; // 未找到
    }

    /**
     * 装入页面
     */
    private static void loadPage(int page, int[] userMemory, int[] virtualMemory) {
        int virtualMemoryIndex = page * PAGE_SIZE;
        if (virtualMemoryIndex < virtualMemory.length) {
            int userMemoryIndex = random.nextInt(userMemory.length / PAGE_SIZE) * PAGE_SIZE; // 随机选择一个页面替换
            System.arraycopy(virtualMemory, virtualMemoryIndex, userMemory, userMemoryIndex, PAGE_SIZE); // 装入页面
        }
    }
}

该程序实现了生成指令序列、将指令序列转换为页地址流、执行指令序列和统计缺页数等功能，具体实现方法参见代码注释。