How to use

StringSelection

in

java.awt.datatransfer

@Override
public void setContents (String content) {
  try {
    StringSelection stringSelection = new StringSelection(content);
    java.awt.datatransfer.Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
    clipboard.setContents(stringSelection, this);
  } catch (Exception ignored) { // Ignore JDK crashes sorting data flavors.
  }
}

throws UnsupportedFlavorException, IOException
Clipboard c = Toolkit.getDefaultToolkit().getSystemClipboard();
StringSelection testData;
  testData = new StringSelection( args[0] );
else
  testData = new StringSelection( "Test Data" );
c.setContents(testData, testData);
Transferable t = c.getContents( null );
if ( t.isDataFlavorSupported(DataFlavor.stringFlavor) )
  Object o = t.getTransferData( DataFlavor.stringFlavor );
  String data = (String)t.getTransferData( DataFlavor.stringFlavor );
  System.out.println( "Clipboard contents: " + data );

@Override
public void type(CharSequence characters) 
{
  Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
  StringSelection stringSelection = new StringSelection( characters.toString() );
  clipboard.setContents(stringSelection, this);
  robot.keyPress(KeyEvent.VK_CONTROL);
  robot.keyPress(KeyEvent.VK_V);
  robot.keyRelease(KeyEvent.VK_V);
  robot.keyRelease(KeyEvent.VK_CONTROL);
}

 String text = "Hello World";
StringSelection stringSelection = new StringSelection(text);
Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
clipboard.setContents(stringSelection, stringSelection);

Robot robot = new Robot();
robot.keyPress(KeyEvent.VK_CONTROL);
robot.keyPress(KeyEvent.VK_V);
robot.keyRelease(KeyEvent.VK_V);
robot.keyRelease(KeyEvent.VK_CONTROL);

Transferable transferable = clipboard.getContents(null);
if (transferable.isDataFlavorSupported(DataFlavor.stringFlavor))
 String data = (String) transferable.getTransferData(DataFlavor.stringFlavor);
  StringSelection selection = new StringSelection("Test");
  clipboard.setContents(selection, selection);

private void clipboardTransfer(Robot robot, char ch) {
 try {
  StringSelection stringSelection = new StringSelection(Character.toString(ch));
  java.awt.datatransfer.Clipboard clpbrd = Toolkit.getDefaultToolkit().getSystemClipboard();
  Object recover = clpbrd.isDataFlavorAvailable(DataFlavor.stringFlavor) ? clpbrd.getData(DataFlavor.stringFlavor) : null;
  clpbrd.setContents(stringSelection, null);
  robot.keyPress(controlKeyEvent);
  robot.keyPress(VK_V);
  robot.keyRelease(VK_V);
  robot.keyRelease(controlKeyEvent);
  robot.delay(50);
  StringSelection recoverSelection = new StringSelection(recover != null ? recover.toString() : "");
  clpbrd.setContents(recoverSelection, null);
 } catch (Exception e) {
  logger.error(e.getMessage(), e);
 }
}

