web-dev-qa-db-ja.com

文字列をKeyEventsに変換

StringをKeyEventに変換して、次のようなことをしたいです。

writeKeyboard(myBot,"abcd");

public void writeKeyboard(Robot bot, String st){
     char[] arr = arr.toCharArray();
     int i = arr.length();
     int j = 0;
     int keycode;
     while (j<i) {
         keycode = arr[j].something;
         bot.keyPress(keycode);
         bot.keyRelease(keycode);
         j++;
     }
}
javaawtrobot
44
Martin Trigaux

基本的に、栄光のあるswitchステートメントを使用しています。シンプルで高速：

_import static Java.awt.event.KeyEvent.*;

public class Keyboard {

    private Robot robot;

    public static void main(String... args) throws Exception {
        Keyboard keyboard = new Keyboard();
        keyboard.type("Hello there, how are you?");
    }

    public Keyboard() throws AWTException {
        this.robot = new Robot();
    }

    public Keyboard(Robot robot) {
        this.robot = robot;
    }

    public void type(CharSequence characters) {
        int length = characters.length();
        for (int i = 0; i < length; i++) {
            char character = characters.charAt(i);
            type(character);
        }
    }

    public void type(char character) {
        switch (character) {
        case 'a': doType(VK_A); break;
        case 'b': doType(VK_B); break;
        case 'c': doType(VK_C); break;
        case 'd': doType(VK_D); break;
        case 'e': doType(VK_E); break;
        case 'f': doType(VK_F); break;
        case 'g': doType(VK_G); break;
        case 'h': doType(VK_H); break;
        case 'i': doType(VK_I); break;
        case 'j': doType(VK_J); break;
        case 'k': doType(VK_K); break;
        case 'l': doType(VK_L); break;
        case 'm': doType(VK_M); break;
        case 'n': doType(VK_N); break;
        case 'o': doType(VK_O); break;
        case 'p': doType(VK_P); break;
        case 'q': doType(VK_Q); break;
        case 'r': doType(VK_R); break;
        case 's': doType(VK_S); break;
        case 't': doType(VK_T); break;
        case 'u': doType(VK_U); break;
        case 'v': doType(VK_V); break;
        case 'w': doType(VK_W); break;
        case 'x': doType(VK_X); break;
        case 'y': doType(VK_Y); break;
        case 'z': doType(VK_Z); break;
        case 'A': doType(VK_SHIFT, VK_A); break;
        case 'B': doType(VK_SHIFT, VK_B); break;
        case 'C': doType(VK_SHIFT, VK_C); break;
        case 'D': doType(VK_SHIFT, VK_D); break;
        case 'E': doType(VK_SHIFT, VK_E); break;
        case 'F': doType(VK_SHIFT, VK_F); break;
        case 'G': doType(VK_SHIFT, VK_G); break;
        case 'H': doType(VK_SHIFT, VK_H); break;
        case 'I': doType(VK_SHIFT, VK_I); break;
        case 'J': doType(VK_SHIFT, VK_J); break;
        case 'K': doType(VK_SHIFT, VK_K); break;
        case 'L': doType(VK_SHIFT, VK_L); break;
        case 'M': doType(VK_SHIFT, VK_M); break;
        case 'N': doType(VK_SHIFT, VK_N); break;
        case 'O': doType(VK_SHIFT, VK_O); break;
        case 'P': doType(VK_SHIFT, VK_P); break;
        case 'Q': doType(VK_SHIFT, VK_Q); break;
        case 'R': doType(VK_SHIFT, VK_R); break;
        case 'S': doType(VK_SHIFT, VK_S); break;
        case 'T': doType(VK_SHIFT, VK_T); break;
        case 'U': doType(VK_SHIFT, VK_U); break;
        case 'V': doType(VK_SHIFT, VK_V); break;
        case 'W': doType(VK_SHIFT, VK_W); break;
        case 'X': doType(VK_SHIFT, VK_X); break;
        case 'Y': doType(VK_SHIFT, VK_Y); break;
        case 'Z': doType(VK_SHIFT, VK_Z); break;
        case '`': doType(VK_BACK_QUOTE); break;
        case '0': doType(VK_0); break;
        case '1': doType(VK_1); break;
        case '2': doType(VK_2); break;
        case '3': doType(VK_3); break;
        case '4': doType(VK_4); break;
        case '5': doType(VK_5); break;
        case '6': doType(VK_6); break;
        case '7': doType(VK_7); break;
        case '8': doType(VK_8); break;
        case '9': doType(VK_9); break;
        case '-': doType(VK_MINUS); break;
        case '=': doType(VK_EQUALS); break;
        case '~': doType(VK_SHIFT, VK_BACK_QUOTE); break;
        case '!': doType(VK_EXCLAMATION_MARK); break;
        case '@': doType(VK_AT); break;
        case '#': doType(VK_NUMBER_SIGN); break;
        case '$': doType(VK_DOLLAR); break;
        case '%': doType(VK_SHIFT, VK_5); break;
        case '^': doType(VK_CIRCUMFLEX); break;
        case '&': doType(VK_AMPERSAND); break;
        case '*': doType(VK_ASTERISK); break;
        case '(': doType(VK_LEFT_PARENTHESIS); break;
        case ')': doType(VK_RIGHT_PARENTHESIS); break;
        case '_': doType(VK_UNDERSCORE); break;
        case '+': doType(VK_PLUS); break;
        case '\t': doType(VK_TAB); break;
        case '\n': doType(VK_ENTER); break;
        case '[': doType(VK_OPEN_BRACKET); break;
        case ']': doType(VK_CLOSE_BRACKET); break;
        case '\\': doType(VK_BACK_SLASH); break;
        case '{': doType(VK_SHIFT, VK_OPEN_BRACKET); break;
        case '}': doType(VK_SHIFT, VK_CLOSE_BRACKET); break;
        case '|': doType(VK_SHIFT, VK_BACK_SLASH); break;
        case ';': doType(VK_SEMICOLON); break;
        case ':': doType(VK_COLON); break;
        case '\'': doType(VK_QUOTE); break;
        case '"': doType(VK_QUOTEDBL); break;
        case ',': doType(VK_COMMA); break;
        case '<': doType(VK_SHIFT, VK_COMMA); break;
        case '.': doType(VK_PERIOD); break;
        case '>': doType(VK_SHIFT, VK_PERIOD); break;
        case '/': doType(VK_SLASH); break;
        case '?': doType(VK_SHIFT, VK_SLASH); break;
        case ' ': doType(VK_SPACE); break;
        default:
            throw new IllegalArgumentException("Cannot type character " + character);
        }
    }

