Module aya.ij.util.text

Package com.intellij.openapi.util.text

Class Strings

java.lang.Object

com.intellij.openapi.util.text.Strings

public final class Strings
extends Object

Field Summary

Fields

Modifier and Type	Field	Description
static final CharSequence	EMPTY_CHAR_SEQUENCE

Constructor Summary

Constructors

Constructor	Description
Strings()

Method Summary

Modifier and Type	Method	Description
static boolean	areSameInstance(@Nullable String s1, @Nullable String s2)	Returns true if s1 and s2 refer to the same instance of String.
static @NotNull String	capitalize(@NotNull String s)	Capitalize the first letter of the sentence.
static boolean	charsEqualIgnoreCase(char a, char b)
static boolean	charsMatch(char c1, char c2, boolean ignoreCase)
static int	compare(char c1, char c2, boolean ignoreCase)
static int	compare(@Nullable CharSequence s1, @Nullable CharSequence s2, boolean ignoreCase)
static boolean	contains(@NotNull CharSequence s, int start, int end, char c)	Allows to answer if target symbol is contained at given char sequence at [start; end) interval.
static boolean	contains(@NotNull CharSequence sequence, @NotNull CharSequence infix)
static boolean	containsAnyChar(@NotNull String value, @NotNull String chars)
static boolean	containsAnyChar(@NotNull String value, @NotNull String chars, int start, int end)
static boolean	containsChar(@NotNull String value, char ch)
static @NotNull String	convertLineSeparators(@NotNull String text)
static @NotNull String	convertLineSeparators(@NotNull String text, boolean keepCarriageReturn)
static @NotNull String	convertLineSeparators(@NotNull String text, @NotNull String newSeparator)
static @NotNull String	convertLineSeparators(@NotNull String text, @NotNull String newSeparator, int @Nullable [] offsetsToKeep)
static int	countChars(@NotNull CharSequence text, char c)
static int	countChars(@NotNull CharSequence text, char c, int offset, boolean stopAtOtherChar)
static int	countChars(@NotNull CharSequence text, char c, int start, int end, boolean stopAtOtherChar)
static boolean	endsWith(@NotNull CharSequence text, @NotNull CharSequence suffix)
static boolean	endsWithChar(@Nullable CharSequence s, char suffix)
static boolean	endsWithIgnoreCase(@NotNull CharSequence str, @NotNull String suffix)
static boolean	equalsIgnoreWhitespaces(@Nullable CharSequence s1, @Nullable CharSequence s2)
static boolean	equalsTrimWhitespaces(@NotNull CharSequence s1, @NotNull CharSequence s2)
static @NotNull StringBuilder	escapeToRegexp(@NotNull CharSequence text, @NotNull StringBuilder builder)
static @NotNull String	escapeXmlEntities(@NotNull String text)
static int	indexOf(char @NotNull [] s, char c, int start, int end, boolean caseSensitive)
static int	indexOf(@NotNull CharSequence s, char c)
static int	indexOf(@NotNull CharSequence s, char c, int start)
static int	indexOf(@NotNull CharSequence s, char c, int start, int end)
static int	indexOf(@NotNull CharSequence s, char c, int start, int end, boolean caseSensitive)
static int	indexOf(@NotNull CharSequence sequence, @NotNull CharSequence infix)
static int	indexOf(@NotNull CharSequence sequence, @NotNull CharSequence infix, int start)
static int	indexOf(@NotNull CharSequence sequence, @NotNull CharSequence infix, int start, int end)
static int	indexOfAny(@NotNull CharSequence s, @NotNull String chars)
static int	indexOfAny(@NotNull CharSequence s, @NotNull String chars, int start, int end)
static int	indexOfAny(@NotNull String s, @NotNull String chars)
static int	indexOfAny(@NotNull String s, @NotNull String chars, int start, int end)
static int	indexOfIgnoreCase(@NotNull CharSequence where, @NotNull CharSequence what, int fromIndex)	Implementation copied from String.indexOf(String, int) except character comparisons made case-insensitive
static int	indexOfIgnoreCase(@NotNull String where, char what, int fromIndex)
static int	indexOfIgnoreCase(@NotNull String where, @NotNull String what, int fromIndex)
static boolean	isAscii(char ch)
static boolean	isCapitalized(@Nullable String s)
static boolean	isDecimalDigit(char c)
static boolean	isEmpty(@Nullable CharSequence cs)
static boolean	isEmpty(@Nullable String s)
static boolean	isEmptyOrSpaces(@Nullable CharSequence s)
static boolean	isNotEmpty(@Nullable String s)
static boolean	isNotNegativeNumber(@Nullable CharSequence s)
static boolean	isWhiteSpace(char c)
static @NotNull String	join(int @NotNull [] values, @NotNull String separator)
static @NotNull String	join(@NotNull Iterable<?> items, @NotNull String separator)
static <T> @NotNull String	join(@NotNull Iterable<? extends T> items, @NotNull Function<? super T,? extends CharSequence> f, @NotNull String separator)
static <T> void	join(@NotNull Iterable<? extends T> items, @NotNull Function<? super T,? extends CharSequence> f, @NotNull String separator, @NotNull StringBuilder result)
static <T> @NotNull String	join(@NotNull Collection<? extends T> items, @NotNull Function<? super T,String> f, @NotNull String separator)
static @NotNull String	join(@NotNull Collection<String> strings, @NotNull String separator)
static void	join(@NotNull Collection<String> strings, @NotNull String separator, @NotNull StringBuilder result)
static @NotNull String	join(String @NotNull ... strings)
static <T> @NotNull String	join(T @NotNull [] items, @NotNull Function<? super T,String> f, @NotNull String separator)
static @NotNull String	notNullize(@Nullable String s)
static @NotNull String	notNullize(@Nullable String s, @NotNull String defaultValue)
static @Nullable String	nullize(@Nullable String s)
static @Nullable String	nullize(@Nullable String s, boolean nullizeSpaces)
static @Nullable String	nullize(@Nullable String s, @Nullable String defaultValue)
static @NotNull String	pluralize(@NotNull String word)
static @NotNull String	replace(@NotNull String text, @NotNull List<String> from, @NotNull List<String> to)
static boolean	startsWith(@NotNull CharSequence text, int startIndex, @NotNull CharSequence prefix)
static int	stringHashCode(char @NotNull [] chars, int from, int to)
static int	stringHashCode(@NotNull CharSequence chars)
static int	stringHashCode(@NotNull CharSequence chars, int from, int to)
static int	stringHashCode(@NotNull CharSequence chars, int from, int to, int prefixHash)
static int	stringHashCodeIgnoreWhitespaces(@NotNull CharSequence chars)
static int	stringHashCodeInsensitive(char @NotNull [] chars, int from, int to)
static int	stringHashCodeInsensitive(@NotNull CharSequence chars)
static int	stringHashCodeInsensitive(@NotNull CharSequence chars, int from, int to)
static int	stringHashCodeInsensitive(@NotNull CharSequence chars, int from, int to, int prefixHash)
static char	toLowerCase(char a)
static String	toLowerCase(@Nullable String str)
static char	toUpperCase(char a)
static String	toUpperCase(String s)
static String	trim(@Nullable String s)
static @NotNull String	trimEnd(@NotNull String s, char suffix)
static @NotNull String	trimEnd(@NotNull String s, @NotNull String suffix)
static @NotNull String	trimEnd(@NotNull String s, @NotNull String suffix, boolean ignoreCase)
static @NotNull String	trimStart(@NotNull String s, @NotNull String prefix)
static @NotNull String	unescapeXmlEntities(@NotNull String text)
static @Nullable String	unpluralize(@NotNull String word)	Returns unpluralized variant using English based heuristics like properties -> property, names -> name, children -> child.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

