使用arraylist从jpanel中删除矩形 ”包javaapplication12； 导入java.awt.*； 导入java.awt.event.KeyEvent； 导入java.awt.event.KeyListener； 导入java.awt.g

使用arraylist从jpanel中删除矩形

”包javaapplication12；
导入java.awt.*；
导入java.awt.event.KeyEvent；
导入java.awt.event.KeyListener；
导入java.awt.geom.Ellipse2D；
导入java.awt.geom.Rectangle2D；
导入java.awt.geom.RoundRectangle2D；
导入java.util.ArrayList；
导入java.util.Iterator；
导入javax.swing.*；
/**通过自定义线程反弹球（动画）*/
公共类JavaApplication12扩展JFrame实现KeyListener{
//定义命名常量
专用静态最终整型画布宽度=640；
专用静态最终整型画布高度=480；
私有静态最终整型更新\u间隔=30；//毫秒
int xx=200；
int yy=400；
形状a1；
形状a2；
矩形2D a3；
矩形2D a12；
矩形；
矩形；
矩形2D a6；
矩形2D a7；
矩形2D a8；
矩形2D a9；
矩形2D a10；
矩形2D a11；
矩形2D a13；
矩形2D a14；
矩形2D a15；
矩形2D a16；
矩形2D a17；
矩形2D a18；
矩形2D a19；
矩形2D a20；
矩形2D a21；
矩形2D a22；
矩形2D a23；
矩形2D a25；
ArrayList s=新的ArrayList（）；
颜色c2=颜色。红色；
私有DrawCanvas；//绘图画布（扩展JPanel）
//运动对象的属性
private int x=375；//左上角（x，y）
私人int y=355；
私有int size=20；//宽度和高度
private int xSpeed=3；//在x和y方向上的移动速度
private int ySpeed=5；//x和y中每一步的位移
/**构造函数来设置GUI组件*/
公共JavaApplication12（）{
画布=新的DrawCanvas（）；
setPreferredSize（新维度（画布宽度、画布高度））；
这个.setContentPane（画布）；
此.setDefaultCloseOperation（关闭时退出）；
这个包（）；
这是setTitle（“弹跳球”）；
此.setVisible（true）；
addKeyListener（此）；
乐趣（）；
//创建一个新线程以定期运行更新
Thread updateThread=新线程（）{
@凌驾
公开募捐{
while（true）{
update（）；//更新（x，y）位置
repaint（）；//刷新JFrame。回调paintComponent（）
试一试{
//延迟并给其他线程一个运行的机会
Thread.sleep（更新间隔）；//毫秒
}捕获（中断异常忽略）{}
}
}
};
updateThread.start（）；//调用回运行（）
}
/**更新移动对象的（x，y）位置*/
公共无效更新（）{
x+=x速度；
y+=y速度；
如果（x>CANVAS|u WIDTH-size | x<0）{
xSpeed=-xSpeed；
}
如果（y>CANVAS|U高度-大小| y<0）{
ySpeed=-ySpeed；
}
}
@凌驾
public void keyTyped（KeyEvent ke）{
}
@凌驾
按下公共无效键（KeyEvent ke）{
int keycode=ke.getKeyCode（）；
if（keycode==KeyEvent.VK_左）
{
xx=xx-15；
}
if（keycode==KeyEvent.VK_RIGHT）
{
xx=xx+15；
}
}
@凌驾
公开无效密钥已释放（密钥事件）{
//抛出新的UnsupportedOperationException（“尚未支持”）；
}
/**DrawCanvas（内部类）是用于自定义绘图的JPanel*/
类DrawCanvas扩展了JPanel{
私有静态最终长serialVersionUID=1L；
@凌驾
公共组件（图形g）{
super.paintComponent（g）；//绘制父对象的背景
图形2d=（图形2d）g；
用于（二维矩形：s）{
d、 填充（r）；
}
挫折背景（颜色：黑色）；
g、 setColor（Color.BLUE）；
a1=新的椭圆E2D双精度（x，y，尺寸，尺寸）；
a2=新的圆形矩形2D.双（xx，yy，120,10,20,20）；
a25=新的矩形2D双（530120100,20）；
d、 填料（a1）；
d、 setPaint（c2）；
d、 填料（a2）；
if（a1.相交（a3.getBounds（）））
{
s、 移除（a3）；ySpeed=-ySpeed；
}
if（a1.相交（a4.getBounds（）））
{
s、 移除（a4）；ySpeed=-ySpeed；
}
if（a1.相交（a5.getBounds（）））
{
s、 移除（a5）；ySpeed=-ySpeed；
}
if（a1.相交（a6.getBounds（）））
{
s、 移除（a6）；ySpeed=-ySpeed；
}
if（a1.相交（a7.getBounds（）））
{
s、 移除（a7）；ySpeed=-ySpeed；
}
if（a1.相交（a8.getBounds（）））
{
s、 移除（a8）；ySpeed=-ySpeed；
}
if（a1.相交（a9.getBounds（）））
{
s、 移除（a9）；ySpeed=-ySpeed；
}
if（a1.相交（a10.getBounds（）））
{
s、 移除（a10）；ySpeed=-ySpeed；
}
if（a1.相交（a11.getBounds（）））
{
s、 移除（a11）；ySpeed=-ySpeed；
}
if（a1.相交（a12.getBounds（）））
{
s、 移除（a12）；ySpeed=-ySpeed；
}
if（a1.相交（a13.getBounds（）））
{
s、 移除（a13）；ySpeed=-ySpeed；
}
if（a1.相交（a14.getBounds（）））
{
s、 移除（a14）；ySpeed=-ySpeed；
}
if（a1.相交（a15.getBounds（）））
{
s、 移除（a15）；ySpeed=-ySpeed；
}
if（a1.相交（a16.getBounds（）））
{
s、 移除（a16）；ySpeed=-ySpeed；
}
if（a1.相交（a17.getBounds（）））
{
s、 移除（a17）；ySpeed=-ySpeed；
}
if（a1.相交（a18.getBounds（）））
{
s、 移除（a18）；ySpeed=-ySpeed；
}
if（a1.相交（a19.getBounds（）））
{
s、 移除（a19）；ySpeed=-ySpeed；
}
if（a1.相交（a20.getBounds（）））
{
s、 移除（a20）；ySpeed=-ySpeed；
}
如果（a1.相交（a21））
{
s、 移除（a21）；ySpeed=-ySpeed；
}
if（a1.相交（a22））
{
s、 移除（a21）；ySpeed=-ySpeed；
ySpeed=-ySpeed；
}
碰撞（）；
}
}
公开决赛
{
a3=新矩形2D双（20,15100,20）；
a4=新矩形2D双（150,15100,20）；
a5=新矩形2D双（280,15100,20）；
a6=新矩形2D双（400,15100,20）；
a7=新矩形2D双（530,15100,20）；
a8=新矩形2D双（20,50100,20）；
a9=新矩形2D双（150,50100,20）；
a10=新矩形2D双（280,50100，
'package javaapplication12;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Rectangle2D;
import java.awt.geom.RoundRectangle2D;
import java.util.ArrayList;
import java.util.Iterator;
import javax.swing.*;

/** Bouncing Ball (Animation) via custom thread */
public class JavaApplication12 extends JFrame implements KeyListener{
// Define named-constants
private static final int CANVAS_WIDTH = 640;
private static final int CANVAS_HEIGHT = 480;
private static final int UPDATE_INTERVAL = 30; // milliseconds
int xx = 200;
int yy = 400;
Shape a1;
Shape a2;
Rectangle2D a3;

Rectangle2D a12;
Rectangle2D a4;
Rectangle2D a5;
Rectangle2D a6;
Rectangle2D a7;
Rectangle2D a8;
Rectangle2D a9;
Rectangle2D a10;
Rectangle2D a11;
Rectangle2D a13;
Rectangle2D a14;
Rectangle2D a15;
Rectangle2D a16;
Rectangle2D a17;
Rectangle2D a18;
Rectangle2D a19;
Rectangle2D a20;
Rectangle2D a21;
Rectangle2D a22;
Rectangle2D a23;
Rectangle2D a25;
ArrayList<Rectangle2D> s = new ArrayList<Rectangle2D>();

Color c2 = Color.RED;

private DrawCanvas canvas; // the drawing canvas (extends JPanel)

// Attributes of moving object
private int x = 375;     // top-left (x, y)
private int y = 355;
private int size = 20;  // width and height
private int xSpeed = 3;  // moving speed in x and y directions
private int ySpeed = 5;  // displacement per step in x and y


 /** Constructor to setup the GUI components */
public JavaApplication12() {
  canvas = new DrawCanvas();
  canvas.setPreferredSize(new Dimension(CANVAS_WIDTH, CANVAS_HEIGHT));
  this.setContentPane(canvas);
  this.setDefaultCloseOperation(EXIT_ON_CLOSE);
  this.pack();
  this.setTitle("Bouncing Ball");
  this.setVisible(true);
  addKeyListener(this);
  fun();

 // Create a new thread to run update at regular interval
  Thread updateThread = new Thread() {
     @Override
     public void run() {
        while (true) {
           update();   // update the (x, y) position

           repaint();  // Refresh the JFrame. Called back paintComponent()

           try {
              // Delay and give other thread a chance to run
              Thread.sleep(UPDATE_INTERVAL);  // milliseconds
           } catch (InterruptedException ignore) {}
        }
     }
  };
  updateThread.start(); // called back run()
}

/** Update the (x, y) position of the moving object */
public void update() {
  x += xSpeed;
  y += ySpeed;
  if (x > CANVAS_WIDTH - size || x < 0) {
     xSpeed = -xSpeed;
  }
  if (y > CANVAS_HEIGHT - size || y < 0) {
     ySpeed = -ySpeed;
  }
}

@Override
public void keyTyped(KeyEvent ke) {
}

@Override
public void keyPressed(KeyEvent ke) {
    int keycode = ke.getKeyCode();
       if(keycode == KeyEvent.VK_LEFT)
       {
          xx = xx-15;
       }

       if(keycode == KeyEvent.VK_RIGHT)
       {
         xx = xx+15;
       }

}

@Override
public void keyReleased(KeyEvent ke) {
   // throw new UnsupportedOperationException("Not supported yet.");
}

/** DrawCanvas (inner class) is a JPanel used for custom drawing */
class DrawCanvas extends JPanel {
    private static final long serialVersionUID = 1L;
    @Override

  public void paintComponent(Graphics g) {
     super.paintComponent(g);  // paint parent's background
  Graphics2D d = (Graphics2D)g; 


  for(Rectangle2D r : s){
            d.fill(r);
        }
     setBackground(Color.BLACK);

     g.setColor(Color.BLUE);
     a1 = new Ellipse2D.Double(x,y,size,size);
     a2 = new RoundRectangle2D.Double(xx,yy,120,10,20,20);

     a25 = new Rectangle2D.Double(530,120,100,20);



     d.fill(a1);
     d.setPaint(c2);
      d.fill(a2);

     if(a1.intersects(a3.getBounds()))
     {


         s.remove(a3);ySpeed = -ySpeed;

     }
     if(a1.intersects(a4.getBounds()))
     {
         s.remove(a4);ySpeed = -ySpeed;
     }
     if(a1.intersects(a5.getBounds()))
     {
         s.remove(a5);ySpeed = -ySpeed;
     }
     if(a1.intersects(a6.getBounds()))
     {
         s.remove(a6);ySpeed = -ySpeed;
     }
     if(a1.intersects(a7.getBounds()))
     {
         s.remove(a7);ySpeed = -ySpeed;
     }
     if(a1.intersects(a8.getBounds()))
     {
         s.remove(a8);ySpeed = -ySpeed;

     }
     if(a1.intersects(a9.getBounds()))
     {
         s.remove(a9);ySpeed = -ySpeed;
     }
     if(a1.intersects(a10.getBounds()))
     {
         s.remove(a10);ySpeed = -ySpeed;
     }
     if(a1.intersects(a11.getBounds()))
     {
         s.remove(a11);ySpeed = -ySpeed;
     }
     if(a1.intersects(a12.getBounds()))
     {
         s.remove(a12);ySpeed = -ySpeed;
     }
     if(a1.intersects(a13.getBounds()))
     {
         s.remove(a13);ySpeed = -ySpeed;
     }
     if(a1.intersects(a14.getBounds()))
     {
         s.remove(a14);ySpeed = -ySpeed;
     }
     if(a1.intersects(a15.getBounds()))
     {
         s.remove(a15);ySpeed = -ySpeed;
     }

     if(a1.intersects(a16.getBounds()))
     {
         s.remove(a16);ySpeed = -ySpeed;
     }

     if(a1.intersects(a17.getBounds()))
     {
         s.remove(a17);ySpeed = -ySpeed;
     }

     if(a1.intersects(a18.getBounds()))
     {
         s.remove(a18);ySpeed = -ySpeed;
     }

     if(a1.intersects(a19.getBounds()))
     {
         s.remove(a19);ySpeed = -ySpeed;
     }

     if(a1.intersects(a20.getBounds()))
     {
         s.remove(a20);ySpeed = -ySpeed;
     }

     if(a1.intersects(a21))
     {
         s.remove(a21);ySpeed = -ySpeed;
     }

     if(a1.intersects(a22))
     {

       s.remove(a21);ySpeed = -ySpeed;
      ySpeed = -ySpeed;
     }
 collide();
}
}
public final void fun()
{
    a3 = new Rectangle2D.Double(20,15,100,20);
      a4 = new Rectangle2D.Double(150,15,100,20);
       a5 = new Rectangle2D.Double(280,15,100,20);



       a6 = new Rectangle2D.Double(400,15,100,20);
         a7 = new Rectangle2D.Double(530,15,100,20);

         a8 = new Rectangle2D.Double(20,50,100,20);
           a9 = new Rectangle2D.Double(150,50,100,20);
            a10 = new Rectangle2D.Double(280,50,100,20);
             a12 = new Rectangle2D.Double(400,50,100,20);
              a11 = new Rectangle2D.Double(530,50,100,20);

          a13 = new Rectangle2D.Double(20,85,100,20);
           a14 = new Rectangle2D.Double(150,85,100,20);
            a15 = new Rectangle2D.Double(280,85,100,20);
             a16 = new Rectangle2D.Double(400,85,100,20);
              a17 = new Rectangle2D.Double(530,85,100,20);

          a18 = new Rectangle2D.Double(20,120,100,20);
           a19 = new Rectangle2D.Double(150,120,100,20);
            a20 = new Rectangle2D.Double(280,120,100,20);
             a21 = new Rectangle2D.Double(400,120,100,20);
               a22 = new Rectangle2D.Double(530,120,100,20);
        s.add(a3);
        s.add(a4);
        s.add(a5);
        s.add(a6);
        s.add(a7);
        s.add(a8);
        s.add(a9);
        s.add(a10);
        s.add(a11);
        s.add(a12);
        s.add(a13);
        s.add(a14);
        s.add(a15);
        s.add(a16);
        s.add(a17);
        s.add(a18);
        s.add(a19);
        s.add(a20);
        s.add(a21);
        s.add(a22);
}

  public void collide()
   {

   if(a2.intersects(a1.getBounds()))
     {
         xSpeed = +xSpeed;
         ySpeed = -ySpeed;

      }
    }
 public static void main(String[] args) {
  // Run GUI codes in Event-Dispatching thread for thread safety
  SwingUtilities.invokeLater(new Runnable() {
     @Override
     public void run() {
        new JavaApplication12(); // Let the constructor do the job

     }
  });

 }
} `

if(a1.intersects(a3.getBounds()))

if(s.contains(a3) && a1.intersects(a3.getBounds()))

if(a1.intersects(a22))
 {

   s.remove(a21);ySpeed = -ySpeed;
  ySpeed = -ySpeed;
 }

if(a1.intersects(a22))
 {
   s.remove(a22);ySpeed = -ySpeed;
 }