    private void doType(int... keyCodes) {
        doType(keyCodes, 0, keyCodes.length);
    }

    private void doType(int[] keyCodes, int offset, int length) {
        if (length == 0) {
            return;
        }

        robot.keyPress(keyCodes[offset]);
        doType(keyCodes, offset + 1, length - 1);
        robot.keyRelease(keyCodes[offset]);
    }

}
_

カスタムキーの入力が必要な場合は、クラスを拡張してtype(char)メソッドをオーバーライドできます。例えば：

_import static Java.awt.event.KeyEvent.*;

public class WindowUnicodeKeyboard extends Keyboard {

    private Robot robot;

    public WindowUnicodeKeyboard(Robot robot) {
        super(robot);
        this.robot = robot;
    }

    @Override
    public void type(char character) {
        try {
            super.type(character);
        } catch (IllegalArgumentException e) {
            String unicodeDigits = String.valueOf(Character.getCodePoint(character));
            robot.keyPress(VK_ALT);
            for (int i = 0; i < unicodeDigits.length(); i++) {
                typeNumPad(Integer.parseInt(unicodeDigits.substring(i, i + 1)));
            }
            robot.keyRelease(VK_ALT);
        }
    }

    private void typeNumPad(int digit) {
        switch (digit) {
        case 0: doType(VK_NUMPAD0); break;
        case 1: doType(VK_NUMPAD1); break;
        case 2: doType(VK_NUMPAD2); break;
        case 3: doType(VK_NUMPAD3); break;
        case 4: doType(VK_NUMPAD4); break;
        case 5: doType(VK_NUMPAD5); break;
        case 6: doType(VK_NUMPAD6); break;
        case 7: doType(VK_NUMPAD7); break;
        case 8: doType(VK_NUMPAD8); break;
        case 9: doType(VK_NUMPAD9); break;
        }
    }

}
_

もちろん、改善の余地はありますが、アイデアは得られます。

83
Adam Paynter

クリップボードを使用して問題を解決しました...

public static void type(String characters) {
    Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
    StringSelection stringSelection = new StringSelection( characters );
    clipboard.setContents(stringSelection, clipboardOwner);

    robot.keyPress(KeyEvent.VK_CONTROL);
    robot.keyPress(KeyEvent.VK_V);
    robot.keyRelease(KeyEvent.VK_V);
    robot.keyRelease(KeyEvent.VK_CONTROL);
}
24
Carl Bosch

JavaリフレクションAPI：

public void writeKeyboard(Robot bot, String st) {
    String upperCase = st.toUpperCase();

    for(int i = 0; i < upperCase.length(); i++) {
        String letter = Character.toString(upperCase.charAt(i));
        String code = "VK_" + letter

        Field f = KeyEvent.class.getField(code);
        int keyEvent = f.getInt(null);

        bot.press(keyEvent);
        bot.release(keyEvent);
    }
}
9
Jindra Helcl

私は最近、これを行うクラスを作成しました。各ケースのキーの組み合わせを個別に把握する代わりに、各文字のAltコードを入力します。最速のソリューションではありませんが、簡潔で非常に幅広いキャラクターに対応しています。

import Java.awt.AWTException;
import Java.awt.Robot;
import static Java.awt.event.KeyEvent.VK_ALT;
import static Java.awt.event.KeyEvent.VK_NUMPAD0;

public class Altbot extends Robot{

    Altbot()throws AWTException{}

    public void type(CharSequence cs){
        for(int i=0;i<cs.length();i++){
            type(cs.charAt(i));
        }
    }

    public void type(char c){
        keyPress(VK_ALT);
        keyPress(VK_NUMPAD0);
        keyRelease(VK_NUMPAD0);
        String altCode=Integer.toString(c);
        for(int i=0;i<altCode.length();i++){
            c=(char)(altCode.charAt(i)+'0');
            //delay(20);//may be needed for certain applications
            keyPress(c);
            //delay(20);//uncomment if necessary
            keyRelease(c);
        }
        keyRelease(VK_ALT);
    }
}
6
Ryan Hilbert

