替代将许多对象绘制到JPanel上

Question

I will be rewriting the below class to use the constructor and do a few smarter things (rather than the four producers() like methods - so don't worry about that.

At the moment I loop through these four array lists and then paint objects onto a JPanel. After about 2-3000 objects, this can result in some significant latency.

What could I use as an alternative to these array lists? Would some type of serialization into JSON/XML work? In my professional coding (rather than this simple side project) I work with a massive system that uses DataNucleus to convert model classes to a table structure in SQL - I feel like that would be massive overkill for my fun side project. Thoughts?

public class Life {
PlayPanel panel;
public int prodSeed;
public int herbSeed;
public int predSeed;
public int decoSeed;
public ArrayList<Producer> prodStore = new ArrayList<Producer>();
public ArrayList<Herbivore> herbStore = new ArrayList<Herbivore>();
public ArrayList<Predator> predStore = new ArrayList<Predator>();
public ArrayList<Decomposer> decoStore = new ArrayList<Decomposer>();


public Life() {
}

public void setPanel(PlayPanel p) {
    panel = p;
}
public void producers() {
    for(int j = 0; j < prodSeed; j++) {
        Producer p = new Producer(panel.life);
        prodStore.add(p);
    }
    panel.producerPaint = true;
}
public void herbivores() {
    for(int j = 0; j < herbSeed; j++) {
        Herbivore h = new Herbivore(panel.life);
        herbStore.add(h);
    }
    panel.herbivorePaint = true;
}
public void predators() {
    for(int j = 0; j < predSeed; j++) {
        Predator p = new Predator(panel.life);
        predStore.add(p);
    }
    panel.predatorPaint = true;
}
public void decomposers() {
    for(int j = 0; j < decoSeed; j++) {
        Decomposer d = new Decomposer(panel.life);
        decoStore.add(d);
    }
    panel.decomposerPaint = true;
}
public void beginAction() {
    for (int j = 0; j < prodStore.size(); j++) {
        prodStore.get(j).behavior();panel.repaint();        
    }
    for (int j = 0; j < herbStore.size(); j++) {
        herbStore.get(j).behavior();panel.repaint();
    }
    for (int j = 0; j < predStore.size(); j++) {
        predStore.get(j).behavior();panel.repaint();
    }
    for (int j = 0; j < decoStore.size(); j++) {
        decoStore.get(j).behavior();panel.repaint();
    }
    //Use booleans between these for loops to not repaint an extra amount of action

}

Horribly painful paintComponent method in the JPanel class:

public void paintComponent(Graphics g) {
    super.paintComponent(g);
    if(producerPaint == true) {
        //int j = 0;

        while(j < life.prodStore.size()) {
            g.setColor(new Color(19,145,14));
            g.fillOval(life.prodStore.get(j).getxAxis(), life.prodStore.get(j).getyAxis(), life.prodStore.get(j).getxSize(), life.prodStore.get(j).getySize());
            j++;
        }
        j=0;
    }
    if(herbivorePaint == true) {
        //int j = 0;

        while(j < life.herbStore.size()) {
            g.setColor(new Color(228,226,158));
            g.fillOval(life.herbStore.get(j).getxAxis(), life.herbStore.get(j).getyAxis(), life.herbStore.get(j).getxSize(), life.herbStore.get(j).getySize());
            j++;
        }
        j=0;
    }
    if(predatorPaint == true) {
        //int j = 0;

        while(j < life.predStore.size()) {
            g.setColor(new Color(207,87,87));
            g.fillOval(life.predStore.get(j).getxAxis(), life.predStore.get(j).getyAxis(), life.predStore.get(j).getxSize(), life.predStore.get(j).getySize());
            j++;
        }
        j=0;
    }
    if(decomposerPaint == true) {
        //int j = 0;

        while(j < life.decoStore.size()) {
            g.setColor(Color.white);
            g.fillOval(life.decoStore.get(j).getxAxis(), life.decoStore.get(j).getyAxis(), life.decoStore.get(j).getxSize(), life.decoStore.get(j).getySize());
            j++;
        }
        j=0;
    }
}

As a pertinent side note: I will be reworking away from the use of booleans as I work through this code (project is a year or two old, before I knew what I was doing)!

Answer 1

Drawing many, many items onto a component isn't a problem, but it shouldn't be happening inside of paintComponent . What you want to do is have a separate image (ex. BufferedImage ), paint onto that image, and then your paintComponent is only responsible for painting that image onto the JPanel. Hence, your user is not seeing all these things painted one by one. They only see the final product.

Search "Double Buffering in Java" for nice demos on this idea.

As for the data structures, keeping 4 lists is fine, but you may want to have more abstract drawing utilities that are shared amongst all your objects. For instance, the way you draw them all is about the same, except for the Color, so create a drawing method that accepts the superclass (ex. BiologyObject ) to any of those subclasses (ex. Producer , Decomposer , etc) as the parameter. Let me know if that doesn't make sense.

UPDATE: proper way to draw onto JPanel

private BufferedImage image;

public MyClass() {
    image = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_ARGB);
}

public void paintOntoImage() {
    //here is where you would draw all the things that you currently have in your paintComponent method
    Graphics2D g = (Graphics2D) image.getGraphics();
    g.setColor(Color.white);
    g.fillRect(0, 0, WIDTH, HEIGHT);

    //now you can call "g.fillOval" or any other methods on "g"
}

public void paintComponent(Graphics g) {
    g.drawImage(image, 0, 0, null);
}