用Java来实现非连续储存分配

非连续储存分配是指将一个进程分配到多个不连续的物理内存块中，通常用于解决内存碎片问题。在Java中，可以使用数组来模拟非连续储存分配。

首先，定义一个内存块类，包含开始地址、结束地址和是否被占用的属性：

class MemoryBlock {
    int startAddr;
    int endAddr;
    boolean isOccupied;
    
    public MemoryBlock(int startAddr, int endAddr, boolean isOccupied) {
        this.startAddr = startAddr;
        this.endAddr = endAddr;
        this.isOccupied = isOccupied;
    }
}

然后，定义一个内存管理类，包含一个内存块数组和一个分配方法：

class MemoryManager {
    MemoryBlock[] memoryBlocks;
    
    public MemoryManager(int size) {
        memoryBlocks = new MemoryBlock[size];
        memoryBlocks[0] = new MemoryBlock(0, size - 1, false);
    }
    
    public int allocate(int size) {
        for (int i = 0; i < memoryBlocks.length; i++) {
            if (!memoryBlocks[i].isOccupied && memoryBlocks[i].endAddr - memoryBlocks[i].startAddr + 1 >= size) {
                int startAddr = memoryBlocks[i].startAddr;
                memoryBlocks[i].isOccupied = true;
                if (memoryBlocks[i].endAddr - memoryBlocks[i].startAddr + 1 == size) {
                    // 如果当前空闲块大小等于请求大小，则直接返回起始地址
                    return startAddr;
                } else {
                    // 否则，将当前空闲块分割成两个块
                    memoryBlocks[i].startAddr += size;
                    memoryBlocks[i+1] = new MemoryBlock(startAddr, startAddr + size - 1, true);
                    if (i < memoryBlocks.length - 2 && !memoryBlocks[i+2].isOccupied) {
                        // 如果分割后的空闲块和下一个空闲块相邻，则合并它们
                        memoryBlocks[i+1].endAddr = memoryBlocks[i+2].endAddr;
                        memoryBlocks[i+1].isOccupied = false;
                        for (int j = i+2; j < memoryBlocks.length; j++) {
                            memoryBlocks[j-1] = memoryBlocks[j];
                        }
                        memoryBlocks[memoryBlocks.length-1] = null;
                    }
                    return startAddr;
                }
            }
        }
        return -1;
    }
}

在这个分配方法中，首先遍历内存块数组，找到一个未被占用的空闲块，并且大小大于等于请求的大小。如果找到了这样的块，则将它标记为占用，并返回它的起始地址。

如果找到的空闲块大小恰好等于请求的大小，则直接返回起始地址。

如果找到的空闲块大小大于请求的大小，则将它分割成两个块。第一个块的大小等于请求的大小，被标记为占用；第二个块的大小等于原来的大小减去请求的大小，被标记为未占用，并插入到数组中，保证数组按照起始地址递增排序。

如果分割后的空闲块和下一个空闲块相邻，则将它们合并成一个块。

如果没有找到合适的空闲块，则返回-1表示分配失败。

使用示例：

MemoryManager manager = new MemoryManager(100);
int addr1 = manager.allocate(20);
int addr2 = manager.allocate(30);
int addr3 = manager.allocate(10);
System.out.println(addr1); // 输出0
System.out.println(addr2); // 输出20
System.out.println(addr3); // 输出50