これが、利用可能なすべてのキーを使用する方法です。 Mapを作成し、fillKeyMapメソッドを使用して地図を埋めます。これで、キーイベントの文字列表現を使用して、マップを使用してKeyEventコードに変換できます。

/** Create map with string values to integer pairs
 */
public static final void fillKeyMap(Map<String, Integer> into) {
    try {
        Field[] fields = KeyEvent.class.getDeclaredFields();
        for(Field f : fields) {
            if(f.getName().startsWith("VK_")) { //we only want these fields
                int code = ((Integer)f.get(null)).intValue();
                into.put(f.getName().substring(3), code);
            }
        }
    } catch(Exception ex) {}
}
4
Dombrovski

ちょっとしたやりかたですが、 コマンドパターン を使用して、文字列内の各文字のキーストロークをカプセル化し、各文字のコマンドを順番に取得してメソッドを呼び出すことができます。これの利点は、マップを一度セットアップするだけで済むことです。欠点は、まだ多くのボリプレートが含まれていることです。

public interface Command {
    void pressKey(Robot bot);
}

//add a command to the map for each keystroke
commandMap.put("A", new Command() {
    void pressKey(Robot bot) {
        pressWithShift(KeyEvent.VK_A);
    }
});
commandMap.put ("a", new Command() {
    void pressKey (Robot bot) {
        press (KeyEvent.VK_A);
    }
});
commandMap.put("B", new Command() {
    void pressKey(Robot bot) {
        pressWithShift(KeyEvent.VK_B);
    }
});
...
//loads more definitions here

//helper methods
private void pressWithShift (Robot bot, KeyEvent event) {
    bot.keyPress (KeyEvent.VK_SHIFT);
    press(bot, event);
    bot.keyRelase(KeyEvent.VK_SHIFT);
}

private void press(Robot bot, KeyEvent event) {
    bot.keyPress(event);
    bot.keyRelease(event);
}

次に、マップを使用するには：

for (int i = 0; i < st.length(); i++) {
    String subString = st.substring(i, i + 1);

    commandMap.get(subString).pressKey(bot);
}
3
Rich Seller

私は基本的に コマンドパターン を使用していますが、簡潔にするために2つのマイナーな変更を加えて、リッチセラーが彼の回答で使用しています。

  • a-zコマンドのインスタンスを再利用するための 装飾パターン の使用
  • リフレクションを使用してKeyEvent.VK _ ???を削除する

コマンドインターフェイス：

interface Command {

    void pressKey(Robot robot);
}

およびデコレーター（変更＃1用）：

class ShiftCommand implements Command {

    private final Command command;

    public ShiftCommand(Command command) {
        this.command = command;
    }

    public void pressKey(Robot robot) {
        robot.keyPress(KeyEvent.VK_SHIFT);
        command.pressKey(robot);
        robot.keyRelease(KeyEvent.VK_SHIFT);
    }

    @Override
    public String toString() {
        return "SHIFT + " + command.toString();
    }
}

このヘルパーの使用（変更＃2用）：

public static int getKeyEvent(Character c) {
    Field f = KeyEvent.class.getField("VK_" + Character.toUpperCase(c));
    f.setAccessible(true);
    return (Integer) f.get(null);
}

[〜＃〜]注意[〜＃〜]：ここでは例外を処理していません。これは演習として残しておきます:)）

次に、forループを使用してコマンドを入力します。

Map<Character, Command> commandMap = new HashMap<Character, Command>();

    for (int i = 'a'; i <= 'z'; i++) {
        final Character c = Character.valueOf((char) i);
        Command pressKeyCommand = new Command() {

            public void pressKey(Robot robot) {
                int keyEventCode = getKeyEvent(c);
                robot.keyPress(c);
                robot.keyRelease(c);
            }

            @Override
            public String toString() {
                return String.format("%c", c);
            }
        };

        // 'a' .. 'z'
        commandMap.put(c, pressKeyCommand);
        // 'A' .. 'Z' by decorating pressKeyCommand
        commandMap.put(Character.toUpperCase(c), new ShiftCommand(pressKeyCommand));
    }

テストケース

String test = "aaaBBB";
for (int i = 0; i < test.length(); i++) {
     System.out.println(commandMap.get(test.charAt(i)));
}

予想どおり、これは次を出力します。

 a 
 a 
 a 
 SHIFT + b 
 SHIFT + b 
 SHIFT + b
3
dfa

コードは、英数字のみを使用している限り機能しますが、「：」などの文字には機能しません。 SmartRobot クラスがこれを処理します。

2
Demiurg

受け入れられた答えは私にとって非常に肥大化したようです。受け入れられた答えに基づいた、もう少し簡潔なソリューションを次に示します。ほとんどすべてのユースケースを処理する必要があります。例で示すように、\n（改行）、\t（タブ）、および\b（バックスペース）も処理します。

import Java.awt.AWTException;
import Java.awt.AWTKeyStroke;
import static Java.awt.AWTKeyStroke.getAWTKeyStroke;
import Java.awt.Robot;
import static Java.awt.event.InputEvent.SHIFT_DOWN_MASK;
import Java.awt.event.KeyEvent;

public class Keyboard {

    private final Robot robot;

    public Keyboard() throws AWTException {
        this.robot = new Robot();
    }

