Pattern (Regular Expression Facade for Java 1.2.0 API)

```
public interface Pattern
```

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`CANON_EQ`
`static int`	`CASE_INSENSITIVE`
`static int`	`COMMENTS`
`static int`	`DOTALL`
`static int`	`LITERAL`
`static int`	`MULTILINE`
`static int`	`UNICODE_CASE`
`static int`	`UNICODE_CHARACTER_CLASS`
`static int`	`UNIX_LINES`

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`Predicate<String>`	`asMatchPredicate()` Creates a predicate that tests if this pattern matches a given input string.
`Predicate<String>`	`asPredicate()` Creates a predicate that tests if this pattern is found in a given input string.
`int`	`flags()`
`Matcher`	`matcher(CharSequence subject)`
`boolean`	`matches(CharSequence subject, int offset)`
`String`	`pattern()`
`String[]`	`split(CharSequence input)`
`String[]`	`split(CharSequence input, int limit)`
`Stream<String>`	`splitAsStream(CharSequence input)` Creates a stream from the given input sequence around matches of this pattern.

- Field Detail
  - CANON_EQ
```
static final int CANON_EQ
```
    See Also:
    
    Pattern.CANON_EQ, Constant Field Values
  - CASE_INSENSITIVE
```
static final int CASE_INSENSITIVE
```
    See Also:
    
    Pattern.CASE_INSENSITIVE, Constant Field Values
  - COMMENTS
```
static final int COMMENTS
```
    See Also:
    
    Pattern.COMMENTS, Constant Field Values
  - DOTALL
```
static final int DOTALL
```
    See Also:
    
    Pattern.DOTALL, Constant Field Values
  - LITERAL
```
static final int LITERAL
```
    See Also:
    
    Pattern.LITERAL, Constant Field Values
  - MULTILINE
```
static final int MULTILINE
```
    See Also:
    
    Pattern.MULTILINE, Constant Field Values
  - UNICODE_CASE
```
static final int UNICODE_CASE
```
    See Also:
    
    Pattern.UNICODE_CASE, Constant Field Values
  - UNIX_LINES
```
static final int UNIX_LINES
```
    See Also:
    
    Pattern.UNIX_LINES, Constant Field Values
  - UNICODE_CHARACTER_CLASS
```
static final int UNICODE_CHARACTER_CLASS
```
    See Also:
    
    Pattern.UNICODE_CHARACTER_CLASS, Constant Field Values
- Method Detail
  - pattern
```
String pattern()
```
    See Also:
    
    Pattern.pattern()
  - matcher
```
Matcher matcher(CharSequence subject)
```
    See Also:
    
    Pattern.matcher(CharSequence)
  - flags
```
int flags()
```
    See Also:
    
    Pattern.flags()
  - matches
```
boolean matches(CharSequence subject,
                int offset)
```
    Returns:
    
    Whether the suffix starting at position offset matches this pattern
    
    See Also:
    
    Pattern.matches(String, CharSequence)
  - split
```
String[] split(CharSequence input)
```
    See Also:
    
    Pattern.split(CharSequence)
  - split
```
String[] split(CharSequence input,
               int limit)
```
    See Also:
    
    Pattern.split(CharSequence, int)
  - asPredicate
```
Predicate<String> asPredicate()
```
    Creates a predicate that tests if this pattern is found in a given input string.
    API Note: This method creates a predicate that behaves as if it creates a matcher from the input sequence and then calls find, for example a predicate of the form:
```
     s -> matcher(s).find();
 
```
    Returns:
    
    The predicate which can be used for finding a match on a subsequence of a string
    
    Since:
    
    JRE 1.8
  - asMatchPredicate
```
Predicate<String> asMatchPredicate()
```
    Creates a predicate that tests if this pattern matches a given input string.
    API Note: This method creates a predicate that behaves as if it creates a matcher from the input sequence and then calls matches, for example a predicate of the form:
```
     s -> matcher(s).matches();
 
```
    Returns:
    
    The predicate which can be used for matching an input string against this pattern.
    
    Since:
    
    JRE 11
  - splitAsStream
```
Stream<String> splitAsStream(CharSequence input)
```
    Creates a stream from the given input sequence around matches of this pattern. The stream returned by this method contains each substring of the input sequence that is terminated by another subsequence that matches this pattern or is terminated by the end of the input sequence. The substrings in the stream are in the order in which they occur in the input. Trailing empty strings will be discarded and not encountered in the stream.
    If this pattern does not match any subsequence of the input then the resulting stream has just one element, namely the input sequence in string form.
    
    When there is a positive-width match at the beginning of the input sequence then an empty leading substring is included at the beginning of the stream. A zero-width match at the beginning however never produces such empty leading substring.
    
    If the input sequence is mutable, it must remain constant during the execution of the terminal stream operation. Otherwise, the result of the terminal stream operation is undefined.
    
    Parameters:
    
    input - The character sequence to be split
    
    Returns:
    
    The stream of strings computed by splitting the input around matches of this pattern
    
    Since:
    
    JRE 1.8

Interface Pattern

Field Summary

Method Summary

Field Detail

CANON_EQ

CASE_INSENSITIVE

COMMENTS

DOTALL

LITERAL

MULTILINE

UNICODE_CASE

UNIX_LINES

UNICODE_CHARACTER_CLASS

Method Detail

pattern

matcher

flags

matches

split

split

asPredicate

asMatchPredicate

splitAsStream