如何在Swing中高效干净地逐像素绘制曼德博集合？

你的当前实现存在两个核心问题导致绘制效果不干净、效率低下：

1. 逐像素调用fillRect的开销：每次循环都切换颜色并绘制1px矩形，会频繁触发图形上下文的状态更新，不仅速度慢，还可能因频繁重绘导致界面闪烁。
2. 坐标映射错误：原代码中i / 500000.0的计算会让y坐标范围超出面板高度（1000px），导致大量像素重复绘制在底部区域，造成视觉混乱。

最优解决方案：使用BufferedImage预先生成图像 #

通过预先在内存中生成完整的曼德博集合图像，再一次性绘制到组件上，既能提升绘制效率，又能保证图像干净清晰。具体步骤如下：

1. 预先创建与组件尺寸匹配的BufferedImage，直接操作其像素数据。
2. 遍历每个像素坐标，计算对应的复平面位置，获取颜色后写入BufferedImage。
3. 在paintComponent方法中一次性绘制整个图像，避免逐像素的冗余操作。

修改后的完整代码 #

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import javax.swing.JFrame;
import javax.swing.JComponent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

public class Mandelbrot {
    private static double xOffset = -1.5;
    private static double yOffset = -1.0;
    private static int zoom = 1;
    private static final int WIDTH = 1000;
    private static final int HEIGHT = 1000;
    private static BufferedImage fractalImage;

    public static void main(String[] args) {
        var panel = new JComponent() {
            @Override
            protected void paintComponent(Graphics g) {
                super.paintComponent(g);
                // 一次性绘制预先生成的图像
                if (fractalImage != null) {
                    g.drawImage(fractalImage, 0, 0, this);
                }
            }

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

        panel.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(MouseEvent e) {
                // 修正坐标偏移计算：将点击位置转换为复平面坐标
                double clickX = (e.getX() / (double) WIDTH) / zoom + xOffset;
                double clickY = (e.getY() / (double) HEIGHT) / zoom + yOffset;
                
                // 更新缩放和偏移，让点击位置居中
                if (e.getButton() == MouseEvent.BUTTON1) {
                    zoom *= 2;
                } else if (zoom > 1) {
                    zoom /= 2;
                }
                xOffset = clickX - (0.5 / zoom);
                yOffset = clickY - (0.5 / zoom);
                
                // 后台线程计算图像，避免阻塞EDT
                new Thread(() -> {
                    generateFractalImage();
                    panel.repaint();
                }).start();
                
                System.out.println("zoom : X" + zoom);
            }
        });

        var frame = new JFrame("FRACTAL");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.add(panel);
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);

        // 初始生成图像
        generateFractalImage();
        panel.repaint();
    }

    /**
     * 预先生成曼德博集合图像
     */
    private static void generateFractalImage() {
        fractalImage = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);
        
        for (int px = 0; px < WIDTH; px++) {
            for (int py = 0; py < HEIGHT; py++) {
                // 将像素坐标映射到复平面
                double real = (px / (double) WIDTH) / zoom + xOffset;
                double imag = (py / (double) HEIGHT) / zoom + yOffset;
                Color color = computeMandelbrotColor(real, imag, 1);
                fractalImage.setRGB(px, py, color.getRGB());
            }
        }
    }

    /**
     * 计算单个点的曼德博集合颜色
     */
    public static Color computeMandelbrotColor(double real, double imag, int accuracy) {
        double a = 0;
        double b = 0;
        double temp;
        int maxIterations = 1024 * accuracy;
        
        while (maxIterations > 0 && a*a + b*b < 4) {
            temp = a;
            a = a*a - b*b + real;
            b = 2 * temp * b + imag;
            maxIterations--;
        }
        
        int iterationCount = (1024 * accuracy - maxIterations) / accuracy;
        if (iterationCount == 1024) {
            return Color.BLACK;
        }
        
        // 颜色映射逻辑保持原逻辑
        int r = iterationCount < 256 ? 255 : (iterationCount < 512 ? 511 - iterationCount : 0);
        int g = iterationCount < 256 ? iterationCount : (iterationCount < 768 ? 255 : 1023 - iterationCount);
        int b = iterationCount < 512 ? 0 : (iterationCount < 768 ? iterationCount - 512 : 255);
        return new Color(r, g, b);
    }
}

关键优化点说明 #

• BufferedImage直接操作像素：setRGB方法直接修改内存中的像素数据，比逐像素调用fillRect效率提升数倍，避免了图形上下文的频繁交互。
• 修正坐标映射：使用px/WIDTH和py/HEIGHT将像素坐标正确映射到0-1的范围，再结合缩放和偏移，确保每个像素对应唯一的复平面位置。
• 后台线程计算：将图像生成逻辑放到后台线程，避免阻塞Swing的事件调度线程（EDT），防止界面卡死。
• 使用paintComponent而非paint：Swing组件推荐重写paintComponent而非paint，并调用super.paintComponent(g)保证组件的默认绘制逻辑（比如背景清除）。

内容的提问来源于stack exchange，提问作者Joshua