    public static void main(String[] args) throws Exception {
        Runtime.getRuntime().exec("notepad.exe");
        Thread.sleep(3000L);
        Keyboard keyboard = new Keyboard();
        keyboard.type("`1234567890-=[]\\;',./\n");
        keyboard.type("~!@#$%^&*()_+{}|:\"<>?\n");
        keyboard.type("abcdefghijklmnopqrstuvwxyz\n\tABCDEFGHIJKLMNOPQRSTUVWXYZ");
        keyboard.type("\n\n\twh\bat");
    }

    private static AWTKeyStroke getKeyStroke(char c) {
        String upper = "`~'\"!@#$%^&*()_+{}|:<>?";
        String lower = "`~'\"1234567890-=[]\\;,./";

        int index = upper.indexOf(c);
        if (index != -1) {
            int keyCode;
            boolean shift = false;
            switch (c) {
                // these chars need to be handled specially because
                // they don't directly translate into the correct keycode
                case '~':
                    shift = true;
                case '`':
                    keyCode = KeyEvent.VK_BACK_QUOTE;
                    break;
                case '\"':
                    shift = true;
                case '\'':
                    keyCode = KeyEvent.VK_QUOTE;
                    break;
                default:
                    keyCode = (int) Character.toUpperCase(lower.charAt(index));
                    shift = true;
            }
            return getAWTKeyStroke(keyCode, shift ? SHIFT_DOWN_MASK : 0);
        }
        return getAWTKeyStroke((int) Character.toUpperCase(c), 0);
    }

    public void type(CharSequence chars) {
        type(chars, 0);
    }

    public void type(CharSequence chars, int ms) {
        ms = ms > 0 ? ms : 0;
        for (int i = 0, len = chars.length(); i < len; i++) {
            char c = chars.charAt(i);
            AWTKeyStroke keyStroke = getKeyStroke(c);
            int keyCode = keyStroke.getKeyCode();
            boolean shift = Character.isUpperCase(c) || keyStroke.getModifiers() == (SHIFT_DOWN_MASK + 1);
            if (shift) {
                robot.keyPress(KeyEvent.VK_SHIFT);
            }

            robot.keyPress(keyCode);
            robot.keyRelease(keyCode);

            if (shift) {
                robot.keyRelease(KeyEvent.VK_SHIFT);
            }
            if (ms > 0) {
                robot.delay(ms);
            }
        }
    }
}
2
Sensei_Shoh

コードがすべてのキーに対して機能していなかったため、Adam Paynterの答えをわずかに変更！、@、＃、$など（最初にVK_SHIFTを押す必要があります）

