用Java实现动态内存分配_操作系统java写的动态内存分配

网上的代码大多是c的，而且java的只是直接分配，没有实现最佳算法，最坏算算法，首次循环，首次算等，我就写了一个，希望大家顶一下，有截图，希望大家顶一下

1.[文件] 2.java ~ 1016B     下载(55)

package Testdemo4;

public class Partation {

private int startAddress ;

private int endAddress ;

private int Id ;//根据下表获取元素

private int Size ;//集合长度

String name;

String state="未完成";

int bottom = 1;//bottom=1表示可以加载，而bottom=0表示不能再加载

public Partation(){}

public Partation(int Id,String name,int Size){

this.Id=Id;

this.Size=Size;

this.name = name;

this.state = "完成";

}

public int getStartAddress() {

return startAddress;

}

public void setStartAddress(int startAddress) {

this.startAddress = startAddress;

}

public int getEndAddress() {

return endAddress;

}

public void setEndAddress(int endAddress) {

this.endAddress = endAddress;

}

public int getId() {

return Id;

}

public void setId(int id) {

Id = id;

}

public int getSize() {

return Size;

}

public void setSize(int size) {

Size = size;

}

public String toString(){

return "分区"+this.getId()+""+"分区大小是："+this.getSize();

}

}

2.[文件] 3.java ~ 5KB     下载(43)

package Testdemo4;

import java.util.ArrayList;

import javax.swing.JOptionPane;

public class ParView {

ArrayList list;

public void menu(){

while(true){

String notice = JOptionPane.showInputDialog("1.分配资源\n2.回收资源\n3.查看分配\n0.退出");

int s=Integer.parseInt(notice);

if(s==1){

operate();

continue;

}else if(s==2){

remove();

continue;

}else if(s==3){

show();

continue;

}else if(s==4){

exit();

continue;

}else{

break;

}

}

}

public void operate(){

list=new ArrayList();

int num=0;

try {

num=Integer.parseInt(JOptionPane.showInputDialog("请输入你的分区个数"));

} catch (Exception e) {

System.out.println("输入错误！！");

}

for (int i = 0; i < num; i++) {

String name=JOptionPane.showInputDialog("请输入分区编号");

int Size=Integer.parseInt(JOptionPane.showInputDialog("请输入分区的大小"));

list.add(new Partation(i,name,Size));

}

boolean flag=true;

String info = "------------ 选择动态分区算法 ------------\n" +

"1- 首次适应算法\n"+

"2- 最佳适应算法\n"+

"3- 最坏适应算法\n"+

"4- 循环首次适应算法\n"+

"5- 设置最小碎片的大小(默认为"+ParTest.g+")\n"+

"6- 选择继续\n"+

"7-退出程序\n";

while(flag){

char changce=JOptionPane.showInputDialog(info).trim().charAt(0);

switch(changce){

case '1':

startFirstFit() ;

break;

case '2':

startBestFit() ;

break;

case '3':

startWorstFit() ;

break;

case '4':

startCycleFirstFit() ;

break;

case '5':

changeG() ;

System.out.println(ParTest.g);

break;

case '6':

menu();

case '7':

System.exit(0) ;

}

}

}

public void remove () {

list=new ArrayList();

Partation p=new Partation();

String content = "| "+"分区号 "+

" | "+"作业名"+

" | "+"起始地址"+

" | "+"结束地址"+

" | "+"分区大小"+

" | "+"状态"+" |";

for (int i=0; i

content+="\n| "+(i+1)+" | ";

content+=list.get(i).name+" | ";

content+=list.get(i).getStartAddress()+" | ";

content+=list.get(i).getEndAddress()+" | ";

content+=list.get(i).getSize()+"KB | ";

content+=list.get(i).state+" | ";

}

String id = JOptionPane.showInputDialog(content + "\n请输入要回收的作业编号：");

if (Integer.parseInt(id)==p.getId()) {

//list.get(Integer.parseInt(id)-1).bottom=1;//1代表可以继续追加

//}

list.remove(Integer.parseInt(id));

JOptionPane.showMessageDialog(null, "回收成功！");

}

}

public void show(){

list=new ArrayList();

String content = "| "+"分区号"+

" | "+"作业名"+

" | "+"起始地址"+

" | "+"结束地址"+

" | "+"分区大小"+

" | "+"状态"+" |";

for (int i=0; i

content+="\n|"+(i+1)+" | ";

content+=list.get(i).name+" | ";

content+=list.get(i).getStartAddress()+" | ";

content+=list.get(i).getStartAddress()+" | ";

content+=list.get(i).getSize()+"KB | ";

content+=list.get(i).state+" | ";

}

JOptionPane.showMessageDialog(null, content,"内存分配情况",JOptionPane.INFORMATION_MESSAGE);

}

public void exit(){

list=new ArrayList();

list.clear();

}

public void startFirstFit(){

int Size = 0 ;

Size = Integer.parseInt(JOptionPane.showInputDialog("请输入所需分区的大小") ) ;

ParTest.首次适应(list, Size);

//System.out.println("===========================");

print(list) ;

}

public void startBestFit(){

int Size = 0 ;

Size = Integer.parseInt(JOptionPane.showInputDialog("请输入所需分区的大小") ) ;

ParTest.最佳适应(list, Size);

//System.out.println("===========================");

print(list) ;

}

public void startWorstFit(){

int Size = 0 ;

Size = Integer.parseInt(JOptionPane.showInputDialog("请输入所需分区的大小") ) ;

ParTest.最坏适应(list, Size);

//System.out.println("===========================");

print(list) ;

}

public void startCycleFirstFit(){

int Size = 0 ;

Size = Integer.parseInt(JOptionPane.showInputDialog("请输入所需分区的大小") ) ;

ParTest.循环首次(list, Size);

//System.out.println("===========================");

print(list) ;

}

public void changeG(){

int size = 0 ;

size = Integer.parseInt(JOptionPane.showInputDialog("请输入最小碎片大小")) ;

ParTest.g = size ;

}

public void print(ArrayList list){

String info="";

for (Partation partation : list) {

info+=partation+"\n";

}

JOptionPane.showMessageDialog(null, info);

}

}

