如何在Java中停止或清除BuffereImage

我目前正在尝试使用键盘上的enter键为我的java platformer游戏创建一个重置按钮。我的级别加载的方式是作为

buffereImage

对象，通过名为

LoadImageLevel

的方法传递。我试着做的只是说

if(key == KeyEvent.VK_ENTER){ LoadImageLevel(level)}  

其中级别是存储级别的my

BuffereImage

对象。这会在按键时重置关卡，但一旦关卡重置几次，游戏就会变得非常缓慢，角色无法移动，因为它太慢了

我想这是因为每次我重置关卡时，它都会把图像放在彼此的上面，直到它一次做的太多，所以会减慢游戏的速度

我一直在环顾四周，看看是否有办法在每次重置级别时清除以前的BuffereImage，以便一次只运行一个图像，从而保持游戏的最新速度。。。我希望如此。不幸的是，

BufferedImage

类中没有

clear（）

或

remove（）

方法，因此我无法创建一个

任何帮助都将不胜感激，谢谢

    package com.tim.neon.window;

import java.awt.Canvas;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
//import java.awt.event.KeyEvent;
import java.awt.image.BufferStrategy;
import java.awt.image.BufferedImage;
import java.util.Random;

//import com.tim.neon.framework.GameObject;
import com.tim.neon.framework.KeyInput;
import com.tim.neon.framework.ObjectId;
import com.tim.neon.objects.Block;
import com.tim.neon.objects.Player;

//Developed by Timothy O'Leary with much help from RealTutsGML

public class Game extends Canvas implements Runnable {

    /**
     * 
     */
    private static final long serialVersionUID = 5023365827045558937L;

    private boolean running = false;
    private Thread thread;

    public static int WIDTH, HEIGHT;

    private BufferedImage level = null;  

    Handler handler;
    Camera cam;

    Random rand = new Random();

    private void init(){
        WIDTH = getWidth();
        HEIGHT = getHeight();

        BufferedImageLoader loader = new BufferedImageLoader();
        level = loader.loadImage("/level2.png");//loading the level

        handler = new Handler();

        cam = new Camera(0, 0);

        LoadImageLevel(level);

        this.addKeyListener(new KeyInput(handler));



    }

    public synchronized void start(){
        if(running)
            return;

        running = true;
        thread = new Thread(this);
        thread.start();

    }

    public void run(){

        init(); //
        this.requestFocus(); //
        long lastTime = System.nanoTime();
        double amountOfTicks = 60.0;
        double ns = 1000000000 / amountOfTicks;
        double delta = 0;
        long timer = System.currentTimeMillis();
        int updates = 0;
        int frames = 0;
        while(running){
            long now = System.nanoTime();
            delta += (now - lastTime) / ns;
            lastTime = now;
            while(delta >= 1){
                tick();
                updates++;
                delta--;
            }
            render();
            frames++;

            if(System.currentTimeMillis() - timer > 1000){
                timer += 1000;
                System.out.println("FPS: " + frames + " Ticks: " + updates);
                frames = 0;
                updates = 0;
            }
        }   
    }

    private void tick(){
        handler.tick();
        for(int i = 0; i < handler.object.size(); i++){
            if(handler.object.get(i).getId() == ObjectId.Player){
                cam.tick(handler.object.get(i));
            }
        }
    }

    private void render(){
        BufferStrategy bs = this.getBufferStrategy();
        if(bs == null){
            this.createBufferStrategy(3);
            return;
        }
        Graphics g = bs.getDrawGraphics();
        Graphics2D g2d = (Graphics2D) g;
        //////////////////////////

        //draw here
        g.setColor(Color.black);
        g.fillRect(0, 0, getWidth(), getHeight());

        g2d.translate(cam.getX(), cam.getY());//begin of cam

        handler.render(g);

        g2d.translate(-cam.getX(), -cam.getY());//end of cam
        /////////////////////////
        g.dispose();
        bs.show();

    }

    private void LoadImageLevel(BufferedImage image){//function to load levels drawn pixel by pixel in paint
        int w = image.getWidth();
        int h = image.getHeight();
        System.out.println("width, height:" + " " + w + " " + h);

        for(int xx = 0; xx < h; xx++){
            for(int yy = 0; yy < w; yy++){
                int pixel = image.getRGB(xx, yy);
                int red = (pixel >> 16) & 0xff;
                int green = (pixel >> 8) & 0xff;
                int blue = (pixel) & 0xff;

                if(red == 255 && green == 255 && blue == 255) handler.addObject(new Block(xx*32, yy*32, ObjectId.Block));
                if(red == 0 && green == 0 && blue == 255) handler.addObject(new Player(xx*32, yy*32,handler, ObjectId.Player));
            }
        }
    }


    public static void main(String args[]){
        new Window(800, 600, "Neon Platform Game Prototype", new Game());
    }
}
    package com.tim.neon.framework;

import java.awt.Component;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.image.BufferedImage;

import com.tim.neon.objects.Block;
import com.tim.neon.objects.Player;
import com.tim.neon.window.BufferedImageLoader;
import com.tim.neon.window.Game;
import com.tim.neon.window.BufferedImageLoader;
import com.tim.neon.window.Handler;
import com.tim.neon.window.Game;
import com.tim.neon.window.Window;

public class KeyInput extends KeyAdapter {

    Handler handler;

    //public BufferedImage level = null;//i added

    public KeyInput(Handler handler){
        this.handler = handler;
    }


