模拟实现内存动态分区分配与回收(完整代码)

memory类：

package memory;
import java.util.LinkedList;
import java.util.Scanner;

public class memory {
        private int size;//内存大小
        private static final int MIN_SIZE =3;//最小剩余分区大小
        private LinkedList<Partition> mpartition;//内存分区
        private int location;//上次分配的空闲区位置

        class Partition{//分区节点类
            private int size;//分区大小
            private int head;//分区始址
            private boolean Free;//空闲状态

            public Partition(int head, int size) {
                this.head = head;
                this.size = size;
                this.Free = true;
            }
        }


        public memory(){
            this.size = 100;//默认内存大小为 100 KB
            this.location = 0;//默认上次分配的空闲区位置为0
            this.mpartition = new LinkedList<>();
            mpartition.add(new Partition(0, size));
        }
        public memory(int size) {
            this.size = size;
            this.location = 0;
            this.mpartition = new LinkedList<>();
            mpartition.add(new Partition(0, size));
        }

        //内存分配
        // size 指定需要分配的大小
        public void allocation(int size){
            System.out.println("1.首次适应算法\n2.循环首次适应算法\n3.最佳适应算法\n4.最坏适应算法");
            System.out.print("请您选择内存分配算法:");
            Scanner in = new Scanner(System.in);
            int input = in.nextInt();
            switch (input){
                case 1:
                    FristFit(size);break;
                case 2:
                    NextFit(size);break;
                case 3:
                    BestFit(size);break;
                case 4:
                    WorstFit(size);break;
                default:
                    System.out.println("请您重新选择!");
            }
        }


        //首次适应算法
        //size 指定需要分配的大小
        private void FristFit(int size){
            //遍历分区链表
            for (location = 0; location < mpartition.size(); location++){//每次从链首开始查找
                Partition temp =mpartition.get(location);
                if (temp.Free && (temp.size > size)){//找到可用空闲分区且大小足够
                    Distribute(size, location, temp);
                    return;
                }
            }
            //遍历结束后未找到可用分区, 则内存分配失败
            System.out.println("无可用内存空间!");
        }


      //循环首次适应算法
      // size 指定需要分配的大小
        private void NextFit(int size){
            Partition temp = mpartition.get(location);//从上次分配的空闲区位置开始遍历分区链表
            if (temp.Free && (temp.size > size)){
                Distribute(size, location, temp);
                return;
            }
            int length= mpartition.size();
            int i = (location + 1) % length;
            for (; i != location; i = (i+1) % length){
                temp = mpartition.get(i);
                //找到可用分区（空闲且大小足够）
                if (temp.Free && (temp.size > size)){
                    Distribute(size, i, temp);
                    return;
                }
            }
            //遍历结束后未找到可用分区, 则内存分配失败
            System.out.println("无可用内存空间!");
        }


         // 最佳适应算法
         //size 指定需要分配的大小
        private void BestFit(int size){
            int flag = -1;
            int min = this.size;
            for (location = 0; location < mpartition.size(); location++){
                Partition temp = mpartition.get(location);
                if (temp.Free && (temp.size > size)){
                    if (min > temp.size - size){
                        min = temp.size - size;
                        flag = location;
                    }
                }
            }
            if (flag == -1){
                System.out.println("无可用内存空间!");
            }else {
                Distribute(size, flag, mpartition.get(flag));
            }
        }


         //最坏适应算法
         //size 指定需要分配的大小
        private void WorstFit(int size){
            int flag = -1;
            int max = 0;
            for (location= 0; location < mpartition.size(); location++){
                Partition temp = mpartition.get(location);
                if (temp.Free && (temp.size > size)){
                    if (max < temp.size - size){
                        max = temp.size - size;
                        flag = location;
                    }
                }
            }
            if (flag == -1){
                System.out.println("无可用内存空间!");
            }else {
                Distribute(size, flag, mpartition.get(flag));
            }
        }

        //执行分配函数,size 申请大小,location 当前可用分区位置,temp 可用空闲区
        private void Distribute(int size, int location, Partition temp) {
            //如果分割后分区剩余大小过小（MIN_SIZE）则将分区全部分配，否则分割为两个分区
            if (temp.size - size <= MIN_SIZE){
                temp.Free = false;
            } else {
                Partition split = new Partition(temp.head + size, temp.size - size);
                mpartition.add(location + 1, split);
                temp.size = size;
                temp.Free = false;
            }
            System.out.println("成功分配 " + size + "KB 的内存!");
        }

         //内存回收,id 指定要回收的分区号
        public void collection(int id){
            if (id >= mpartition.size()){
                System.out.println("没有此分区号!");
                return;
            }
            Partition temp = mpartition.get(id);
            int size = temp.size;
            if (temp.Free) {
                System.out.println("分区未被分配, 无需回收");
                return;
            }
            //如果回收分区不是尾分区且后一个分区为空闲, 则与后一个分区合并（上不邻下邻或者上下都邻）
            if (id < mpartition.size() - 1 && mpartition.get(id + 1).Free){
                Partition next = mpartition.get(id + 1);
                temp.size += next.size;
                mpartition.remove(next);
            }
            //如果回收分区不是首分区且前一个分区为空闲, 则与前一个分区合并（上邻下不邻或者上下都邻）
            if (id > 0 && mpartition.get(id - 1).Free){
                Partition previous = mpartition.get(id - 1);
                previous.size += temp.size;
                mpartition.remove(id);
                id--;
            }
            mpartition.get(id).Free = true;
            System.out.println("内存回收成功!, 本次回收了 " + size + "KB 空间!");
        }

        //展示内存分区状况
        public void showmpartition(){
            System.out.println("*****************************************");
            System.out.println("分区编号\t分区始址\t分区大小\t空闲状态\t");
            for (int i = 0; i < mpartition.size(); i++){
                Partition temp = mpartition.get(i);
                System.out.println(i + "\t\t\t" + temp.head + "\t\t\t" +
                        temp.size + "\t\t\t" + temp.Free);
            }
            System.out.println("*****************************************");
        }
    }

主函数：main类

package main;
import java.util.Scanner;
import memory.memory;

public class main {
        public static void main(String[] args) {
            memory memory = null;
            Scanner in = new Scanner(System.in);
            System.out.print("请初始化内存大小:");
            int size = in.nextInt();
            memory = new memory(size);
            memory.showmpartition();
            while (true){
                System.out.println("1.申请分配空间\n2.回收已分配空间\n3.显示分区状况");
                System.out.print("请选择指令:");
                size = in.nextInt();
                switch (size) {
                    case 1:
                        System.out.print("请输入需要申请的空间大小:");
                        size = in.nextInt();
                        memory.allocation(size);
                        break;
                    case 2:
                        System.out.print("请输入需要回收的分区号:");
                        size = in.nextInt();
                        memory.collection(size);
                        break;
                    case 3:
                        memory.showmpartition();
                        break;
                    default:
                        System.out.println("请重新选择!");
                }
            }
        }
    }