public void type(char character) {
    switch (character) {
    case 'a': doType(VK_A); break;
    case 'b': doType(VK_B); break;
    case 'c': doType(VK_C); break;
    case 'd': doType(VK_D); break;
    case 'e': doType(VK_E); break;
    case 'f': doType(VK_F); break;
    case 'g': doType(VK_G); break;
    case 'h': doType(VK_H); break;
    case 'i': doType(VK_I); break;
    case 'j': doType(VK_J); break;
    case 'k': doType(VK_K); break;
    case 'l': doType(VK_L); break;
    case 'm': doType(VK_M); break;
    case 'n': doType(VK_N); break;
    case 'o': doType(VK_O); break;
    case 'p': doType(VK_P); break;
    case 'q': doType(VK_Q); break;
    case 'r': doType(VK_R); break;
    case 's': doType(VK_S); break;
    case 't': doType(VK_T); break;
    case 'u': doType(VK_U); break;
    case 'v': doType(VK_V); break;
    case 'w': doType(VK_W); break;
    case 'x': doType(VK_X); break;
    case 'y': doType(VK_Y); break;
    case 'z': doType(VK_Z); break;
    case 'A': doType(VK_SHIFT, VK_A); break;
    case 'B': doType(VK_SHIFT, VK_B); break;
    case 'C': doType(VK_SHIFT, VK_C); break;
    case 'D': doType(VK_SHIFT, VK_D); break;
    case 'E': doType(VK_SHIFT, VK_E); break;
    case 'F': doType(VK_SHIFT, VK_F); break;
    case 'G': doType(VK_SHIFT, VK_G); break;
    case 'H': doType(VK_SHIFT, VK_H); break;
    case 'I': doType(VK_SHIFT, VK_I); break;
    case 'J': doType(VK_SHIFT, VK_J); break;
    case 'K': doType(VK_SHIFT, VK_K); break;
    case 'L': doType(VK_SHIFT, VK_L); break;
    case 'M': doType(VK_SHIFT, VK_M); break;
    case 'N': doType(VK_SHIFT, VK_N); break;
    case 'O': doType(VK_SHIFT, VK_O); break;
    case 'P': doType(VK_SHIFT, VK_P); break;
    case 'Q': doType(VK_SHIFT, VK_Q); break;
    case 'R': doType(VK_SHIFT, VK_R); break;
    case 'S': doType(VK_SHIFT, VK_S); break;
    case 'T': doType(VK_SHIFT, VK_T); break;
    case 'U': doType(VK_SHIFT, VK_U); break;
    case 'V': doType(VK_SHIFT, VK_V); break;
    case 'W': doType(VK_SHIFT, VK_W); break;
    case 'X': doType(VK_SHIFT, VK_X); break;
    case 'Y': doType(VK_SHIFT, VK_Y); break;
    case 'Z': doType(VK_SHIFT, VK_Z); break;
    case '`': doType(VK_BACK_QUOTE); break;
    case '0': doType(VK_0); break;
    case '1': doType(VK_1); break;
    case '2': doType(VK_2); break;
    case '3': doType(VK_3); break;
    case '4': doType(VK_4); break;
    case '5': doType(VK_5); break;
    case '6': doType(VK_6); break;
    case '7': doType(VK_7); break;
    case '8': doType(VK_8); break;
    case '9': doType(VK_9); break;
    case '-': doType(VK_MINUS); break;
    case '=': doType(VK_EQUALS); break;
    case '~': doType(VK_BACK_QUOTE); break;
    case '!': doType(VK_SHIFT, VK_EXCLAMATION_MARK); break;
    case '@': doType(VK_SHIFT, VK_AT); break;
    case '#': doType(VK_SHIFT, VK_NUMBER_SIGN); break;
    case '$': doType(VK_SHIFT, VK_DOLLAR); break;
    case '%': doType(VK_SHIFT, VK_5); break;
    case '^': doType(VK_SHIFT, VK_CIRCUMFLEX); break;
    case '&': doType(VK_SHIFT, VK_AMPERSAND); break;
    case '*': doType(VK_SHIFT, VK_ASTERISK); break;
    case '(': doType(VK_LEFT_PARENTHESIS); break;
    case ')': doType(VK_RIGHT_PARENTHESIS); break;
    case '_': doType(VK_SHIFT, VK_UNDERSCORE); break;
    case '+': doType(VK_SHIFT, VK_PLUS); break;
    case '\t': doType(VK_TAB); break;
    case '\n': doType(VK_ENTER); break;
    case '[': doType(VK_OPEN_BRACKET); break;
    case ']': doType(VK_CLOSE_BRACKET); break;
    case '\\': doType(VK_BACK_SLASH); break;
    case '{': doType(VK_SHIFT, VK_OPEN_BRACKET); break;
    case '}': doType(VK_SHIFT, VK_CLOSE_BRACKET); break;
    case '|': doType(VK_SHIFT, VK_BACK_SLASH); break;
    case ';': doType(VK_SEMICOLON); break;
    case ':': doType(VK_SHIFT, VK_COLON); break;
    case '\'': doType(VK_QUOTE); break;
    case '"': doType(VK_SHIFT, VK_QUOTEDBL); break;
    case ',': doType(VK_COMMA); break;
    case '<': doType(VK_SHIFT, VK_COMMA); break;
    case '.': doType(VK_PERIOD); break;
    case '>': doType(VK_SHIFT, VK_PERIOD); break;
    case '/': doType(VK_SLASH); break;
    case '?': doType(VK_SHIFT, VK_SLASH); break;
    case ' ': doType(VK_SPACE); break;
    case '\b': doType(VK_BACK_SPACE); break;
    default:
        throw new IllegalArgumentException("Cannot type character " + character);
    }
}
1
Varun Kumar

同じ問題がありました。以下のコードは、文字列をキーイベントに変換する簡単な方法であることがわかりました。ほとんどの人は、小文字と大文字の違いを説明するための非常に実装固有の修正プログラムを持っているようです。 VKキーは大文字と小文字を区別しないため、すべてを大文字にキャストすると問題が解決するようです。

for(int i = 0; i < string.length(); i++){
    char c = Character.toUpperCase(s.charAt(i));
    KeyEvent ke = new KeyEvent(source, KeyEvent.KEY_PRESSED, System.currentTimeMillis(), 0, (int)c, c);
    //do whatever with key event
}

また、これは文字や数字に対してはうまくいくと言いたかったのですが、他の文字に対してはうまくいかないかもしれません。この手法は、アクセント/バックティックマークを数字パッド0（VK_NUMPAD0）

1
Gregory Peck

Adam Paynterのソリューションについてコメントするために50の評判ポイントがあればいいのですが、まだありません。

彼のKeyboardクラスはうまく機能しましたが、_:_、_\_、_/_など、アルファベット順ではないキーに問題がありました。

私が見つけた解決策は、そのようなキーの_<ALT>_が入力されている間に_<ASCII code>_を押して保持することでした。

まず、メソッドdoType()を変更してSHIFTおよび/またはALTpressedのみを保持しますが、ASCIIコードを構成するすべてのキーを保持するわけではありません。かなり、それは人間がキーボードを使用する方法です:)

_private void doType(int[] keyCodes, int offset, int length) {
    if (length == 0) {
        return;
    }

    robot.keyPress(keyCodes[offset]);

    if (keyCodes[offset] == KeyEvent.VK_ALT
        || keyCodes[offset] == KeyEvent.VK_SHIFT) {
        doType(keyCodes, offset + 1, length - 1);
        robot.keyRelease(keyCodes[offset]);
    } else {
        robot.keyRelease(keyCodes[offset]);
        doType(keyCodes, offset + 1, length - 1);
    }

}
_

次に、switch caseを変更して、ALTとASCIIコードを渡します。

_        case '\\' :
            doType(KeyEvent.VK_ALT, KeyEvent.VK_NUMPAD9,
                    KeyEvent.VK_NUMPAD2);
        case ':' :
            doType(KeyEvent.VK_ALT, KeyEvent.VK_NUMPAD5,
                    KeyEvent.VK_NUMPAD8);
        case '/' :
            doType(KeyEvent.VK_ALT, KeyEvent.VK_NUMPAD4,
                    KeyEvent.VK_NUMPAD7);
