RSyntaxTextArea has built-in support for search and replace operations, with all of the options you'd expect, including:

• Search forward or backward
• Match case
• Regular expressions
• Whole word
• Mark all

These actions (except for Mark All) are done with the SearchEngine class. This class contains self-explanatory methods for all your searching needs:

• find - Find the next/previous match with any of the above options.
• replace - Finds the next/previous match and replaces it with new text.
• replaceAll - Finds all matches and replaces them with the new text.

Each of these methods takes two parameters: The RSyntaxTextArea instance to search in, and a SearchContext specifying what to search for, and how to search for it.

Finally, RTextArea (and thus RSyntaxTextArea) has a markAll method that uses the SearchEngine class to mark all instances of a given string in the editor.

Using the SearchEngine class makes implementing Find & Replace in an RSyntaxTextArea extremely easy. Below is a simple example of how it can be used.

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

import org.fife.ui.rtextarea.*;
import org.fife.ui.rsyntaxtextarea.*;

/**
 * A simple example showing how to do search and replace in a RSyntaxTextArea.
 * The toolbar isn't very user-friendly, but this is just to show you how to use
 * the API.<p>
 * 
 * This example uses RSyntaxTextArea 2.0.1.<p>
 * 
 * Project Home: http://fifesoft.com/rsyntaxtextarea<br>
 * Downloads: https://sourceforge.net/projects/rsyntaxtextarea
 */
public class FindAndReplaceDemo extends JFrame implements ActionListener {

   private static final long serialVersionUID = 1L;

   private RSyntaxTextArea textArea;
   private JTextField searchField;
   private JCheckBox regexCB;
   private JCheckBox matchCaseCB;

   public FindAndReplaceDemo() {

      JPanel cp = new JPanel(new BorderLayout());

      textArea = new RSyntaxTextArea(20, 60);
      textArea.setSyntaxEditingStyle(SyntaxConstants.SYNTAX_STYLE_JAVA);
      textArea.setCodeFoldingEnabled(true);
      textArea.setAntiAliasingEnabled(true);
      RTextScrollPane sp = new RTextScrollPane(textArea);
      sp.setFoldIndicatorEnabled(true);
      cp.add(sp);

      // Create a toolbar with searching options.
      JToolBar toolBar = new JToolBar();
      searchField = new JTextField(30);
      toolBar.add(searchField);
      final JButton nextButton = new JButton("Find Next");
      nextButton.setActionCommand("FindNext");
      nextButton.addActionListener(this);
      toolBar.add(nextButton);
      searchField.addActionListener(new ActionListener() {
         public void actionPerformed(ActionEvent e) {
            nextButton.doClick(0);
         }
      });
      JButton prevButton = new JButton("Find Previous");
      prevButton.setActionCommand("FindPrev");
      prevButton.addActionListener(this);
      toolBar.add(prevButton);
      regexCB = new JCheckBox("Regex");
      toolBar.add(regexCB);
      matchCaseCB = new JCheckBox("Match Case");
      toolBar.add(matchCaseCB);
      cp.add(toolBar, BorderLayout.NORTH);

      setContentPane(cp);
      setTitle("Find and Replace Demo");
      setDefaultCloseOperation(EXIT_ON_CLOSE);
      pack();
      setLocationRelativeTo(null);

   }

   public void actionPerformed(ActionEvent e) {

      // "FindNext" => search forward, "FindPrev" => search backward
      String command = e.getActionCommand();
      boolean forward = "FindNext".equals(command);

      // Create an object defining our search parameters.
      SearchContext context = new SearchContext();
      String text = searchField.getText();
      if (text.length() == 0) {
         return;
      }
      context.setSearchFor(text);
      context.setMatchCase(matchCaseCB.isSelected());
      context.setRegularExpression(regexCB.isSelected());
      context.setSearchForward(forward);
      context.setWholeWord(false);

      boolean found = SearchEngine.find(textArea, context);
      if (!found) {
         JOptionPane.showMessageDialog(this, "Text not found");
      }

   }

   public static void main(String[] args) {
      // Start all Swing applications on the EDT.
      SwingUtilities.invokeLater(new Runnable() {
         public void run() {
            try {
               String laf = UIManager.getSystemLookAndFeelClassName();
               UIManager.setLookAndFeel(laf);
            } catch (Exception e) { /* never happens */ }
            FindAndReplaceDemo demo = new FindAndReplaceDemo();
            demo.setVisible(true);
            demo.textArea.requestFocusInWindow();
         }
      });
   }

}

Save this file as FindAndReplaceDemo.java.

For simplicity, we will just use javac on the command line to compile. Bring up a command prompt or shell, make sure javac is on your PATH, and run the following command:

Windows:  javac -classpath <path-to-jar>\rsyntaxtextarea.jar FindAndReplaceDemo.java
Unix:     javac -classpath <path-to-jar>/rsyntaxtextarea.jar FindAndReplaceDemo.java

where <path-to-jar> is the path to the rsyntaxtextarea.jar file. This should yield no errors or warnings, and on completion there should see a file named FindAndReplaceDemo.class in your current directory.

Running the example is just as simple as compiling it:

Windows:  java -classpath <path-to-jar>\rsyntaxtextarea.jar;. FindAndReplaceDemo
Unix:     java -classpath <path-to-jar>/rsyntaxtextarea.jar:. FindAndReplaceDemo

A window should pop up, containing a text editor. At the top is a toolbar that allows you to search for text using several of the common options found in most editing applications.