EMPTY_CHAR_SEQUENCE

public static final CharSequence EMPTY_CHAR_SEQUENCE

Constructor Details

Strings

public Strings()

Method Details

isAscii

public static boolean isAscii(char ch)

isDecimalDigit

@Contract(pure=true)
public static boolean isDecimalDigit(char c)

isNotNegativeNumber

@Contract("null -> false")
public static boolean isNotNegativeNumber(@Nullable
 @Nullable CharSequence s)

compare

@Contract(pure=true)
public static int compare(char c1,
 char c2,
 boolean ignoreCase)

compare

@Contract(pure=true)
public static int compare(@Nullable
 @Nullable CharSequence s1,
 @Nullable
 @Nullable CharSequence s2,
 boolean ignoreCase)

charsMatch

@Contract(pure=true)
public static boolean charsMatch(char c1,
 char c2,
 boolean ignoreCase)

toLowerCase

@Contract(value="null -> null; !null -> !null",
          pure=true)
public static String toLowerCase(@Nullable
 @Nullable String str)

toLowerCase

@Contract(pure=true)
public static char toLowerCase(char a)

toUpperCase

@Contract(value="null -> null; !null -> !null",
          pure=true)
public static String toUpperCase(String s)

toUpperCase

@Contract(pure=true)
public static char toUpperCase(char a)

contains

@Contract(pure=true)
public static boolean contains(@NotNull
 @NotNull CharSequence sequence,
 @NotNull
 @NotNull CharSequence infix)

