An invocation of this method of the form str .replaceFirst( regex , repl ) yields exactly the same result as the expression Pattern . compile ( regex ). matcher ( str ). replaceFirst ( repl ) Note that backslashes ( \ ) and dollar signs ( $ ) in the replacement string may cause the results to be different than if it were being treated as a literal replacement string; see Matcher.replaceFirst(java.lang.String) . Use Matcher.quoteReplacement(java.lang.String) to suppress the special meaning of these characters, if desired.

An invocation of this method of the form str .replaceAll( regex , repl ) yields exactly the same result as the expression Pattern . compile ( regex ). matcher ( str ). replaceAll ( repl ) Note that backslashes ( \ ) and dollar signs ( $ ) in the replacement string may cause the results to be different than if it were being treated as a literal replacement string; see Matcher.replaceAll . Use Matcher.quoteReplacement(java.lang.String) to suppress the special meaning of these characters, if desired.

The array returned by this method contains each substring of this string that is terminated by another substring that matches the given expression or is terminated by the end of the string. The substrings in the array are in the order in which they occur in this string. If the expression does not match any part of the input then the resulting array has just one element, namely this string.

When there is a positive-width match at the beginning of this string then an empty leading substring is included at the beginning of the resulting array. A zero-width match at the beginning however never produces such empty leading substring.

The limit parameter controls the number of times the pattern is applied and therefore affects the length of the resulting array. If the limit is positive then the pattern will be applied at most limit - 1 times, the array's length will be no greater than limit , and the array's last entry will contain all input beyond the last matched delimiter.

The string "boo:and:foo" , for example, yields the following results with these parameters: Split example showing regex, limit, and result Regex Limit Result { "boo", "and:foo" } { "boo", "and", "foo" } { "boo", "and", "foo" } { "b", "", ":and:f", "", "" } { "b", "", ":and:f", "", "" } { "b", "", ":and:f" }

An invocation of this method of the form str. split( regex , n ) yields the same result as the expression Pattern . compile ( regex ). split ( str , n )

split

public String[] split​(String regex)

public static String join​(CharSequence delimiter,
                          CharSequence... elements)

public static String join​(CharSequence delimiter,
                          Iterable<? extends CharSequence> elements)

public String toLowerCase​(Locale locale)

public String toLowerCase()

public String toUpperCase​(Locale locale)

public String toUpperCase()

public String trim()

public String strip()

public String stripLeading()

public String stripTrailing()

public boolean isBlank()

public Stream<String> lines()

public String toString()

public IntStream chars()

public IntStream codePoints()

public static String format​(String format,
                            Object... args)

public static String valueOf​(Object obj)

public static String valueOf​(char[] data)

public static String copyValueOf​(char[] data)

public static String valueOf​(boolean b)

public static String valueOf​(char c)

public static String valueOf​(int i)

public static String valueOf​(long l)

public static String valueOf​(float f)

public static String valueOf​(double d)

public String repeat​(int count)