    public void keyPressed(KeyEvent e){
        int key = e.getKeyCode();

        //BufferedImageLoader loader = new BufferedImageLoader();///
        //level = loader.loadImage("/level2.png");//loading the level///

        for(int i = 0; i < handler.object.size(); i++){
            GameObject tempObject = handler.object.get(i);

            if(tempObject.getId() == ObjectId.Player){
                if(key == KeyEvent.VK_D) tempObject.setVelX(5);
                if(key == KeyEvent.VK_A) tempObject.setVelX(-5);
                if(key == KeyEvent.VK_SPACE && !tempObject.isJumping()){//for double jump do if(key == KeyEvent.VK.SPACE) tempObject.setVelY(-15)
                    tempObject.setJumping(true);
                    tempObject.setVelY(-15);//change number to increase or decrease jump height
                }
            }
        }

        if(key == KeyEvent.VK_ESCAPE){
            System.exit(1);
        }
        //if(key == KeyEvent.VK_ENTER){/// trying to make reset button
        //  level.repaint();
        //}///
    }

    public void keyReleased(KeyEvent e){
int key = e.getKeyCode();

        for(int i = 0; i < handler.object.size(); i++){
            GameObject tempObject = handler.object.get(i);

            if(tempObject.getId() == ObjectId.Player){
                if(key == KeyEvent.VK_D) tempObject.setVelX(0);
                if(key == KeyEvent.VK_A) tempObject.setVelX(0);
            }
        }
    }

    /*private void LoadImageLevel(BufferedImage image){// this function is used in both this clas and the Game class
        int w = image.getWidth();
        int h = image.getHeight();
        System.out.println("width, height:" + " " + w + " " + h);

        for(int xx = 0; xx < h; xx++){
            for(int yy = 0; yy < w; yy++){
                int pixel = image.getRGB(xx, yy);
                int red = (pixel >> 16) & 0xff;
                int green = (pixel >> 8) & 0xff;
                int blue = (pixel) & 0xff;

                if(red == 255 && green == 255 && blue == 255) handler.addObject(new Block(xx*32, yy*32, ObjectId.Block));
                if(red == 0 && green == 0 && blue == 255) handler.addObject(new Player(xx*32, yy*32,handler, ObjectId.Player));
            }
        }
    }*/

}

package com.tim.neon.window；
导入java.awt.Canvas；
导入java.awt.Color；
导入java.awt.Graphics；
导入java.awt.Graphics2D；
//导入java.awt.event.KeyEvent；
导入java.awt.image.BufferStrategy；
导入java.awt.image.buffereImage；
导入java.util.Random；
//导入com.tim.neon.framework.GameObject；
导入com.tim.neon.framework.KeyInput；
导入com.tim.neon.framework.ObjectId；
导入com.tim.neon.objects.Block；
导入com.tim.neon.objects.Player；
//由Timothy O'Leary在RealTutsGML的帮助下开发
公共类游戏扩展画布实现可运行{
/**
* 
*/
私有静态最终长serialVersionUID=5023365827045558937L；
私有布尔运行=false；
私有线程；
公共静态int宽度、高度；
私有缓冲区映像级别=null；
处理者；
摄像机；
Random rand=新的Random（）；
私有void init（）{
宽度=getWidth（）；
高度=getHeight（）；
BufferedImageLoader=新的BufferedImageLoader（）；
level=loader.loadImage（“/level2.png”）；//加载级别
handler=新的handler（）；
cam=新摄像头（0,0）；
LoadImageLevel（级别）；
this.addKeyListener（新的KeyInput（处理程序））；
}
公共同步的void start（）{
如果（正在运行）
返回；
运行=真；
线程=新线程（此）；
thread.start（）；
}
公开募捐{
init（）//
this.requestFocus（）//
long lastTime=System.nanoTime（）；
双amountOfTicks=60.0；
双ns=1000000000/个；
双增量=0；
长定时器=System.currentTimeMillis（）；
int=0；
int帧=0；
（跑步时）{
long now=System.nanoTime（）；
增量+=（现在-上次）/ns；
上次=现在；
而（增量>=1）{
勾选（）；
更新++；
三角洲--；
}
render（）；
frames++；
if（System.currentTimeMillis（）-计时器>1000）{
定时器+=1000；
System.out.println（“FPS:+frames+”Ticks:+updates）；
帧=0；
更新=0；
}
}   
}
私人空白勾号（）{
handler.tick（）；
对于（int i=0；i>16）和0xff；
绿色整数=（像素>>8）&0xff；
蓝色整数=（像素）&0xff；
if（红色==255&&绿色==255&&蓝色==255）handler.addObject（新块（xx*32，yy*32，ObjectId.Block））；
if（红色==0&&绿色==0&&蓝色==255）handler.addObject（新播放器（xx*32，yy*32，handler，ObjectId.Player））；
}
}
}
公共静态void main（字符串参数[]）{
新窗口（800600，“霓虹平台游戏原型”，新游戏（））；
}
}
包com.tim.neon.framework；
导入java.awt.Component；
导入java.awt.event.KeyAdapter；
导入java.awt.event.KeyEvent；
导入java.awt.image.buffereImage；
导入com.tim.neon.objects.Block；
导入com.tim.neon.objects.Player；
导入com.tim.neon.window.BufferedImageLoader；
导入com.tim.neon.window.Game；
导入com.tim.neon.window.BufferedImageLoader；
导入com.tim.neon.window.Handler；
导入com.tim.neon.window.Game；
导入com.tim.neon.window.window；
公共类KeyInput扩展了KeyAdapter{
处理者；
//public buffereImage level=null；//我添加了
公钥输入（处理程序）{
this.handler=handler；
}
按下公共无效键（按键事件e）{