Tapez une chaîne de caractères en utilisant java.awt.Robot

vous devez "taper" le caractère, qui est une action de presse et de publication...

robot.keyPress(KeyEvent.VK_1);  
robot.keyRelease(KeyEvent.VK_1);  

Maintenant vous pouvez simplement le copier et le coller trois fois, mais je le mettrais dans une boucle

Vous pouvez entrer la valeur dans une chaîne et ensuite vous pouvez utiliser cette chaîne comme expliqué par Eng.Fouad. Mais il n'y a pas de plaisir en l'utilisant, vous pouvez donner un essai à ce

Robot robot = new Robot();
robot.keyPress(KeyEvent.VK_H);
robot.keyRelease(KeyEvent.VK_H);
robot.keyPress(KeyEvent.VK_E);
robot.keyRelease(KeyEvent.VK_E);
robot.keyPress(KeyEvent.VK_L);
robot.keyRelease(KeyEvent.VK_L);
robot.keyPress(KeyEvent.VK_L);
robot.keyRelease(KeyEvent.VK_L);
robot.keyPress(KeyEvent.VK_O);
robot.keyRelease(KeyEvent.VK_O);

et vous pouvez également utiliser Thread.dormir pour qu'il puisse entrer des données un peu lentement.

depuis Java 7, Vous pouvez également utiliser KeyEvent.getExtendedKeyCodeForChar (c). Un exemple pour les minuscules seulement pourrait être:

void sendKeys(Robot robot, String keys) {
    for (char c : keys.toCharArray()) {
        int keyCode = KeyEvent.getExtendedKeyCodeForChar(c);
        if (KeyEvent.CHAR_UNDEFINED == keyCode) {
            throw new RuntimeException(
                "Key code not found for character '" + c + "'");
        }
        robot.keyPress(keyCode);
        robot.delay(100);
        robot.keyRelease(keyCode);
        robot.delay(100);
    }
}

je pense que j'ai mis en place une meilleure soultion, peut-être quelqu'un l'a trouvé utile (l'approche principale est de lire toutes les valeurs de l'enum mot de Code et de le mettre dans une table de hachage et l'utiliser plus tard pour trouver une clé de type int code)

public class KeysMapper {

    private static HashMap<Character, Integer> charMap = new HashMap<Character, Integer>();

    static {
        for (KeyCode keyCode : KeyCode.values()) {
            if (keyCode.impl_getCode() >= 65 && keyCode.impl_getCode() <= 90){
                charMap.put(keyCode.getName().toLowerCase().toCharArray()[0], keyCode.impl_getCode());
            }
            else{
                charMap.put(keyCode.getName().toLowerCase().toCharArray()[0], keyCode.impl_getCode());
            }
        }
    }
    public static Key charToKey(char c){
        if(c>=65 && c<=90){
            return new Key(charMap.get(c), true);
        } else {
            return new Key(charMap.get(c), false);
        }
    }

    public static List<Key> stringToKeys(String text){
        List<Key> keys = new ArrayList<Key>();
        for (char c : text.toCharArray()) {
            keys.add(charToKey(c));
        }
        return keys;
    }

j'ai aussi créé une classe clé pour savoir si je dois taper un char en majuscules ou en minuscules:

public class Key {

    int keyCode;
    boolean uppercase;

//getters setter constructors}

et enfin, vous pouvez l'utiliser comme ça (pour un seul caractère) robot.keyPress(charToKey('a').getKeyCode()); Si vous voulez appuyer sur une majuscule, vous devez appuyer et relâcher avec shift clé simultanément

StringSelection path = new StringSelection ("chemin de votre document");

    // create an object to desktop

    Toolkit tol = Toolkit.getDefaultToolkit();

    // get control of mouse cursor

    Clipboard c = tol.getSystemClipboard();

    // copy the path into mouse
    c.setContents(path, null);

    // create a object of robot class

    Robot r = new Robot();

    r.keyPress(KeyEvent.VK_CONTROL);
    r.keyPress(KeyEvent.VK_V);
    r.keyRelease(KeyEvent.VK_CONTROL);
    r.keyRelease(KeyEvent.VK_V);
    r.keyPress(KeyEvent.VK_ENTER);
    r.keyRelease(KeyEvent.VK_ENTER);

}

ceci ne tape pas la chaîne entière mais aide à taper ce que vous voulez autre qu'un caractère à la fois.

    Runtime.getRuntime().exec("notepad.exe");//or anywhere you want.
   Thread.sleep(5000);//not required though gives a good feel.
    Robot r=new Robot();      
     String a="Hi My name is Whatever you want to say.";
    char c;
     int d=a.length(),e=0,f=0;

     while(e<=d)
    {
     c=a.charAt(e);
     f=(int) c; //converts character to Unicode. 
      r.keyPress(KeyEvent.getExtendedKeyCodeForChar(f));
     e++;
       Thread.sleep(150);

       }

voir cela fonctionne parfaitement et c'est génial! Bien qu'il ne fonctionne pas pour les caractères spéciaux qui ne peuvent pas être tracés par unicode comme |,!...etc.