contains

@Contract(pure=true)
public static boolean contains(@NotNull
 @NotNull CharSequence s,
 int start,
 int end,
 char c)

Allows to answer if target symbol is contained at given char sequence at [start; end) interval.

Parameters:

s - target char sequence to check

start - start offset to use within the given char sequence (inclusive)

end - end offset to use within the given char sequence (exclusive)

c - target symbol to check

Returns:

true if given symbol is contained at the target range of the given char sequence; false otherwise

containsChar

@Contract(pure=true)
public static boolean containsChar(@NotNull
 @NotNull String value,
 char ch)

containsAnyChar

@Contract(pure=true)
public static boolean containsAnyChar(@NotNull
 @NotNull String value,
 @NotNull
 @NotNull String chars)

containsAnyChar

@Contract(pure=true)
public static boolean containsAnyChar(@NotNull
 @NotNull String value,
 @NotNull
 @NotNull String chars,
 int start,
 int end)

indexOf

@Contract(pure=true)
public static int indexOf(@NotNull
 @NotNull CharSequence s,
 char c)

indexOf

@Contract(pure=true)
public static int indexOf(@NotNull
 @NotNull CharSequence s,
 char c,
 int start)

indexOf

@Contract(pure=true)
public static int indexOf(@NotNull
 @NotNull CharSequence s,
 char c,
 int start,
 int end)

indexOf

@Contract(pure=true)
public static int indexOf(@NotNull
 @NotNull CharSequence sequence,
 @NotNull
 @NotNull CharSequence infix)

indexOf

@Contract(pure=true)
public static int indexOf(@NotNull
 @NotNull CharSequence sequence,
 @NotNull
 @NotNull CharSequence infix,
 int start)

indexOf

@Contract(pure=true)
public static int indexOf(@NotNull
 @NotNull CharSequence sequence,
 @NotNull
 @NotNull CharSequence infix,
 int start,
 int end)

indexOf

@Contract(pure=true)
public static int indexOf(@NotNull
 @NotNull CharSequence s,
 char c,
 int start,
 int end,
 boolean caseSensitive)

indexOf

@Contract(pure=true)
public static int indexOf(char @NotNull [] s,
 char c,
 int start,
 int end,
 boolean caseSensitive)

indexOfAny

@Contract(pure=true)
public static int indexOfAny(@NotNull
 @NotNull String s,
 @NotNull
 @NotNull String chars)

indexOfAny

@Contract(pure=true)
public static int indexOfAny(@NotNull
 @NotNull CharSequence s,
 @NotNull
 @NotNull String chars)

indexOfAny

@Contract(pure=true)
public static int indexOfAny(@NotNull
 @NotNull String s,
 @NotNull
 @NotNull String chars,
 int start,
 int end)

indexOfAny

@Contract(pure=true)
public static int indexOfAny(@NotNull
 @NotNull CharSequence s,
 @NotNull
 @NotNull String chars,
 int start,
 int end)

indexOfIgnoreCase

@Contract(pure=true)
public static int indexOfIgnoreCase(@NotNull
 @NotNull String where,
 @NotNull
 @NotNull String what,
 int fromIndex)

indexOfIgnoreCase

@Contract(pure=true)
public static int indexOfIgnoreCase(@NotNull
 @NotNull CharSequence where,
 @NotNull
 @NotNull CharSequence what,
 int fromIndex)

Implementation copied from String.indexOf(String, int) except character comparisons made case-insensitive

indexOfIgnoreCase

@Contract(pure=true)
public static int indexOfIgnoreCase(@NotNull
 @NotNull String where,
 char what,
 int fromIndex)

charsEqualIgnoreCase

@Contract(pure=true)
public static boolean charsEqualIgnoreCase(char a,
 char b)

capitalize

@Contract(pure=true)
@NotNull
public static @NotNull String capitalize(@NotNull
 @NotNull String s)

Capitalize the first letter of the sentence.

isCapitalized

@Contract(value="null -> false",
          pure=true)
public static boolean isCapitalized(@Nullable
 @Nullable String s)

startsWith

@Contract(pure=true)
public static boolean startsWith(@NotNull
 @NotNull CharSequence text,
 int startIndex,
 @NotNull
 @NotNull CharSequence prefix)

endsWith

@Contract(pure=true)
public static boolean endsWith(@NotNull
 @NotNull CharSequence text,
 @NotNull
 @NotNull CharSequence suffix)

endsWithChar

@Contract(pure=true)
public static boolean endsWithChar(@Nullable
 @Nullable CharSequence s,
 char suffix)

endsWithIgnoreCase

