Cross Reference: /libcore/ojluni/src/main/java/java/util/regex/Pattern.java

Lines Matching refs:input
63  * compiles an expression and matches an input sequence against it in a single
242  *     <td headers="matches">The beginning of the input</td></tr>
246  *     <td headers="matches">The end of the input but for the final
249  *     <td headers="matches">The end of the input</td></tr>
436  * the end of a line of the input character sequence.  The following are
463  * of the entire input sequence. If {@link #MULTILINE} mode is activated then
464  * <tt>^</tt> matches at the beginning of input and after any line terminator
465  * except at the end of input. When in {@link #MULTILINE} mode <tt>$</tt>
466  * matches just before a line terminator or the end of the input sequence.
491  * of the input sequence that matches such a group is saved.  The captured
514  * <p> The captured input associated with a group is always the subsequence
519  * group two set to <tt>"b"</tt>.  All captured input is discarded at the
552  * the input has the property <i>prop</i>, while <tt>\P{</tt><i>prop</i><tt>}</tt>
553  * does not match if the input has that property.
827      * the input sequence.  By default these expressions only match at the
828      * beginning and the end of the entire input sequence.
838      * <p> When this flag is specified then the input string that specifies
840      * Metacharacters or escape sequences in the input sequence will be
1001      * Creates a matcher that will match the given input against this pattern.
1004      * @param  input
1009     public Matcher matcher(CharSequence input) {
1010         Matcher m = new Matcher(this, input);
1025      * input against it.
1030      * Pattern.matches(regex, input);</pre></blockquote>
1035      * Pattern.compile(regex).matcher(input).matches()</pre></blockquote>
1043      * @param  input
1049     public static boolean matches(String regex, CharSequence input) {
1051         Matcher m = p.matcher(input);
1056      * Splits the given input sequence around matches of this pattern.
1059      * input sequence that is terminated by another subsequence that matches
1060      * this pattern or is terminated by the end of the input sequence.  The
1062      * input.  If this pattern does not match any subsequence of the input then
1063      * the resulting array has just one element, namely the input sequence in
1071      * will contain all input beyond the last matched delimiter.  If <i>n</i>
1077      * <p> The input <tt>"boo:and:foo"</tt>, for example, yields the following
1106      * @param  input
1112      * @return  The array of strings computed by splitting the input
1115     public String[] split(CharSequence input, int limit) {
1116         String[] fast = fastSplit(pattern, input.toString(), limit);
1124         Matcher m = matcher(input);
1129                 String match = input.subSequence(index, m.start()).toString();
1133                 String match = input.subSequence(index,
1134                                                  input.length()).toString();
1142             return new String[] {input.toString()};
1146             matchList.add(input.subSequence(index, input.length()).toString());
1171     public static String[] fastSplit(String re, String input, int limit) {
1195         if (input.isEmpty()) {
1203         while (separatorCount + 1 != limit && (end = input.indexOf(ch, begin)) != -1) {
1207         int lastPartEnd = input.length();
1217             } while (input.charAt(begin - 1) == ch);
1219             separatorCount -= input.length() - begin;
1227             end = input.indexOf(ch, begin);
1228             result[i] = input.substring(begin, end);
1232         result[separatorCount] = input.substring(begin, lastPartEnd);
1237      * Splits the given input sequence around matches of this pattern.
1240      * #split(java.lang.CharSequence, int) split} method with the given input
1244      * <p> The input <tt>"boo:and:foo"</tt>, for example, yields the following
1258      * @param  input
1261      * @return  The array of strings computed by splitting the input
1264     public String[] split(CharSequence input) {
1265         return split(input, 0);
1275      * or escape sequences in the input sequence will be given no special
1363      * Creates a stream from the given input sequence around matches of this
1367      * input sequence that is terminated by another subsequence that matches
1368      * this pattern or is terminated by the end of the input sequence.  The
1370      * input. Trailing empty strings will be discarded and not encountered in
1373      * <p> If this pattern does not match any subsequence of the input then
1374      * the resulting stream has just one element, namely the input sequence in
1377      * <p> When there is a positive-width match at the beginning of the input
1382      * <p> If the input sequence is mutable, it must remain constant during the
1386      * @param   input
1389      * @return  The stream of strings computed by splitting the input
1394     public Stream<String> splitAsStream(final CharSequence input) {
1397             // The start position of the next sub-sequence of input
1398             // when current == input.length there are no more elements
1406                 this.matcher = matcher(input);
1427                 if (current == input.length())
1433                     nextElement = input.subSequence(current, matcher.start()).toString();
1438                                               // match at the beginning of the input
1444                 nextElement = input.subSequence(current, input.length()).toString();
1445                 current = input.length();