Java G2D使用坐标列表进行更新

我想做一个程序来模拟蚂蚁。假设我有100只蚂蚁，每只蚂蚁都有坐标（

2个整数）。我使用Java图形（Graphics2D）

现在我想要一个类，它读取这样的列表：

List<List<Integer>> list = new ArrayList();

List List=new ArrayList（）；

例如，该列表包括：

[100200]，[200100]

作为其中的坐标。现在我想让类随时更新并删除所有的“点”（蚂蚁），然后用列表中的坐标绘制新的点

现在这行不通

public class FrameHandler {

Panel panel  = new Panel();

public FrameHandler() {
    //initialize frame
    frame.repaint();

    List<List<Integer>> test = new ArrayList();
    List<Integer> t1 = new ArrayList();
    t1.add(100);
    t1.add(200);
    test.add(gunther);

    frame.add(panel);

    panel.setList(test);

    //the thread sleeps for 5 seconds

    List<Integer> t2 = new ArrayList();
    t2.add(100);
    t2.add(100);
    test.add(gunther2);

    panel.removeAll();

    panel.setList(olaf);
}


public void setList(List<Integer> list) {
    panel.setList(list);
}

public void setSize(int width, int height) {
    frame.setSize(width, height);
}

private class Panel extends JPanel {

    List<List<Integer>> antList = new ArrayList();

    private void doDrawing(Graphics g) {

        Graphics2D g2d = (Graphics2D) g;

        for(int i = 0; i < antList.size(); i++) {
            g2d.fillRect(antList.get(i).get(0), antList.get(i).get(1), 2, 2);
        }
    }

    @Override
    public void paintComponent(Graphics g) {

        super.paintComponent(g);
        doDrawing(g);
    }

    public void setList(List<List<Integer>> list) {
        antList = list;
    }
}

}

公共类框架处理程序{
面板=新面板（）；
公共FrameHandler（）{
//初始化帧
frame.repaint（）；
列表测试=新建ArrayList（）；
列表t1=新的ArrayList（）；
t1.增加（100）；
t1.增加（200）；
测试。添加（gunther）；
框架。添加（面板）；
面板设置列表（测试）；
//线程休眠5秒钟
列表t2=新的ArrayList（）；
t2.加入（100）；
t2.加入（100）；
测试。添加（gunther2）；
panel.removeAll（）；
面板设置列表（olaf）；
}
公共无效集合列表（列表）{
面板设置列表（列表）；
}
公共空白设置大小（整数宽度、整数高度）{
框架尺寸（宽度、高度）；
}
私有类面板扩展了JPanel{
List antList=新的ArrayList（）；
私人空间绘制（图g）{
Graphics2D g2d=（Graphics2D）g；
对于（int i=0；i

如果你对如何解决这个问题有其他的想法，也许可以使用API或其他图形处理方法，我很乐意听到

现在我想让类随时更新并删除所有的“点”（蚂蚁），然后用列表中的坐标绘制新的点

这基本上就是在Swing中绘制的工作方式，在每个绘制周期中，您都需要从头开始重新绘制组件的整个状态。有关更多详细信息，请参阅

import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

public class FrameHandler {

    public static void main(String[] args) {
        new FrameHandler();
    }

    public FrameHandler() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
                    ex.printStackTrace();
                }

                JFrame frame = new JFrame("Testing");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public static class TestPane extends JPanel {

        protected static final Random RANDOM_DELTA = new Random();

        private List<List<Integer>> ants;

        public TestPane() {
            Random rnd = new Random();
            ants = new ArrayList<>(25);
            for (int index = 0; index < 10; index++) {
                List<Integer> ant = new ArrayList<>(2);
                // You should also have a look at the java.awt.Point class :P
                ant.add(rnd.nextInt(200 - 2)); //x
                ant.add(rnd.nextInt(200 - 2)); //y
                ants.add(ant);
            }

            Timer timer = new Timer(40, new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {

                    for (List<Integer> ant : ants) {
                        int xDelta = randomDelta();
                        int yDelta = randomDelta();

                        int x = ant.get(0) + xDelta;
                        int y = ant.get(1) + yDelta;

                        if (x < 0) {
                            x = 0;
                        } else if (x + 2 > getWidth()) {
                            x = getWidth() - 2;
                        }
                        if (y < 0) {
                            y = 0;
                        } else if (y + 2 > getHeight()) {
                            y = getHeight() - 2;
                        }

                        ant.set(0, x);
                        ant.set(1, y);
                    }
                    repaint();

                }
            });
            timer.start();
        }

        protected int randomDelta() {
            int delta = 0;
            do {
                double rnd = Math.random();
                delta = rnd < 0.5d ? -1 : 1;
            } while (delta == 0);
            return delta;
        }

        @Override
        public Dimension getPreferredSize() {
            return new Dimension(200, 200);
        }

        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2d = (Graphics2D) g.create();
            for (List<Integer> ant : ants) {
                g2d.fillRect(ant.get(0), ant.get(1), 2, 2);
            }
            g2d.dispose();
        }

    }

}