System.out.println("Paste " + text);
setClip(text);
rob.keyPress(KeyEvent.VK_CONTROL);
rob.keyPress(KeyEvent.VK_V);
rob.keyRelease(KeyEvent.VK_V);
rob.keyRelease(KeyEvent.VK_CONTROL);
  Clipboard sysClip = Toolkit.getDefaultToolkit().getSystemClipboard();
  System.out.println("Current clipboard contents = " + getClipboardContents(sysClip));
  sysClip.setContents(new StringSelection(toPaste), null);
  System.out.println("New clipboard contents = " + getClipboardContents(sysClip));
  int retries = 0;
  while (!successful && retries < 20) {
    Transferable contents = clipboard.getContents(null);
    if (contents.isDataFlavorSupported(DataFlavor.stringFlavor)) {
      try {
        value = (String) contents.getTransferData(DataFlavor.stringFlavor);
        successful = true;
      } catch (Exception exp) {

 // If a string is on the system clipboard, this method returns it;
// otherwise it returns null.
public static String getClipboard() {
  Transferable t = Toolkit.getDefaultToolkit().getSystemClipboard().getContents(null);

  try {
    if (t != null && t.isDataFlavorSupported(DataFlavor.stringFlavor)) {
      String text = (String)t.getTransferData(DataFlavor.stringFlavor);
      return text;
    }
  } catch (UnsupportedFlavorException e) {
  } catch (IOException e) {
  }
  return null;
}

// This method writes a string to the system clipboard.
// otherwise it returns null.
public static void setClipboard(String str) {
  StringSelection ss = new StringSelection(str);
  Toolkit.getDefaultToolkit().getSystemClipboard().setContents(ss, null);
}

if (contents != null) { 
  try {
    String s = (String)contents.getTransferData(DataFlavor.stringFlavor);
    if (s != null)
StringSelection ss = new StringSelection(data); 
if (ss != null)
  setClipboardContents(ss);

  public void actionPerformed(ActionEvent actionEvent) {
    Clipboard clipboard = getToolkit().getSystemClipboard();
    StringSelection ss = new StringSelection(log);
    clipboard.setContents(ss, ExceptionDialog.this);
  }
});

 String myString = "This text will be copied into clipboard when running this code!";
StringSelection stringSelection = new StringSelection(myString);
Clipboard clpbrd = Toolkit.getDefaultToolkit().getSystemClipboard();
clpbrd.setContents(stringSelection, null);

final StringSelection ss = new StringSelection(text+"\n");
return new Transferable() {
 @Override public DataFlavor[] getTransferDataFlavors() {
  ArrayList<DataFlavor> list = new ArrayList<>();
  for(DataFlavor f:ss.getTransferDataFlavors()) {
   list.add(f);
   return dh.getTransferData(flavor);
  } else {
   return ss.getTransferData(flavor);
DragPanel target = (DragPanel)support.getComponent();
try {
 DragPanel src = (DragPanel)support.getTransferable().getTransferData(localObjectFlavor);
 JLabel l = new JLabel();
 l.setIcon(src.draggingLabel.getIcon());

 //First of all declare the method setClipboardData as below:
public void setClipboardData(String string) {
    StringSelection stringSelection = new StringSelection(string);
    Toolkit.getDefaultToolkit().getSystemClipboard().setContents(stringSelection, null);
  }
//Call the method setClipboardData and write other Robot code:
driver.get("https://www.google.com/");
    driver.findElement(By.id("lst-ib")).clear();
    driver.findElement(By.id("lst-ib")).sendKeys("");

    Robot robot = new Robot();
    setClipboardData("ALL CAPS");
    robot.keyPress(KeyEvent.VK_CONTROL);
    robot.keyPress(KeyEvent.VK_V);
    robot.keyRelease(KeyEvent.VK_V);
    robot.keyRelease(KeyEvent.VK_CONTROL);
    robot.keyPress(KeyEvent.VK_ENTER);
    robot.keyRelease(KeyEvent.VK_ENTER);

@Override
protected Transferable createTransferable(JComponent c) {
 return new StringSelection(exportString(c));
}

public DataFlavor[] getTransferDataFlavors() {
  DataFlavor[] dfs = super.getTransferDataFlavors();
  List flavors = new ArrayList(Arrays.asList(dfs));
  flavors.add(CODE_CLIP_DATA_FLAVOR);
  return (DataFlavor[])flavors.toArray(new DataFlavor[0]);
}

  @Override
  public void actionPerformed(ActionEvent e) {
    try {
      Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
      Transferable transf = clipboard.getContents(null); // argument is useless according to javaDoc
      if (transf.isDataFlavorSupported(DataFlavor.stringFlavor)) {
        String data = (String) transf.getTransferData(DataFlavor.stringFlavor);
        StringSelection stringSelection = new StringSelection(StringUtils.trim(data));
        clipboard.setContents(stringSelection, stringSelection);
      }
    } catch (Exception ex) {
    }
    action.actionPerformed(e);
  }
}

private void executeMessage(String message) {
  this.gameToFront();
  StringSelection selection = new StringSelection(message);
  Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
  clipboard.setContents(selection, null);
  MercuryStoreCore.blockHotkeySubject.onNext(true);
  robot.keyRelease(KeyEvent.VK_ALT);
  robot.keyPress(KeyEvent.VK_ENTER);
  robot.keyRelease(KeyEvent.VK_ENTER);
  robot.keyPress(KeyEvent.VK_CONTROL);
  robot.keyPress(KeyEvent.VK_A);
  robot.keyRelease(KeyEvent.VK_CONTROL);
  robot.keyRelease(KeyEvent.VK_A);
  robot.keyPress(KeyEvent.VK_BACK_SPACE);
  robot.keyRelease(KeyEvent.VK_BACK_SPACE);
  robot.keyPress(KeyEvent.VK_CONTROL);
  robot.keyPress(KeyEvent.VK_V);
  robot.keyRelease(KeyEvent.VK_V);
  robot.keyRelease(KeyEvent.VK_CONTROL);
  robot.keyPress(KeyEvent.VK_ENTER);
  robot.keyRelease(KeyEvent.VK_ENTER);
  MercuryStoreCore.blockHotkeySubject.onNext(false);
}

 Robot rb = new Robot();

StringSelection textToPaste= new StringSelection("  ");//make sure u enter tab here

Toolkit.getDefaultToolkit().getSystemClipboard().setContents(textToPaste, null);

rb.keyPress(KeyEvent.VK_CONTROL);    
rb.keyPress(KeyEvent.VK_V);    
rb.keyRelease(KeyEvent.VK_V);    
rb.keyRelease(KeyEvent.VK_CONTROL);

StringSelection ss = new StringSelection(message);
Clipboard cb = Toolkit.getDefaultToolkit().getSystemClipboard();
cb.setContents(ss, null);
Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
Transferable contents = clipboard.getContents(null);
boolean hasTransferableText =
    (contents != null)
    && contents.isDataFlavorSupported(DataFlavor.stringFlavor);
if (hasTransferableText) {
  try {
    result = (String) contents.getTransferData(DataFlavor.stringFlavor);
  } catch (UnsupportedFlavorException ex) {

StringSelection stringSelection = new StringSelection( aString );
Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
clipboard.setContents( stringSelection, this );
boolean hasTransferableText =
 (contents != null) &&
 contents.isDataFlavorSupported(DataFlavor.stringFlavor)
  result = (String)contents.getTransferData(DataFlavor.stringFlavor);