StringBuilder version of java.util.regex.Matcher.append* (original) (raw)

Tue Mar 25 21:07:59 UTC 2014

     that does not exist in the pattern
    // If no match, return error
    if (first < 0)
        throw new IllegalStateException("No match available");
   // Process substitution string to replace group references with groups
   StringBuilder result = new StringBuilder();
   appendExpandedReplacement(replacement, result);
   // Append the intervening text
   sb.append(text, lastAppendPosition, first);
   // Append the match substitution
   sb.append(result);
   lastAppendPosition = last;
   return this;
* Implements a non-terminal append-and-replace step.
*
* <p> This method performs the following actions: </p>
*
* <ol>
*
*   <li><p> It reads characters from the input sequence, starting at the
*   append position, and appends them to the given string builder.  It
*   stops after reading the last character preceding the previous match,
*   that is, the character at index {@link
*   #start()} <tt>-</tt> <tt>1</tt>.  </p></li>
*
*   <li><p> It appends the given replacement string to the string builder.
*   </p></li>
*
*   <li><p> It sets the append position of this matcher to the index of
*   the last character matched, plus one, that is, to {@link #end()}.
*   </p></li>
*
* </ol>
*
* <p> The replacement string may contain references to subsequences
* captured during the previous match: Each occurrence of
* <tt>$</tt><i>g</i><tt></tt> will be replaced by the result of
* evaluating {@link #group(int) group}<tt>(</tt><i>g</i><tt>)</tt>.
* The first number after the <tt>$</tt> is always treated as part of
* the group reference. Subsequent numbers are incorporated into g if
* they would form a legal group reference. Only the numerals '0'
* through '9' are considered as potential components of the group
* reference. If the second group matched the string <tt>"foo"</tt>, for
* example, then passing the replacement string <tt>"$2bar"</tt> would
* cause <tt>"foobar"</tt> to be appended to the string builder. A dollar
* sign (<tt>$</tt>) may be included as a literal in the replacement
* string by preceding it with a backslash (<tt>\$</tt>).
*
* <p> Note that backslashes (<tt>\</tt>) and dollar signs (<tt>$</tt>) in
* the replacement string may cause the results to be different than if it
* were being treated as a literal replacement string. Dollar signs may be
* treated as references to captured subsequences as described above, and
* backslashes are used to escape literal characters in the replacement
* string.
*
* <p> This method is intended to be used in a loop together with the
* {@link #appendTail appendTail} and {@link #find find} methods.  The
* following code, for example, writes <tt>one dog two dogs in the
* yard</tt> to the standard-output stream: </p>
*
* <blockquote><pre>
* Pattern p = Pattern.compile("cat");
* Matcher m = p.matcher("one cat two cats in the yard");
* StringBuilder sb = new StringBuilder();
* while (m.find()) {
*     m.appendReplacement(sb, "dog");
* }
* m.appendTail(sb);
* System.out.println(sb.toString());</pre></blockquote>
*
* @param  sb
*         The target string builder
*
* @param  replacement
*         The replacement string
*
* @return  This matcher
*
* @throws  IllegalStateException
*          If no match has yet been attempted,
*          or if the previous match operation failed
*
* @throws  IndexOutOfBoundsException
*          If the replacement string refers to a capturing group
*          that does not exist in the pattern
*/
   // If no match, return error
   if (first < 0)
       throw new IllegalStateException("No match available");
   // Append the intervening text
   sb.append(text, lastAppendPosition, first);
   // Append the match substitution
   appendExpandedReplacement(replacement, sb);
   lastAppendPosition = last;
   return this;
* Processes replacement string to replace group references with
* groups.
*/
   String replacement, StringBuilder result) {
   int cursor = 0;
   StringBuilder result = new StringBuilder();

   while (cursor < replacement.length()) {
       char nextChar = replacement.charAt(cursor);
   lastAppendPosition = last;
   return this;
   return result;
 /**
* Implements a terminal append-and-replace step.
*
* <p> This method reads characters from the input sequence, starting at
* the append position, and appends them to the given string builder.  It is
* intended to be invoked after one or more invocations of the {@link
* #appendReplacement appendReplacement} method in order to copy the
* remainder of the input sequence.  </p>
*
* @param  sb
*         The target string builder
*
* @return  The target string builder
*/
   sb.append(text, lastAppendPosition, getTextLength());
   return sb;
       StringBuffer sb = new StringBuffer();
       StringBuilder sb = new StringBuilder();
       do {
           appendReplacement(sb, replacement);
           result = find();
   StringBuffer sb = new StringBuffer();
   StringBuilder sb = new StringBuilder();
   appendReplacement(sb, replacement);
   appendTail(sb);
   return sb.toString();