Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JDK 1.1 Source Code Directory
JDK 1.1 source code directory contains Java source code for JDK 1.1 core classes:
"C:\fyicenter\jdk-1.1.8\src".
Here is the list of Java classes of the JDK 1.1 source code:
✍: FYIcenter
⏎ java/lang/String.java
/* * @(#)String.java 1.88 01/12/10 * * Copyright 2002 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package java.lang; import java.util.Hashtable; import java.util.Locale; import sun.io.ByteToCharConverter; import sun.io.CharToByteConverter; import java.io.CharConversionException; import java.io.UnsupportedEncodingException; /** * The <code>String</code> class represents character strings. All * string literals in Java programs, such as <code>"abc"</code>, are * implemented as instances of this class. * <p> * 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: * <p><blockquote><pre> * String str = "abc"; * </pre></blockquote><p> * is equivalent to: * <p><blockquote><pre> * char data[] = {'a', 'b', 'c'}; * String str = new String(data); * </pre></blockquote><p> * Here are some more examples of how strings can be used: * <p><blockquote><pre> * System.out.println("abc"); * String cde = "cde"; * System.out.println("abc" + cde); * String c = "abc".substring(2,3); * String d = cde.substring(1, 2); * </pre></blockquote> * <p> * The class <code>String</code> 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. * <p> * The Java language provides special support for the string * concatentation operator ( + ), and for conversion of * other objects to strings. String concatenation is implemented * through the <code>StringBuffer</code> class and its * <code>append</code> method. * String conversions are implemented through the method * <code>toString</code>, defined by <code>Object</code> and * inherited by all classes in Java. For additional information on * string concatenation and conversion, see Gosling, Joy, and Steele, * <i>The Java Language Specification</i>. * * @author Lee Boynton * @author Arthur van Hoff * @version 1.88, 12/10/01 * @see java.lang.Object#toString() * @see java.lang.StringBuffer * @see java.lang.StringBuffer#append(boolean) * @see java.lang.StringBuffer#append(char) * @see java.lang.StringBuffer#append(char[]) * @see java.lang.StringBuffer#append(char[], int, int) * @see java.lang.StringBuffer#append(double) * @see java.lang.StringBuffer#append(float) * @see java.lang.StringBuffer#append(int) * @see java.lang.StringBuffer#append(long) * @see java.lang.StringBuffer#append(java.lang.Object) * @see java.lang.StringBuffer#append(java.lang.String) * @since JDK1.0 */ public final class String implements java.io.Serializable { /** The value is used for character storage. */ private char value[]; /** The offset is the first index of the storage that is used. */ private int offset; /** The count is the number of characters in the String. */ private int count; /** use serialVersionUID from JDK 1.0.2 for interoperability */ private static final long serialVersionUID = -6849794470754667710L; /** * Allocates a new <code>String</code> containing no characters. */ public String() { value = new char[0]; } /** * Allocates a new string that contains the same sequence of * characters as the string argument. * * @param value a <code>String</code>. */ public String(String value) { count = value.length(); this.value = new char[count]; value.getChars(0, count, this.value, 0); } /** * Allocates a new <code>String</code> so that it represents the * sequence of characters currently contained in the character array * argument. * * @param value the initial value of the string. */ public String(char value[]) { this.count = value.length; this.value = new char[count]; System.arraycopy(value, 0, this.value, 0, count); } /** * Allocates a new <code>String</code> that contains characters from * a subarray of the character array argument. The <code>offset</code> * argument is the index of the first character of the subarray and * the <code>count</code> argument specifies the length of the * subarray. * * @param value array that is the source of characters. * @param offset the initial offset. * @param count the length. * @exception StringIndexOutOfBoundsException if the <code>offset</code> * and <code>count</code> arguments index characters outside * the bounds of the <code>value</code> array. */ public String(char value[], int offset, int count) { if (offset < 0) { throw new StringIndexOutOfBoundsException(offset); } if (count < 0) { throw new StringIndexOutOfBoundsException(count); } // Note: offset or count might be near -1>>>1. if (offset > value.length - count) { throw new StringIndexOutOfBoundsException(offset + count); } this.value = new char[count]; this.count = count; System.arraycopy(value, offset, this.value, 0, count); } /** * Allocates a new <code>String</code> constructed from a subarray * of an array of 8-bit integer values. * <p> * The <code>offset</code> argument is the index of the first byte * of the subarray, and the <code>count</code> argument specifies the * length of the subarray. * <p> * Each <code>byte</code> in the subarray is converted to a * <code>char</code> as specified in the method above. * * @deprecated This method does not properly convert bytes into characters. * As of JDK 1.1, the preferred way to do this is via the * <code>String</code> constructors that take a character-encoding name or * that use the platform's default encoding. * * @param ascii the bytes to be converted to characters. * @param hibyte the top 8 bits of each 16-bit Unicode character. * @param offset the initial offset. * @param count the length. * @exception StringIndexOutOfBoundsException if the <code>offset</code> * or <code>count</code> argument is invalid. * @see java.lang.String#String(byte[], int) * @see java.lang.String#String(byte[], int, int, java.lang.String) * @see java.lang.String#String(byte[], int, int) * @see java.lang.String#String(byte[], java.lang.String) * @see java.lang.String#String(byte[]) */ public String(byte ascii[], int hibyte, int offset, int count) { if (offset < 0) { throw new StringIndexOutOfBoundsException(offset); } if (count < 0) { throw new StringIndexOutOfBoundsException(count); } // Note: offset or count might be near -1>>>1. if (offset > ascii.length - count) { throw new StringIndexOutOfBoundsException(offset + count); } char value[] = new char[count]; this.count = count; this.value = value; if (hibyte == 0) { for (int i = count ; i-- > 0 ;) { value[i] = (char) (ascii[i + offset] & 0xff); } } else { hibyte <<= 8; for (int i = count ; i-- > 0 ;) { value[i] = (char) (hibyte | (ascii[i + offset] & 0xff)); } } } /** * Allocates a new <code>String</code> containing characters * constructed from an array of 8-bit integer values. Each character * <i>c</i>in the resulting string is constructed from the * corresponding component <i>b</i> in the byte array such that: * <p><blockquote><pre> * <b><i>c</i></b> == (char)(((hibyte & 0xff) << 8) * | (<b><i>b</i></b> & 0xff)) * </pre></blockquote> * * @deprecated This method does not properly convert bytes into characters. * As of JDK 1.1, the preferred way to do this is via the * <code>String</code> constructors that take a character-encoding name or * that use the platform's default encoding. * * @param ascii the bytes to be converted to characters. * @param hibyte the top 8 bits of each 16-bit Unicode character. * @see java.lang.String#String(byte[], int, int, java.lang.String) * @see java.lang.String#String(byte[], int, int) * @see java.lang.String#String(byte[], java.lang.String) * @see java.lang.String#String(byte[]) */ public String(byte ascii[], int hibyte) { this(ascii, hibyte, 0, ascii.length); } /** * Construct a new <code>String</code> by converting the specified * subarray of bytes using the specified character-encoding converter. The * length of the new <code>String</code> is a function of the encoding, and * hence may not be equal to the length of the subarray. * * @param bytes The bytes to be converted into characters * @param offset Index of the first byte to convert * @param length Number of bytes to convert * @param btc A ByteToCharConverter */ private String(byte bytes[], int offset, int length, ByteToCharConverter btc) { int estCount = btc.getMaxCharsPerByte() * length; value = new char[estCount]; try { count = btc.convert(bytes, offset, offset+length, value, 0, estCount); count += btc.flush(value, btc.nextCharIndex(), estCount); } catch (CharConversionException x) { count = btc.nextCharIndex(); } if (count < estCount) { // A multi-byte format was used: Trim the char array. char[] trimValue = new char[count]; System.arraycopy(value, 0, trimValue, 0, count); value = trimValue; } } /** * Construct a new <code>String</code> by converting the specified * subarray of bytes using the specified character encoding. The length of * the new <code>String</code> is a function of the encoding, and hence may * not be equal to the length of the subarray. * * @param bytes The bytes to be converted into characters * @param offset Index of the first byte to convert * @param length Number of bytes to convert * @param enc The name of a character encoding * * @exception UnsupportedEncodingException * If the named encoding is not supported * @since JDK1.1 */ public String(byte bytes[], int offset, int length, String enc) throws UnsupportedEncodingException { this(bytes, offset, length, ByteToCharConverter.getConverter(enc)); } /** * Construct a new <code>String</code> by converting the specified array * of bytes using the specified character encoding. The length of the new * <code>String</code> is a function of the encoding, and hence may not be * equal to the length of the byte array. * * @param bytes The bytes to be converted into characters * @param enc A character-encoding name * * @exception UnsupportedEncodingException * If the named encoding is not supported * @since JDK1.1 */ public String(byte bytes[], String enc) throws UnsupportedEncodingException { this(bytes, 0, bytes.length, enc); } /** * Construct a new <code>String</code> by converting the specified * subarray of bytes using the platform's default character encoding. The * length of the new <code>String</code> is a function of the encoding, and * hence may not be equal to the length of the subarray. * * @param bytes The bytes to be converted into characters * @param offset Index of the first byte to convert * @param length Number of bytes to convert * @since JDK1.1 */ public String(byte bytes[], int offset, int length) { this(bytes, offset, length, ByteToCharConverter.getDefault()); } /** * Construct a new <code>String</code> by converting the specified array * of bytes using the platform's default character encoding. The length of * the new <code>String</code> is a function of the encoding, and hence may * not be equal to the length of the byte array. * * @param bytes The bytes to be converted into characters * @since JDK1.1 */ public String(byte bytes[]) { this(bytes, 0, bytes.length, ByteToCharConverter.getDefault()); } /** * Allocates a new string that contains the sequence of characters * currently contained in the string buffer argument. * * @param buffer a <code>StringBuffer</code>. */ public String (StringBuffer buffer) { synchronized(buffer) { buffer.setShared(); this.value = buffer.getValue(); this.offset = 0; this.count = buffer.length(); } } // Private constructor which shares value array for speed. private String(int offset, int count, char value[]) { this.value = value; this.offset = offset; this.count = count; } /** * Returns the length of this string. * The length is equal to the number of 16-bit * Unicode characters in the string. * * @return the length of the sequence of characters represented by this * object. */ public int length() { return count; } /** * Returns the character at the specified index. An index ranges * from <code>0</code> to <code>length() - 1</code>. * * @param index the index of the character. * @return the character at the specified index of this string. * The first character is at index <code>0</code>. * @exception StringIndexOutOfBoundsException if the index is out of * range. */ public char charAt(int index) { if ((index < 0) || (index >= count)) { throw new StringIndexOutOfBoundsException(index); } return value[index + offset]; } /** * Copies characters from this string into the destination character array. * <p> * The first character to be copied is at index <code>srcBegin</code>; * the last character to be copied is at index <code>srcEnd-1</code> * (thus the total number of characters to be copied is * <code>srcEnd-srcBegin</code>). The characters are copied into the * subarray of <code>dst</code> starting at index <code>dstBegin</code> * and ending at index: * <p><blockquote><pre> * dstbegin + (srcEnd-srcBegin) - 1 * </pre></blockquote> * * @param srcBegin index of the first character in the string * to copy. * @param srcEnd index after the last character in the string * to copy. * @param dst the destination array. * @param dstBegin the start offset in the destination array. * @exception StringIndexOutOfBoundsException If srcBegin or srcEnd is out * of range, or if srcBegin is greater than the srcEnd. */ public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) { if (srcBegin < 0) { throw new StringIndexOutOfBoundsException(srcBegin); } if (srcEnd > count) { throw new StringIndexOutOfBoundsException(srcEnd); } if (srcBegin > srcEnd) { throw new StringIndexOutOfBoundsException(srcEnd - srcBegin); } System.arraycopy(value, offset + srcBegin, dst, dstBegin, srcEnd - srcBegin); } /** * Copies characters from this string into the destination byte * array. Each byte receives the 8 low-order bits of the * corresponding character. * <p> * The first character to be copied is at index <code>srcBegin</code>; * the last character to be copied is at index <code>srcEnd-1</code>. * The total number of characters to be copied is * <code>srcEnd-srcBegin</code>. The characters, converted to bytes, * are copied into the subarray of <code>dst</code> starting at index * <code>dstBegin</code> and ending at index: * <p><blockquote><pre> * dstbegin + (srcEnd-srcBegin) - 1 * </pre></blockquote> * * @deprecated This method does not properly convert characters into bytes. * As of JDK 1.1, the preferred way to do this is via the * <code>getBytes(String enc)</code> method, which takes a * character-encoding name, or the <code>getBytes()</code> method, which * uses the platform's default encoding. * * @param srcBegin index of the first character in the string * to copy. * @param srcEnd index after the last character in the string * to copy. * @param dst the destination array. * @param dstBegin the start offset in the destination array. * @exception StringIndexOutOfBoundsException if srcBegin or srcEnd is out * of range, or if srcBegin is greater than srcEnd. */ public void getBytes(int srcBegin, int srcEnd, byte dst[], int dstBegin) { if (srcBegin < 0) { throw new StringIndexOutOfBoundsException(srcBegin); } if (srcEnd > count) { throw new StringIndexOutOfBoundsException(srcEnd); } if (srcBegin > srcEnd) { throw new StringIndexOutOfBoundsException(srcEnd - srcBegin); } int j = dstBegin; int n = offset + srcEnd; int i = offset + srcBegin; char[] val = value; /* avoid getfield opcode */ while (i < n) { dst[j++] = (byte)val[i++]; } } /** * Apply the specified character-encoding converter to this String, * storing the resulting bytes into a new byte array. * * @param ctb A CharToByteConverter * @return The resultant byte array */ private byte[] getBytes(CharToByteConverter ctb) { ctb.reset(); int estLength = ctb.getMaxBytesPerChar() * count; byte[] result = new byte[estLength]; int length; try { length = ctb.convert(value, offset, offset + count, result, 0, estLength); length += ctb.flush(result, ctb.nextByteIndex(), estLength); } catch (CharConversionException e) { length = ctb.nextByteIndex(); } if (length < estLength) { // A short format was used: Trim the byte array. byte[] trimResult = new byte[length]; System.arraycopy(result, 0, trimResult, 0, length); return trimResult; } else { return result; } } /** * Convert this <code>String</code> into bytes according to the specified * character encoding, storing the result into a new byte array. * * @param enc A character-encoding name * @return The resultant byte array * * @exception UnsupportedEncodingException * If the named encoding is not supported * @since JDK1.1 */ public byte[] getBytes(String enc) throws UnsupportedEncodingException { return getBytes(CharToByteConverter.getConverter(enc)); } /** * Convert this <code>String</code> into bytes according to the platform's * default character encoding, storing the result into a new byte array. * * @return the resultant byte array. * @since JDK1.1 */ public byte[] getBytes() { return getBytes(CharToByteConverter.getDefault()); } /** * Compares this string to the specified object. * The result is <code>true</code> if and only if the argument is not * <code>null</code> and is a <code>String</code> object that represents * the same sequence of characters as this object. * * @param anObject the object to compare this <code>String</code> * against. * @return <code>true</code> if the <code>String </code>are equal; * <code>false</code> otherwise. * @see java.lang.String#compareTo(java.lang.String) * @see java.lang.String#equalsIgnoreCase(java.lang.String) */ public boolean equals(Object anObject) { if (this == anObject) { return true; } if ((anObject != null) && (anObject instanceof String)) { String anotherString = (String)anObject; int n = count; if (n == anotherString.count) { char v1[] = value; char v2[] = anotherString.value; int i = offset; int j = anotherString.offset; while (n-- != 0) { if (v1[i++] != v2[j++]) { return false; } } return true; } } return false; } /** * Compares this String to another object. * The result is <code>true</code> if and only if the argument is not * <code>null</code> and is a <code>String</code> object that represents * the same sequence of characters as this object, where case is ignored. * <p> * Two characters are considered the same, ignoring case, if at * least one of the following is true: * <ul> * <li>The two characters are the same (as compared by the <code>==</code> * operator). * <li>Applying the method <code>Character.toUppercase</code> to each * character produces the same result. * <li>Applying the method <code>Character.toLowercase</code> to each * character produces the same result. * </ul> * <p> * Two sequences of characters are the same, ignoring case, if the * sequences have the same length and corresponding characters are * the same, ignoring case. * * @param anotherString the <code>String</code> to compare this * <code>String</code> against. * @return <code>true</code> if the <code>String</code>s are equal, * ignoring case; <code>false</code> otherwise. * @see java.lang.Character#toLowerCase(char) * @see java.lang.Character#toUpperCase(char) */ public boolean equalsIgnoreCase(String anotherString) { return (anotherString != null) && (anotherString.count == count) && regionMatches(true, 0, anotherString, 0, count); } /** * Compares two strings lexicographically. * The comparison is based on the Unicode value of each character in * the strings. * * @param anotherString the <code>String</code> to be compared. * @return the value <code>0</code> if the argument string is equal to * this string; a value less than <code>0</code> if this string * is lexicographically less than the string argument; and a * value greater than <code>0</code> if this string is * lexicographically greater than the string argument. */ public int compareTo(String anotherString) { int len1 = count; int len2 = anotherString.count; int n = Math.min(len1, len2); char v1[] = value; char v2[] = anotherString.value; int i = offset; int j = anotherString.offset; while (n-- != 0) { char c1 = v1[i++]; char c2 = v2[j++]; if (c1 != c2) { return c1 - c2; } } return len1 - len2; } /** * Tests if two string regions are equal. * <p> * If <code>toffset</code> or <code>ooffset</code> is negative, or * if <code>toffset</code>+<code>length</code> is greater than the * length of this string, or if * <code>ooffset</code>+<code>length</code> is greater than the * length of the string argument, then this method returns * <code>false</code>. * * @param toffset the starting offset of the subregion in this string. * @param other the string argument. * @param ooffset the starting offset of the subregion in the string * argument. * @param len the number of characters to compare. * @return <code>true</code> if the specified subregion of this string * exactly matches the specified subregion of the string argument; * <code>false</code> otherwise. */ public boolean regionMatches(int toffset, String other, int ooffset, int len) { char ta[] = value; int to = offset + toffset; int tlim = offset + count; char pa[] = other.value; int po = other.offset + ooffset; // Note: toffset, ooffset, or len might be near -1>>>1. if ((ooffset < 0) || (toffset < 0) || (toffset > count - len) || (ooffset > other.count - len)) { return false; } while (len-- > 0) { if (ta[to++] != pa[po++]) { return false; } } return true; } /** * Tests if two string regions are equal. * <p> * If <code>toffset</code> or <code>ooffset</code> is negative, or * if <code>toffset</code>+<code>length</code> is greater than the * length of this string, or if * <code>ooffset</code>+<code>length</code> is greater than the * length of the string argument, then this method returns * <code>false</code>. * * @param ignoreCase if <code>true</code>, ignore case when comparing * characters. * @param toffset the starting offset of the subregion in this * string. * @param other the string argument. * @param ooffset the starting offset of the subregion in the string * argument. * @param len the number of characters to compare. * @return <code>true</code> if the specified subregion of this string * matches the specified subregion of the string argument; * <code>false</code> otherwise. Whether the matching is exact * or case insensitive depends on the <code>ignoreCase</code> * argument. */ public boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) { char ta[] = value; int to = offset + toffset; int tlim = offset + count; char pa[] = other.value; int po = other.offset + ooffset; // Note: toffset, ooffset, or len might be near -1>>>1. if ((ooffset < 0) || (toffset < 0) || (toffset > count - len) || (ooffset > other.count - len)) { return false; } while (len-- > 0) { char c1 = ta[to++]; char c2 = pa[po++]; if (c1 == c2) continue; if (ignoreCase) { // If characters don't match but case may be ignored, // try converting both characters to uppercase. // If the results match, then the comparison scan should // continue. char u1 = Character.toUpperCase(c1); char u2 = Character.toUpperCase(c2); if (u1 == u2) continue; // Unfortunately, conversion to uppercase does not work properly // for the Georgian alphabet, which has strange rules about case // conversion. So we need to make one last check before // exiting. if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) continue; } return false; } return true; } /** * Tests if this string starts with the specified prefix. * * @param prefix the prefix. * @param toffset where to begin looking in the string. * @return <code>true</code> if the character sequence represented by the * argument is a prefix of the substring of this object starting * at index <code>toffset</code>; <code>false</code> otherwise. */ public boolean startsWith(String prefix, int toffset) { char ta[] = value; int to = offset + toffset; int tlim = offset + count; char pa[] = prefix.value; int po = prefix.offset; int pc = prefix.count; // Note: toffset might be near -1>>>1. if ((toffset < 0) || (toffset > count - pc)) { return false; } while (--pc >= 0) { if (ta[to++] != pa[po++]) { return false; } } return true; } /** * Tests if this string starts with the specified prefix. * * @param prefix the prefix. * @return <code>true</code> if the character sequence represented by the * argument is a prefix of the character sequence represented by * this string; <code>false</code> otherwise. * @since JDK1. 0 */ public boolean startsWith(String prefix) { return startsWith(prefix, 0); } /** * Tests if this string ends with the specified suffix. * * @param suffix the suffix. * @return <code>true</code> if the character sequence represented by the * argument is a suffix of the character sequence represented by * this object; <code>false</code> otherwise. */ public boolean endsWith(String suffix) { return startsWith(suffix, count - suffix.count); } /** * Returns a hashcode for this string. * * @return a hash code value for this object. */ public int hashCode() { int h = 0; int off = offset; char val[] = value; int len = count; if (len < 16) { for (int i = len ; i > 0; i--) { h = (h * 37) + val[off++]; } } else { // only sample some characters int skip = len / 8; for (int i = len ; i > 0; i -= skip, off += skip) { h = (h * 39) + val[off]; } } return h; } /** * Returns the index within this string of the first occurrence of the * specified character. * * @param ch a character. * @return the index of the first occurrence of the character in the * character sequence represented by this object, or * <code>-1</code> if the character does not occur. */ public int indexOf(int ch) { return indexOf(ch, 0); } /** * Returns the index within this string of the first occurrence of the * specified character, starting the search at the specified index. * * @param ch a character. * @param fromIndex the index to start the search from. * @return the index of the first occurrence of the character in the * character sequence represented by this object that is greater * than or equal to <code>fromIndex</code>, or <code>-1</code> * if the character does not occur. */ public int indexOf(int ch, int fromIndex) { int max = offset + count; char v[] = value; if (fromIndex < 0) { fromIndex = 0; } else if (fromIndex >= count) { // Note: fromIndex might be near -1>>>1. return -1; } for (int i = offset + fromIndex ; i < max ; i++) { if (v[i] == ch) { return i - offset; } } return -1; } /** * Returns the index within this string of the last occurrence of the * specified character. * The String is searched backwards starting at the last character. * * @param ch a character. * @return the index of the last occurrence of the character in the * character sequence represented by this object, or * <code>-1</code> if the character does not occur. */ public int lastIndexOf(int ch) { return lastIndexOf(ch, count - 1); } /** * Returns the index within this string of the last occurrence of the * specified character, searching backward starting at the specified index. * * @param ch a character. * @param fromIndex the index to start the search from. * @return the index of the last occurrence of the character in the * character sequence represented by this object that is less * than or equal to <code>fromIndex</code>, or <code>-1</code> * if the character does not occur before that point. */ public int lastIndexOf(int ch, int fromIndex) { int min = offset; char v[] = value; for (int i = offset + ((fromIndex >= count) ? count - 1 : fromIndex) ; i >= min ; i--) { if (v[i] == ch) { return i - offset; } } return -1; } /** * Returns the index within this string of the first occurrence of the * specified substring. * * @param str any string. * @return if the string argument occurs as a substring within this * object, then the index of the first character of the first * such substring is returned; if it does not occur as a * substring, <code>-1</code> is returned. */ public int indexOf(String str) { return indexOf(str, 0); } /** * Returns the index within this string of the first occurrence of the * specified substring, starting at the specified index. * * @param str the substring to search for. * @param fromIndex the index to start the search from. * @return If the string argument occurs as a substring within this * object at a starting index no smaller than * <code>fromIndex</code>, then the index of the first character * of the first such substring is returned. If it does not occur * as a substring starting at <code>fromIndex</code> or beyond, * <code>-1</code> is returned. */ public int indexOf(String str, int fromIndex) { char v1[] = value; char v2[] = str.value; int max = offset + (count - str.count); if (fromIndex >= count) { /* Note: fromIndex might be near -1>>>1 */ return -1; } if (fromIndex < 0) { fromIndex = 0; } if (str.count == 0) { return fromIndex; } int strOffset = str.offset; char first = v2[strOffset]; int i = offset + fromIndex; startSearchForFirstChar: while (true) { /* Look for first character. */ while (i <= max && v1[i] != first) { i++; } if (i > max) { return -1; } /* Found first character, now look at the rest of v2 */ int j = i + 1; int end = j + str.count - 1; int k = strOffset + 1; while (j < end) { if (v1[j++] != v2[k++]) { i++; /* Look for str's first char again. */ continue startSearchForFirstChar; } } return i - offset; /* Found whole string. */ } } /** * Returns the index within this string of the rightmost occurrence * of the specified substring. The rightmost empty string "" is * considered to occur at the index value <code>this.length()</code>. * * @param str the substring to search for. * @return if the string argument occurs one or more times as a substring * within this object, then the index of the first character of * the last such substring is returned. If it does not occur as * a substring, <code>-1</code> is returned. */ public int lastIndexOf(String str) { return lastIndexOf(str, count); } /** * Returns the index within this string of the last occurrence of * the specified substring. * The returned index indicates the start of the substring, and it * must be equal to or less than <code>fromIndex</code>. * * @param str the substring to search for. * @param fromIndex the index to start the search from. * @return If the string argument occurs one or more times as a substring * within this object at a starting index no greater than * <code>fromIndex</code>, then the index of the first character of * the last such substring is returned. If it does not occur as a * substring starting at <code>fromIndex</code> or earlier, * <code>-1</code> is returned. */ public int lastIndexOf(String str, int fromIndex) { /* * Check arguments; return immediately where possible. For * consistency, don't check for null str. */ int rightIndex = count - str.count; if (fromIndex < 0) { return -1; } if (fromIndex > rightIndex) { fromIndex = rightIndex; } /* Empty string always matches. */ if (str.count == 0) { return fromIndex; } char v1[] = value; char v2[] = str.value; int strLastIndex = str.offset + str.count - 1; char strLastChar = v2[strLastIndex]; int min = offset + str.count - 1; int i = min + fromIndex; startSearchForLastChar: while (true) { /* Look for the last character */ while (i >= min && v1[i] != strLastChar) { i--; } if (i < min) { return -1; } /* Found last character, now look at the rest of v2. */ int j = i - 1; int start = j - (str.count - 1); int k = strLastIndex - 1; while (j > start) { if (v1[j--] != v2[k--]) { i--; /* Look for str's last char again. */ continue startSearchForLastChar; } } return start - offset + 1; /* Found whole string. */ } } /** * Returns a new string that is a substring of this string. The * substring begins at the specified index and extends to the end of * this string. * * @param beginIndex the beginning index, inclusive. * @return the specified substring. * @exception StringIndexOutOfBoundsException if the * <code>beginIndex</code> is out of range. */ public String substring(int beginIndex) { return substring(beginIndex, length()); } /** * Returns a new string that is a substring of this string. The * substring begins at the specified <code>beginIndex</code> and * extends to the character at index <code>endIndex - 1</code>. * * @param beginIndex the beginning index, inclusive. * @param endIndex the ending index, exclusive. * @return the specified substring. * @exception StringIndexOutOfBoundsException if the * <code>beginIndex</code> or the <code>endIndex</code> is * out of range. */ public String substring(int beginIndex, int endIndex) { if (beginIndex < 0) { throw new StringIndexOutOfBoundsException(beginIndex); } if (endIndex > count) { throw new StringIndexOutOfBoundsException(endIndex); } if (beginIndex > endIndex) { throw new StringIndexOutOfBoundsException(endIndex - beginIndex); } return ((beginIndex == 0) && (endIndex == count)) ? this : new String(offset + beginIndex, endIndex - beginIndex, value); } /** * Concatenates the specified string to the end of this string. * <p> * If the length of the argument string is <code>0</code>, then this * object is returned. * * @param str the <code>String</code> that is concatenated to the end * of this <code>String</code>. * @return a string that represents the concatenation of this object's * characters followed by the string argument's characters. */ public String concat(String str) { int otherLen = str.length(); if (otherLen == 0) { return this; } char buf[] = new char[count + otherLen]; getChars(0, count, buf, 0); str.getChars(0, otherLen, buf, count); return new String(0, count + otherLen, buf); } /** * Returns a new string resulting from replacing all occurrences of * <code>oldChar</code> in this string with <code>newChar</code>. * <p> * If the character <code>oldChar</code> does not occur in the * character sequence represented by this object, then this string is * returned. * * @param oldChar the old character. * @param newChar the new character. * @return a string derived from this string by replacing every * occurrence of <code>oldChar</code> with <code>newChar</code>. */ public String replace(char oldChar, char newChar) { if (oldChar != newChar) { int len = count; int i = -1; char[] val = value; /* avoid getfield opcode */ int off = offset; /* avoid getfield opcode */ while (++i < len) { if (val[off + i] == oldChar) { break; } } if (i < len) { char buf[] = new char[len]; for (int j = 0 ; j < i ; j++) { buf[j] = val[off+j]; } while (i < len) { char c = val[off + i]; buf[i] = (c == oldChar) ? newChar : c; i++; } return new String(0, len, buf); } } return this; } /** * Converts all of the characters in this <code>String</code> to lower * case using the rules of the given locale. * @param locale use the case transformation rules for this locale * @return the String, converted to lowercase. * @see java.lang.Character#toLowerCase(char) * @see java.lang.String#toUpperCase() * @since JDK1.1 */ public String toLowerCase(Locale locale) { char[] result = new char[count]; int i; int len = count; int off = offset; /* avoid getfield opcode */ char[] val = value; /* avoid getfield opcode */ if (locale.getLanguage().equals("tr")) { // special loop for Turkey for (i = 0; i < len; ++i) { char ch = val[off+i]; if (ch == 'I') { result[i] = '\u0131'; // dotless small i continue; } if (ch == '\u0130') { // dotted I result[i] = 'i'; // dotted i continue; } result[i] = Character.toLowerCase(ch); } } else { // normal, fast loop for (i = 0; i < len; ++i) { result[i] = Character.toLowerCase(val[off+i]); } } return new String(result); } /** * Converts this <code>String</code> to lowercase. * <p> * If no character in the string has a different lowercase version, * based on calling the <code>toLowerCase</code> method defined by * <code>Character</code>, then the original string is returned. * <p> * Otherwise, a new string is allocated, whose length is identical * to this string, and such that each character that has a different * lowercase version is mapped to this lowercase equivalent. * * @return the string, converted to lowercase. * @see java.lang.Character#toLowerCase(char) * @see java.lang.String#toUpperCase() */ public String toLowerCase() { return toLowerCase( Locale.getDefault() ); } /** * Converts all of the characters in this <code>String</code> to upper * case using the rules of the given locale. * @param locale use the case transformation rules for this locale * @return the String, converted to uppercase. * @see java.lang.Character#toUpperCase(char) * @see java.lang.String#toLowerCase(char) * @since JDK1.1 */ public String toUpperCase(Locale locale) { char[] result = new char[count]; /* warning: might grow! */ int i; int resultOffset = 0; /* result might grow, so i+resultOffset * gives correct write location in result */ int len = count; int off = offset; /* avoid getfield opcode */ char[] val = value; /* avoid getfield opcode */ if (locale.getLanguage().equals("tr")) { // special loop for Turkey for (i = 0; i < len; ++i) { char ch = val[off+i]; if (ch == 'i') { result[i+resultOffset] = '\u0130'; // dotted cap i continue; } if (ch == '\u0131') { // dotless i result[i+resultOffset] = 'I'; // cap I continue; } if (ch == '\u00DF') { // sharp s /* Grow result. */ char[] result2 = new char[result.length + 1]; System.arraycopy(result, 0, result2, 0, i + 1 + resultOffset); result2[i+resultOffset] = 'S'; resultOffset++; result2[i+resultOffset] = 'S'; result = result2; continue; } result[i+resultOffset] = Character.toUpperCase(ch); } } else { // normal, fast loop for (i = 0; i < len; ++i) { char ch = val[off+i]; if (ch == '\u00DF') { // sharp s /* Grow result. */ char[] result2 = new char[result.length + 1]; System.arraycopy(result, 0, result2, 0, i + 1 + resultOffset); result2[i+resultOffset] = 'S'; resultOffset++; result2[i+resultOffset] = 'S'; result = result2; continue; } result[i+resultOffset] = Character.toUpperCase(ch); } } return new String(result); } /** * Converts this string to uppercase. * <p> * If no character in this string has a different uppercase version, * based on calling the <code>toUpperCase</code> method defined by * <code>Character</code>, then the original string is returned. * <p> * Otherwise, a new string is allocated, whose length is identical * to this string, and such that each character that has a different * uppercase version is mapped to this uppercase equivalent. * * @return the string, converted to uppercase. * @see java.lang.Character#toUpperCase(char) * @see java.lang.String#toLowerCase() */ public String toUpperCase() { return toUpperCase( Locale.getDefault() ); } /** * Removes white space from both ends of this string. * <p> * All characters that have codes less than or equal to * <code>'\u0020'</code> (the space character) are considered to be * white space. * * @return this string, with white space removed from the front and end. */ public String trim() { int len = count; int st = 0; int off = offset; /* avoid getfield opcode */ char[] val = value; /* avoid getfield opcode */ while ((st < len) && (val[off + st] <= ' ')) { st++; } while ((st < len) && (val[off + len - 1] <= ' ')) { len--; } return ((st > 0) || (len < count)) ? substring(st, len) : this; } /** * This object (which is already a string!) is itself returned. * * @return the string itself. */ public String toString() { return this; } /** * Converts this string to a new character array. * * @return a newly allocated character array whose length is the length * of this string and whose contents are initialized to contain * the character sequence represented by this string. */ public char[] toCharArray() { int max = length(); char result[] = new char[max]; getChars(0, max, result, 0); return result; } /** * Returns the string representation of the <code>Object</code> argument. * * @param obj an <code>Object</code>. * @return if the argument is <code>null</code>, then a string equal to * <code>"null"</code>; otherwise, the value of * <code>obj.toString()</code> is returned. * @see java.lang.Object#toString() */ public static String valueOf(Object obj) { return (obj == null) ? "null" : obj.toString(); } /** * Returns the string representation of the <code>char</code> array * argument. * * @param data a <code>char</code> array. * @return a newly allocated string representing the same sequence of * characters contained in the character array argument. */ public static String valueOf(char data[]) { return new String(data); } /** * Returns the string representation of a specific subarray of the * <code>char</code> array argument. * <p> * The <code>offset</code> argument is the index of the first * character of the subarray. The <code>count</code> argument * specifies the length of the subarray. * * @param data the character array. * @param offset the initial offset into the value of the * <code>String</code>. * @param count the length of the value of the <code>String</code>. * @return a newly allocated string representing the sequence of * characters contained in the subarray of the character array * argument. */ public static String valueOf(char data[], int offset, int count) { return new String(data, offset, count); } /** * Returns a String that is equivalent to the specified character array. * It creates a new array and copies the characters into it. * * @param data the character array. * @param offset initial offset of the subarray. * @param count length of the subarray. * @return a <code>String</code> that contains the characters of the * specified subarray of the character array. */ public static String copyValueOf(char data[], int offset, int count) { // All public String constructors now copy the data. return new String(data, offset, count); } /** * Returns a String that is equivalent to the specified character array. * It creates a new array and copies the characters into it. * * @param data the character array. * @return a <code>String</code> that contains the characters of the * character array. */ public static String copyValueOf(char data[]) { return copyValueOf(data, 0, data.length); } /** * Returns the string representation of the <code>boolean</code> argument. * * @param b a <code>boolean</code>. * @return if the argument is <code>true</code>, a string equal to * <code>"true"</code> is returned; otherwise, a string equal to * <code>"false"</code> is returned. */ public static String valueOf(boolean b) { return b ? "true" : "false"; } /** * Returns the string representation of the <code>char</code> argument. * * @param c a <code>char</code>. * @return a newly allocated string of length <code>1</code> containing * as its single character the argument <code>c</code>. */ public static String valueOf(char c) { char data[] = {c}; return new String(0, 1, data); } /** * Returns the string representation of the <code>int</code> argument. * <p> * The representation is exactly the one returned by the * <code>Integer.toString</code> method of one argument. * * @param i an <code>int</code>. * @return a newly allocated string containing a string representation of * the <code>int</code> argument. * @see java.lang.Integer#toString(int, int) */ public static String valueOf(int i) { return Integer.toString(i, 10); } /** * Returns the string representation of the <code>long</code> argument. * <p> * The representation is exactly the one returned by the * <code>Long.toString</code> method of one argument. * * @param l a <code>long</code>. * @return a newly allocated string containing a string representation of * the <code>long</code> argument. * @see java.lang.Long#toString(long) */ public static String valueOf(long l) { return Long.toString(l, 10); } /** * Returns the string representation of the <code>float</code> argument. * <p> * The representation is exactly the one returned by the * <code>Float.toString</code> method of one argument. * * @param f a <code>float</code>. * @return a newly allocated string containing a string representation of * the <code>float</code> argument. * @see java.lang.Float#toString(float) */ public static String valueOf(float f) { return Float.toString(f); } /** * Returns the string representation of the <code>double</code> argument. * <p> * The representation is exactly the one returned by the * <code>Double.toString</code> method of one argument. * * @param d a <code>double</code>. * @return a newly allocated string containing a string representation of * the <code>double</code> argument. * @see java.lang.Double#toString(double) */ public static String valueOf(double d) { return Double.toString(d); } /** * Returns a canonical representation for the string object. * <p> * If <code>s</code> and <code>t</code> are strings such that * <code>s.equals(t)</code>, it is guaranteed that<br> * <code>s.intern() == t.intern(). </code> * * @return a string that has the same contents as this string, but is * guaranteed to be from a pool of unique strings. */ public native String intern(); /** * Returns the length of this string's UTF encoded form. */ int utfLength() { int limit = offset + count; int utflen = 0; char[] val = value; for (int i = offset; i < limit; i++) { int c = val[i]; if ((c >= 0x0001) && (c <= 0x007F)) { utflen++; } else if (c > 0x07FF) { utflen += 3; } else { utflen += 2; } } return utflen; } }
⏎ java/lang/String.java
Or download all of them as a single archive file:
File name: jdk-1.1.8-src.zip File size: 1574187 bytes Release date: 2018-11-16 Download
⇒ Backup JDK 1.1 Installation Directory
2018-11-17, 176052👍, 0💬
Popular Posts:
What Is mail.jar of JavaMail 1.4? I got the JAR file from javamail-1_4.zip. mail.jar in javamail-1_4...
iText is an ideal library for developers looking to enhance web- and other applications with dynamic...
ANTLR is a powerful parser generator for multiple programming languages including Java. ANTLR contai...
JDK 11 jdk.jshell.jmod is the JMOD file for JDK 11 JShell tool, which can be invoked by the "jshell"...
Apache ZooKeeper is an open-source server which enables highly reliable distributed coordination. Ap...