@Contract(pure=true)
public static boolean endsWithIgnoreCase(@NotNull
 @NotNull CharSequence str,
 @NotNull
 @NotNull String suffix)

isNotEmpty

@Contract(value="null -> false",
          pure=true)
public static boolean isNotEmpty(@Nullable
 @Nullable String s)

isEmpty

@Contract(value="null -> true",
          pure=true)
public static boolean isEmpty(@Nullable
 @Nullable String s)

isEmpty

@Contract(value="null -> true",
          pure=true)
public static boolean isEmpty(@Nullable
 @Nullable CharSequence cs)

pluralize

@Contract(pure=true)
@NotNull
public static @NotNull String pluralize(@NotNull
 @NotNull String word)

unpluralize

@Contract(pure=true)
@Nullable
public static @Nullable String unpluralize(@NotNull
 @NotNull String word)

Returns unpluralized variant using English based heuristics like properties -> property, names -> name, children -> child. Returns null if failed to match appropriate heuristic.

Parameters:

word - english word in plural form

Returns:

name in singular form or null if failed to find one.

notNullize

@Contract(pure=true)
@NotNull
public static @NotNull String notNullize(@Nullable
 @Nullable String s)

notNullize

@Contract(pure=true)
@NotNull
public static @NotNull String notNullize(@Nullable
 @Nullable String s,
 @NotNull
 @NotNull String defaultValue)

nullize

@Contract(pure=true)
@Nullable
public static @Nullable String nullize(@Nullable
 @Nullable String s)

nullize

@Contract(pure=true)
@Nullable
public static @Nullable String nullize(@Nullable
 @Nullable String s,
 @Nullable
 @Nullable String defaultValue)

nullize

@Contract(pure=true)
@Nullable
public static @Nullable String nullize(@Nullable
 @Nullable String s,
 boolean nullizeSpaces)

isEmptyOrSpaces

@Contract(value="null -> true",
          pure=true)
public static boolean isEmptyOrSpaces(@Nullable
 @Nullable CharSequence s)

trim

@Contract(value="null -> null; !null -> !null",
          pure=true)
public static String trim(@Nullable
 @Nullable String s)

trimEnd

@Contract(pure=true)
@NotNull
public static @NotNull String trimEnd(@NotNull
 @NotNull String s,
 @NotNull
 @NotNull String suffix)

trimEnd

@Contract(pure=true)
@NotNull
public static @NotNull String trimEnd(@NotNull
 @NotNull String s,
 @NotNull
 @NotNull String suffix,
 boolean ignoreCase)

trimEnd

@Contract(pure=true)
@NotNull
public static @NotNull String trimEnd(@NotNull
 @NotNull String s,
 char suffix)

trimStart

@Contract(pure=true)
@NotNull
public static @NotNull String trimStart(@NotNull
 @NotNull String s,
 @NotNull
 @NotNull String prefix)

stringHashCode

@Contract(pure=true)
public static int stringHashCode(@NotNull
 @NotNull CharSequence chars)

stringHashCode

@Contract(pure=true)
public static int stringHashCode(@NotNull
 @NotNull CharSequence chars,
 int from,
 int to)

stringHashCode

@Contract(pure=true)
public static int stringHashCode(@NotNull
 @NotNull CharSequence chars,
 int from,
 int to,
 int prefixHash)

stringHashCode

@Contract(pure=true)
public static int stringHashCode(char @NotNull [] chars,
 int from,
 int to)

stringHashCodeInsensitive

@Contract(pure=true)
public static int stringHashCodeInsensitive(char @NotNull [] chars,
 int from,
 int to)

stringHashCodeInsensitive

@Contract(pure=true)
public static int stringHashCodeInsensitive(@NotNull
 @NotNull CharSequence chars,
 int from,
 int to)

stringHashCodeInsensitive

@Contract(pure=true)
public static int stringHashCodeInsensitive(@NotNull
 @NotNull CharSequence chars,
 int from,
 int to,
 int prefixHash)

stringHashCodeInsensitive

@Contract(pure=true)
public static int stringHashCodeInsensitive(@NotNull
 @NotNull CharSequence chars)

countChars

@Contract(pure=true)
public static int countChars(@NotNull
 @NotNull CharSequence text,
 char c)

countChars

@Contract(pure=true)
public static int countChars(@NotNull
 @NotNull CharSequence text,
 char c,
 int offset,
 boolean stopAtOtherChar)

countChars

@Contract(pure=true)
public static int countChars(@NotNull
 @NotNull CharSequence text,
 char c,
 int start,
 int end,
 boolean stopAtOtherChar)

escapeToRegexp