_

================================================== =====追加

このクラスをもう少し調整しました。

_import Java.awt.AWTException;
import Java.awt.Robot;
import Java.awt.event.KeyEvent;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Keyboard {

    private static final Logger LOG = LoggerFactory.getLogger(Utils.class);

    private Robot robot;

    public Keyboard() {
        try {
            this.robot = new Robot();
        } catch (AWTException e) {
            LOG.error("Unable to create Robot object", e);
            throw new RuntimeException(e);
        }
    }

    public void type(String text) {
        char c;

        for (int ii = 0; ii < text.length(); ii++) {
            c = text.charAt(ii);

            if (c <= 31 || c == 129) {
                pressControlKey(c);
            } else {
                typeAsciiCode(c);
            }
        }
    }

    private void pressControlKey(char c) {
        robot.keyPress(c);
        robot.keyRelease(c);
    }

    private void typeAsciiCode(char c) {
        robot.keyPress(KeyEvent.VK_ALT);

        String asciiCode = Integer.toString(c);
        for (int i = 0; i < asciiCode.length(); i++) {
            c = (char) (asciiCode.charAt(i) + '0');
            robot.keyPress(c);
            robot.keyRelease(c);
        }
        robot.keyRelease(KeyEvent.VK_ALT);
    }
}
_
1
cbaldan
import Java.awt.Robot;
import Java.awt.event.KeyEvent;

/**
 * @author Trevor
 * Handles alpha numerics and common punctuation
 */
public class RobotKeyboard{

    private Robot robot;

    public RobotKeyboard(Robot robot){
        this.robot = robot;
    }

    public void typeMessage(String message){
        for (int i = 0; i < message.length(); i++){
            handleRepeatCharacter(message, i);
            type(message.charAt(i));
        }
    }

    private void handleRepeatCharacter(String message, int i){
        if(i == 0)
            return;
        //The robot won't type the same letter twice unless we release a key.
        if(message.charAt(i) == message.charAt(i-1)){
            robot.keyPress(KeyEvent.VK_SHIFT);
            robot.keyRelease(KeyEvent.VK_SHIFT);
        }
    }

    private void type(char character){
        handleSpecialCharacter(character);

        if (Character.isLowerCase(character)){
            typeCharacter(Character.toUpperCase(character));
        }
        if (Character.isUpperCase(character)){
            typeShiftCharacter(character);
        }
        if (Character.isDigit(character)){
            typeCharacter(character);
        }
    }

    private void handleSpecialCharacter(char character){
        if (character == ' ')
            typeCharacter(KeyEvent.VK_SPACE);
        if (character == '.')
            typeCharacter(KeyEvent.VK_PERIOD);
        if (character == '!')
            typeShiftCharacter(KeyEvent.VK_1);
        if (character == '?')
            typeShiftCharacter(KeyEvent.VK_SLASH);
        if (character == ',')
            typeCharacter(KeyEvent.VK_COMMA);

        //More specials here as needed
    }

    private void typeCharacter(int character){
        robot.keyPress(character);
    }

    private void typeShiftCharacter(int character){
        robot.keyPress(KeyEvent.VK_SHIFT);
        robot.keyPress(character);
        robot.keyRelease(KeyEvent.VK_SHIFT);
    }

}
1
trevorism

ちょうど別の例。便利になることがあります。

public void writeKeyboard(Robot robot, String string)  {
    int ascii;
    for(int i = 0; i < string.length(); i++) {
        ascii = (int)string.charAt(i);
        robot.keyPress(ascii);
        robot.delay(10);// choose your time or random it
        robot.keyRelease(ascii);
        robot.delay(10);
    }
}
0
Nelson Macieira

Ryan HilbertとAdam Paynterの回答を組み合わせることで、最高の結果が得られることがわかりました。単一キーの速度と代替コードの堅牢性を兼ね備えています。結合されたコード：

/**
 * Created by Daniel on 25/8/2016.
 */

import Java.awt.AWTException;
import Java.awt.Robot;