所以问题变成了，如何更新
列表
。虽然有很多方法可以做到这一点，但使用Swing
定时器可能是最简单的（通常也是最安全的）。有关更多详细信息，请参阅

import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

public class FrameHandler {

    public static void main(String[] args) {
        new FrameHandler();
    }

    public FrameHandler() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
                    ex.printStackTrace();
                }

                JFrame frame = new JFrame("Testing");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public static class TestPane extends JPanel {

        protected static final Random RANDOM_DELTA = new Random();

        private List<List<Integer>> ants;

        public TestPane() {
            Random rnd = new Random();
            ants = new ArrayList<>(25);
            for (int index = 0; index < 10; index++) {
                List<Integer> ant = new ArrayList<>(2);
                // You should also have a look at the java.awt.Point class :P
                ant.add(rnd.nextInt(200 - 2)); //x
                ant.add(rnd.nextInt(200 - 2)); //y
                ants.add(ant);
            }

            Timer timer = new Timer(40, new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {

                    for (List<Integer> ant : ants) {
                        int xDelta = randomDelta();
                        int yDelta = randomDelta();

                        int x = ant.get(0) + xDelta;
                        int y = ant.get(1) + yDelta;

                        if (x < 0) {
                            x = 0;
                        } else if (x + 2 > getWidth()) {
                            x = getWidth() - 2;
                        }
                        if (y < 0) {
                            y = 0;
                        } else if (y + 2 > getHeight()) {
                            y = getHeight() - 2;
                        }

                        ant.set(0, x);
                        ant.set(1, y);
                    }
                    repaint();

                }
            });
            timer.start();
        }

        protected int randomDelta() {
            int delta = 0;
            do {
                double rnd = Math.random();
                delta = rnd < 0.5d ? -1 : 1;
            } while (delta == 0);
            return delta;
        }

        @Override
        public Dimension getPreferredSize() {
            return new Dimension(200, 200);
        }

        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2d = (Graphics2D) g.create();
            for (List<Integer> ant : ants) {
                g2d.fillRect(ant.get(0), ant.get(1), 2, 2);
            }
            g2d.dispose();
        }

    }

}

导入java.awt.Dimension；
导入java.awt.EventQueue；
导入java.awt.Graphics；
导入java.awt.Graphics2D；
导入java.awt.event.ActionEvent；
导入java.awt.event.ActionListener；
导入java.util.ArrayList；
导入java.util.List；
导入java.util.Random；
导入javax.swing.JFrame；
导入javax.swing.JPanel；
导入javax.swing.Timer；
导入javax.swing.UIManager；
导入javax.swing.UnsupportedLookAndFeelException；
公共类FrameHandler{
公共静态void main（字符串[]args）{
新的FrameHandler（）；
}
公共FrameHandler（）{
invokeLater（新的Runnable（）{
@凌驾
公开募捐{
试一试{
UIManager.setLookAndFeel（UIManager.getSystemLookAndFeelClassName（））；
}catch（ClassNotFoundException |实例化Exception | IllegalacessException |不支持ookandfeelException ex）{
例如printStackTrace（）；
}
JFrame=新JFrame（“测试”）；
frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
frame.add（newtestpane（））；
frame.pack（）；
frame.setLocationRelativeTo（空）；
frame.setVisible（true）；
}
});
}
公共静态类TestPane扩展了JPanel{
受保护的静态最终随机_DELTA=新随机（）；
私人名单蚂蚁；
公共测试窗格（）{
随机rnd=新随机（）；
ants=新阵列列表（25）；
对于（int-index=0；index<10；index++）{
List ant=新阵列列表（2）；
//您还应该看看java.awt.Point类：P
ant.add（rnd.nextInt（200-2））；//x
ant.add（rnd.nextInt（200-2））；//y
蚂蚁。添加（蚂蚁）；
}
计时器计时器=新计时器（40，新ActionListener（）{
@凌驾
已执行的公共无效操作（操作事件e）{
用于（列表蚂蚁：蚂蚁）{
int xDelta=randomDelta（）；
int yDelta=randomDelta（）；
intx=ant.get（0）+xDelta；
int y=ant.get（1）+yDelta；
if（x<0）{
x=0；
}如果（x+2>getWidth（）），则为else{
x=getWidth（）-2；
}
if（y<0）{
y=0；
}否则如果（y+2>getHeight（））{
y=getHeight（）-2；
}
蚂蚁集（0，x）；
蚂蚁集（1，y）；
}
重新油漆（）；
}
});
timer.start（）；
}
受保护的整数（）{
int delta=0；
做{
double rnd=Math.random（）；
delta=rnd<0.5d？-1:1；
}而（δ=0）；
返回三角洲；
}
@凌驾
公共维度getPreferredSize（）{
返回新维度（200200）；
}
受保护组件（图形g）{
超级组件（g）；
Graphics2D g2d=（Graphics2D）g.create（）；
用于（列表蚂蚁：蚂蚁）{
g2d.fillRect（ant.get（0）、ant.get（1）、2、2）；
}
g2d.dispose（）；
}
}
}

该示例基本上生成一个随机增量（direc中的变化