Java 如何设置按键绑定？

此应用程序的箭头键需要引起与焦点无关的按下和释放事件。 将onKeyRelease设置为true会导致预期的释放事件，但将onKeyRelease设置为false（下面的代码）似乎不会停止自动重复。 是否有一种方法可以实现键绑定，以便在按住箭头键时触发一次

Action right = new AbstractAction() {
    public void actionPerformed(ActionEvent e) {
        ...
    }
};
mainPanel.getInputMap(JPanel.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT)
        .put(KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, 0, false), "right");
mainPanel.getActionMap().put("right", right);

---

。。。可能是个好问题，但请不要把一切都搞清楚，你能不能详细说明一下

import java.awt.*;
import java.awt.event.*;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.net.*;
import java.util.HashMap;
import java.util.Map;
import javax.imageio.ImageIO;
import javax.swing.*;

public class MoveIcon extends JPanel {

    private static final long serialVersionUID = 1L;
    private static final String IMAGE_PATH = "http://duke.kenai.com/misc/Bullfight.jpg";
    private static final String IMAGE_PATH_PLAYER = "http://duke.kenai.com/iconSized/duke4.gif";
    public static final int STEP = 3;
    private static final int TIMER_DELAY = STEP * 8;
    private BufferedImage bkgrndImage = null;
    private BufferedImage playerImage = null;
    private Map<Direction, Boolean> directionMap = new HashMap<Direction, Boolean>();
    private int playerX = 0;
    private int playerY = 0;

    enum Direction {

        UP(KeyEvent.VK_UP, 0, -1), DOWN(KeyEvent.VK_DOWN, 0, 1),
        LEFT(KeyEvent.VK_LEFT, -1, 0), RIGHT(KeyEvent.VK_RIGHT, 1, 0);
        private int keyCode;
        private int xDirection;
        private int yDirection;

        private Direction(int keyCode, int xDirection, int yDirection) {
            this.keyCode = keyCode;
            this.xDirection = xDirection;
            this.yDirection = yDirection;
        }

        public int getKeyCode() {
            return keyCode;
        }

        public int getXDirection() {
            return xDirection;
        }

        public int getYDirection() {
            return yDirection;
        }
    }

