java.lang.String
+
+
+
|
+
+ Java™ Platform Standard Ed. 6 + |
+ |||||||||
| + PREV CLASS + NEXT CLASS | ++ FRAMES + NO FRAMES + + + + + | +|||||||||
| + SUMMARY: NESTED | FIELD | CONSTR | METHOD | ++ DETAIL: FIELD | CONSTR | METHOD | +|||||||||
+java.lang.Object ++
public final class String
The String class represents character strings. All
+ string literals in Java programs, such as "abc", are
+ implemented as instances of this class.
+
+ Strings are constant; their values cannot be changed after they + are created. String buffers support mutable strings. + Because String objects are immutable they can be shared. For example: +
+ String str = "abc"; +
+ is equivalent to: +
+ char data[] = {'a', 'b', 'c'};
+ String str = new String(data);
+ + Here are some more examples of how strings can be used: +
+ System.out.println("abc");
+ String cde = "cde";
+ System.out.println("abc" + cde);
+ String c = "abc".substring(2,3);
+ String d = cde.substring(1, 2);
+
+ The class String includes methods for examining
+ individual characters of the sequence, for comparing strings, for
+ searching strings, for extracting substrings, and for creating a
+ copy of a string with all characters translated to uppercase or to
+ lowercase. Case mapping is based on the Unicode Standard version
+ specified by the Character class.
+
+ The Java language provides special support for the string
+ concatenation operator ( + ), and for conversion of
+ other objects to strings. String concatenation is implemented
+ through the StringBuilder(or StringBuffer)
+ class and its append method.
+ String conversions are implemented through the method
+ toString, defined by Object and
+ inherited by all classes in Java. For additional information on
+ string concatenation and conversion, see Gosling, Joy, and Steele,
+ The Java Language Specification.
+
+
Unless otherwise noted, passing a null argument to a constructor
+ or method in this class will cause a NullPointerException to be
+ thrown.
+
+
A String represents a string in the UTF-16 format
+ in which supplementary characters are represented by surrogate
+ pairs (see the section Unicode
+ Character Representations in the Character class for
+ more information).
+ Index values refer to char code units, so a supplementary
+ character uses two positions in a String.
+
The String class provides methods for dealing with
+ Unicode code points (i.e., characters), in addition to those for
+ dealing with Unicode code units (i.e., char values).
+
+ +
+
Object.toString(),
+ StringBuffer,
+ StringBuilder,
+ Charset,
+ Serialized Form+ \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/externalJavadoc/String/invalid/page.html b/java/java-tests/testData/codeInsight/externalJavadoc/String/invalid/page.html new file mode 100644 index 000000000000..d8bf96587b9a --- /dev/null +++ b/java/java-tests/testData/codeInsight/externalJavadoc/String/invalid/page.html @@ -0,0 +1,3543 @@ + + + + +
+ +
+
+
|
+
+ Java™ Platform Standard Ed. 6 + |
+ |||||||||
| + PREV CLASS + NEXT CLASS | ++ FRAMES + NO FRAMES + + + + + | +|||||||||
| + SUMMARY: NESTED | FIELD | CONSTR | METHOD | ++ DETAIL: FIELD | CONSTR | METHOD | +|||||||||
+java.lang.Object ++
public final class String
+ The String class represents character strings. All
+ string literals in Java programs, such as "abc", are
+ implemented as instances of this class.
+
+ Strings are constant; their values cannot be changed after they + are created. String buffers support mutable strings. + Because String objects are immutable they can be shared. For example: +
+ String str = "abc"; +
+ is equivalent to: +
+ char data[] = {'a', 'b', 'c'};
+ String str = new String(data);
+ + Here are some more examples of how strings can be used: +
+ System.out.println("abc");
+ String cde = "cde";
+ System.out.println("abc" + cde);
+ String c = "abc".substring(2,3);
+ String d = cde.substring(1, 2);
+
+ The class String includes methods for examining
+ individual characters of the sequence, for comparing strings, for
+ searching strings, for extracting substrings, and for creating a
+ copy of a string with all characters translated to uppercase or to
+ lowercase. Case mapping is based on the Unicode Standard version
+ specified by the Character class.
+
+ The Java language provides special support for the string
+ concatenation operator ( + ), and for conversion of
+ other objects to strings. String concatenation is implemented
+ through the StringBuilder(or StringBuffer)
+ class and its append method.
+ String conversions are implemented through the method
+ toString, defined by Object and
+ inherited by all classes in Java. For additional information on
+ string concatenation and conversion, see Gosling, Joy, and Steele,
+ The Java Language Specification.
+
+
Unless otherwise noted, passing a null argument to a constructor
+ or method in this class will cause a NullPointerException to be
+ thrown.
+
+
A String represents a string in the UTF-16 format
+ in which supplementary characters are represented by surrogate
+ pairs (see the section Unicode
+ Character Representations in the Character class for
+ more information).
+ Index values refer to char code units, so a supplementary
+ character uses two positions in a String.
+
The String class provides methods for dealing with
+ Unicode code points (i.e., characters), in addition to those for
+ dealing with Unicode code units (i.e., char values).
+
+ +
+
Object.toString(),
+ StringBuffer,
+ StringBuilder,
+ Charset,
+ Serialized Form| + Field Summary | +|
|---|---|
+ static Comparator<String> |
+ CASE_INSENSITIVE_ORDER
+
+ + A Comparator that orders String objects as by
+ compareToIgnoreCase. |
+
| + Constructor Summary | +|
|---|---|
String()
+
+ + Initializes a newly created String object so that it represents
+ an empty character sequence. |
+ |
String(byte[] bytes)
+
+ + Constructs a new String by decoding the specified array of bytes
+ using the platform's default charset. |
+ |
String(byte[] bytes,
+ Charset charset)
+
+ + Constructs a new String by decoding the specified array of
+ bytes using the specified charset. |
+ |
String(byte[] ascii,
+ int hibyte)
+
+ + Deprecated. This method does not properly convert bytes into + characters. As of JDK 1.1, the preferred way to do this is via the + String constructors that take a Charset, charset name, or that use the platform's
+ default charset. |
+ |
String(byte[] bytes,
+ int offset,
+ int length)
+
+ + Constructs a new String by decoding the specified subarray of
+ bytes using the platform's default charset. |
+ |
String(byte[] bytes,
+ int offset,
+ int length,
+ Charset charset)
+
+ + Constructs a new String by decoding the specified subarray of
+ bytes using the specified charset. |
+ |
String(byte[] ascii,
+ int hibyte,
+ int offset,
+ int count)
+
+ + Deprecated. This method does not properly convert bytes into characters. + As of JDK 1.1, the preferred way to do this is via the + String constructors that take a Charset, charset name, or that use the platform's
+ default charset. |
+ |
String(byte[] bytes,
+ int offset,
+ int length,
+ String charsetName)
+
+ + Constructs a new String by decoding the specified subarray of
+ bytes using the specified charset. |
+ |
String(byte[] bytes,
+ String charsetName)
+
+ + Constructs a new String by decoding the specified array of bytes
+ using the specified charset. |
+ |
String(char[] value)
+
+ + Allocates a new String so that it represents the sequence of
+ characters currently contained in the character array argument. |
+ |
String(char[] value,
+ int offset,
+ int count)
+
+ + Allocates a new String that contains characters from a subarray
+ of the character array argument. |
+ |
String(int[] codePoints,
+ int offset,
+ int count)
+
+ + Allocates a new String that contains characters from a subarray
+ of the Unicode code point array argument. |
+ |
String(String original)
+
+ + Initializes a newly created String object so that it represents
+ the same sequence of characters as the argument; in other words, the
+ newly created string is a copy of the argument string. |
+ |
String(StringBuffer buffer)
+
+ + Allocates a new string that contains the sequence of characters + currently contained in the string buffer argument. |
+ |
String(StringBuilder builder)
+
+ + Allocates a new string that contains the sequence of characters + currently contained in the string builder argument. |
+ |
| + Method Summary | +|
|---|---|
+ char |
+ charAt(int index)
+
+ + Returns the char value at the
+ specified index. |
+
+ int |
+ codePointAt(int index)
+
+ + Returns the character (Unicode code point) at the specified + index. |
+
+ int |
+ codePointBefore(int index)
+
+ + Returns the character (Unicode code point) before the specified + index. |
+
+ int |
+ codePointCount(int beginIndex,
+ int endIndex)
+
+ + Returns the number of Unicode code points in the specified text + range of this String. |
+
+ int |
+ compareTo(String anotherString)
+
+ + Compares two strings lexicographically. |
+
+ int |
+ compareToIgnoreCase(String str)
+
+ + Compares two strings lexicographically, ignoring case + differences. |
+
+ String |
+ concat(String str)
+
+ + Concatenates the specified string to the end of this string. |
+
+ boolean |
+ contains(CharSequence s)
+
+ + Returns true if and only if this string contains the specified + sequence of char values. |
+
+ boolean |
+ contentEquals(CharSequence cs)
+
+ + Compares this string to the specified CharSequence. |
+
+ boolean |
+ contentEquals(StringBuffer sb)
+
+ + Compares this string to the specified StringBuffer. |
+
+ static String |
+ copyValueOf(char[] data)
+
+ + Returns a String that represents the character sequence in the + array specified. |
+
+ static String |
+ copyValueOf(char[] data,
+ int offset,
+ int count)
+
+ + Returns a String that represents the character sequence in the + array specified. |
+
+ boolean |
+ endsWith(String suffix)
+
+ + Tests if this string ends with the specified suffix. |
+
+ boolean |
+ equals(Object anObject)
+
+ + Compares this string to the specified object. |
+
+ boolean |
+ equalsIgnoreCase(String anotherString)
+
+ + Compares this String to another String, ignoring case
+ considerations. |
+
+ static String |
+ format(Locale l,
+ String format,
+ Object... args)
+
+ + Returns a formatted string using the specified locale, format string, + and arguments. |
+
+ static String |
+ format(String format,
+ Object... args)
+
+ + Returns a formatted string using the specified format string and + arguments. |
+
+ byte[] |
+ getBytes()
+
+ + Encodes this String into a sequence of bytes using the
+ platform's default charset, storing the result into a new byte array. |
+
+ byte[] |
+ getBytes(Charset charset)
+
+ + Encodes this String into a sequence of bytes using the given
+ charset, storing the result into a
+ new byte array. |
+
+ void |
+ getBytes(int srcBegin,
+ int srcEnd,
+ byte[] dst,
+ int dstBegin)
+
+ + Deprecated. This method does not properly convert characters into + bytes. As of JDK 1.1, the preferred way to do this is via the + getBytes() method, which uses the platform's default charset. |
+
+ byte[] |
+ getBytes(String charsetName)
+
+ + Encodes this String into a sequence of bytes using the named
+ charset, storing the result into a new byte array. |
+
+ void |
+ getChars(int srcBegin,
+ int srcEnd,
+ char[] dst,
+ int dstBegin)
+
+ + Copies characters from this string into the destination character + array. |
+
+ int |
+ hashCode()
+
+ + Returns a hash code for this string. |
+
+ int |
+ indexOf(int ch)
+
+ + Returns the index within this string of the first occurrence of + the specified character. |
+
+ int |
+ indexOf(int ch,
+ int fromIndex)
+
+ + Returns the index within this string of the first occurrence of the + specified character, starting the search at the specified index. |
+
+ int |
+ indexOf(String str)
+
+ + Returns the index within this string of the first occurrence of the + specified substring. |
+
+ int |
+ indexOf(String str,
+ int fromIndex)
+
+ + Returns the index within this string of the first occurrence of the + specified substring, starting at the specified index. |
+
+ String |
+ intern()
+
+ + Returns a canonical representation for the string object. |
+
+ boolean |
+ isEmpty()
+
+ + Returns true if, and only if, length() is 0. |
+
+ int |
+ lastIndexOf(int ch)
+
+ + Returns the index within this string of the last occurrence of + the specified character. |
+
+ int |
+ lastIndexOf(int ch,
+ int fromIndex)
+
+ + Returns the index within this string of the last occurrence of + the specified character, searching backward starting at the + specified index. |
+
+ int |
+ lastIndexOf(String str)
+
+ + Returns the index within this string of the rightmost occurrence + of the specified substring. |
+
+ int |
+ lastIndexOf(String str,
+ int fromIndex)
+
+ + Returns the index within this string of the last occurrence of the + specified substring, searching backward starting at the specified index. |
+
+ int |
+ length()
+
+ + Returns the length of this string. |
+
+ boolean |
+ matches(String regex)
+
+ + Tells whether or not this string matches the given regular expression. |
+
+ int |
+ offsetByCodePoints(int index,
+ int codePointOffset)
+
+ + Returns the index within this String that is
+ offset from the given index by
+ codePointOffset code points. |
+
+ boolean |
+ regionMatches(boolean ignoreCase,
+ int toffset,
+ String other,
+ int ooffset,
+ int len)
+
+ + Tests if two string regions are equal. |
+
+ boolean |
+ regionMatches(int toffset,
+ String other,
+ int ooffset,
+ int len)
+
+ + Tests if two string regions are equal. |
+
+ String |
+ replace(char oldChar,
+ char newChar)
+
+ + Returns a new string resulting from replacing all occurrences of + oldChar in this string with newChar. |
+
+ String |
+ replace(CharSequence target,
+ CharSequence replacement)
+
+ + Replaces each substring of this string that matches the literal target + sequence with the specified literal replacement sequence. |
+
+ String |
+ replaceAll(String regex,
+ String replacement)
+
+ + Replaces each substring of this string that matches the given regular expression with the + given replacement. |
+
+ String |
+ replaceFirst(String regex,
+ String replacement)
+
+ + Replaces the first substring of this string that matches the given regular expression with the + given replacement. |
+
+ String[] |
+ split(String regex)
+
+ + Splits this string around matches of the given regular expression. |
+
+ String[] |
+ split(String regex,
+ int limit)
+
+ + Splits this string around matches of the given + regular expression. |
+
+ boolean |
+ startsWith(String prefix)
+
+ + Tests if this string starts with the specified prefix. |
+
+ boolean |
+ startsWith(String prefix,
+ int toffset)
+
+ + Tests if the substring of this string beginning at the + specified index starts with the specified prefix. |
+
+ CharSequence |
+ subSequence(int beginIndex,
+ int endIndex)
+
+ + Returns a new character sequence that is a subsequence of this sequence. |
+
+ String |
+ substring(int beginIndex)
+
+ + Returns a new string that is a substring of this string. |
+
+ String |
+ substring(int beginIndex,
+ int endIndex)
+
+ + Returns a new string that is a substring of this string. |
+
+ char[] |
+ toCharArray()
+
+ + Converts this string to a new character array. |
+
+ String |
+ toLowerCase()
+
+ + Converts all of the characters in this String to lower
+ case using the rules of the default locale. |
+
+ String |
+ toLowerCase(Locale locale)
+
+ + Converts all of the characters in this String to lower
+ case using the rules of the given Locale. |
+
+ String |
+ toString()
+
+ + This object (which is already a string!) is itself returned. |
+
+ String |
+ toUpperCase()
+
+ + Converts all of the characters in this String to upper
+ case using the rules of the default locale. |
+
+ String |
+ toUpperCase(Locale locale)
+
+ + Converts all of the characters in this String to upper
+ case using the rules of the given Locale. |
+
+ String |
+ trim()
+
+ + Returns a copy of the string, with leading and trailing whitespace + omitted. |
+
+ static String |
+ valueOf(boolean b)
+
+ + Returns the string representation of the boolean argument. |
+
+ static String |
+ valueOf(char c)
+
+ + Returns the string representation of the char
+ argument. |
+
+ static String |
+ valueOf(char[] data)
+
+ + Returns the string representation of the char array
+ argument. |
+
+ static String |
+ valueOf(char[] data,
+ int offset,
+ int count)
+
+ + Returns the string representation of a specific subarray of the + char array argument. |
+
+ static String |
+ valueOf(double d)
+
+ + Returns the string representation of the double argument. |
+
+ static String |
+ valueOf(float f)
+
+ + Returns the string representation of the float argument. |
+
+ static String |
+ valueOf(int i)
+
+ + Returns the string representation of the int argument. |
+
+ static String |
+ valueOf(long l)
+
+ + Returns the string representation of the long argument. |
+
+ static String |
+ valueOf(Object obj)
+
+ + Returns the string representation of the Object argument. |
+
| Methods inherited from class java.lang.Object | +
|---|
clone, finalize, getClass, notify, notifyAll, wait, wait, wait |
+
| + Field Detail | +
|---|
+public static final Comparator<String> CASE_INSENSITIVE_ORDER+
String objects as by
+ compareToIgnoreCase. This comparator is serializable.
+ + Note that this Comparator does not take locale into account, + and will result in an unsatisfactory ordering for certain locales. + The java.text package provides Collators to allow + locale-sensitive ordering. +
+
Collator.compare(String, String)| + Constructor Detail | +
|---|
+public String()+
String object so that it represents
+ an empty character sequence. Note that use of this constructor is
+ unnecessary since Strings are immutable.
+ +
+public String(String original)+
String object so that it represents
+ the same sequence of characters as the argument; in other words, the
+ newly created string is a copy of the argument string. Unless an
+ explicit copy of original is needed, use of this constructor is
+ unnecessary since Strings are immutable.
+ +
original - A String+public String(char[] value)+
String so that it represents the sequence of
+ characters currently contained in the character array argument. The
+ contents of the character array are copied; subsequent modification of
+ the character array does not affect the newly created string.
+ +
value - The initial value of the string+public String(char[] value, + int offset, + int count)+
String that contains characters from a subarray
+ of the character array argument. The offset argument is the
+ index of the first character of the subarray and the count
+ argument specifies the length of the subarray. The contents of the
+ subarray are copied; subsequent modification of the character array does
+ not affect the newly created string.
+ +
value - Array that is the source of charactersoffset - The initial offsetcount - The length
+ IndexOutOfBoundsException - If the offset and count arguments index
+ characters outside the bounds of the value array+public String(int[] codePoints, + int offset, + int count)+
String that contains characters from a subarray
+ of the Unicode code point array argument. The offset argument
+ is the index of the first code point of the subarray and the
+ count argument specifies the length of the subarray. The
+ contents of the subarray are converted to chars; subsequent
+ modification of the int array does not affect the newly created
+ string.
+ +
codePoints - Array that is the source of Unicode code pointsoffset - The initial offsetcount - The length
+ IllegalArgumentException - If any invalid Unicode code point is found in codePoints
+ IndexOutOfBoundsException - If the offset and count arguments index
+ characters outside the bounds of the codePoints array+@Deprecated +public String(byte[] ascii, + int hibyte, + int offset, + int count)+
String constructors that take a Charset, charset name, or that use the platform's
+ default charset.
+ +
String constructed from a subarray of an array
+ of 8-bit integer values.
+
+ The offset argument is the index of the first byte of the
+ subarray, and the count argument specifies the length of the
+ subarray.
+
+
Each byte in the subarray is converted to a char as
+ specified in the method above.
+
+
ascii - The bytes to be converted to charactershibyte - The top 8 bits of each 16-bit Unicode code unitoffset - The initial offsetcount - The length
+ IndexOutOfBoundsException - If the offset or count argument is invalidString(byte[], int),
+ String(byte[], int, int, java.lang.String),
+ String(byte[], int, int, java.nio.charset.Charset),
+ String(byte[], int, int),
+ String(byte[], java.lang.String),
+ String(byte[], java.nio.charset.Charset),
+ String(byte[])+@Deprecated +public String(byte[] ascii, + int hibyte)+
String constructors that take a Charset, charset name, or that use the platform's
+ default charset.
+ +
String containing characters constructed from
+ an array of 8-bit integer values. Each character cin the
+ resulting string is constructed from the corresponding component
+ b in the byte array such that:
+
+ ++ c == (char)(((hibyte & 0xff) << 8) + | (b & 0xff)) +
+
ascii - The bytes to be converted to charactershibyte - The top 8 bits of each 16-bit Unicode code unitString(byte[], int, int, java.lang.String),
+ String(byte[], int, int, java.nio.charset.Charset),
+ String(byte[], int, int),
+ String(byte[], java.lang.String),
+ String(byte[], java.nio.charset.Charset),
+ String(byte[])+public String(byte[] bytes, + int offset, + int length, + String charsetName) + throws UnsupportedEncodingException+
String by decoding the specified subarray of
+ bytes using the specified charset. The length of the new String
+ is a function of the charset, and hence may not be equal to the length
+ of the subarray.
+
+ The behavior of this constructor when the given bytes are not valid
+ in the given charset is unspecified. The CharsetDecoder class should be used when more control
+ over the decoding process is required.
+
+
bytes - The bytes to be decoded into charactersoffset - The index of the first byte to decodelength - The number of bytes to decodecharsetName - The name of a supported charset
+ UnsupportedEncodingException - If the named charset is not supported
+ IndexOutOfBoundsException - If the offset and length arguments index
+ characters outside the bounds of the bytes array+public String(byte[] bytes, + int offset, + int length, + Charset charset)+
String by decoding the specified subarray of
+ bytes using the specified charset.
+ The length of the new String is a function of the charset, and
+ hence may not be equal to the length of the subarray.
+
+ This method always replaces malformed-input and unmappable-character
+ sequences with this charset's default replacement string. The CharsetDecoder class should be used when more control
+ over the decoding process is required.
+
+
bytes - The bytes to be decoded into charactersoffset - The index of the first byte to decodelength - The number of bytes to decodecharset - The charset to be used to
+ decode the bytes
+ IndexOutOfBoundsException - If the offset and length arguments index
+ characters outside the bounds of the bytes array+public String(byte[] bytes, + String charsetName) + throws UnsupportedEncodingException+
String by decoding the specified array of bytes
+ using the specified charset. The
+ length of the new String is a function of the charset, and hence
+ may not be equal to the length of the byte array.
+
+ The behavior of this constructor when the given bytes are not valid
+ in the given charset is unspecified. The CharsetDecoder class should be used when more control
+ over the decoding process is required.
+
+
bytes - The bytes to be decoded into characterscharsetName - The name of a supported charset
+ UnsupportedEncodingException - If the named charset is not supported+public String(byte[] bytes, + Charset charset)+
String by decoding the specified array of
+ bytes using the specified charset.
+ The length of the new String is a function of the charset, and
+ hence may not be equal to the length of the byte array.
+
+ This method always replaces malformed-input and unmappable-character
+ sequences with this charset's default replacement string. The CharsetDecoder class should be used when more control
+ over the decoding process is required.
+
+
bytes - The bytes to be decoded into characterscharset - The charset to be used to
+ decode the bytes+public String(byte[] bytes, + int offset, + int length)+
String by decoding the specified subarray of
+ bytes using the platform's default charset. The length of the new
+ String is a function of the charset, and hence may not be equal
+ to the length of the subarray.
+
+ The behavior of this constructor when the given bytes are not valid
+ in the default charset is unspecified. The CharsetDecoder class should be used when more control
+ over the decoding process is required.
+
+
bytes - The bytes to be decoded into charactersoffset - The index of the first byte to decodelength - The number of bytes to decode
+ IndexOutOfBoundsException - If the offset and the length arguments index
+ characters outside the bounds of the bytes array+public String(byte[] bytes)+
String by decoding the specified array of bytes
+ using the platform's default charset. The length of the new String is a function of the charset, and hence may not be equal to the
+ length of the byte array.
+
+ The behavior of this constructor when the given bytes are not valid
+ in the default charset is unspecified. The CharsetDecoder class should be used when more control
+ over the decoding process is required.
+
+
bytes - The bytes to be decoded into characters+public String(StringBuffer buffer)+
+
buffer - A StringBuffer+public String(StringBuilder builder)+
This constructor is provided to ease migration to StringBuilder. Obtaining a string from a string builder via the toString method is likely to run faster and is generally preferred.
+
+
builder - A StringBuilder| + Method Detail | +
|---|
+public int length()+
+
length in interface CharSequence+public boolean isEmpty()+
length() is 0.
+ +
length() is 0, otherwise
+ false+public char charAt(int index)+
char value at the
+ specified index. An index ranges from 0 to
+ length() - 1. The first char value of the sequence
+ is at index 0, the next at index 1,
+ and so on, as for array indexing.
+
+ If the char value specified by the index is a
+ surrogate, the surrogate
+ value is returned.
+
+
charAt in interface CharSequenceindex - the index of the char value.
+ char value at the specified index of this string.
+ The first char value is at index 0.
+ IndexOutOfBoundsException - if the index
+ argument is negative or not less than the length of this
+ string.+public int codePointAt(int index)+
char values
+ (Unicode code units) and ranges from 0 to
+ length() - 1.
+
+ If the char value specified at the given index
+ is in the high-surrogate range, the following index is less
+ than the length of this String, and the
+ char value at the following index is in the
+ low-surrogate range, then the supplementary code point
+ corresponding to this surrogate pair is returned. Otherwise,
+ the char value at the given index is returned.
+
+
index - the index to the char values
+ index
+ IndexOutOfBoundsException - if the index
+ argument is negative or not less than the length of this
+ string.+public int codePointBefore(int index)+
char values
+ (Unicode code units) and ranges from 1 to length.
+
+ If the char value at (index - 1)
+ is in the low-surrogate range, (index - 2) is not
+ negative, and the char value at (index -
+ 2) is in the high-surrogate range, then the
+ supplementary code point value of the surrogate pair is
+ returned. If the char value at index -
+ 1 is an unpaired low-surrogate or a high-surrogate, the
+ surrogate value is returned.
+
+
index - the index following the code point that should be returned
+ IndexOutOfBoundsException - if the index
+ argument is less than 1 or greater than the length
+ of this string.+public int codePointCount(int beginIndex, + int endIndex)+
String. The text range begins at the
+ specified beginIndex and extends to the
+ char at index endIndex - 1. Thus the
+ length (in chars) of the text range is
+ endIndex-beginIndex. Unpaired surrogates within
+ the text range count as one code point each.
+ +
beginIndex - the index to the first char of
+ the text range.endIndex - the index after the last char of
+ the text range.
+ IndexOutOfBoundsException - if the
+ beginIndex is negative, or endIndex
+ is larger than the length of this String, or
+ beginIndex is larger than endIndex.+public int offsetByCodePoints(int index, + int codePointOffset)+
String that is
+ offset from the given index by
+ codePointOffset code points. Unpaired surrogates
+ within the text range given by index and
+ codePointOffset count as one code point each.
+ +
index - the index to be offsetcodePointOffset - the offset in code points
+ String
+ IndexOutOfBoundsException - if index
+ is negative or larger then the length of this
+ String, or if codePointOffset is positive
+ and the substring starting with index has fewer
+ than codePointOffset code points,
+ or if codePointOffset is negative and the substring
+ before index has fewer than the absolute value
+ of codePointOffset code points.+public void getChars(int srcBegin, + int srcEnd, + char[] dst, + int dstBegin)+
+ The first character to be copied is at index srcBegin;
+ the last character to be copied is at index srcEnd-1
+ (thus the total number of characters to be copied is
+ srcEnd-srcBegin). The characters are copied into the
+ subarray of dst starting at index dstBegin
+ and ending at index:
+
++ dstbegin + (srcEnd-srcBegin) - 1 +
+
srcBegin - index of the first character in the string
+ to copy.srcEnd - index after the last character in the string
+ to copy.dst - the destination array.dstBegin - the start offset in the destination array.
+ IndexOutOfBoundsException - If any of the following
+ is true:
+ srcBegin is negative.
+ srcBegin is greater than srcEnd
+ srcEnd is greater than the length of this
+ string
+ dstBegin is negative
+ dstBegin+(srcEnd-srcBegin) is larger than
+ dst.length+@Deprecated +public void getBytes(int srcBegin, + int srcEnd, + byte[] dst, + int dstBegin)+
getBytes() method, which uses the platform's default charset.
+ +
The first character to be copied is at index srcBegin; the
+ last character to be copied is at index srcEnd-1. The total
+ number of characters to be copied is srcEnd-srcBegin. The
+ characters, converted to bytes, are copied into the subarray of dst starting at index dstBegin and ending at index:
+
+
++ dstbegin + (srcEnd-srcBegin) - 1 +
+
srcBegin - Index of the first character in the string to copysrcEnd - Index after the last character in the string to copydst - The destination arraydstBegin - The start offset in the destination array
+ IndexOutOfBoundsException - If any of the following is true:
+ srcBegin is negative
+ srcBegin is greater than srcEnd
+ srcEnd is greater than the length of this String
+ dstBegin is negative
+ dstBegin+(srcEnd-srcBegin) is larger than dst.length
+ +public byte[] getBytes(String charsetName) + throws UnsupportedEncodingException+
String into a sequence of bytes using the named
+ charset, storing the result into a new byte array.
+
+ The behavior of this method when this string cannot be encoded in
+ the given charset is unspecified. The CharsetEncoder class should be used when more control
+ over the encoding process is required.
+
+
charsetName - The name of a supported charset
+ UnsupportedEncodingException - If the named charset is not supported+public byte[] getBytes(Charset charset)+
String into a sequence of bytes using the given
+ charset, storing the result into a
+ new byte array.
+
+ This method always replaces malformed-input and unmappable-character
+ sequences with this charset's default replacement byte array. The
+ CharsetEncoder class should be used when more
+ control over the encoding process is required.
+
+
charset - The Charset to be used to encode
+ the String
+ +public byte[] getBytes()+
String into a sequence of bytes using the
+ platform's default charset, storing the result into a new byte array.
+
+ The behavior of this method when this string cannot be encoded in
+ the default charset is unspecified. The CharsetEncoder class should be used when more control
+ over the encoding process is required.
+
+
+public boolean equals(Object anObject)+
true if and only if the argument is not null and is a String object that represents the same sequence of characters as this
+ object.
+ +
anObject - The object to compare this String against
+ true if the given object represents a String
+ equivalent to this string, false otherwisecompareTo(String),
+ equalsIgnoreCase(String)+public boolean contentEquals(StringBuffer sb)+
StringBuffer. The result
+ is true if and only if this String represents the same
+ sequence of characters as the specified StringBuffer.
+ +
sb - The StringBuffer to compare this String against
+ true if this String represents the same
+ sequence of characters as the specified StringBuffer,
+ false otherwise+public boolean contentEquals(CharSequence cs)+
CharSequence. The result
+ is true if and only if this String represents the same
+ sequence of char values as the specified sequence.
+ +
cs - The sequence to compare this String against
+ true if this String represents the same
+ sequence of char values as the specified sequence, false otherwise+public boolean equalsIgnoreCase(String anotherString)+
String to another String, ignoring case
+ considerations. Two strings are considered equal ignoring case if they
+ are of the same length and corresponding characters in the two strings
+ are equal ignoring case.
+
+ Two characters c1 and c2 are considered the same
+ ignoring case if at least one of the following is true:
+
== operator)
+ Character.toUpperCase(char) to each character
+ produces the same result
+ Character.toLowerCase(char) to each character
+ produces the same result
+ +
anotherString - The String to compare this String against
+ true if the argument is not null and it
+ represents an equivalent String ignoring case; false otherwiseequals(Object)+public int compareTo(String anotherString)+
String object is compared lexicographically to the
+ character sequence represented by the argument string. The result is
+ a negative integer if this String object
+ lexicographically precedes the argument string. The result is a
+ positive integer if this String object lexicographically
+ follows the argument string. The result is zero if the strings
+ are equal; compareTo returns 0 exactly when
+ the equals(Object) method would return true.
+
+ This is the definition of lexicographic ordering. If two strings are
+ different, then either they have different characters at some index
+ that is a valid index for both strings, or their lengths are different,
+ or both. If they have different characters at one or more index
+ positions, let k be the smallest such index; then the string
+ whose character at position k has the smaller value, as
+ determined by using the < operator, lexicographically precedes the
+ other string. In this case, compareTo returns the
+ difference of the two character values at position k in
+ the two string -- that is, the value:
+
+ If there is no index position at which they differ, then the shorter + string lexicographically precedes the longer string. In this case, ++ this.charAt(k)-anotherString.charAt(k) +
compareTo returns the difference of the lengths of the
+ strings -- that is, the value:
+ ++ this.length()-anotherString.length() +
+
compareTo in interface Comparable<String>anotherString - the String to be compared.
+ 0 if the argument string is equal to
+ this string; a value less than 0 if this string
+ is lexicographically less than the string argument; and a
+ value greater than 0 if this string is
+ lexicographically greater than the string argument.+public int compareToIgnoreCase(String str)+
compareTo with normalized versions of the strings
+ where case differences have been eliminated by calling
+ Character.toLowerCase(Character.toUpperCase(character)) on
+ each character.
+ + Note that this method does not take locale into account, + and will result in an unsatisfactory ordering for certain locales. + The java.text package provides collators to allow + locale-sensitive ordering. +
+
str - the String to be compared.
+ Collator.compare(String, String)+public boolean regionMatches(int toffset, + String other, + int ooffset, + int len)+
+ A substring of this String object is compared to a substring + of the argument other. The result is true if these substrings + represent identical character sequences. The substring of this + String object to be compared begins at index toffset + and has length len. The substring of other to be compared + begins at index ooffset and has length len. The + result is false if and only if at least one of the following + is true: +
+
toffset - the starting offset of the subregion in this string.other - the string argument.ooffset - the starting offset of the subregion in the string
+ argument.len - the number of characters to compare.
+ true if the specified subregion of this string
+ exactly matches the specified subregion of the string argument;
+ false otherwise.+public boolean regionMatches(boolean ignoreCase, + int toffset, + String other, + int ooffset, + int len)+
+ A substring of this String object is compared to a substring + of the argument other. The result is true if these + substrings represent character sequences that are the same, ignoring + case if and only if ignoreCase is true. The substring of + this String object to be compared begins at index + toffset and has length len. The substring of + other to be compared begins at index ooffset and + has length len. The result is false if and only if + at least one of the following is true: +
++ this.charAt(toffset+k) != other.charAt(ooffset+k) +
+ and: ++ Character.toLowerCase(this.charAt(toffset+k)) != + Character.toLowerCase(other.charAt(ooffset+k)) +
++ Character.toUpperCase(this.charAt(toffset+k)) != + Character.toUpperCase(other.charAt(ooffset+k)) +
+
ignoreCase - if true, ignore case when comparing
+ characters.toffset - the starting offset of the subregion in this
+ string.other - the string argument.ooffset - the starting offset of the subregion in the string
+ argument.len - the number of characters to compare.
+ true if the specified subregion of this string
+ matches the specified subregion of the string argument;
+ false otherwise. Whether the matching is exact
+ or case insensitive depends on the ignoreCase
+ argument.+public boolean startsWith(String prefix, + int toffset)+
+
prefix - the prefix.toffset - where to begin looking in this string.
+ true if the character sequence represented by the
+ argument is a prefix of the substring of this object starting
+ at index toffset; false otherwise.
+ The result is false if toffset is
+ negative or greater than the length of this
+ String object; otherwise the result is the same
+ as the result of the expression
+ + this.substring(toffset).startsWith(prefix) +
+public boolean startsWith(String prefix)+
+
prefix - the prefix.
+ true if the character sequence represented by the
+ argument is a prefix of the character sequence represented by
+ this string; false otherwise.
+ Note also that true will be returned if the
+ argument is an empty string or is equal to this
+ String object as determined by the
+ equals(Object) method.+public boolean endsWith(String suffix)+
+
suffix - the suffix.
+ true if the character sequence represented by the
+ argument is a suffix of the character sequence represented by
+ this object; false otherwise. Note that the
+ result will be true if the argument is the
+ empty string or is equal to this String object
+ as determined by the equals(Object) method.+public int hashCode()+
String object is computed as
+ + using+ s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1] +
int arithmetic, where s[i] is the
+ ith character of the string, n is the length of
+ the string, and ^ indicates exponentiation.
+ (The hash value of the empty string is zero.)
+ +
Object.equals(java.lang.Object),
+ Hashtable+public int indexOf(int ch)+
ch occurs in the character sequence represented by
+ this String object, then the index (in Unicode
+ code units) of the first such occurrence is returned. For
+ values of ch in the range from 0 to 0xFFFF
+ (inclusive), this is the smallest value k such that:
+ + is true. For other values of+ this.charAt(k) == ch +
ch, it is the
+ smallest value k such that:
+ + is true. In either case, if no such character occurs in this + string, then+ this.codePointAt(k) == ch +
-1 is returned.
+ +
ch - a character (Unicode code point).
+ -1 if the character does not occur.+public int indexOf(int ch, + int fromIndex)+
+ If a character with value ch occurs in the
+ character sequence represented by this String
+ object at an index no smaller than fromIndex, then
+ the index of the first such occurrence is returned. For values
+ of ch in the range from 0 to 0xFFFF (inclusive),
+ this is the smallest value k such that:
+
+ is true. For other values of+ (this.charAt(k) == ch) && (k >= fromIndex) +
ch, it is the
+ smallest value k such that:
+ + is true. In either case, if no such character occurs in this + string at or after position+ (this.codePointAt(k) == ch) && (k >= fromIndex) +
fromIndex, then
+ -1 is returned.
+
+
+ There is no restriction on the value of fromIndex. If it
+ is negative, it has the same effect as if it were zero: this entire
+ string may be searched. If it is greater than the length of this
+ string, it has the same effect as if it were equal to the length of
+ this string: -1 is returned.
+
+
All indices are specified in char values
+ (Unicode code units).
+
+
ch - a character (Unicode code point).fromIndex - the index to start the search from.
+ fromIndex, or -1
+ if the character does not occur.+public int lastIndexOf(int ch)+
ch in the
+ range from 0 to 0xFFFF (inclusive), the index (in Unicode code
+ units) returned is the largest value k such that:
+ + is true. For other values of+ this.charAt(k) == ch +
ch, it is the
+ largest value k such that:
+ + is true. In either case, if no such character occurs in this + string, then+ this.codePointAt(k) == ch +
-1 is returned. The
+ String is searched backwards starting at the last
+ character.
+ +
ch - a character (Unicode code point).
+ -1 if the character does not occur.+public int lastIndexOf(int ch, + int fromIndex)+
ch in the range
+ from 0 to 0xFFFF (inclusive), the index returned is the largest
+ value k such that:
+ + is true. For other values of+ (this.charAt(k) == ch) && (k <= fromIndex) +
ch, it is the
+ largest value k such that:
+ + is true. In either case, if no such character occurs in this + string at or before position+ (this.codePointAt(k) == ch) && (k <= fromIndex) +
fromIndex, then
+ -1 is returned.
+
+ All indices are specified in char values
+ (Unicode code units).
+
+
ch - a character (Unicode code point).fromIndex - the index to start the search from. There is no
+ restriction on the value of fromIndex. If it is
+ greater than or equal to the length of this string, it has
+ the same effect as if it were equal to one less than the
+ length of this string: this entire string may be searched.
+ If it is negative, it has the same effect as if it were -1:
+ -1 is returned.
+ fromIndex, or -1
+ if the character does not occur before that point.+public int indexOf(String str)+
+ is+ this.startsWith(str, k) +
true.
+ +
str - any string.
+ -1 is returned.+public int indexOf(String str, + int fromIndex)+
+ If no such value of k exists, then -1 is returned. ++ k >= Math.min(fromIndex, this.length()) && this.startsWith(str, k) +
+
str - the substring for which to search.fromIndex - the index from which to start the search.
+ +public int lastIndexOf(String str)+
this.length().
+ The returned index is the largest value k such that
+ + is true. ++ this.startsWith(str, k) +
+
str - the substring to search for.
+ -1 is returned.+public int lastIndexOf(String str, + int fromIndex)+
+ If no such value of k exists, then -1 is returned. ++ k <= Math.min(fromIndex, this.length()) && this.startsWith(str, k) +
+
str - the substring to search for.fromIndex - the index to start the search from.
+ +public String substring(int beginIndex)+
+ Examples: +
++ "unhappy".substring(2) returns "happy" + "Harbison".substring(3) returns "bison" + "emptiness".substring(9) returns "" (an empty string) +
+
beginIndex - the beginning index, inclusive.
+ IndexOutOfBoundsException - if
+ beginIndex is negative or larger than the
+ length of this String object.+public String substring(int beginIndex, + int endIndex)+
beginIndex and
+ extends to the character at index endIndex - 1.
+ Thus the length of the substring is endIndex-beginIndex.
+ + Examples: +
++ "hamburger".substring(4, 8) returns "urge" + "smiles".substring(1, 5) returns "mile" +
+
beginIndex - the beginning index, inclusive.endIndex - the ending index, exclusive.
+ IndexOutOfBoundsException - if the
+ beginIndex is negative, or
+ endIndex is larger than the length of
+ this String object, or
+ beginIndex is larger than
+ endIndex.+public CharSequence subSequence(int beginIndex, + int endIndex)+
An invocation of this method of the form + +
+ + behaves in exactly the same way as the invocation + ++ str.subSequence(begin, end)
+ + This method is defined so that the String class can implement + the+ str.substring(begin, end)
CharSequence interface.
+ +
subSequence in interface CharSequencebeginIndex - the begin index, inclusive.endIndex - the end index, exclusive.
+ IndexOutOfBoundsException - if beginIndex or endIndex are negative,
+ if endIndex is greater than length(),
+ or if beginIndex is greater than startIndex+public String concat(String str)+
+ If the length of the argument string is 0, then this
+ String object is returned. Otherwise, a new
+ String object is created, representing a character
+ sequence that is the concatenation of the character sequence
+ represented by this String object and the character
+ sequence represented by the argument string.
+ Examples: +
+ "cares".concat("s") returns "caress"
+ "to".concat("get").concat("her") returns "together"
+ +
str - the String that is concatenated to the end
+ of this String.
+ +public String replace(char oldChar, + char newChar)+
oldChar in this string with newChar.
+
+ If the character oldChar does not occur in the
+ character sequence represented by this String object,
+ then a reference to this String object is returned.
+ Otherwise, a new String object is created that
+ represents a character sequence identical to the character sequence
+ represented by this String object, except that every
+ occurrence of oldChar is replaced by an occurrence
+ of newChar.
+
+ Examples: +
+ "mesquite in your cellar".replace('e', 'o')
+ returns "mosquito in your collar"
+ "the war of baronets".replace('r', 'y')
+ returns "the way of bayonets"
+ "sparring with a purple porpoise".replace('p', 't')
+ returns "starring with a turtle tortoise"
+ "JonL".replace('q', 'x') returns "JonL" (no change)
+ +
oldChar - the old character.newChar - the new character.
+ oldChar with newChar.+public boolean matches(String regex)+
An invocation of this method of the form + str.matches(regex) yields exactly the + same result as the expression + +
+Pattern.matches(regex, str)
+
regex - the regular expression to which this string is to be matched
+ PatternSyntaxException - if the regular expression's syntax is invalidPattern+public boolean contains(CharSequence s)+
+
s - the sequence to search for
+ s, false otherwise
+ NullPointerException - if s is null+public String replaceFirst(String regex, + String replacement)+
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.
+
+
regex - the regular expression to which this string is to be matchedreplacement - the string to be substituted for the first match
+ PatternSyntaxException - if the regular expression's syntax is invalidPattern+public String replaceAll(String regex, + String replacement)+
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.
+
+
regex - the regular expression to which this string is to be matchedreplacement - the string to be substituted for each match
+ PatternSyntaxException - if the regular expression's syntax is invalidPattern+public String replace(CharSequence target, + CharSequence replacement)+
+
target - The sequence of char values to be replacedreplacement - The replacement sequence of char values
+ NullPointerException - if target or
+ replacement is null.+public String[] split(String regex, + int limit)+
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. + +
The limit parameter controls the number of times the + pattern is applied and therefore affects the length of the resulting + array. If the limit n is greater than zero then the pattern + will be applied at most n - 1 times, the array's + length will be no greater than n, and the array's last entry + will contain all input beyond the last matched delimiter. If n + is non-positive then the pattern will be applied as many times as + possible and the array can have any length. If n is zero then + the pattern will be applied as many times as possible, the array can + have any length, and trailing empty strings will be discarded. + +
The string "boo:and:foo", for example, yields the + following results with these parameters: + +
+ ++
+ +Regex +Limit +Result ++ : +2 +{ "boo", "and:foo" } + : +5 +{ "boo", "and", "foo" } + : +-2 +{ "boo", "and", "foo" } + o +5 +{ "b", "", ":and:f", "", "" } + o +-2 +{ "b", "", ":and:f", "", "" } + o +0 +{ "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) +
+
regex - the delimiting regular expressionlimit - the result threshold, as described above
+ PatternSyntaxException - if the regular expression's syntax is invalidPattern+public String[] split(String regex)+
This method works as if by invoking the two-argument split method with the given expression and a limit
+ argument of zero. Trailing empty strings are therefore not included in
+ the resulting array.
+
+
The string "boo:and:foo", for example, yields the following + results with these expressions: + +
++
+ +Regex +Result ++ : +{ "boo", "and", "foo" } + o +{ "b", "", ":and:f" }
+
regex - the delimiting regular expression
+ PatternSyntaxException - if the regular expression's syntax is invalidPattern+public String toLowerCase(Locale locale)+
String to lower
+ case using the rules of the given Locale. Case mapping is based
+ on the Unicode Standard version specified by the Character
+ class. Since case mappings are not always 1:1 char mappings, the resulting
+ String may be a different length than the original String.
+ + Examples of lowercase mappings are in the following table: +
| Language Code of Locale | +Upper Case | +Lower Case | +Description | +
|---|---|---|---|
| tr (Turkish) | +\u0130 | +\u0069 | +capital letter I with dot above -> small letter i | +
| tr (Turkish) | +\u0049 | +\u0131 | +capital letter I -> small letter dotless i | +
| (all) | +French Fries | +french fries | +lowercased all chars in String | +
| (all) | + 
+  
+  |
+  
+  
+  |
+ lowercased all chars in String | +
+
locale - use the case transformation rules for this locale
+ String, converted to lowercase.toLowerCase(),
+ toUpperCase(),
+ toUpperCase(Locale)+public String toLowerCase()+
String to lower
+ case using the rules of the default locale. This is equivalent to calling
+ toLowerCase(Locale.getDefault()).
+
+ Note: This method is locale sensitive, and may produce unexpected
+ results if used for strings that are intended to be interpreted locale
+ independently.
+ Examples are programming language identifiers, protocol keys, and HTML
+ tags.
+ For instance, "TITLE".toLowerCase() in a Turkish locale
+ returns "t?tle", where '?' is the LATIN SMALL
+ LETTER DOTLESS I character.
+ To obtain correct results for locale insensitive strings, use
+ toLowerCase(Locale.ENGLISH).
+
+
+
String, converted to lowercase.toLowerCase(Locale)+public String toUpperCase(Locale locale)+
String to upper
+ case using the rules of the given Locale. Case mapping is based
+ on the Unicode Standard version specified by the Character
+ class. Since case mappings are not always 1:1 char mappings, the resulting
+ String may be a different length than the original String.
+ + Examples of locale-sensitive and 1:M case mappings are in the following table. +
+
| Language Code of Locale | +Lower Case | +Upper Case | +Description | +
|---|---|---|---|
| tr (Turkish) | +\u0069 | +\u0130 | +small letter i -> capital letter I with dot above | +
| tr (Turkish) | +\u0131 | +\u0049 | +small letter dotless i -> capital letter I | +
| (all) | +\u00df | +\u0053 \u0053 | +small letter sharp s -> two letters: SS | +
| (all) | +Fahrvergnügen | +FAHRVERGNÜGEN | ++ |
+
locale - use the case transformation rules for this locale
+ String, converted to uppercase.toUpperCase(),
+ toLowerCase(),
+ toLowerCase(Locale)+public String toUpperCase()+
String to upper
+ case using the rules of the default locale. This method is equivalent to
+ toUpperCase(Locale.getDefault()).
+
+ Note: This method is locale sensitive, and may produce unexpected
+ results if used for strings that are intended to be interpreted locale
+ independently.
+ Examples are programming language identifiers, protocol keys, and HTML
+ tags.
+ For instance, "title".toUpperCase() in a Turkish locale
+ returns "T?TLE", where '?' is the LATIN CAPITAL
+ LETTER I WITH DOT ABOVE character.
+ To obtain correct results for locale insensitive strings, use
+ toUpperCase(Locale.ENGLISH).
+
+
+
String, converted to uppercase.toUpperCase(Locale)+public String trim()+
+ If this String object represents an empty character
+ sequence, or the first and last characters of character sequence
+ represented by this String object both have codes
+ greater than '\u0020' (the space character), then a
+ reference to this String object is returned.
+
+ Otherwise, if there is no character with a code greater than
+ '\u0020' in the string, then a new
+ String object representing an empty string is created
+ and returned.
+
+ Otherwise, let k be the index of the first character in the
+ string whose code is greater than '\u0020', and let
+ m be the index of the last character in the string whose code
+ is greater than '\u0020'. A new String
+ object is created, representing the substring of this string that
+ begins with the character at index k and ends with the
+ character at index m-that is, the result of
+ this.substring(k, m+1).
+
+ This method may be used to trim whitespace (as defined above) from + the beginning and end of a string. +
+
+public String toString()+
+
toString in interface CharSequencetoString in class Object+public char[] toCharArray()+
+
+public static String format(String format, + Object... args)+
The locale always used is the one returned by Locale.getDefault().
+
+
format - A format stringargs - Arguments referenced by the format specifiers in the format
+ string. If there are more arguments than format specifiers, the
+ extra arguments are ignored. The number of arguments is
+ variable and may be zero. The maximum number of arguments is
+ limited by the maximum dimension of a Java array as defined by
+ the Java
+ Virtual Machine Specification. The behaviour on a
+ null argument depends on the conversion.
+ IllegalFormatException - If a format string contains an illegal syntax, a format
+ specifier that is incompatible with the given arguments,
+ insufficient arguments given the format string, or other
+ illegal conditions. For specification of all possible
+ formatting errors, see the Details section of the
+ formatter class specification.
+ NullPointerException - If the format is nullFormatter+public static String format(Locale l, + String format, + Object... args)+
+
l - The locale to apply during
+ formatting. If l is null then no localization
+ is applied.format - A format stringargs - Arguments referenced by the format specifiers in the format
+ string. If there are more arguments than format specifiers, the
+ extra arguments are ignored. The number of arguments is
+ variable and may be zero. The maximum number of arguments is
+ limited by the maximum dimension of a Java array as defined by
+ the Java
+ Virtual Machine Specification. The behaviour on a
+ null argument depends on the conversion.
+ IllegalFormatException - If a format string contains an illegal syntax, a format
+ specifier that is incompatible with the given arguments,
+ insufficient arguments given the format string, or other
+ illegal conditions. For specification of all possible
+ formatting errors, see the Details section of the
+ formatter class specification
+ NullPointerException - If the format is nullFormatter+public static String valueOf(Object obj)+
Object argument.
+ +
obj - an Object.
+ null, then a string equal to
+ "null"; otherwise, the value of
+ obj.toString() is returned.Object.toString()+public static String valueOf(char[] data)+
char array
+ argument. The contents of the character array are copied; subsequent
+ modification of the character array does not affect the newly
+ created string.
+ +
data - a char array.
+ +public static String valueOf(char[] data, + int offset, + int count)+
char array argument.
+
+ The offset argument is the index of the first
+ character of the subarray. The count argument
+ specifies the length of the subarray. The contents of the subarray
+ are copied; subsequent modification of the character array does not
+ affect the newly created string.
+
+
data - the character array.offset - the initial offset into the value of the
+ String.count - the length of the value of the String.
+ IndexOutOfBoundsException - if offset is
+ negative, or count is negative, or
+ offset+count is larger than
+ data.length.+public static String copyValueOf(char[] data, + int offset, + int count)+
+
data - the character array.offset - initial offset of the subarray.count - length of the subarray.
+ String that contains the characters of the
+ specified subarray of the character array.+public static String copyValueOf(char[] data)+
+
data - the character array.
+ String that contains the characters of the
+ character array.+public static String valueOf(boolean b)+
boolean argument.
+ +
b - a boolean.
+ true, a string equal to
+ "true" is returned; otherwise, a string equal to
+ "false" is returned.+public static String valueOf(char c)+
char
+ argument.
+ +
c - a char.
+ 1 containing
+ as its single character the argument c.+public static String valueOf(int i)+
int argument.
+
+ The representation is exactly the one returned by the
+ Integer.toString method of one argument.
+
+
i - an int.
+ int argument.Integer.toString(int, int)+public static String valueOf(long l)+
long argument.
+
+ The representation is exactly the one returned by the
+ Long.toString method of one argument.
+
+
l - a long.
+ long argument.Long.toString(long)+public static String valueOf(float f)+
float argument.
+
+ The representation is exactly the one returned by the
+ Float.toString method of one argument.
+
+
f - a float.
+ float argument.Float.toString(float)+public static String valueOf(double d)+
double argument.
+
+ The representation is exactly the one returned by the
+ Double.toString method of one argument.
+
+
d - a double.
+ double argument.Double.toString(double)+public String intern()+
+ A pool of strings, initially empty, is maintained privately by the
+ class String.
+
+ When the intern method is invoked, if the pool already contains a
+ string equal to this String object as determined by
+ the equals(Object) method, then the string from the pool is
+ returned. Otherwise, this String object is added to the
+ pool and a reference to this String object is returned.
+
+ It follows that for any two strings s and t,
+ s.intern() == t.intern() is true
+ if and only if s.equals(t) is true.
+
+ All literal strings and string-valued constant expressions are + interned. String literals are defined in §3.10.5 of the + Java Language + Specification +
+
+
+
|
+
+ Java™ Platform Standard Ed. 6 + |
+ |||||||||
| + PREV CLASS + NEXT CLASS | ++ FRAMES + NO FRAMES + + + + + | +|||||||||
| + SUMMARY: NESTED | FIELD | CONSTR | METHOD | ++ DETAIL: FIELD | CONSTR | METHOD | +|||||||||
Copyright © 1993, 2011, Oracle and/or its affiliates. All rights reserved.
+ + + + + + + + + + + + diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/javadoc/ExternalJavadocPresentationTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/javadoc/ExternalJavadocPresentationTest.java index 540f1e3caa31..e88a90298d77 100644 --- a/java/java-tests/testSrc/com/intellij/codeInsight/javadoc/ExternalJavadocPresentationTest.java +++ b/java/java-tests/testSrc/com/intellij/codeInsight/javadoc/ExternalJavadocPresentationTest.java @@ -50,12 +50,23 @@ public class ExternalJavadocPresentationTest extends LightCodeInsightTestCase { doTest("lang/String.html#toLowerCase()", "String/7/page.html", "String/7/expectedToLowerCase.html"); doTest("lang/String.html#toLowerCase()", "String/6/page.html", "String/6/expectedToLowerCase.html"); } - + + public void testInvalidJavadoc() throws Exception { + doTest("", "String/invalid/page.html", "String/invalid/expected.html", false); + } + public void testPackageSummary() throws Exception { doTest("java/lang/package-summary.html", "packageSummary/util/page.html", "packageSummary/util/expected.html"); } private void doTest(@NonNls String url, @NonNls String pageText, @NonNls String expected) throws Exception { + doTest(url, pageText, expected, true); + } + + private void doTest(@NonNls String url, + @NonNls String pageText, + @NonNls String expected, + final boolean matchStart) throws Exception { final String basePath = getTestDataPath() + TEST_ROOT; final VirtualFile pageTextFile = LocalFileSystem.getInstance().findFileByPath(basePath + pageText); assertNotNull(pageTextFile); @@ -71,13 +82,17 @@ public class ExternalJavadocPresentationTest extends LightCodeInsightTestCase { } @Override - public void doBuildFromStream(String url, Reader input, StringBuilder data, boolean searchForEncoding) throws IOException { - super.doBuildFromStream(url, input, data, searchForEncoding); + public void doBuildFromStream(String url, Reader input, StringBuilder data, boolean searchForEncoding, boolean matchStart) throws IOException { + super.doBuildFromStream(url, input, data, searchForEncoding, matchStart); } } JavadocExternalTestFilter filter = new JavadocExternalTestFilter(getProject()); StringBuilder extractedData = new StringBuilder(); - filter.doBuildFromStream(url, new StringReader(LoadTextUtil.loadText(pageTextFile).toString()), extractedData, false); + filter.doBuildFromStream(url, new StringReader(LoadTextUtil.loadText(pageTextFile).toString()), extractedData, false, true); + if (!matchStart) { + assertEmpty(extractedData.toString()); + filter.doBuildFromStream(url, new StringReader(LoadTextUtil.loadText(pageTextFile).toString()), extractedData, false, false); + } assertEquals(LoadTextUtil.loadText(expectedTextFile).toString(), extractedData.toString()); } } diff --git a/platform/lang-impl/src/com/intellij/codeInsight/documentation/AbstractExternalFilter.java b/platform/lang-impl/src/com/intellij/codeInsight/documentation/AbstractExternalFilter.java index f3254c2e2b92..5068726ad8c6 100644 --- a/platform/lang-impl/src/com/intellij/codeInsight/documentation/AbstractExternalFilter.java +++ b/platform/lang-impl/src/com/intellij/codeInsight/documentation/AbstractExternalFilter.java @@ -171,10 +171,10 @@ public abstract class AbstractExternalFilter { } protected void doBuildFromStream(String url, Reader input, StringBuilder data) throws IOException { - doBuildFromStream(url, input, data, true); + doBuildFromStream(url, input, data, true, true); } - protected void doBuildFromStream(final String url, Reader input, final StringBuilder data, boolean searchForEncoding) throws IOException { + protected void doBuildFromStream(final String url, Reader input, final StringBuilder data, boolean searchForEncoding, boolean matchStart) throws IOException { Trinity