java 从内存中编译 java编程简易内存池

题目描述
请实现一个简易内存池,根据请求命令完成内存分配和释放。
内存池支持两种操作命令，REQUEST和RELEASE，其格式为：
REQUEST=请求的内存大小 表示请求分配指定大小内存，如果分配成功，返回分配到的内存首地址；如果内存不足，或指定的大小为0，则输出error。
RELEASE=释放的内存首地址 表示释放掉之前分配的内存，释放成功无需输出，如果释放不存在的首地址则输出error。
注意：
1.内存池总大小为100字节。
2.内存池地址分配必须是连续内存，并优先从低地址分配。
3.内存释放后可被再次分配，已释放的内存在空闲时不能被二次释放。
4.不会释放已申请的内存块的中间地址。
5.释放操作只是针对首地址所对应的单个内存块进行操作，不会影响其它内存块。

解答要求
时间限制: 1000ms, 内存限制: 256MB
输入
首行为整数 N , 表示操作命令的个数，取值范围：0 < N <= 100。
接下来的N行, 每行将给出一个操作命令，操作命令和参数之间用 “=”分割。

输出
见题面输出要求

样例
输入样例1
2
REQUEST=10
REQUEST=20
输出样例1
0
10
输入样例2
5
REQUEST=10
REQUEST=20
RELEASE=0
REQUEST=20
REQUEST=10
输出样例2
0
10
30
0
提示
第一条指令，申请地址0~9的10个字节内存，返回首地址0
第二条指令，申请地址10~29的20字节内存，返回首地址10
第三条指令，释放首地址为0的内存申请，0~9地址内存被释放，变为空闲，释放成功，无需输出
第四条指令，申请20字节内存，0_{9地址内存连续空间不足20字节，往后查找到30}49地址，返回首地址30
第五条指令，申请10字节，0~9地址内存空间足够，返回首地址0

代码实现：

import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {
    static class AllocatedMemory {
        private List<Integer[]> free;
        private List<Integer[]> busy;
        AllocatedMemory() {
            free = new ArrayList<>();
            busy = new ArrayList<>();
            Integer[] info=new Integer[2];
            info[0]=0;info[1]=100;
            free.add(info);
        }
        // 返回分配的内存首地址(string)，失败返回字符串 "error"
        String request(int size) {
            if(size<=0) return "error";
            int removeIndex=-1;
            for(int i=0;i<free.size();i++){
                Integer[] info=free.get(i);
                if(info[1]-info[0]>=size){
                    removeIndex=i;
                    break;
                }
            }
            if(removeIndex!=-1){
                Integer[] info=free.get(removeIndex);
                Integer[] res=new Integer[2];
                res[0]=info[0];res[1]=info[0]+size;
                if(info[1]-info[0]-size>0){
                    free.get(removeIndex)[0]=info[0]+size;
                }else{
                    free.remove(removeIndex);
                }
                busy.add(res);
                return res[0].toString();
            }
            // 在此补充你的代码
            return "error";
        }
        void changeFree(int start,int end){
            int index;
            for(index=0;index<free.size();index++){
                Integer[] info = free.get(index);
                if(info[0]>start) break;
            }
            Integer[] info=new Integer[2];
            info[0]=start;info[1]=end;
            free.add(index,info);

            // 整理碎片
            boolean change=true;
            while(change){
                change=false;
                int i;
                for(i=1;i<free.size();i++){
                    if (free.get(i)[0] == free.get(i - 1)[1]) {
                        change=true;
                        break;
                    }
                }
                if(change) {
                    free.get(i)[0] = free.get(i - 1)[0];
                    free.remove(i - 1);
                }
            }
        }
        // 成功返回 true；失败返回 false，失败时框架会自动输出 "error"
        boolean release(int startAddress) {
            int removeIndex=-1;
            for(int i=0;i<busy.size();i++){
                Integer[] info = busy.get(i);
                if (info[0] == startAddress) {
                    removeIndex=i;
                    break;
                }
            }
            if (removeIndex != -1) {
                Integer[] info = busy.get(removeIndex);
                changeFree(info[0], info[1]);
                busy.remove(removeIndex);
                return true;
            }
            // 在此补充你的代码
            return false;
        }
    }

    public static void main(String[] args) {
        AllocatedMemory allocatedMemory = new AllocatedMemory();
        Scanner cin = new Scanner(System.in, StandardCharsets.UTF_8.name());
        int line = Integer.parseInt(cin.nextLine());
        String[][] ins = new String[line][2];
        for (int i = 0; i < line; i++) {
            ins[i] = cin.nextLine().split("=");
            if (ins[i][0].startsWith("REQUEST")) {
                System.out.println(allocatedMemory.request(Integer.parseInt(ins[i][1])));
            } else {
                boolean ret = allocatedMemory.release(Integer.parseInt(ins[i][1]));
                if (!ret) {
                    System.out.println("error");
                }
            }
        }

        cin.close();
    }
}