@NotNull
public static @NotNull StringBuilder escapeToRegexp(@NotNull
 @NotNull CharSequence text,
 @NotNull
 @NotNull StringBuilder builder)

unescapeXmlEntities

@Contract(pure=true)
@NotNull
public static @NotNull String unescapeXmlEntities(@NotNull
 @NotNull String text)

Returns:

text with some standard XML entities replaced with corresponding characters, e.g. '<' replaced with '<'

escapeXmlEntities

@Contract(pure=true)
@NotNull
public static @NotNull String escapeXmlEntities(@NotNull
 @NotNull String text)

Returns:

text with some characters replaced with standard XML entities, e.g. '<' replaced with '<'

replace

@Contract(pure=true)
@NotNull
public static @NotNull String replace(@NotNull
 @NotNull String text,
 @NotNull
 @NotNull List<String> from,
 @NotNull
 @NotNull List<String> to)

join

@Contract(pure=true)
@NotNull
public static <T> @NotNull String join(T @NotNull [] items,
 @NotNull
 @NotNull Function<? super T,String> f,
 @NotNull
 @NotNull String separator)

join

@Contract(pure=true)
@NotNull
public static <T> @NotNull String join(@NotNull
 @NotNull Collection<? extends T> items,
 @NotNull
 @NotNull Function<? super T,String> f,
 @NotNull
 @NotNull String separator)

join

@Contract(pure=true)
@NotNull
public static @NotNull String join(@NotNull
 @NotNull Iterable<?> items,
 @NotNull
 @NotNull String separator)

join

@Contract(pure=true)
@NotNull
public static <T> @NotNull String join(@NotNull
 @NotNull Iterable<? extends T> items,
 @NotNull
 @NotNull Function<? super T,? extends CharSequence> f,
 @NotNull
 @NotNull String separator)

join

public static <T> void join(@NotNull
 @NotNull Iterable<? extends T> items,
 @NotNull
 @NotNull Function<? super T,? extends CharSequence> f,
 @NotNull
 @NotNull String separator,
 @NotNull
 @NotNull StringBuilder result)

join

@Contract(pure=true)
@NotNull
public static @NotNull String join(@NotNull
 @NotNull Collection<String> strings,
 @NotNull
 @NotNull String separator)

join

public static void join(@NotNull
 @NotNull Collection<String> strings,
 @NotNull
 @NotNull String separator,
 @NotNull
 @NotNull StringBuilder result)

join

@Contract(pure=true)
@NotNull
public static @NotNull String join(int @NotNull [] values,
 @NotNull
 @NotNull String separator)

join

@Contract(pure=true)
@NotNull
public static @NotNull String join(String @NotNull ... strings)

isWhiteSpace

@Contract(pure=true)
public static boolean isWhiteSpace(char c)

stringHashCodeIgnoreWhitespaces

@Contract(pure=true)
public static int stringHashCodeIgnoreWhitespaces(@NotNull
 @NotNull CharSequence chars)

equalsIgnoreWhitespaces

@Contract(pure=true)
public static boolean equalsIgnoreWhitespaces(@Nullable
 @Nullable CharSequence s1,
 @Nullable
 @Nullable CharSequence s2)

equalsTrimWhitespaces

@Contract(pure=true)
public static boolean equalsTrimWhitespaces(@NotNull
 @NotNull CharSequence s1,
 @NotNull
 @NotNull CharSequence s2)

convertLineSeparators

@Contract(pure=true)
@NotNull
public static @NotNull String convertLineSeparators(@NotNull
 @NotNull String text)

convertLineSeparators

@Contract(pure=true)
@NotNull
public static @NotNull String convertLineSeparators(@NotNull
 @NotNull String text,
 boolean keepCarriageReturn)

convertLineSeparators

@Contract(pure=true)
@NotNull
public static @NotNull String convertLineSeparators(@NotNull
 @NotNull String text,
 @NotNull
 @NotNull String newSeparator)

convertLineSeparators

@NotNull
public static @NotNull String convertLineSeparators(@NotNull
 @NotNull String text,
 @NotNull
 @NotNull String newSeparator,
 int @Nullable [] offsetsToKeep)

areSameInstance

public static boolean areSameInstance(@Nullable
 @Nullable String s1,
 @Nullable
 @Nullable String s2)

Returns true if s1 and s2 refer to the same instance of String. There are only few cases when you really need to use this method instead of String.equals(java.lang.Object) or Objects.equals(java.lang.Object, java.lang.Object):

• for small performance improvement if you're sure that there will be no different instances of the same string;
• to implement "Sentinel" pattern; in that case use String(String) constructor to create the sentinel instance.