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("请重新选择!");
}
}
}
}