Java：如何在Swing中进行双缓冲？

编辑两个

为了防止讽刺评论和单行答案错过了重点： IFF 它是就像调用 setDoubleBuffered（true）一样简单，那么如何访问当前的离线缓冲区以便我可以开始搞乱BufferedImage的底层像素数据缓冲区呢？

To prevent snarky comments and one-line answers missing the point: IFF it is as simple as calling setDoubleBuffered(true), then how do I get access to the current offline buffer so that I can start messing with the BufferedImage's underlying pixel databuffer?

我花时间写了一段正在运行的代码（看起来也很有趣）所以我真的很感激答案实际回答（多么令人震惊;）我的问题并解释这是什么/如何工作而不是one-liners and snarky comments;）

I took the time to write a running piece of code (which looks kinda fun too) so I'd really appreciate answers actually answering (what a shock ;) my question and explaining what/how this is working instead of one-liners and snarky comments ;)

这是一段代码，可以在JFrame上反弹一个正方形。我想知道可以用来转换这段代码的各种方法，以便它使用双缓冲。

Here's a working piece of code that bounces a square across a JFrame. I'd like to know about the various ways that can be used to transform this piece of code so that it uses double-buffering.

请注意我清除的方式屏幕和重绘方块不是最有效的，但这不是这个问题的关键（在某种程度上，为了这个例子它更好，它有点慢）。

Note that the way I clear the screen and redraw the square ain't the most efficient but this is really not what this question is about (in a way, it's better for the sake of this example that it is somewhat slow).

基本上，我需要不断修改BufferedImage中的大量像素（以便有某种动画），我不希望看到由于屏幕上的单缓冲造成的视觉伪像。

Basically, I need to constantly modify a lot pixels in a BufferedImage (as to have some kind of animation) and I don't want to see the visual artifacts due to single-buffering on screen.

我有一个JLabel，其Icon是包含BufferedImage的ImageIcon。我想修改那个BufferedImage。

I've got a JLabel whose Icon is an ImageIcon wrapping a BufferedImage. I want to modify that BufferedImage.

必须做什么才能使它成为双缓冲？

What has to be done so that this becomes double-buffered?

据我所知，在我将使用image 2时，将会以某种方式显示image 1。但是，一旦我完成了image 2的绘制，我如何快速替换image 1 image 2？

I understand that somehow "image 1" will be shown while I'll be drawing on "image 2". But then once I'm done drawing on "image 2", how do I "quickly" replace "image 1" by "image 2"?

这是我应该手动做的事情，比如说，自己交换JLabel的ImageIcon吗？

Is this something I should be doing manually, like, say, by swapping the JLabel's ImageIcon myself?

我是否应该总是在同一个BufferedImage中绘图，然后在JLabel的ImageIcon的BufferedImage中快速'blit'显示BufferedImage的像素？ （我猜不是，我不知道我怎么能与显示器的垂直空白线[或平板屏幕中的等效物同步：我的意思是，'同步'而不会干扰显示器本身刷新它的时刻像素，以防止剪切]）。

Should I be always drawing in the same BufferedImage then do a fast 'blit' of that BufferedImage's pixels in the JLabel's ImageIcon's BufferedImage? (I guess no and I don't see how I could "synch" this with the monitor's "vertical blank line" [or equivalent in flat-screen: I mean, to 'synch' without interfering with the moment the monitor itselfs refreshes its pixels, as to prevent shearing]).

重绘订单怎么样？我想我自己触发这些吗？哪个/什么时候应该调用 repaint（）或其他什么？

What about the "repaint" orders? Am I suppose to trigger these myself? Which/when exactly should I call repaint() or something else?

最重要的要求是我应该直接修改像素images的像素databuffer。

The most important requirement is that I should be modifying pixels directly in the images's pixel databuffer.

import javax.swing.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferInt;

public class DemosDoubleBuffering extends JFrame {

    private static final int WIDTH  = 600;
    private static final int HEIGHT = 400;

    int xs = 3;
    int ys = xs;

    int x = 0;
    int y = 0;

    final int r = 80;

    final BufferedImage bi1;

    public static void main( final String[] args ) {
        final DemosDoubleBuffering frame = new DemosDoubleBuffering();
        frame.addWindowListener(new WindowAdapter() {
            public void windowClosing( WindowEvent e) {
                System.exit(0);
            }
        });
        frame.setSize( WIDTH, HEIGHT );
        frame.pack();
        frame.setVisible( true );
    }

    public DemosDoubleBuffering() {
        super( "Trying to do double buffering" );
        final JLabel jl = new JLabel();
        bi1 = new BufferedImage( WIDTH, HEIGHT, BufferedImage.TYPE_INT_ARGB );
        final Thread t = new Thread( new Runnable() {
            public void run() {
                while ( true ) {
                    move();
                    drawSquare( bi1 );
                    jl.repaint();
                    try {Thread.sleep(10);} catch (InterruptedException e) {}
                }
            }
        });
        t.start();
        jl.setIcon( new ImageIcon( bi1 ) );
        getContentPane().add( jl );
    }

    private void drawSquare( final BufferedImage bi ) {
        final int[] buf = ((DataBufferInt) bi.getRaster().getDataBuffer()).getData();
        for (int i = 0; i < buf.length; i++) {
            buf[i] = 0xFFFFFFFF;    // clearing all white
        }
        for (int xx = 0; xx < r; xx++) {
            for (int yy = 0; yy < r; yy++) {
                buf[WIDTH*(yy+y)+xx+x] = 0xFF000000;
            }
        }
    }

    private void move() {
        if ( !(x + xs >= 0 && x + xs + r < bi1.getWidth()) ) {
            xs = -xs;
        }
        if ( !(y + ys >= 0 && y + ys + r < bi1.getHeight()) ) {
            ys = -ys;
        }
        x += xs;
        y += ys;
    }

}

编辑

对于全屏Java应用程序，这是不，而是在自己的（有点小）窗口中运行的常规Java应用程序。

This is not for a full-screen Java application, but a regular Java application, running in its own (somewhat small) window.