    public MoveIcon() {
        try {
            URL bkgrdImageURL = new URL(IMAGE_PATH);
            URL playerImageURL = new URL(IMAGE_PATH_PLAYER);
            bkgrndImage = ImageIO.read(bkgrdImageURL);
            playerImage = ImageIO.read(playerImageURL);
            setPreferredSize(new Dimension(bkgrndImage.getWidth(), bkgrndImage.getHeight()));
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        for (Direction direction : Direction.values()) {
            directionMap.put(direction, false);
        }
        setKeyBindings();
        Timer timer = new Timer(TIMER_DELAY, new TimerListener());
        timer.start();
    }

    private void setKeyBindings() {
        InputMap inMap = getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
        ActionMap actMap = getActionMap();
        for (final Direction direction : Direction.values()) {
            KeyStroke pressed = KeyStroke.getKeyStroke(direction.getKeyCode(), 0, false);
            KeyStroke released = KeyStroke.getKeyStroke(direction.getKeyCode(), 0, true);
            inMap.put(pressed, direction.toString() + "pressed");
            inMap.put(released, direction.toString() + "released");
            actMap.put(direction.toString() + "pressed", new AbstractAction() {

                private static final long serialVersionUID = 1L;

                @Override
                public void actionPerformed(ActionEvent e) {
                    directionMap.put(direction, true);
                }
            });
            actMap.put(direction.toString() + "released", new AbstractAction() {

                private static final long serialVersionUID = 1L;

                @Override
                public void actionPerformed(ActionEvent e) {
                    directionMap.put(direction, false);
                }
            });
        }

    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        if (bkgrndImage != null) {
            g.drawImage(bkgrndImage, 0, 0, null);
        }
        if (playerImage != null) {
            g.drawImage(playerImage, playerX, playerY, null);
        }
    }

    private class TimerListener implements ActionListener {

        @Override
        public void actionPerformed(ActionEvent e) {
            boolean moved = false;
            for (Direction direction : Direction.values()) {
                if (directionMap.get(direction)) {
                    playerX += STEP * direction.getXDirection();
                    playerY += STEP * direction.getYDirection();
                    moved = true;
                }
            }
            if (moved) {
                int x = playerX - 2 * STEP;
                int y = playerY - 2 * STEP;
                int w = playerImage.getWidth() + 4 * STEP;
                int h = playerImage.getHeight() + 4 * STEP;
                MoveIcon.this.repaint(x, y, w, h); // !! repaint just the player
            }
        }
    }

    private static void createAndShowUI() {
        JFrame frame = new JFrame("MoveIcon");
        frame.getContentPane().add(new MoveIcon());
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        java.awt.EventQueue.invokeLater(new Runnable() {

            @Override
            public void run() {
                createAndShowUI();
            }
        });
    }
}

import java.awt.*；
导入java.awt.event.*；
导入java.awt.image.buffereImage；
导入java.io.IOException；
导入java.net。*；
导入java.util.HashMap；
导入java.util.Map；
导入javax.imageio.imageio；
导入javax.swing.*；
公共类MoveIcon扩展了JPanel{
私有静态最终长serialVersionUID=1L；
私有静态最终字符串图像_路径=”http://duke.kenai.com/misc/Bullfight.jpg";
私有静态最终字符串图像\u路径\u播放器=”http://duke.kenai.com/iconSized/duke4.gif";
公共静态最终int步骤=3；
专用静态最终int定时器_延迟=步骤*8；
私有缓冲区映像bkgrndImage=null；
private BuffereImage playerImage=null；
private Map directionMap=新HashMap（）；
私有整数playerX=0；
私有int playerY=0；
枚举方向{
向上（KeyEvent.VK_向上，0，-1），向下（KeyEvent.VK_向下，0，1），
左（KeyEvent.VK_LEFT，-1,0），右（KeyEvent.VK_RIGHT，1,0）；
私钥密码；
私有int-xDirection；
私人内部指导；
专用方向（int键码、int xDirection、int yDirection）{
this.keyCode=keyCode；
this.xDirection=xDirection；
this.yDirection=yDirection；
}
public int getKeyCode（）{
返回键码；
}
public int getXDirection（）{
返回方向；
}
public int getYDirection（）{
返回方向；
}
}
公共运动图标（）{
试一试{
URL bkgrdImageURL=新URL（图像路径）；
URL playerImageURL=新URL（图像\路径\播放器）；
bkgrndImage=ImageIO.read（bkgrdImageURL）；
playerImage=ImageIO.read（playerImageURL）；
setPreferredSize（新维度（bkgrnImage.getWidth（），bkgrnImage.getHeight（））；
}捕获（格式错误）{
e、 printStackTrace（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
对于（方向：Direction.values（））{
directionMap.put（方向，false）；
}
setKeyBindings（）；
定时器定时器=新定时器（定时器延迟，新定时器延迟（）；
timer.start（）；
}
私有void setKeyBindings（）{
InputMap inMap=getInputMap（JComponent.WHEN_IN_FOCUSED_窗口）；
ActionMap actMap=getActionMap（）；
对于（最终方向：Direction.values（））{
按下击键=击键.getKeyStroke（direction.getKeyCode（），0，false）；
击键释放=击键.getKeyStroke（direction.getKeyCode（），0，true）；
inMap.put（按下，方向.toString（）+“按下”）；
inMap.put（已释放，direction.toString（）+“已释放”）；
actMap.put（direction.toString（）+“按下”，新的AbstractAction（）{
私有静态最终长serialVersionUID=1L；
@凌驾
已执行的公共无效操作（操作事件e）{
directionMap.put（方向，true）；
}
});
put（direction.toString（）+“released”，新的AbstractAction（））{
私有静态最终长serialVersionUID=1L；
@凌驾
已执行的公共无效操作（操作事件e）{
directionMap.put（方向，false）；
}
});
}
}
@凌驾
受保护组件（图形g）{
超级组件（g）；
如果（bkgrndImage！=null）{
g、 drawImage（bkgrnImage，0，0，null）；
}
如果（playerImage！=null）{
g、 drawImage（playerImage、playerX、playerY、null）；
}
}
私有类TimerListener实现ActionListener{
@凌驾
已执行的公共无效操作（操作事件e）{
布尔值=假；
对于（方向：Direction.values（））{
if（directionMap.get（direction））{
playerX+=STEP*direction.getXDirection（）；
playerY+=STEP*direction.getYDirection（）；
移动=真；
}
}
如果（移动）{
int x=播放器x-2*步；
int y=玩耍-2*步；
int w=playerImage.getWidth（）+4*步；
inth=playerImage.getHeight（）+4*步；
MoveIcon.this.重新绘制（x，y，w，h）；/！！仅重新绘制播放器
}
}
}
私有静态void createAndShowUI（）{
JFrame=新JFrame（“移动图标”）；
frame.getContentPane（）.add（新的MoveIcon（））；
frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
frame.pack（）；
frame.setLocationRelativeTo（空）；
frame.setVisible（true）；
}
公共静态void main（字符串[]args）{
invokeLater（new Runnable（））{
@凌驾
公开募捐{
createAndShowUI（）；
}
});
}
}

（1）：长时间按下某个键时，是否试图阻止自动重复（2） ：你在寻找跨平台解决方案吗？@ring Bear:我不是想阻止自动重复，我只是想在按下或释放箭头键时触发一次事件。是的，这需要在不同的Windows和Linux平台上工作。这里的内容基本上与我的相同。问题是“按键按下”触发器