import static Java.awt.event.KeyEvent.VK_0;
import static Java.awt.event.KeyEvent.VK_1;
import static Java.awt.event.KeyEvent.VK_2;
import static Java.awt.event.KeyEvent.VK_3;
import static Java.awt.event.KeyEvent.VK_4;
import static Java.awt.event.KeyEvent.VK_5;
import static Java.awt.event.KeyEvent.VK_6;
import static Java.awt.event.KeyEvent.VK_7;
import static Java.awt.event.KeyEvent.VK_8;
import static Java.awt.event.KeyEvent.VK_9;
import static Java.awt.event.KeyEvent.VK_A;
import static Java.awt.event.KeyEvent.VK_ALT;
import static Java.awt.event.KeyEvent.VK_B;
import static Java.awt.event.KeyEvent.VK_BACK_QUOTE;
import static Java.awt.event.KeyEvent.VK_BACK_SLASH;
import static Java.awt.event.KeyEvent.VK_C;
import static Java.awt.event.KeyEvent.VK_CLOSE_BRACKET;
import static Java.awt.event.KeyEvent.VK_COLON;
import static Java.awt.event.KeyEvent.VK_COMMA;
import static Java.awt.event.KeyEvent.VK_D;
import static Java.awt.event.KeyEvent.VK_E;
import static Java.awt.event.KeyEvent.VK_ENTER;
import static Java.awt.event.KeyEvent.VK_EQUALS;
import static Java.awt.event.KeyEvent.VK_F;
import static Java.awt.event.KeyEvent.VK_G;
import static Java.awt.event.KeyEvent.VK_H;
import static Java.awt.event.KeyEvent.VK_I;
import static Java.awt.event.KeyEvent.VK_J;
import static Java.awt.event.KeyEvent.VK_K;
import static Java.awt.event.KeyEvent.VK_L;
import static Java.awt.event.KeyEvent.VK_M;
import static Java.awt.event.KeyEvent.VK_MINUS;
import static Java.awt.event.KeyEvent.VK_N;
import static Java.awt.event.KeyEvent.VK_NUMPAD0;
import static Java.awt.event.KeyEvent.VK_O;
import static Java.awt.event.KeyEvent.VK_OPEN_BRACKET;
import static Java.awt.event.KeyEvent.VK_P;
import static Java.awt.event.KeyEvent.VK_PERIOD;
import static Java.awt.event.KeyEvent.VK_Q;
import static Java.awt.event.KeyEvent.VK_QUOTE;
import static Java.awt.event.KeyEvent.VK_QUOTEDBL;
import static Java.awt.event.KeyEvent.VK_R;
import static Java.awt.event.KeyEvent.VK_S;
import static Java.awt.event.KeyEvent.VK_SEMICOLON;
import static Java.awt.event.KeyEvent.VK_SHIFT;
import static Java.awt.event.KeyEvent.VK_SLASH;
import static Java.awt.event.KeyEvent.VK_SPACE;
import static Java.awt.event.KeyEvent.VK_T;
import static Java.awt.event.KeyEvent.VK_TAB;
import static Java.awt.event.KeyEvent.VK_U;
import static Java.awt.event.KeyEvent.VK_V;
import static Java.awt.event.KeyEvent.VK_W;
import static Java.awt.event.KeyEvent.VK_X;
import static Java.awt.event.KeyEvent.VK_Y;
import static Java.awt.event.KeyEvent.VK_Z;

public class Keyboard { // http://stackoverflow.com/a/1248709/4330555

    private Robot robot;

    public Keyboard() throws AWTException {
        this.robot = new Robot();
    }

    public Keyboard(Robot robot) {
        this.robot = robot;
    }

    public void type(CharSequence characters) {
        int length = characters.length();
        for (int i = 0; i < length; i++) {
            char character = characters.charAt(i);
            try {
                type(character);
            } catch (IllegalArgumentException e) {
                robot.keyPress(VK_ALT);
                robot.keyPress(VK_NUMPAD0);
                robot.keyRelease(VK_NUMPAD0);
                String altCode = Integer.toString(character);
                for (int j = 0; j < altCode.length(); j++) {
                    char c = (char) (altCode.charAt(j) + '0');
                    robot.keyPress(c);
                    robot.keyRelease(c);
                }
                robot.keyRelease(VK_ALT);
            }
        }
    }

