可变分区管理方式下最先适应分配算法

import java.util.Scanner;

class MemoryUnit{
    public boolean state = false;//内存单元的状态（0表示已使用 1表示未使用） 
}

class Memory{
    public MemoryUnit[] memories;//表示内存大小
    
    Memory（int n）{
    //初始化内存大小
        memories = new MemoryUnit[n];
        for （int i = 0; i < n; i++）{
            memories[i] = new MemoryUnit（）;
        }
    }
}

class FirstFit{//采用最先使用算法对内存进行分配
    public Memory memory;
    public int mSize;//表示内存大小
    public Job[] jobs;

    public FirstFit（int mSize Memory memory Job[] jobs）{
        this.mSize = mSize;
        this.memory = memory;
        this.jobs = jobs;
    }
    
    public void alloc（int jOrder）{//为job分配内存
        int i j k count;
        for （i = 0; i < mSize; i++）{
        //先遍历整个内存寻找最先适应的内存区域，将job装载进内存
            if（memory.memories[i].state == false）{
            //找到未被占用的第一个内存地址，并计算从这个地址开始连续单元长度
            //判断大小是否可以装载进job
                count = 0;
                for （j = i; j < mSize; j++）{
                    if（memory.memories[j].state == true）{
                        break;
                    }
                    count++;  
                }

                if（count >= jobs[jOrder].len）{
                    System.out.println（“~~~~第“ + jOrder + “个job分配成功!~~~~“）;
                    System.out.println（）;
                    jobs[jOrder].state = true;
                    jobs[jOrder].start = i;//设置job在内存中的起始单元
                //连续的内存单元长度大于job长度 可以装载进去
                    for（k = i; k < i + jobs[jOrder].len; k++）{
                        memory.memories[k].state = true;
                    }
                    emptyMemory（）;
                }
                
                //i从j的地址开始继续循环
                i = j;
            }
        }

        if （jobs[jOrder].state == false）{
            System.out.println（jOrder + “~~~~分配失败!~~~~“）;
        } 
    }

    public void back（int jOrder）{//释放job所占用的内存
        int i j endLocation = 0;
        boolean flag = false;//用来标记是否找到了下一个job

        //回收的时候只能回收到下一个job的起始位置
        for（i = jobs[jOrder].start + 1; i < mSize; i++）{
            endLocation = 0;
            for （j = 0; j < jobs.length; j++）{
                //遍历每一个job 寻找在内存中当前job的下一个job
                if （jobs[j].start == i && j != jOrder）{
                    endLocation = jobs[j].start--;
                    flag = true;
                    break;//跳出内循环
                }   
            }
            
            if（flag == true）{//如果找到了下一个job
                i = mSize;
            }
        }

         //判断endlocation是否超出当前job的地址范围
        if（endLocation > jobs[jOrder].start + jobs[jOrder].len - 1）{
            endLocation = jobs[jOrder].start + jobs[jOrder].len;
        }

        for （i = jobs[jOrder].start; i < endLocation; i++）{
            memory.memories[i].state = false;
        }
        System.out.println（“~~~~回收成功~~~~“）;
        emptyMemory（）;
    }

    public void emptyMemory（）{//打印出当前空闲的内存单元区域
        int i j k count;

        System.out.println（“<======空闲的内存区域======>“）;