Преобразование String в 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++; } } 

Я в основном использую прославленный оператор 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) пользовательский ключ, вы можете расширить class и переопределить метод 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; } } } 

Конечно, есть место для улучшения, но вы понимаете.

Я использовал буфер обмена для решения проблемы …

 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); } 

Вы можете сделать это просто через API отражения Java:

 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); } } 

Недавно я написал class для этого. Он вводит код 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 

Вот как мне удалось использовать все доступные ключи. Создайте карту и заполните карту, используя метод fillKeyMap. Теперь вы можете использовать строковое представление ключевых событий и преобразовать его обратно в коды KeyEvent с помощью карты.

 /** Create map with string values to integer pairs */ public static final void fillKeyMap(Map 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) {} } 

Я в основном использую шаблон Command, как Rich Seller делает в своем ответе, с двумя незначительными изменениями для краткости:

  • использование шаблона украшения для повторного использования экземпляров команды az
  • использование отражения для удаления 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 commandMap = new HashMap(); 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))); } 

как ожидалось, эти результаты:



 SHIFT + b
 SHIFT + b
 SHIFT + b

Это немного Kludge, но вы можете использовать шаблон Command, чтобы инкапсулировать нажатия клавиш для каждого символа в String, затем получить команду для каждого символа поочередно и вызвать метод. Преимущество этого заключается в том, что вам нужно только настроить карту один раз. Недостатком является то, что он по-прежнему включает в себя кучу болтера:

 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); } 

Ваш код будет работать до тех пор, пока вы используете только буквенно-цифровые символы, он не будет работать для таких символов, как «:». Класс SmartRobot справится с этим.

Принятый ответ кажется мне очень раздутым. Вот немного более сжатое решение, которое основано на принятом ответе. Он должен обрабатывать практически любой вариант использования. Также обрабатывает \n (новая строка), \t (tab) и \b (backspace), как показано в примере.

 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("[email protected]#$%^&*()_+{}|:\"<>?\n"); keyboard.type("abcdefghijklmnopqrstuvwxyz\n\tABCDEFGHIJKLMNOPQRSTUVWXYZ"); keyboard.type("\n\n\twh\bat"); } private static AWTKeyStroke getKeyStroke(char c) { String upper = "`~'\"[email protected]#$%^&*()_+{}|:<>?"; 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); } } } } 
 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); } } 

Я была такая же проблема. Я обнаружил, что приведенный ниже код был простым способом перевести строку в ключевые события. Похоже, что у большинства людей были специфические исправления для внедрения различий между нижним и верхним регистром. Поскольку клавиши 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 )

Хотелось бы, чтобы у меня было 50 очков репутации, чтобы прокомментировать решение Адама Пейнтера , но еще нет.

Класс Keyboard работал хорошо, но у меня были проблемы с ключами, которые не являются алфавитами, такими как : \ и / .

Решение, которое я нашел, было нажатием и удерживанием пока набирается таких клавиш.

Прежде всего, я изменил метод doType() чтобы удерживать только SHIFT и / или ALT нажатыми, но не каждый отдельный ключ, который составляет код 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); } } 

Затем я изменил корпус коммутатора, чтобы передать 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); 

================================================== ===== ДОБАВЛЕНИЕ

Я немного изменил этот class:

 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); } } 

Небольшая модификация ответа Адама Пейнтера, потому что код не работал для всех ключей, например!, @, #, $ И т. Д. (Необходимо сначала нажать 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); } } 

Я не знаю метод командной строки, но выглядит хорошо, я посмотрю.

Наконец, я обнаружил, что код ключа от a до z составляет от 65 до 90. Итак

 private void write(Robot bot, String st) { char[] arr = st.toCharArray(); int i = arr.length; int j = 0; while (j 

Он просто работает для строчных букв (вы можете легко исправить его с помощью простого теста для прописных букв).

Для того, что я искал, он отлично работает 🙂

Я обнаружил, что сочетание ответов Райана Гилберта и Адама Пейнтера дало мне лучший результат. Он сочетает в себе скорость одиночных ключей с надежностью альт-кодов. Комбинированный код:

 /** * 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]); } } 

Еще один пример. Может стать удобным.

 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); } } 
  • Открыты ли статические поля для сбора мусора?
  • Неплохо ли использовать рефлексию в модульном тестировании?
  • Слушатель модели JTable слишком быстро обнаруживает вставленные строки (до их рисования)
  • Что такое Maven Snapshot и зачем нам это нужно?
  • BigInteger: подсчитывает количество десятичных цифр в масштабируемом методе
  • Пример XML Parser DOM
  • Не удалось создать JAXBContext, создав мой wsdl
  • Hibernate: как переопределить атрибут из сопоставленного суперclassа
  • Статические конечные значения Java заменяются в коде при компиляции?
  • Разбор файла yaml
  • Весна 3.1, Hibernate 4, SessionFactory
  • Interesting Posts

    Android – извлечение файлов cookie после входа в webview

    Воспроизведение файлов MP3 с iPhone SDK

    Общее представление DbDataReader для отображения

    Весенняя безопасность: добавление «При успешном прослушивании событий входа в систему»

    Отобразить свободное пространство файловой системы для пользователя root

    Xcode Version 6.1 (6A1030) – Ошибка Apple-O-Linker – создание

    Установленная память 4 ГБ, но только 1,93 ГБ – полезная информация в диалоговом окне свойств системы?

    Приложение преобразования DJVU в PDF

    Процессор потребляет меньше энергии, когда он не работает?

    Список привязок к DataGridView в WinForm

    Мышь работает и выключается и делает звуковые звуки … как это исправить?

    Укажите порядок сортировки в «copy / b * .dat foo» в Windows cmd

    У Microsoft SkyDrive есть API?

    В Perl, как мне изменить, удалить или вставить строку в файл или добавить к началу файла?

    Восстановите поведение браузера в среднем клике

    Давайте будем гением компьютера.