3.[文件] 2 (2).java ~ 3KB     下载(43)

package Testdemo4;

import java.util.ArrayList;

import Testdemo4.Partation;

public class ParTest {

public static int g = 15 ;//默认的

private static int index = 0 ;

/***********最佳适应算法**************/

public static void 最佳适应(ArrayList list, int needSize) {

sortSmallToLarge(list);//每次分配最小的

setSize(list,needSize) ;

sortIDSmallToLarge(list);

}

/***********最坏适应算法**************/

public static void 最坏适应(ArrayList list, int needSize) {

sortLargeToSmall(list);//每次分配最大的

setSize(list,needSize) ;

sortIDSmallToLarge(list);

}

/***********首次适应算法**************/

public static void 首次适应(ArrayList list, int needSize) {

setSize(list,needSize) ;//找出一个能满足要求的空闲分区给所需要的请求

sortIDSmallToLarge(list);//地址由低到高

}

/***********循环首次适应算法**************/

public static void 循环首次(ArrayList list, int needSize) {

/**** 这里要设置一个参数，如果分配后小于这个参数，那么就不进行分配，反之还是可以进行分配的 ****/

index++ ;

if(index == list.size()-1){

//list.size() = index+1，所以通过等于判断前一个分配的分区是否是List中的最后一个

index = 0;

}

setIndexSize(list, needSize,index) ;//设置参数，就是分配后还剩余的空间

sortIDSmallToLarge(list);

}

/***********设置大小**************/

public static void setSize(ArrayList list, int needSize){

for (int i = 0; i < list.size(); i++) {

if (list.get(i).getSize() >= needSize) {

if ( list.get(i).getSize()-needSize <= g) {

list.get(i).setSize(0) ;

index = i ;//重新定位需要分配的地方

break ;

} else {

//从新给size赋值，创建的大小为分配后剩余的大小

list.get(i).setSize(list.get(i).getSize()-needSize );

index = i ;

break ;

}

}

}

}

public static void setIndexSize(ArrayList list, int needSize,int setIndex){

for (int i = setIndex; i < list.size(); i++) {

if (list.get(i).getSize() >= needSize) {

if ( list.get(i).getSize()-needSize <= g) {

list.get(i).setSize(0) ;

index = i ;

break ;

} else {

list.get(i).setSize(list.get(i).getSize()-needSize );

index = i ;

break ;

}

}

}

}

/***********从小到大排序**************/

public static void sortSmallToLarge(ArrayList list){

Partation p = new Partation() ;

for (int i = 0; i < list.size(); i++) {

for (int j = 0; j < list.size()-1; j++) {

if( list.get(j).getSize()> list.get(j+1).getSize() ){

//三个变量交换，排序

p = list.get(j) ;

list.set(j, list.get(j+1)) ;

list.set(j+1, p) ;

}

}

}

}

/***********Id从小到大排序**************/

public static void sortIDSmallToLarge(ArrayList list){

Partation p = new Partation() ;

for (int i = 0; i < list.size(); i++) {

for (int j = 0; j < list.size()-1; j++) {

if( list.get(j).getId() > list.get(j+1).getId() ){

p = list.get(j) ;

list.set(j, list.get(j+1)) ;

list.set(j+1, p) ;

}

}

}

}

/***********从大到小**************/

public static void sortLargeToSmall(ArrayList list){

Partation p = new Partation() ;

for (int i = 0; i < list.size(); i++) {

for (int j = 0; j < list.size()-1; j++) {

if( list.get(j).getSize() > list.get(j+1).getSize() ){

p = list.get(j+1) ;

list.set(j+1, list.get(j)) ;

list.set(j, p) ;

}

}

}

}

}

4.[文件] 4.java ~ 128B     下载(39)

package Testdemo4;

public class Test {

public static void main(String[] args) {

ParView p=new ParView();

p.menu();

}

}

5.[图片] 33.png

6.[图片] 44.png

7.[图片] 88.png