    public void type(char character) {
        switch (character) {
            case 'a':
                doType(VK_A);
                break;
            case 'b':
                doType(VK_B);
                break;
            case 'c':
                doType(VK_C);
                break;
            case 'd':
                doType(VK_D);
                break;
            case 'e':
                doType(VK_E);
                break;
            case 'f':
                doType(VK_F);
                break;
            case 'g':
                doType(VK_G);
                break;
            case 'h':
                doType(VK_H);
                break;
            case 'i':
                doType(VK_I);
                break;
            case 'j':
                doType(VK_J);
                break;
            case 'k':
                doType(VK_K);
                break;
            case 'l':
                doType(VK_L);
                break;
            case 'm':
                doType(VK_M);
                break;
            case 'n':
                doType(VK_N);
                break;
            case 'o':
                doType(VK_O);
                break;
            case 'p':
                doType(VK_P);
                break;
            case 'q':
                doType(VK_Q);
                break;
            case 'r':
                doType(VK_R);
                break;
            case 's':
                doType(VK_S);
                break;
            case 't':
                doType(VK_T);
                break;
            case 'u':
                doType(VK_U);
                break;
            case 'v':
                doType(VK_V);
                break;
            case 'w':
                doType(VK_W);
                break;
            case 'x':
                doType(VK_X);
                break;
            case 'y':
                doType(VK_Y);
                break;
            case 'z':
                doType(VK_Z);
                break;
            case 'A':
                doType(VK_SHIFT, VK_A);
                break;
            case 'B':
                doType(VK_SHIFT, VK_B);
                break;
            case 'C':
                doType(VK_SHIFT, VK_C);
                break;
            case 'D':
                doType(VK_SHIFT, VK_D);
                break;
            case 'E':
                doType(VK_SHIFT, VK_E);
                break;
            case 'F':
                doType(VK_SHIFT, VK_F);
                break;
            case 'G':
                doType(VK_SHIFT, VK_G);
                break;
            case 'H':
                doType(VK_SHIFT, VK_H);
                break;
            case 'I':
                doType(VK_SHIFT, VK_I);
                break;
            case 'J':
                doType(VK_SHIFT, VK_J);
                break;
            case 'K':
                doType(VK_SHIFT, VK_K);
                break;
            case 'L':
                doType(VK_SHIFT, VK_L);
                break;
            case 'M':
                doType(VK_SHIFT, VK_M);
                break;
            case 'N':
                doType(VK_SHIFT, VK_N);
                break;
            case 'O':
                doType(VK_SHIFT, VK_O);
                break;
            case 'P':
                doType(VK_SHIFT, VK_P);
                break;
            case 'Q':
                doType(VK_SHIFT, VK_Q);
                break;
            case 'R':
                doType(VK_SHIFT, VK_R);
                break;
            case 'S':
                doType(VK_SHIFT, VK_S);
                break;
            case 'T':
                doType(VK_SHIFT, VK_T);
                break;
            case 'U':
                doType(VK_SHIFT, VK_U);
                break;
            case 'V':
                doType(VK_SHIFT, VK_V);
                break;
            case 'W':
                doType(VK_SHIFT, VK_W);
                break;
            case 'X':
                doType(VK_SHIFT, VK_X);
                break;
            case 'Y':
                doType(VK_SHIFT, VK_Y);
                break;
            case 'Z':
                doType(VK_SHIFT, VK_Z);
                break;
            case '`':
                doType(VK_BACK_QUOTE);
                break;
            case '0':
                doType(VK_0);
                break;
            case '1':
                doType(VK_1);
                break;
            case '2':
                doType(VK_2);
                break;
            case '3':
                doType(VK_3);
                break;
            case '4':
                doType(VK_4);
                break;
            case '5':
                doType(VK_5);
                break;
            case '6':
                doType(VK_6);
                break;
            case '7':
                doType(VK_7);
                break;
            case '8':
                doType(VK_8);
                break;
            case '9':
                doType(VK_9);
                break;
            case '-':
                doType(VK_MINUS);
                break;
            case '=':
                doType(VK_EQUALS);
                break;
            case '~':
                doType(VK_SHIFT, VK_BACK_QUOTE);
                break;
            case '!':
                doType(VK_SHIFT, VK_1);
                break;
            case '@':
                doType(VK_SHIFT, VK_2);
                break;
            case '#':
                doType(VK_SHIFT, VK_3);
                break;
            case '$':
                doType(VK_SHIFT, VK_4);
                break;
            case '%':
                doType(VK_SHIFT, VK_5);
                break;
            case '^':
                doType(VK_SHIFT, VK_6);
                break;
            case '&':
                doType(VK_SHIFT, VK_7);
                break;
            case '*':
                doType(VK_SHIFT, VK_8);
                break;
            case '(':
                doType(VK_SHIFT, VK_9);
                break;
            case ')':
                doType(VK_SHIFT, VK_0);
                break;
            case '_':
                doType(VK_SHIFT, VK_MINUS);
                break;
            case '+':
                doType(VK_SHIFT, VK_EQUALS);
                break;
            case '\t':
                doType(VK_TAB);
                break;
            case '\n':
                doType(VK_ENTER);
                break;
            case '[':
                doType(VK_OPEN_BRACKET);
                break;
            case ']':
                doType(VK_CLOSE_BRACKET);
                break;
            case '\\':
                doType(VK_BACK_SLASH);
                break;
            case '{':
                doType(VK_SHIFT, VK_OPEN_BRACKET);
                break;
            case '}':
                doType(VK_SHIFT, VK_CLOSE_BRACKET);
                break;
            case '|':
                doType(VK_SHIFT, VK_BACK_SLASH);
                break;
            case ';':
                doType(VK_SEMICOLON);
                break;
            case ':':
                doType(VK_COLON);
                break;
            case '\'':
                doType(VK_QUOTE);
                break;
            case '"':
                doType(VK_QUOTEDBL);
                break;
            case ',':
                doType(VK_COMMA);
                break;
            case '<':
                doType(VK_SHIFT, VK_COMMA);
                break;
            case '.':
                doType(VK_PERIOD);
                break;
            case '>':
                doType(VK_SHIFT, VK_PERIOD);
                break;
            case '/':
                doType(VK_SLASH);
                break;
            case '?':
                doType(VK_SHIFT, VK_SLASH);
                break;
            case ' ':
                doType(VK_SPACE);
                break;
            default:
                throw new IllegalArgumentException("Cannot type character " + character);
        }
    }

    private void doType(int... keyCodes) {
        doType(keyCodes, 0, keyCodes.length);
    }

    private void doType(int[] keyCodes, int offset, int length) {
        if (length == 0) {
            return;
        }

        robot.keyPress(keyCodes[offset]);
        doType(keyCodes, offset + 1, length - 1);
        robot.keyRelease(keyCodes[offset]);
    }

}
0
Daniël van den Berg

私はcommandmapメソッドを知りませんが、見た目が良いので、見てみましょう。

最後に、a〜zのキーコードが65〜90であることを発見しました。

private void write(Robot bot, String st) {
    char[] arr = st.toCharArray();
    int i = arr.length;
    int j = 0;
    while (j<i) {
        int kcode = (int) arr[j] - 32;
        bot.keyPress(kcode);
        bot.keyRelease(kcode);
        j++;
    }       
}

小文字でのみ機能します（大文字の簡単なテストで簡単に修正できます）。

私が探していたものは完璧に動作します:-)

0
Martin Trigaux