sample/java.util.regex.Matcher.txt

   1 *java.util.regex.Matcher* *Matcher* An engine that performs match operations on
   2
   3 public final class Matcher
   4   extends    |java.lang.Object|
   5   implements |java.util.regex.MatchResult|
   6
   7 |java.util.regex.Matcher_Description|
   8 |java.util.regex.Matcher_Fields|
   9 |java.util.regex.Matcher_Constructors|
  10 |java.util.regex.Matcher_Methods|
  11
  12 ================================================================================
  13
  14 *java.util.regex.Matcher_Methods*
  15 |java.util.regex.Matcher.appendReplacement(StringBuffer,String)|Implements a no
  16 |java.util.regex.Matcher.appendTail(StringBuffer)|Implements a terminal append-
  17 |java.util.regex.Matcher.end()|Returns the offset after the last character matc
  18 |java.util.regex.Matcher.end(int)|Returns the offset after the last character o
  19 |java.util.regex.Matcher.find()|Attempts to find the next subsequence of the in
  20 |java.util.regex.Matcher.find(int)|Resets this matcher and then attempts to fin
  21 |java.util.regex.Matcher.group()|Returns the input subsequence matched by the p
  22 |java.util.regex.Matcher.group(int)|Returns the input subsequence captured by t
  23 |java.util.regex.Matcher.groupCount()|Returns the number of capturing groups in
  24 |java.util.regex.Matcher.hasAnchoringBounds()|Queries the anchoring of region b
  25 |java.util.regex.Matcher.hasTransparentBounds()|Queries the transparency of reg
  26 |java.util.regex.Matcher.hitEnd()|Returns true if the end of input was hit by t
  27 |java.util.regex.Matcher.lookingAt()|Attempts to match the input sequence, star
  28 |java.util.regex.Matcher.matches()|Attempts to match the entire region against
  29 |java.util.regex.Matcher.pattern()|Returns the pattern that is interpreted by t
  30 |java.util.regex.Matcher.quoteReplacement(String)|Returns a literal replacement
  31 |java.util.regex.Matcher.region(int,int)|Sets the limits of this matcher's regi
  32 |java.util.regex.Matcher.regionEnd()|Reports the end index (exclusive) of this
  33 |java.util.regex.Matcher.regionStart()|Reports the start index of this matcher'
  34 |java.util.regex.Matcher.replaceAll(String)|Replaces every subsequence of the i
  35 |java.util.regex.Matcher.replaceFirst(String)|Replaces the first subsequence of
  36 |java.util.regex.Matcher.requireEnd()|Returns true if more input could change a
  37 |java.util.regex.Matcher.reset()|Resets this matcher.
  38 |java.util.regex.Matcher.reset(CharSequence)|Resets this matcher with a new inp
  39 |java.util.regex.Matcher.start()|Returns the start index of the previous match.
  40 |java.util.regex.Matcher.start(int)|Returns the start index of the subsequence
  41 |java.util.regex.Matcher.toMatchResult()|Returns the match state of this matche
  42 |java.util.regex.Matcher.toString()|Returns the string representation of this m
  43 |java.util.regex.Matcher.useAnchoringBounds(boolean)|Sets the anchoring of regi
  44 |java.util.regex.Matcher.usePattern(Pattern)|Changes the Pattern that this Matc
  45 |java.util.regex.Matcher.useTransparentBounds(boolean)|Sets the transparency of
  46
  47 *java.util.regex.Matcher_Description*
  48
  49 An engine that performs match operations on a </code>character
  50 sequence<code>(|java.lang.CharSequence|) by interpreting a
  51 (|java.util.regex.Pattern|) .
  52
  53 A matcher is created from a pattern by invoking the pattern's
  54 matcher(|java.util.regex.Pattern|) method. Once created, a matcher can be used
  55 to perform three different kinds of match operations:
  56
  57
  58
  59 The matches(|java.util.regex.Matcher|) method attempts to match the entire
  60 input sequence against the pattern.
  61
  62 The lookingAt(|java.util.regex.Matcher|) method attempts to match the input
  63 sequence, starting at the beginning, against the pattern.
  64
  65 The find(|java.util.regex.Matcher|) method scans the input sequence looking for
  66 the next subsequence that matches the pattern.
  67
  68
  69
  70 Each of these methods returns a boolean indicating success or failure. More
  71 information about a successful match can be obtained by querying the state of
  72 the matcher.
  73
  74 A matcher finds matches in a subset of its input called the region. By default,
  75 the region contains all of the matcher's input. The region can be modified via
  76 the region(|java.util.regex.Matcher|) method and queried via the
  77 regionStart(|java.util.regex.Matcher|) and regionEnd(|java.util.regex.Matcher|)
  78 methods. The way that the region boundaries interact with some pattern
  79 constructs can be changed. See useAnchoringBounds(|java.util.regex.Matcher|)
  80 and useTransparentBounds(|java.util.regex.Matcher|) for more details.
  81
  82 This class also defines methods for replacing matched subsequences with new
  83 strings whose contents can, if desired, be computed from the match result. The
  84 appendReplacement(|java.util.regex.Matcher|) and
  85 appendTail(|java.util.regex.Matcher|) methods can be used in tandem in order to
  86 collect the result into an existing string buffer, or the more convenient
  87 replaceAll(|java.util.regex.Matcher|) method can be used to create a string in
  88 which every matching subsequence in the input sequence is replaced.
  89
  90 The explicit state of a matcher includes the start and end indices of the most
  91 recent successful match. It also includes the start and end indices of the
  92 input subsequence captured by each capturing group in the pattern as well as a
  93 total count of such subsequences. As a convenience, methods are also provided
  94 for returning these captured subsequences in string form.
  95
  96 The explicit state of a matcher is initially undefined; attempting to query any
  97 part of it before a successful match will cause an
  98 (|java.lang.IllegalStateException|) to be thrown. The explicit state of a
  99 matcher is recomputed by every match operation.
 100
 101 The implicit state of a matcher includes the input character sequence as well
 102 as the append position, which is initially zero and is updated by the
 103 appendReplacement(|java.util.regex.Matcher|) method.
 104
 105 A matcher may be reset explicitly by invoking its (|java.util.regex.Matcher|)
 106 method or, if a new input sequence is desired, its
 107 reset(CharSequence)(|java.util.regex.Matcher|) method. Resetting a matcher
 108 discards its explicit state information and sets the append position to zero.
 109
 110 Instances of this class are not safe for use by multiple concurrent threads.
 111
 112
 113
 114 *java.util.regex.Matcher.appendReplacement(StringBuffer,String)*
 115
 116 public |java.util.regex.Matcher| appendReplacement(
 117   java.lang.StringBuffer sb,
 118   java.lang.String replacement)
 119
 120 Implements a non-terminal append-and-replace step.
 121
 122 This method performs the following actions:
 123
 124
 125
 126 It reads characters from the input sequence, starting at the append position,
 127 and appends them to the given string buffer. It stops after reading the last
 128 character preceding the previous match, that is, the character at index
 129 (|java.util.regex.Matcher|) -1.
 130
 131 It appends the given replacement string to the string buffer.
 132
 133 It sets the append position of this matcher to the index of the last character
 134 matched, plus one, that is, to (|java.util.regex.Matcher|) .
 135
 136
 137
 138 The replacement string may contain references to subsequences captured during
 139 the previous match: Each occurrence of $g will be replaced by the result of
 140 evaluating group(|java.util.regex.Matcher|) (g). The first number after the $
 141 is always treated as part of the group reference. Subsequent numbers are
 142 incorporated into g if they would form a legal group reference. Only the
 143 numerals '0' through '9' are considered as potential components of the group
 144 reference. If the second group matched the string "foo", for example, then
 145 passing the replacement string "$2bar" would cause "foobar" to be appended to
 146 the string buffer. A dollar sign ($) may be included as a literal in the
 147 replacement string by preceding it with a backslash (\$).
 148
 149 Note that backslashes (\) and dollar signs ($) in the replacement string may
 150 cause the results to be different than if it were being treated as a literal
 151 replacement string. Dollar signs may be treated as references to captured
 152 subsequences as described above, and backslashes are used to escape literal
 153 characters in the replacement string.
 154
 155 This method is intended to be used in a loop together with the
 156 appendTail(|java.util.regex.Matcher|) and find(|java.util.regex.Matcher|)
 157 methods. The following code, for example, writes one dog two dogs in the yard
 158 to the standard-output stream:
 159
 160
 161
 162 Pattern p = Pattern.compile("cat"); Matcher m = p.matcher("one cat two cats in
 163 the yard"); StringBuffer sb = new StringBuffer(); while (m.find()) {
 164 m.appendReplacement(sb, "dog"); } m.appendTail(sb);
 165 System.out.println(sb.toString());
 166
 167
 168     sb - The target string buffer
 169     replacement - The replacement string
 170
 171     Returns:
 172
 173 *java.util.regex.Matcher.appendTail(StringBuffer)*
 174
 175 public |java.lang.StringBuffer| appendTail(java.lang.StringBuffer sb)
 176
 177 Implements a terminal append-and-replace step.
 178
 179 This method reads characters from the input sequence, starting at the append
 180 position, and appends them to the given string buffer. It is intended to be
 181 invoked after one or more invocations of the
 182 appendReplacement(|java.util.regex.Matcher|) method in order to copy the
 183 remainder of the input sequence.
 184
 185
 186     sb - The target string buffer
 187
 188     Returns: The target string buffer
 189
 190 *java.util.regex.Matcher.end()*
 191
 192 public int end()
 193
 194 Returns the offset after the last character matched.
 195
 196
 197
 198     Returns: The offset after the last character matched
 199
 200 *java.util.regex.Matcher.end(int)*
 201
 202 public int end(int group)
 203
 204 Returns the offset after the last character of the subsequence captured by the
 205 given group during the previous match operation.
 206
 207 Capturing groups are indexed from left to right, starting at one. Group zero
 208 denotes the entire pattern, so the expression m.end(0) is equivalent to
 209 m.end().
 210
 211
 212     group - The index of a capturing group in this matcher's pattern
 213
 214     Returns: The offset after the last character captured by the group, or -1 if the match
 215              was successful but the group itself did not match anything
 216
 217 *java.util.regex.Matcher.find()*
 218
 219 public boolean find()
 220
 221 Attempts to find the next subsequence of the input sequence that matches the
 222 pattern.
 223
 224 This method starts at the beginning of this matcher's region, or, if a previous
 225 invocation of the method was successful and the matcher has not since been
 226 reset, at the first character not matched by the previous match.
 227
 228 If the match succeeds then more information can be obtained via the start, end,
 229 and group methods.
 230
 231
 232
 233     Returns: true if, and only if, a subsequence of the input sequence matches this
 234              matcher's pattern
 235
 236 *java.util.regex.Matcher.find(int)*
 237
 238 public boolean find(int start)
 239
 240 Resets this matcher and then attempts to find the next subsequence of the input
 241 sequence that matches the pattern, starting at the specified index.
 242
 243 If the match succeeds then more information can be obtained via the start, end,
 244 and group methods, and subsequent invocations of the
 245 (|java.util.regex.Matcher|) method will start at the first character not
 246 matched by this match.
 247
 248
 249
 250     Returns: true if, and only if, a subsequence of the input sequence starting at the given
 251              index matches this matcher's pattern
 252
 253 *java.util.regex.Matcher.group()*
 254
 255 public |java.lang.String| group()
 256
 257 Returns the input subsequence matched by the previous match.
 258
 259 For a matcher m with input sequence s, the expressions m.group() and
 260 s.substring(m.start(),m.end()) are equivalent.
 261
 262 Note that some patterns, for example a*, match the empty string. This method
 263 will return the empty string when the pattern successfully matches the empty
 264 string in the input.
 265
 266
 267
 268     Returns: The (possibly empty) subsequence matched by the previous match, in string form
 269
 270 *java.util.regex.Matcher.group(int)*
 271
 272 public |java.lang.String| group(int group)
 273
 274 Returns the input subsequence captured by the given group during the previous
 275 match operation.
 276
 277 For a matcher m, input sequence s, and group index g, the expressions
 278 m.group(g) and s.substring(m.start(g),m.end(g)) are equivalent.
 279
 280 Capturing groups are indexed from left to right, starting at one. Group zero
 281 denotes the entire pattern, so the expression m.group(0) is equivalent to
 282 m.group().
 283
 284 If the match was successful but the group specified failed to match any part of
 285 the input sequence, then null is returned. Note that some groups, for example
 286 (a*), match the empty string. This method will return the empty string when
 287 such a group successfully matches the empty string in the input.
 288
 289
 290     group - The index of a capturing group in this matcher's pattern
 291
 292     Returns: The (possibly empty) subsequence captured by the group during the previous
 293              match, or null if the group failed to match part of the input
 294
 295 *java.util.regex.Matcher.groupCount()*
 296
 297 public int groupCount()
 298
 299 Returns the number of capturing groups in this matcher's pattern.
 300
 301 Group zero denotes the entire pattern by convention. It is not included in this
 302 count.
 303
 304 Any non-negative integer smaller than or equal to the value returned by this
 305 method is guaranteed to be a valid group index for this matcher.
 306
 307
 308
 309     Returns: The number of capturing groups in this matcher's pattern
 310
 311 *java.util.regex.Matcher.hasAnchoringBounds()*
 312
 313 public boolean hasAnchoringBounds()
 314
 315 Queries the anchoring of region bounds for this matcher.
 316
 317 This method returns true if this matcher uses anchoring bounds, false
 318 otherwise.
 319
 320 See useAnchoringBounds(|java.util.regex.Matcher|) for a description of
 321 anchoring bounds.
 322
 323 By default, a matcher uses anchoring region boundaries.
 324
 325
 326
 327     Returns: true iff this matcher is using anchoring bounds, false otherwise.
 328
 329 *java.util.regex.Matcher.hasTransparentBounds()*
 330
 331 public boolean hasTransparentBounds()
 332
 333 Queries the transparency of region bounds for this matcher.
 334
 335 This method returns true if this matcher uses transparent bounds, false if it
 336 uses opaque bounds.
 337
 338 See useTransparentBounds(|java.util.regex.Matcher|) for a description of
 339 transparent and opaque bounds.
 340
 341 By default, a matcher uses opaque region boundaries.
 342
 343
 344
 345     Returns: true iff this matcher is using transparent bounds, false otherwise.
 346
 347 *java.util.regex.Matcher.hitEnd()*
 348
 349 public boolean hitEnd()
 350
 351 Returns true if the end of input was hit by the search engine in the last match
 352 operation performed by this matcher.
 353
 354 When this method returns true, then it is possible that more input would have
 355 changed the result of the last search.
 356
 357
 358
 359     Returns: true iff the end of input was hit in the last match; false otherwise
 360
 361 *java.util.regex.Matcher.lookingAt()*
 362
 363 public boolean lookingAt()
 364
 365 Attempts to match the input sequence, starting at the beginning of the region,
 366 against the pattern.
 367
 368 Like the matches(|java.util.regex.Matcher|) method, this method always starts
 369 at the beginning of the region; unlike that method, it does not require that
 370 the entire region be matched.
 371
 372 If the match succeeds then more information can be obtained via the start, end,
 373 and group methods.
 374
 375
 376
 377     Returns: true if, and only if, a prefix of the input sequence matches this matcher's
 378              pattern
 379
 380 *java.util.regex.Matcher.matches()*
 381
 382 public boolean matches()
 383
 384 Attempts to match the entire region against the pattern.
 385
 386 If the match succeeds then more information can be obtained via the start, end,
 387 and group methods.
 388
 389
 390
 391     Returns: true if, and only if, the entire region sequence matches this matcher's pattern
 392
 393 *java.util.regex.Matcher.pattern()*
 394
 395 public |java.util.regex.Pattern| pattern()
 396
 397 Returns the pattern that is interpreted by this matcher.
 398
 399
 400
 401     Returns: The pattern for which this matcher was created
 402
 403 *java.util.regex.Matcher.quoteReplacement(String)*
 404
 405 public static |java.lang.String| quoteReplacement(java.lang.String s)
 406
 407 Returns a literal replacement String for the specified String.
 408
 409 This method produces a String that will work as a literal replacement s in the
 410 appendReplacement method of the (|java.util.regex.Matcher|) class. The String
 411 produced will match the sequence of characters in s treated as a literal
 412 sequence. Slashes ('\') and dollar signs ('$') will be given no special
 413 meaning.
 414
 415
 416     s - The string to be literalized
 417
 418     Returns: A literal string replacement
 419
 420 *java.util.regex.Matcher.region(int,int)*
 421
 422 public |java.util.regex.Matcher| region(
 423   int start,
 424   int end)
 425
 426 Sets the limits of this matcher's region. The region is the part of the input
 427 sequence that will be searched to find a match. Invoking this method resets the
 428 matcher, and then sets the region to start at the index specified by the start
 429 parameter and end at the index specified by the end parameter.
 430
 431 Depending on the transparency and anchoring being used (see
 432 useTransparentBounds(|java.util.regex.Matcher|) and
 433 useAnchoringBounds(|java.util.regex.Matcher|) ), certain constructs such as
 434 anchors may behave differently at or around the boundaries of the region.
 435
 436
 437     start - The index to start searching at (inclusive)
 438     end - The index to end searching at (exclusive)
 439
 440     Returns:
 441
 442 *java.util.regex.Matcher.regionEnd()*
 443
 444 public int regionEnd()
 445
 446 Reports the end index (exclusive) of this matcher's region. The searches this
 447 matcher conducts are limited to finding matches within
 448 regionStart(|java.util.regex.Matcher|) (inclusive) and
 449 regionEnd(|java.util.regex.Matcher|) (exclusive).
 450
 451
 452
 453     Returns: the ending point of this matcher's region
 454
 455 *java.util.regex.Matcher.regionStart()*
 456
 457 public int regionStart()
 458
 459 Reports the start index of this matcher's region. The searches this matcher
 460 conducts are limited to finding matches within
 461 regionStart(|java.util.regex.Matcher|) (inclusive) and
 462 regionEnd(|java.util.regex.Matcher|) (exclusive).
 463
 464
 465
 466     Returns: The starting point of this matcher's region
 467
 468 *java.util.regex.Matcher.replaceAll(String)*
 469
 470 public |java.lang.String| replaceAll(java.lang.String replacement)
 471
 472 Replaces every subsequence of the input sequence that matches the pattern with
 473 the given replacement string.
 474
 475 This method first resets this matcher. It then scans the input sequence looking
 476 for matches of the pattern. Characters that are not part of any match are
 477 appended directly to the result string; each match is replaced in the result by
 478 the replacement string. The replacement string may contain references to
 479 captured subsequences as in the appendReplacement(|java.util.regex.Matcher|)
 480 method.
 481
 482 Note that backslashes (\) and dollar signs ($) in the replacement string may
 483 cause the results to be different than if it were being treated as a literal
 484 replacement string. Dollar signs may be treated as references to captured
 485 subsequences as described above, and backslashes are used to escape literal
 486 characters in the replacement string.
 487
 488 Given the regular expression a*b, the input "aabfooaabfooabfoob", and the
 489 replacement string "-", an invocation of this method on a matcher for that
 490 expression would yield the string "-foo-foo-foo-".
 491
 492 Invoking this method changes this matcher's state. If the matcher is to be used
 493 in further matching operations then it should first be reset.
 494
 495
 496     replacement - The replacement string
 497
 498     Returns: The string constructed by replacing each matching subsequence by the
 499              replacement string, substituting captured subsequences as needed
 500
 501 *java.util.regex.Matcher.replaceFirst(String)*
 502
 503 public |java.lang.String| replaceFirst(java.lang.String replacement)
 504
 505 Replaces the first subsequence of the input sequence that matches the pattern
 506 with the given replacement string.
 507
 508 This method first resets this matcher. It then scans the input sequence looking
 509 for a match of the pattern. Characters that are not part of the match are
 510 appended directly to the result string; the match is replaced in the result by
 511 the replacement string. The replacement string may contain references to
 512 captured subsequences as in the appendReplacement(|java.util.regex.Matcher|)
 513 method.
 514
 515 Note that backslashes (\) and dollar signs ($) in the replacement string may
 516 cause the results to be different than if it were being treated as a literal
 517 replacement string. Dollar signs may be treated as references to captured
 518 subsequences as described above, and backslashes are used to escape literal
 519 characters in the replacement string.
 520
 521 Given the regular expression dog, the input "zzzdogzzzdogzzz", and the
 522 replacement string "cat", an invocation of this method on a matcher for that
 523 expression would yield the string "zzzcatzzzdogzzz".
 524
 525 Invoking this method changes this matcher's state. If the matcher is to be used
 526 in further matching operations then it should first be reset.
 527
 528
 529     replacement - The replacement string
 530
 531     Returns: The string constructed by replacing the first matching subsequence by the
 532              replacement string, substituting captured subsequences as needed
 533
 534 *java.util.regex.Matcher.requireEnd()*
 535
 536 public boolean requireEnd()
 537
 538 Returns true if more input could change a positive match into a negative one.
 539
 540 If this method returns true, and a match was found, then more input could cause
 541 the match to be lost. If this method returns false and a match was found, then
 542 more input might change the match but the match won't be lost. If a match was
 543 not found, then requireEnd has no meaning.
 544
 545
 546
 547     Returns: true iff more input could change a positive match into a negative one.
 548
 549 *java.util.regex.Matcher.reset()*
 550
 551 public |java.util.regex.Matcher| reset()
 552
 553 Resets this matcher.
 554
 555 Resetting a matcher discards all of its explicit state information and sets its
 556 append position to zero. The matcher's region is set to the default region,
 557 which is its entire character sequence. The anchoring and transparency of this
 558 matcher's region boundaries are unaffected.
 559
 560
 561
 562     Returns:
 563
 564 *java.util.regex.Matcher.reset(CharSequence)*
 565
 566 public |java.util.regex.Matcher| reset(java.lang.CharSequence input)
 567
 568 Resets this matcher with a new input sequence.
 569
 570 Resetting a matcher discards all of its explicit state information and sets its
 571 append position to zero. The matcher's region is set to the default region,
 572 which is its entire character sequence. The anchoring and transparency of this
 573 matcher's region boundaries are unaffected.
 574
 575
 576     input - The new input character sequence
 577
 578     Returns:
 579
 580 *java.util.regex.Matcher.start()*
 581
 582 public int start()
 583
 584 Returns the start index of the previous match.
 585
 586
 587
 588     Returns: The index of the first character matched
 589
 590 *java.util.regex.Matcher.start(int)*
 591
 592 public int start(int group)
 593
 594 Returns the start index of the subsequence captured by the given group during
 595 the previous match operation.
 596
 597 Capturing groups are indexed from left to right, starting at one. Group zero
 598 denotes the entire pattern, so the expression m.start(0) is equivalent to
 599 m.start().
 600
 601
 602     group - The index of a capturing group in this matcher's pattern
 603
 604     Returns: The index of the first character captured by the group, or -1 if the match was
 605              successful but the group itself did not match anything
 606
 607 *java.util.regex.Matcher.toMatchResult()*
 608
 609 public |java.util.regex.MatchResult| toMatchResult()
 610
 611 Returns the match state of this matcher as a (|java.util.regex.MatchResult|) .
 612 The result is unaffected by subsequent operations performed upon this matcher.
 613
 614
 615
 616     Returns: a MatchResult with the state of this matcher
 617
 618 *java.util.regex.Matcher.toString()*
 619
 620 public |java.lang.String| toString()
 621
 622 Returns the string representation of this matcher. The string representation of
 623 a Matcher contains information that may be useful for debugging. The exact
 624 format is unspecified.
 625
 626
 627
 628     Returns: The string representation of this matcher
 629
 630 *java.util.regex.Matcher.useAnchoringBounds(boolean)*
 631
 632 public |java.util.regex.Matcher| useAnchoringBounds(boolean b)
 633
 634 Sets the anchoring of region bounds for this matcher.
 635
 636 Invoking this method with an argument of true will set this matcher to use
 637 anchoring bounds. If the boolean argument is false, then non-anchoring bounds
 638 will be used.
 639
 640 Using anchoring bounds, the boundaries of this matcher's region match anchors
 641 such as ^ and $.
 642
 643 Without anchoring bounds, the boundaries of this matcher's region will not
 644 match anchors such as ^ and $.
 645
 646 By default, a matcher uses anchoring region boundaries.
 647
 648
 649     b - a boolean indicating whether or not to use anchoring bounds.
 650
 651     Returns:
 652
 653 *java.util.regex.Matcher.usePattern(Pattern)*
 654
 655 public |java.util.regex.Matcher| usePattern(java.util.regex.Pattern newPattern)
 656
 657 Changes the Pattern that this Matcher uses to find matches with.
 658
 659 This method causes this matcher to lose information about the groups of the
 660 last match that occurred. The matcher's position in the input is maintained and
 661 its last append position is unaffected.
 662
 663
 664     newPattern - The new pattern used by this matcher
 665
 666     Returns:
 667
 668 *java.util.regex.Matcher.useTransparentBounds(boolean)*
 669
 670 public |java.util.regex.Matcher| useTransparentBounds(boolean b)
 671
 672 Sets the transparency of region bounds for this matcher.
 673
 674 Invoking this method with an argument of true will set this matcher to use
 675 transparent bounds. If the boolean argument is false, then opaque bounds will
 676 be used.
 677
 678 Using transparent bounds, the boundaries of this matcher's region are
 679 transparent to lookahead, lookbehind, and boundary matching constructs. Those
 680 constructs can see beyond the boundaries of the region to see if a match is
 681 appropriate.
 682
 683 Using opaque bounds, the boundaries of this matcher's region are opaque to
 684 lookahead, lookbehind, and boundary matching constructs that may try to see
 685 beyond them. Those constructs cannot look past the boundaries so they will fail
 686 to match anything outside of the region.
 687
 688 By default, a matcher uses opaque bounds.
 689
 690
 691     b - a boolean indicating whether to use opaque or transparent regions
 692
 693     Returns:
 694
 695