All Downloads are FREE. Search and download functionalities are using the official Maven repository.

java.lang.String Maven / Gradle / Ivy

There is a newer version: 1.2.9
Show newest version
/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package java.lang;

import java.io.Serializable;
import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.Charsets;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Formatter;
import java.util.Locale;
import java.util.regex.Pattern;
import libcore.util.EmptyArray;

/**
 * An immutable sequence of characters/code units ({@code char}s). A
 * {@code String} is represented by array of UTF-16 values, such that
 * Unicode supplementary characters (code points) are stored/encoded as
 * surrogate pairs via Unicode code units ({@code char}).
 *
 * 

Backing Arrays

* This class is implemented using a char[]. The length of the array may exceed * the length of the string. For example, the string "Hello" may be backed by * the array {@code ['H', 'e', 'l', 'l', 'o', 'W'. 'o', 'r', 'l', 'd']} with * offset 0 and length 5. * *

Multiple strings can share the same char[] because strings are immutable. * The {@link #substring} method always returns a string that * shares the backing array of its source string. Generally this is an * optimization: fewer character arrays need to be allocated, and less copying * is necessary. But this can also lead to unwanted heap retention. Taking a * short substring of long string means that the long shared char[] won't be * garbage until both strings are garbage. This typically happens when parsing * small substrings out of a large input. To avoid this where necessary, call * {@code new String(longString.subString(...))}. The string copy constructor * always ensures that the backing array is no larger than necessary. * * @see StringBuffer * @see StringBuilder * @see Charset * @since 1.0 */ public final class String implements Serializable, Comparable, CharSequence { private static final long serialVersionUID = -6849794470754667710L; private static final char REPLACEMENT_CHAR = (char) 0xfffd; /** * CaseInsensitiveComparator compares Strings ignoring the case of the * characters. */ private static final class CaseInsensitiveComparator implements Comparator, Serializable { private static final long serialVersionUID = 8575799808933029326L; /** * Compare the two objects to determine the relative ordering. * * @param o1 * an Object to compare * @param o2 * an Object to compare * @return an int < 0 if object1 is less than object2, 0 if they are * equal, and > 0 if object1 is greater * * @exception ClassCastException * if objects are not the correct type */ public int compare(String o1, String o2) { return o1.compareToIgnoreCase(o2); } } /** * A comparator ignoring the case of the characters. */ public static final Comparator CASE_INSENSITIVE_ORDER = new CaseInsensitiveComparator(); private static final char[] ASCII; static { ASCII = new char[128]; for (int i = 0; i < ASCII.length; ++i) { ASCII[i] = (char) i; } } private final char[] value; private final int offset; private final int count; private int hashCode; /** * Creates an empty string. */ public String() { value = EmptyArray.CHAR; offset = 0; count = 0; } /* * Private constructor used for JIT optimization. */ @SuppressWarnings("unused") private String(String s, char c) { offset = 0; value = new char[s.count + 1]; count = s.count + 1; System.arraycopy(s.value, s.offset, value, 0, s.count); value[s.count] = c; } /** * Converts the byte array to a string using the system's * {@link java.nio.charset.Charset#defaultCharset default charset}. */ @FindBugsSuppressWarnings("DM_DEFAULT_ENCODING") public String(byte[] data) { this(data, 0, data.length); } /** * Converts the byte array to a string, setting the high byte of every * character to the specified value. * * @param data * the byte array to convert to a string. * @param high * the high byte to use. * @throws NullPointerException * if {@code data == null}. * @deprecated Use {@link #String(byte[])} or {@link #String(byte[], String)} instead. */ @Deprecated public String(byte[] data, int high) { this(data, high, 0, data.length); } /** * Converts a subsequence of the byte array to a string using the system's * {@link java.nio.charset.Charset#defaultCharset default charset}. * * @throws NullPointerException * if {@code data == null}. * @throws IndexOutOfBoundsException * if {@code byteCount < 0 || offset < 0 || offset + byteCount > data.length}. */ public String(byte[] data, int offset, int byteCount) { this(data, offset, byteCount, Charset.defaultCharset()); } /** * Converts the byte array to a string, setting the high byte of every * character to {@code high}. * * @throws NullPointerException * if {@code data == null}. * @throws IndexOutOfBoundsException * if {@code byteCount < 0 || offset < 0 || offset + byteCount > data.length} * * @deprecated Use {@link #String(byte[], int, int)} instead. */ @Deprecated public String(byte[] data, int high, int offset, int byteCount) { if ((offset | byteCount) < 0 || byteCount > data.length - offset) { throw failedBoundsCheck(data.length, offset, byteCount); } this.offset = 0; this.value = new char[byteCount]; this.count = byteCount; high <<= 8; for (int i = 0; i < count; i++) { value[i] = (char) (high + (data[offset++] & 0xff)); } } /** * Converts the byte array to a string using the named charset. * *

The behavior when the bytes cannot be decoded by the named charset * is unspecified. Use {@link java.nio.charset.CharsetDecoder} for more control. * * @throws NullPointerException * if {@code data == null}. * @throws IndexOutOfBoundsException * if {@code byteCount < 0 || offset < 0 || offset + byteCount > data.length}. * @throws UnsupportedEncodingException * if the named charset is not supported. */ public String(byte[] data, int offset, int byteCount, String charsetName) throws UnsupportedEncodingException { this(data, offset, byteCount, Charset.forNameUEE(charsetName)); } /** * Converts the byte array to a string using the named charset. * *

The behavior when the bytes cannot be decoded by the named charset * is unspecified. Use {@link java.nio.charset.CharsetDecoder} for more control. * * @throws NullPointerException * if {@code data == null}. * @throws UnsupportedEncodingException * if {@code charsetName} is not supported. */ public String(byte[] data, String charsetName) throws UnsupportedEncodingException { this(data, 0, data.length, Charset.forNameUEE(charsetName)); } /** * Converts the byte array to a string using the given charset. * *

The behavior when the bytes cannot be decoded by the given charset * is to replace malformed input and unmappable characters with the charset's default * replacement string. Use {@link java.nio.charset.CharsetDecoder} for more control. * * @throws IndexOutOfBoundsException * if {@code byteCount < 0 || offset < 0 || offset + byteCount > data.length} * @throws NullPointerException * if {@code data == null} * * @since 1.6 */ public String(byte[] data, int offset, int byteCount, Charset charset) { if ((offset | byteCount) < 0 || byteCount > data.length - offset) { throw failedBoundsCheck(data.length, offset, byteCount); } // We inline UTF-8, ISO-8859-1, and US-ASCII decoders for speed and because 'count' and // 'value' are final. String canonicalCharsetName = charset.name(); if (canonicalCharsetName.equals("UTF-8")) { byte[] d = data; char[] v = new char[byteCount]; int idx = offset; int last = offset + byteCount; int s = 0; outer: while (idx < last) { byte b0 = d[idx++]; if ((b0 & 0x80) == 0) { // 0xxxxxxx // Range: U-00000000 - U-0000007F int val = b0 & 0xff; v[s++] = (char) val; } else if (((b0 & 0xe0) == 0xc0) || ((b0 & 0xf0) == 0xe0) || ((b0 & 0xf8) == 0xf0) || ((b0 & 0xfc) == 0xf8) || ((b0 & 0xfe) == 0xfc)) { int utfCount = 1; if ((b0 & 0xf0) == 0xe0) utfCount = 2; else if ((b0 & 0xf8) == 0xf0) utfCount = 3; else if ((b0 & 0xfc) == 0xf8) utfCount = 4; else if ((b0 & 0xfe) == 0xfc) utfCount = 5; // 110xxxxx (10xxxxxx)+ // Range: U-00000080 - U-000007FF (count == 1) // Range: U-00000800 - U-0000FFFF (count == 2) // Range: U-00010000 - U-001FFFFF (count == 3) // Range: U-00200000 - U-03FFFFFF (count == 4) // Range: U-04000000 - U-7FFFFFFF (count == 5) if (idx + utfCount > last) { v[s++] = REPLACEMENT_CHAR; continue; } // Extract usable bits from b0 int val = b0 & (0x1f >> (utfCount - 1)); for (int i = 0; i < utfCount; ++i) { byte b = d[idx++]; if ((b & 0xc0) != 0x80) { v[s++] = REPLACEMENT_CHAR; idx--; // Put the input char back continue outer; } // Push new bits in from the right side val <<= 6; val |= b & 0x3f; } // Note: Java allows overlong char // specifications To disallow, check that val // is greater than or equal to the minimum // value for each count: // // count min value // ----- ---------- // 1 0x80 // 2 0x800 // 3 0x10000 // 4 0x200000 // 5 0x4000000 // Allow surrogate values (0xD800 - 0xDFFF) to // be specified using 3-byte UTF values only if ((utfCount != 2) && (val >= 0xD800) && (val <= 0xDFFF)) { v[s++] = REPLACEMENT_CHAR; continue; } // Reject chars greater than the Unicode maximum of U+10FFFF. if (val > 0x10FFFF) { v[s++] = REPLACEMENT_CHAR; continue; } // Encode chars from U+10000 up as surrogate pairs if (val < 0x10000) { v[s++] = (char) val; } else { int x = val & 0xffff; int u = (val >> 16) & 0x1f; int w = (u - 1) & 0xffff; int hi = 0xd800 | (w << 6) | (x >> 10); int lo = 0xdc00 | (x & 0x3ff); v[s++] = (char) hi; v[s++] = (char) lo; } } else { // Illegal values 0x8*, 0x9*, 0xa*, 0xb*, 0xfd-0xff v[s++] = REPLACEMENT_CHAR; } } if (s == byteCount) { // We guessed right, so we can use our temporary array as-is. this.offset = 0; this.value = v; this.count = s; } else { // Our temporary array was too big, so reallocate and copy. this.offset = 0; this.value = new char[s]; this.count = s; System.arraycopy(v, 0, value, 0, s); } } else if (canonicalCharsetName.equals("ISO-8859-1")) { this.offset = 0; this.value = new char[byteCount]; this.count = byteCount; Charsets.isoLatin1BytesToChars(data, offset, byteCount, value); } else if (canonicalCharsetName.equals("US-ASCII")) { this.offset = 0; this.value = new char[byteCount]; this.count = byteCount; Charsets.asciiBytesToChars(data, offset, byteCount, value); } else { CharBuffer cb = charset.decode(ByteBuffer.wrap(data, offset, byteCount)); this.offset = 0; this.count = cb.length(); if (count > 0) { // We could use cb.array() directly, but that would mean we'd have to trust // the CharsetDecoder doesn't hang on to the CharBuffer and mutate it later, // which would break String's immutability guarantee. It would also tend to // mean that we'd be wasting memory because CharsetDecoder doesn't trim the // array. So we copy. this.value = new char[count]; System.arraycopy(cb.array(), 0, value, 0, count); } else { this.value = EmptyArray.CHAR; } } } /** * Converts the byte array to a String using the given charset. * * @throws NullPointerException if {@code data == null} * @since 1.6 */ public String(byte[] data, Charset charset) { this(data, 0, data.length, charset); } /** * Initializes this string to contain the characters in the specified * character array. Modifying the character array after creating the string * has no effect on the string. * * @throws NullPointerException if {@code data == null} */ public String(char[] data) { this(data, 0, data.length); } /** * Initializes this string to contain the specified characters in the * character array. Modifying the character array after creating the string * has no effect on the string. * * @throws NullPointerException * if {@code data == null}. * @throws IndexOutOfBoundsException * if {@code charCount < 0 || offset < 0 || offset + charCount > data.length} */ public String(char[] data, int offset, int charCount) { if ((offset | charCount) < 0 || charCount > data.length - offset) { throw failedBoundsCheck(data.length, offset, charCount); } this.offset = 0; this.value = new char[charCount]; this.count = charCount; System.arraycopy(data, offset, value, 0, count); } /* * Internal version of the String(char[], int, int) constructor. * Does not range check, null check, or copy the character array. */ String(int offset, int charCount, char[] chars) { this.value = chars; this.offset = offset; this.count = charCount; } /** * Constructs a new string with the same sequence of characters as {@code * toCopy}. The returned string's backing array * is no larger than necessary. */ public String(String toCopy) { value = (toCopy.value.length == toCopy.count) ? toCopy.value : Arrays.copyOfRange(toCopy.value, toCopy.offset, toCopy.offset + toCopy.length()); offset = 0; count = value.length; } /* * Private constructor useful for JIT optimization. */ @SuppressWarnings( { "unused", "nls" }) private String(String s1, String s2) { if (s1 == null) { s1 = "null"; } if (s2 == null) { s2 = "null"; } count = s1.count + s2.count; value = new char[count]; offset = 0; System.arraycopy(s1.value, s1.offset, value, 0, s1.count); System.arraycopy(s2.value, s2.offset, value, s1.count, s2.count); } /* * Private constructor useful for JIT optimization. */ @SuppressWarnings( { "unused", "nls" }) private String(String s1, String s2, String s3) { if (s1 == null) { s1 = "null"; } if (s2 == null) { s2 = "null"; } if (s3 == null) { s3 = "null"; } count = s1.count + s2.count + s3.count; value = new char[count]; offset = 0; System.arraycopy(s1.value, s1.offset, value, 0, s1.count); System.arraycopy(s2.value, s2.offset, value, s1.count, s2.count); System.arraycopy(s3.value, s3.offset, value, s1.count + s2.count, s3.count); } /** * Creates a {@code String} from the contents of the specified * {@code StringBuffer}. */ public String(StringBuffer stringBuffer) { offset = 0; synchronized (stringBuffer) { value = stringBuffer.shareValue(); count = stringBuffer.length(); } } /** * Creates a {@code String} from the sub-array of Unicode code points. * * @throws NullPointerException * if {@code codePoints == null}. * @throws IllegalArgumentException * if any of the elements of {@code codePoints} are not valid * Unicode code points. * @throws IndexOutOfBoundsException * if {@code offset} or {@code count} are not within the bounds * of {@code codePoints}. * @since 1.5 */ public String(int[] codePoints, int offset, int count) { if (codePoints == null) { throw new NullPointerException("codePoints == null"); } if ((offset | count) < 0 || count > codePoints.length - offset) { throw failedBoundsCheck(codePoints.length, offset, count); } this.offset = 0; this.value = new char[count * 2]; int end = offset + count; int c = 0; for (int i = offset; i < end; i++) { c += Character.toChars(codePoints[i], this.value, c); } this.count = c; } /** * Creates a {@code String} from the contents of the specified {@code * StringBuilder}. * * @throws NullPointerException * if {@code stringBuilder == null}. * @since 1.5 */ public String(StringBuilder stringBuilder) { if (stringBuilder == null) { throw new NullPointerException("stringBuilder == null"); } this.offset = 0; this.count = stringBuilder.length(); this.value = new char[this.count]; stringBuilder.getChars(0, this.count, this.value, 0); } /* * Creates a {@code String} that is s1 + v1. May be used by JIT code. */ @SuppressWarnings("unused") private String(String s1, int v1) { if (s1 == null) { s1 = "null"; } String s2 = String.valueOf(v1); int len = s1.count + s2.count; value = new char[len]; offset = 0; System.arraycopy(s1.value, s1.offset, value, 0, s1.count); System.arraycopy(s2.value, s2.offset, value, s1.count, s2.count); count = len; } /** * Returns the character at the specified offset in this string. * * @param index * the zero-based index in this string. * @return the character at the index. * @throws IndexOutOfBoundsException * if {@code index < 0} or {@code index >= length()}. */ public char charAt(int index) { if (index < 0 || index >= count) { throw indexAndLength(index); } return value[offset + index]; } private StringIndexOutOfBoundsException indexAndLength(int index) { throw new StringIndexOutOfBoundsException(this, index); } private StringIndexOutOfBoundsException startEndAndLength(int start, int end) { throw new StringIndexOutOfBoundsException(this, start, end - start); } private StringIndexOutOfBoundsException failedBoundsCheck(int arrayLength, int offset, int count) { throw new StringIndexOutOfBoundsException(arrayLength, offset, count); } /** * This isn't equivalent to either of ICU's u_foldCase case folds, and thus any of the Unicode * case folds, but it's what the RI uses. */ private char foldCase(char ch) { if (ch < 128) { if ('A' <= ch && ch <= 'Z') { return (char) (ch + ('a' - 'A')); } return ch; } return Character.toLowerCase(Character.toUpperCase(ch)); } /** * Compares the specified string to this string using the Unicode values of * the characters. Returns 0 if the strings contain the same characters in * the same order. Returns a negative integer if the first non-equal * character in this string has a Unicode value which is less than the * Unicode value of the character at the same position in the specified * string, or if this string is a prefix of the specified string. Returns a * positive integer if the first non-equal character in this string has a * Unicode value which is greater than the Unicode value of the character at * the same position in the specified string, or if the specified string is * a prefix of this string. * * @param string * the string to compare. * @return 0 if the strings are equal, a negative integer if this string is * before the specified string, or a positive integer if this string * is after the specified string. * @throws NullPointerException * if {@code string} is {@code null}. */ public int compareTo(String string) { // BugVM note: This method is native in Android if (string == this) { return 0; } // The code below comes from Apache Harmony // Code adapted from K&R, pg 101 int o1 = offset, o2 = string.offset, result; int end = offset + (count < string.count ? count : string.count); char[] target = string.value; while (o1 < end) { if ((result = value[o1++] - target[o2++]) != 0) { return result; } } return count - string.count; } /** * Compares the specified string to this string using the Unicode values of * the characters, ignoring case differences. Returns 0 if the strings * contain the same characters in the same order. Returns a negative integer * if the first non-equal character in this string has a Unicode value which * is less than the Unicode value of the character at the same position in * the specified string, or if this string is a prefix of the specified * string. Returns a positive integer if the first non-equal character in * this string has a Unicode value which is greater than the Unicode value * of the character at the same position in the specified string, or if the * specified string is a prefix of this string. * * @param string * the string to compare. * @return 0 if the strings are equal, a negative integer if this string is * before the specified string, or a positive integer if this string * is after the specified string. * @throws NullPointerException * if {@code string} is {@code null}. */ public int compareToIgnoreCase(String string) { int o1 = offset, o2 = string.offset, result; int end = offset + (count < string.count ? count : string.count); char c1, c2; char[] target = string.value; while (o1 < end) { if ((c1 = value[o1++]) == (c2 = target[o2++])) { continue; } c1 = foldCase(c1); c2 = foldCase(c2); if ((result = c1 - c2) != 0) { return result; } } return count - string.count; } /** * Concatenates this string and the specified string. * * @param string * the string to concatenate * @return a new string which is the concatenation of this string and the * specified string. */ public String concat(String string) { if (string.count > 0 && count > 0) { char[] buffer = new char[count + string.count]; System.arraycopy(value, offset, buffer, 0, count); System.arraycopy(string.value, string.offset, buffer, count, string.count); return new String(0, buffer.length, buffer); } return count == 0 ? string : this; } /** * Creates a new string containing the characters in the specified character * array. Modifying the character array after creating the string has no * effect on the string. * * @param data * the array of characters. * @return the new string. * @throws NullPointerException * if {@code data} is {@code null}. */ public static String copyValueOf(char[] data) { return new String(data, 0, data.length); } /** * Creates a new string containing the specified characters in the character * array. Modifying the character array after creating the string has no * effect on the string. * * @param data * the array of characters. * @param start * the starting offset in the character array. * @param length * the number of characters to use. * @return the new string. * @throws NullPointerException * if {@code data} is {@code null}. * @throws IndexOutOfBoundsException * if {@code length < 0, start < 0} or {@code start + length > * data.length}. */ public static String copyValueOf(char[] data, int start, int length) { return new String(data, start, length); } /** * Compares the specified string to this string to determine if the * specified string is a suffix. * * @param suffix * the suffix to look for. * @return {@code true} if the specified string is a suffix of this string, * {@code false} otherwise. * @throws NullPointerException * if {@code suffix} is {@code null}. */ public boolean endsWith(String suffix) { return regionMatches(count - suffix.count, suffix, 0, suffix.count); } /** * Compares the specified object to this string and returns true if they are * equal. The object must be an instance of string with the same characters * in the same order. * * @param object * the object to compare. * @return {@code true} if the specified object is equal to this string, * {@code false} otherwise. * @see #hashCode */ @Override public boolean equals(Object object) { // BugVM note: This method is native in Android // The code below has been copied from Apache Harmony // and changed to be faster if (object == this) { return true; } if (object instanceof String) { String s = (String) object; int _count = count; int _scount = s.count; int _hash = hashCode; int _shash = s.hashCode; if (_count != _scount || (_hash != _shash && _hash != 0 && _shash != 0)) { return false; } int i = offset; int j = s.offset; char[] _value = value; char[] _svalue = s.value; while (_count > 0) { if (_value[i++] != _svalue[j++]) { return false; } _count--; } return true; } return false; } /** * Compares the specified string to this string ignoring the case of the * characters and returns true if they are equal. * * @param string * the string to compare. * @return {@code true} if the specified string is equal to this string, * {@code false} otherwise. */ @FindBugsSuppressWarnings("ES_COMPARING_PARAMETER_STRING_WITH_EQ") public boolean equalsIgnoreCase(String string) { if (string == this) { return true; } if (string == null || count != string.count) { return false; } int o1 = offset, o2 = string.offset; int end = offset + count; char[] target = string.value; while (o1 < end) { char c1 = value[o1++]; char c2 = target[o2++]; if (c1 != c2 && foldCase(c1) != foldCase(c2)) { return false; } } return true; } /** * Mangles this string into a byte array by stripping the high order bits from * each character. Use {@link #getBytes()} or {@link #getBytes(String)} instead. * * @param start * the starting offset of characters to copy. * @param end * the ending offset of characters to copy. * @param data * the destination byte array. * @param index * the starting offset in the destination byte array. * @throws NullPointerException * if {@code data} is {@code null}. * @throws IndexOutOfBoundsException * if {@code start < 0}, {@code end > length()}, {@code index < * 0} or {@code end - start > data.length - index}. * @deprecated Use {@link #getBytes()} or {@link #getBytes(String)} instead. */ @Deprecated public void getBytes(int start, int end, byte[] data, int index) { // Note: last character not copied! if (start >= 0 && start <= end && end <= count) { end += offset; try { for (int i = offset + start; i < end; i++) { data[index++] = (byte) value[i]; } } catch (ArrayIndexOutOfBoundsException ignored) { throw failedBoundsCheck(data.length, index, end - start); } } else { throw startEndAndLength(start, end); } } /** * Returns a new byte array containing the characters of this string encoded using the * system's {@link java.nio.charset.Charset#defaultCharset default charset}. * *

The behavior when this string cannot be represented in the system's default charset * is unspecified. In practice, when the default charset is UTF-8 (as it is on Android), * all strings can be encoded. */ public byte[] getBytes() { return getBytes(Charset.defaultCharset()); } /** * Returns a new byte array containing the characters of this string encoded using the * named charset. * *

The behavior when this string cannot be represented in the named charset * is unspecified. Use {@link java.nio.charset.CharsetEncoder} for more control. * * @throws UnsupportedEncodingException if the charset is not supported */ public byte[] getBytes(String charsetName) throws UnsupportedEncodingException { return getBytes(Charset.forNameUEE(charsetName)); } /** * Returns a new byte array containing the characters of this string encoded using the * given charset. * *

The behavior when this string cannot be represented in the given charset * is to replace malformed input and unmappable characters with the charset's default * replacement byte array. Use {@link java.nio.charset.CharsetEncoder} for more control. * * @since 1.6 */ public byte[] getBytes(Charset charset) { String canonicalCharsetName = charset.name(); if (canonicalCharsetName.equals("UTF-8")) { return Charsets.toUtf8Bytes(value, offset, count); } else if (canonicalCharsetName.equals("ISO-8859-1")) { return Charsets.toIsoLatin1Bytes(value, offset, count); } else if (canonicalCharsetName.equals("US-ASCII")) { return Charsets.toAsciiBytes(value, offset, count); } else if (canonicalCharsetName.equals("UTF-16BE")) { return Charsets.toBigEndianUtf16Bytes(value, offset, count); } else { CharBuffer chars = CharBuffer.wrap(this.value, this.offset, this.count); ByteBuffer buffer = charset.encode(chars.asReadOnlyBuffer()); byte[] bytes = new byte[buffer.limit()]; buffer.get(bytes); return bytes; } } /** * Copies the specified characters in this string to the character array * starting at the specified offset in the character array. * * @param start * the starting offset of characters to copy. * @param end * the ending offset of characters to copy. * @param buffer * the destination character array. * @param index * the starting offset in the character array. * @throws NullPointerException * if {@code buffer} is {@code null}. * @throws IndexOutOfBoundsException * if {@code start < 0}, {@code end > length()}, {@code start > * end}, {@code index < 0}, {@code end - start > buffer.length - * index} */ public void getChars(int start, int end, char[] buffer, int index) { // Note: last character not copied! if (start >= 0 && start <= end && end <= count) { System.arraycopy(value, start + offset, buffer, index, end - start); } else { // We throw StringIndexOutOfBoundsException rather than System.arraycopy's AIOOBE. throw startEndAndLength(start, end); } } /** * Version of getChars without bounds checks, for use by other classes * within the java.lang package only. The caller is responsible for * ensuring that start >= 0 && start <= end && end <= count. */ void _getChars(int start, int end, char[] buffer, int index) { // NOTE last character not copied! System.arraycopy(value, start + offset, buffer, index, end - start); } @Override public int hashCode() { int hash = hashCode; if (hash == 0) { if (count == 0) { return 0; } final int end = count + offset; final char[] chars = value; for (int i = offset; i < end; ++i) { hash = 31*hash + chars[i]; } hashCode = hash; } return hash; } /** * Searches in this string for the first index of the specified character. * The search for the character starts at the beginning and moves towards * the end of this string. * * @param c * the character to find. * @return the index in this string of the specified character, -1 if the * character isn't found. */ public int indexOf(int c) { // TODO: just "return indexOf(c, 0);" when the JIT can inline that deep. if (c > 0xffff) { return indexOfSupplementary(c, 0); } return fastIndexOf(c, 0); } /** * Searches in this string for the index of the specified character. The * search for the character starts at the specified offset and moves towards * the end of this string. * * @param c * the character to find. * @param start * the starting offset. * @return the index in this string of the specified character, -1 if the * character isn't found. */ public int indexOf(int c, int start) { if (c > 0xffff) { return indexOfSupplementary(c, start); } return fastIndexOf(c, start); } private int fastIndexOf(int c, int start) { // BugVM note: This is native in Android int _count = count; int _offset = offset; char[] _value = value; if (start < _count) { if (start < 0) { start = 0; } for (int i = _offset + start; i < _offset + _count; i++) { if (_value[i] == c) { return i - _offset; } } } return -1; } private int indexOfSupplementary(int c, int start) { if (!Character.isSupplementaryCodePoint(c)) { return -1; } char[] chars = Character.toChars(c); String needle = new String(0, chars.length, chars); return indexOf(needle, start); } /** * Searches in this string for the first index of the specified string. The * search for the string starts at the beginning and moves towards the end * of this string. * * @param string * the string to find. * @return the index of the first character of the specified string in this * string, -1 if the specified string is not a substring. * @throws NullPointerException * if {@code string} is {@code null}. */ public int indexOf(String string) { int start = 0; int subCount = string.count; int _count = count; if (subCount > 0) { if (subCount > _count) { return -1; } char[] target = string.value; int subOffset = string.offset; char firstChar = target[subOffset]; int end = subOffset + subCount; while (true) { int i = indexOf(firstChar, start); if (i == -1 || subCount + i > _count) { return -1; // handles subCount > count || start >= count } int o1 = offset + i, o2 = subOffset; char[] _value = value; while (++o2 < end && _value[++o1] == target[o2]) { // Intentionally empty } if (o2 == end) { return i; } start = i + 1; } } return start < _count ? start : _count; } /** * Searches in this string for the index of the specified string. The search * for the string starts at the specified offset and moves towards the end * of this string. * * @param subString * the string to find. * @param start * the starting offset. * @return the index of the first character of the specified string in this * string, -1 if the specified string is not a substring. * @throws NullPointerException * if {@code subString} is {@code null}. */ public int indexOf(String subString, int start) { if (start < 0) { start = 0; } int subCount = subString.count; int _count = count; if (subCount > 0) { if (subCount + start > _count) { return -1; } char[] target = subString.value; int subOffset = subString.offset; char firstChar = target[subOffset]; int end = subOffset + subCount; while (true) { int i = indexOf(firstChar, start); if (i == -1 || subCount + i > _count) { return -1; // handles subCount > count || start >= count } int o1 = offset + i, o2 = subOffset; char[] _value = value; while (++o2 < end && _value[++o1] == target[o2]) { // Intentionally empty } if (o2 == end) { return i; } start = i + 1; } } return start < _count ? start : _count; } /** * Returns an interned string equal to this string. The VM maintains an internal set of * unique strings. All string literals found in loaded classes' * constant pools are automatically interned. Manually-interned strings are only weakly * referenced, so calling {@code intern} won't lead to unwanted retention. * *

Interning is typically used because it guarantees that for interned strings * {@code a} and {@code b}, {@code a.equals(b)} can be simplified to * {@code a == b}. (This is not true of non-interned strings.) * *

Many applications find it simpler and more convenient to use an explicit * {@link java.util.HashMap} to implement their own pools. */ public native String intern(); /** * Returns true if the length of this string is 0. * * @since 1.6 */ public boolean isEmpty() { // BugVM note: This method is native in Android return count == 0; } /** * Returns the last index of the code point {@code c}, or -1. * The search for the character starts at the end and moves towards the * beginning of this string. */ public int lastIndexOf(int c) { if (c > 0xffff) { return lastIndexOfSupplementary(c, Integer.MAX_VALUE); } int _count = count; int _offset = offset; char[] _value = value; for (int i = _offset + _count - 1; i >= _offset; --i) { if (_value[i] == c) { return i - _offset; } } return -1; } /** * Returns the last index of the code point {@code c}, or -1. * The search for the character starts at offset {@code start} and moves towards * the beginning of this string. */ public int lastIndexOf(int c, int start) { if (c > 0xffff) { return lastIndexOfSupplementary(c, start); } int _count = count; int _offset = offset; char[] _value = value; if (start >= 0) { if (start >= _count) { start = _count - 1; } for (int i = _offset + start; i >= _offset; --i) { if (_value[i] == c) { return i - _offset; } } } return -1; } private int lastIndexOfSupplementary(int c, int start) { if (!Character.isSupplementaryCodePoint(c)) { return -1; } char[] chars = Character.toChars(c); String needle = new String(0, chars.length, chars); return lastIndexOf(needle, start); } /** * Searches in this string for the last index of the specified string. The * search for the string starts at the end and moves towards the beginning * of this string. * * @param string * the string to find. * @return the index of the first character of the specified string in this * string, -1 if the specified string is not a substring. * @throws NullPointerException * if {@code string} is {@code null}. */ public int lastIndexOf(String string) { // Use count instead of count - 1 so lastIndexOf("") returns count return lastIndexOf(string, count); } /** * Searches in this string for the index of the specified string. The search * for the string starts at the specified offset and moves towards the * beginning of this string. * * @param subString * the string to find. * @param start * the starting offset. * @return the index of the first character of the specified string in this * string , -1 if the specified string is not a substring. * @throws NullPointerException * if {@code subString} is {@code null}. */ public int lastIndexOf(String subString, int start) { int subCount = subString.count; if (subCount <= count && start >= 0) { if (subCount > 0) { if (start > count - subCount) { start = count - subCount; } // count and subCount are both >= 1 char[] target = subString.value; int subOffset = subString.offset; char firstChar = target[subOffset]; int end = subOffset + subCount; while (true) { int i = lastIndexOf(firstChar, start); if (i == -1) { return -1; } int o1 = offset + i, o2 = subOffset; while (++o2 < end && value[++o1] == target[o2]) { // Intentionally empty } if (o2 == end) { return i; } start = i - 1; } } return start < count ? start : count; } return -1; } /** * Returns the number of characters in this string. */ public int length() { return count; } /** * Compares the specified string to this string and compares the specified * range of characters to determine if they are the same. * * @param thisStart * the starting offset in this string. * @param string * the string to compare. * @param start * the starting offset in the specified string. * @param length * the number of characters to compare. * @return {@code true} if the ranges of characters are equal, {@code false} * otherwise * @throws NullPointerException * if {@code string} is {@code null}. */ public boolean regionMatches(int thisStart, String string, int start, int length) { if (string == null) { throw new NullPointerException("string == null"); } if (start < 0 || string.count - start < length) { return false; } if (thisStart < 0 || count - thisStart < length) { return false; } if (length <= 0) { return true; } int o1 = offset + thisStart, o2 = string.offset + start; char[] value1 = value; char[] value2 = string.value; for (int i = 0; i < length; ++i) { if (value1[o1 + i] != value2[o2 + i]) { return false; } } return true; } /** * Compares the specified string to this string and compares the specified * range of characters to determine if they are the same. When ignoreCase is * true, the case of the characters is ignored during the comparison. * * @param ignoreCase * specifies if case should be ignored. * @param thisStart * the starting offset in this string. * @param string * the string to compare. * @param start * the starting offset in the specified string. * @param length * the number of characters to compare. * @return {@code true} if the ranges of characters are equal, {@code false} * otherwise. * @throws NullPointerException * if {@code string} is {@code null}. */ public boolean regionMatches(boolean ignoreCase, int thisStart, String string, int start, int length) { if (!ignoreCase) { return regionMatches(thisStart, string, start, length); } if (string == null) { throw new NullPointerException("string == null"); } if (thisStart < 0 || length > count - thisStart) { return false; } if (start < 0 || length > string.count - start) { return false; } thisStart += offset; start += string.offset; int end = thisStart + length; char[] target = string.value; while (thisStart < end) { char c1 = value[thisStart++]; char c2 = target[start++]; if (c1 != c2 && foldCase(c1) != foldCase(c2)) { return false; } } return true; } /** * Copies this string replacing occurrences of the specified character with * another character. * * @param oldChar * the character to replace. * @param newChar * the replacement character. * @return a new string with occurrences of oldChar replaced by newChar. */ public String replace(char oldChar, char newChar) { char[] buffer = value; int _offset = offset; int _count = count; int idx = _offset; int last = _offset + _count; boolean copied = false; while (idx < last) { if (buffer[idx] == oldChar) { if (!copied) { char[] newBuffer = new char[_count]; System.arraycopy(buffer, _offset, newBuffer, 0, _count); buffer = newBuffer; idx -= _offset; last -= _offset; copied = true; } buffer[idx] = newChar; } idx++; } return copied ? new String(0, count, buffer) : this; } /** * Copies this string replacing occurrences of the specified target sequence * with another sequence. The string is processed from the beginning to the * end. * * @param target * the sequence to replace. * @param replacement * the replacement sequence. * @return the resulting string. * @throws NullPointerException * if {@code target} or {@code replacement} is {@code null}. */ public String replace(CharSequence target, CharSequence replacement) { if (target == null) { throw new NullPointerException("target == null"); } if (replacement == null) { throw new NullPointerException("replacement == null"); } String targetString = target.toString(); int matchStart = indexOf(targetString, 0); if (matchStart == -1) { // If there's nothing to replace, return the original string untouched. return this; } String replacementString = replacement.toString(); // The empty target matches at the start and end and between each character. int targetLength = targetString.length(); if (targetLength == 0) { // The result contains the original 'count' characters, a copy of the // replacement string before every one of those characters, and a final // copy of the replacement string at the end. int resultLength = count + (count + 1) * replacementString.length(); StringBuilder result = new StringBuilder(resultLength); result.append(replacementString); int end = offset + count; for (int i = offset; i != end; ++i) { result.append(value[i]); result.append(replacementString); } return result.toString(); } StringBuilder result = new StringBuilder(count); int searchStart = 0; do { // Copy characters before the match... result.append(value, offset + searchStart, matchStart - searchStart); // Insert the replacement... result.append(replacementString); // And skip over the match... searchStart = matchStart + targetLength; } while ((matchStart = indexOf(targetString, searchStart)) != -1); // Copy any trailing chars... result.append(value, offset + searchStart, count - searchStart); return result.toString(); } /** * Compares the specified string to this string to determine if the * specified string is a prefix. * * @param prefix * the string to look for. * @return {@code true} if the specified string is a prefix of this string, * {@code false} otherwise * @throws NullPointerException * if {@code prefix} is {@code null}. */ public boolean startsWith(String prefix) { return startsWith(prefix, 0); } /** * Compares the specified string to this string, starting at the specified * offset, to determine if the specified string is a prefix. * * @param prefix * the string to look for. * @param start * the starting offset. * @return {@code true} if the specified string occurs in this string at the * specified offset, {@code false} otherwise. * @throws NullPointerException * if {@code prefix} is {@code null}. */ public boolean startsWith(String prefix, int start) { return regionMatches(start, prefix, 0, prefix.count); } /** * Returns a string containing a suffix of this string. The returned string * shares this string's backing array. * * @param start * the offset of the first character. * @return a new string containing the characters from start to the end of * the string. * @throws IndexOutOfBoundsException * if {@code start < 0} or {@code start > length()}. */ public String substring(int start) { if (start == 0) { return this; } if (start >= 0 && start <= count) { return new String(offset + start, count - start, value); } throw indexAndLength(start); } /** * Returns a string containing a subsequence of characters from this string. * The returned string shares this string's backing * array. * * @param start * the offset of the first character. * @param end * the offset one past the last character. * @return a new string containing the characters from start to end - 1 * @throws IndexOutOfBoundsException * if {@code start < 0}, {@code start > end} or {@code end > * length()}. */ public String substring(int start, int end) { if (start == 0 && end == count) { return this; } // NOTE last character not copied! // Fast range check. if (start >= 0 && start <= end && end <= count) { return new String(offset + start, end - start, value); } throw startEndAndLength(start, end); } /** * Returns a new {@code char} array containing a copy of the characters in this string. * This is expensive and rarely useful. If you just want to iterate over the characters in * the string, use {@link #charAt} instead. */ public char[] toCharArray() { char[] buffer = new char[count]; System.arraycopy(value, offset, buffer, 0, count); return buffer; } /** * Converts this string to lower case, using the rules of the user's default locale. * See "Be wary of the default locale". * * @return a new lower case string, or {@code this} if it's already all lower case. */ public String toLowerCase() { return CaseMapper.toLowerCase(Locale.getDefault(), this, value, offset, count); } /** * Converts this string to lower case, using the rules of {@code locale}. * *

Most case mappings are unaffected by the language of a {@code Locale}. Exceptions include * dotted and dotless I in Azeri and Turkish locales, and dotted and dotless I and J in * Lithuanian locales. On the other hand, it isn't necessary to provide a Greek locale to get * correct case mapping of Greek characters: any locale will do. * *

See http://www.unicode.org/Public/UNIDATA/SpecialCasing.txt * for full details of context- and language-specific special cases. * * @return a new lower case string, or {@code this} if it's already all lower case. */ public String toLowerCase(Locale locale) { return CaseMapper.toLowerCase(locale, this, value, offset, count); } /** * Returns this string. */ @Override public String toString() { return this; } /** * Converts this this string to upper case, using the rules of the user's default locale. * See "Be wary of the default locale". * * @return a new upper case string, or {@code this} if it's already all upper case. */ public String toUpperCase() { return CaseMapper.toUpperCase(Locale.getDefault(), this, value, offset, count); } /** * Converts this this string to upper case, using the rules of {@code locale}. * *

Most case mappings are unaffected by the language of a {@code Locale}. Exceptions include * dotted and dotless I in Azeri and Turkish locales, and dotted and dotless I and J in * Lithuanian locales. On the other hand, it isn't necessary to provide a Greek locale to get * correct case mapping of Greek characters: any locale will do. * *

See http://www.unicode.org/Public/UNIDATA/SpecialCasing.txt * for full details of context- and language-specific special cases. * * @return a new upper case string, or {@code this} if it's already all upper case. */ public String toUpperCase(Locale locale) { return CaseMapper.toUpperCase(locale, this, value, offset, count); } /** * Copies this string removing white space characters from the beginning and * end of the string. * * @return a new string with characters <= \\u0020 removed from * the beginning and the end. */ public String trim() { int start = offset, last = offset + count - 1; int end = last; while ((start <= end) && (value[start] <= ' ')) { start++; } while ((end >= start) && (value[end] <= ' ')) { end--; } if (start == offset && end == last) { return this; } return new String(start, end - start + 1, value); } /** * Creates a new string containing the characters in the specified character * array. Modifying the character array after creating the string has no * effect on the string. * * @param data * the array of characters. * @return the new string. * @throws NullPointerException * if {@code data} is {@code null}. */ public static String valueOf(char[] data) { return new String(data, 0, data.length); } /** * Creates a new string containing the specified characters in the character * array. Modifying the character array after creating the string has no * effect on the string. * * @param data * the array of characters. * @param start * the starting offset in the character array. * @param length * the number of characters to use. * @return the new string. * @throws IndexOutOfBoundsException * if {@code length < 0}, {@code start < 0} or {@code start + * length > data.length} * @throws NullPointerException * if {@code data} is {@code null}. */ public static String valueOf(char[] data, int start, int length) { return new String(data, start, length); } /** * Converts the specified character to its string representation. * * @param value * the character. * @return the character converted to a string. */ public static String valueOf(char value) { String s; if (value < 128) { s = new String(value, 1, ASCII); } else { s = new String(0, 1, new char[] { value }); } s.hashCode = value; return s; } /** * Converts the specified double to its string representation. * * @param value * the double. * @return the double converted to a string. */ public static String valueOf(double value) { return Double.toString(value); } /** * Converts the specified float to its string representation. * * @param value * the float. * @return the float converted to a string. */ public static String valueOf(float value) { return Float.toString(value); } /** * Converts the specified integer to its string representation. * * @param value * the integer. * @return the integer converted to a string. */ public static String valueOf(int value) { return Integer.toString(value); } /** * Converts the specified long to its string representation. * * @param value * the long. * @return the long converted to a string. */ public static String valueOf(long value) { return Long.toString(value); } /** * Converts the specified object to its string representation. If the object * is null return the string {@code "null"}, otherwise use {@code * toString()} to get the string representation. * * @param value * the object. * @return the object converted to a string, or the string {@code "null"}. */ public static String valueOf(Object value) { return value != null ? value.toString() : "null"; } /** * Converts the specified boolean to its string representation. When the * boolean is {@code true} return {@code "true"}, otherwise return {@code * "false"}. * * @param value * the boolean. * @return the boolean converted to a string. */ public static String valueOf(boolean value) { return value ? "true" : "false"; } /** * Returns whether the characters in the StringBuffer {@code strbuf} are the * same as those in this string. * * @param strbuf * the StringBuffer to compare this string to. * @return {@code true} if the characters in {@code strbuf} are identical to * those in this string. If they are not, {@code false} will be * returned. * @throws NullPointerException * if {@code strbuf} is {@code null}. * @since 1.4 */ public boolean contentEquals(StringBuffer strbuf) { synchronized (strbuf) { int size = strbuf.length(); if (count != size) { return false; } return regionMatches(0, new String(0, size, strbuf.getValue()), 0, size); } } /** * Compares a {@code CharSequence} to this {@code String} to determine if * their contents are equal. * * @param cs * the character sequence to compare to. * @return {@code true} if equal, otherwise {@code false} * @since 1.5 */ public boolean contentEquals(CharSequence cs) { if (cs == null) { throw new NullPointerException("cs == null"); } int len = cs.length(); if (len != count) { return false; } if (len == 0 && count == 0) { return true; // since both are empty strings } return regionMatches(0, cs.toString(), 0, len); } /** * Tests whether this string matches the given {@code regularExpression}. This method returns * true only if the regular expression matches the entire input string. A common mistake is * to assume that this method behaves like {@link #contains}; if you want to match anywhere * within the input string, you need to add {@code .*} to the beginning and end of your * regular expression. See {@link Pattern#matches}. * *

If the same regular expression is to be used for multiple operations, it may be more * efficient to reuse a compiled {@code Pattern}. * * @throws PatternSyntaxException * if the syntax of the supplied regular expression is not * valid. * @throws NullPointerException if {@code regularExpression == null} * @since 1.4 */ public boolean matches(String regularExpression) { return Pattern.matches(regularExpression, this); } /** * Replaces all matches for {@code regularExpression} within this string with the given * {@code replacement}. * See {@link Pattern} for regular expression syntax. * *

If the same regular expression is to be used for multiple operations, it may be more * efficient to reuse a compiled {@code Pattern}. * * @throws PatternSyntaxException * if the syntax of the supplied regular expression is not * valid. * @throws NullPointerException if {@code regularExpression == null} * @see Pattern * @since 1.4 */ public String replaceAll(String regularExpression, String replacement) { return Pattern.compile(regularExpression).matcher(this).replaceAll(replacement); } /** * Replaces the first match for {@code regularExpression} within this string with the given * {@code replacement}. * See {@link Pattern} for regular expression syntax. * *

If the same regular expression is to be used for multiple operations, it may be more * efficient to reuse a compiled {@code Pattern}. * * @throws PatternSyntaxException * if the syntax of the supplied regular expression is not * valid. * @throws NullPointerException if {@code regularExpression == null} * @see Pattern * @since 1.4 */ public String replaceFirst(String regularExpression, String replacement) { return Pattern.compile(regularExpression).matcher(this).replaceFirst(replacement); } /** * Splits this string using the supplied {@code regularExpression}. * Equivalent to {@code split(regularExpression, 0)}. * See {@link Pattern#split(CharSequence, int)} for an explanation of {@code limit}. * See {@link Pattern} for regular expression syntax. * *

If the same regular expression is to be used for multiple operations, it may be more * efficient to reuse a compiled {@code Pattern}. * * @throws NullPointerException if {@code regularExpression == null} * @throws PatternSyntaxException * if the syntax of the supplied regular expression is not * valid. * @see Pattern * @since 1.4 */ public String[] split(String regularExpression) { return split(regularExpression, 0); } /** * Splits this string using the supplied {@code regularExpression}. * See {@link Pattern#split(CharSequence, int)} for an explanation of {@code limit}. * See {@link Pattern} for regular expression syntax. * *

If the same regular expression is to be used for multiple operations, it may be more * efficient to reuse a compiled {@code Pattern}. * * @throws NullPointerException if {@code regularExpression == null} * @throws PatternSyntaxException * if the syntax of the supplied regular expression is not * valid. * @since 1.4 */ public String[] split(String regularExpression, int limit) { String[] result = java.util.regex.Splitter.fastSplit(regularExpression, this, limit); return result != null ? result : Pattern.compile(regularExpression).split(this, limit); } /** * Has the same result as the substring function, but is present so that * string may implement the CharSequence interface. * * @param start * the offset the first character. * @param end * the offset of one past the last character to include. * @return the subsequence requested. * @throws IndexOutOfBoundsException * if {@code start < 0}, {@code end < 0}, {@code start > end} or * {@code end > length()}. * @see java.lang.CharSequence#subSequence(int, int) * @since 1.4 */ public CharSequence subSequence(int start, int end) { return substring(start, end); } /** * Returns the Unicode code point at the given {@code index}. * * @throws IndexOutOfBoundsException if {@code index < 0 || index >= length()} * @see Character#codePointAt(char[], int, int) * @since 1.5 */ public int codePointAt(int index) { if (index < 0 || index >= count) { throw indexAndLength(index); } return Character.codePointAt(value, offset + index, offset + count); } /** * Returns the Unicode code point that precedes the given {@code index}. * * @throws IndexOutOfBoundsException if {@code index < 1 || index > length()} * @see Character#codePointBefore(char[], int, int) * @since 1.5 */ public int codePointBefore(int index) { if (index < 1 || index > count) { throw indexAndLength(index); } return Character.codePointBefore(value, offset + index, offset); } /** * Calculates the number of Unicode code points between {@code start} * and {@code end}. * * @param start * the inclusive beginning index of the subsequence. * @param end * the exclusive end index of the subsequence. * @return the number of Unicode code points in the subsequence. * @throws IndexOutOfBoundsException * if {@code start < 0 || end > length() || start > end} * @see Character#codePointCount(CharSequence, int, int) * @since 1.5 */ public int codePointCount(int start, int end) { if (start < 0 || end > count || start > end) { throw startEndAndLength(start, end); } return Character.codePointCount(value, offset + start, end - start); } /** * Determines if this {@code String} contains the sequence of characters in * the {@code CharSequence} passed. * * @param cs * the character sequence to search for. * @return {@code true} if the sequence of characters are contained in this * string, otherwise {@code false}. * @since 1.5 */ public boolean contains(CharSequence cs) { if (cs == null) { throw new NullPointerException("cs == null"); } return indexOf(cs.toString()) >= 0; } /** * Returns the index within this object that is offset from {@code index} by * {@code codePointOffset} code points. * * @param index * the index within this object to calculate the offset from. * @param codePointOffset * the number of code points to count. * @return the index within this object that is the offset. * @throws IndexOutOfBoundsException * if {@code index} is negative or greater than {@code length()} * or if there aren't enough code points before or after {@code * index} to match {@code codePointOffset}. * @since 1.5 */ public int offsetByCodePoints(int index, int codePointOffset) { int s = index + offset; int r = Character.offsetByCodePoints(value, offset, count, s, codePointOffset); return r - offset; } /** * Returns a localized formatted string, using the supplied format and arguments, * using the user's default locale. * *

If you're formatting a string other than for human * consumption, you should use the {@code format(Locale, String, Object...)} * overload and supply {@code Locale.US}. See * "Be wary of the default locale". * * @param format the format string (see {@link java.util.Formatter#format}) * @param args * the list of arguments passed to the formatter. If there are * more arguments than required by {@code format}, * additional arguments are ignored. * @return the formatted string. * @throws NullPointerException if {@code format == null} * @throws java.util.IllegalFormatException * if the format is invalid. * @since 1.5 */ public static String format(String format, Object... args) { return format(Locale.getDefault(), format, args); } /** * Returns a formatted string, using the supplied format and arguments, * localized to the given locale. * * @param locale * the locale to apply; {@code null} value means no localization. * @param format the format string (see {@link java.util.Formatter#format}) * @param args * the list of arguments passed to the formatter. If there are * more arguments than required by {@code format}, * additional arguments are ignored. * @return the formatted string. * @throws NullPointerException if {@code format == null} * @throws java.util.IllegalFormatException * if the format is invalid. * @since 1.5 */ public static String format(Locale locale, String format, Object... args) { if (format == null) { throw new NullPointerException("format == null"); } int bufferSize = format.length() + (args == null ? 0 : args.length * 10); Formatter f = new Formatter(new StringBuilder(bufferSize), locale); return f.format(format, args).toString(); } /* * An implementation of a String.indexOf that is supposed to perform * substantially better than the default algorithm if the "needle" (the * subString being searched for) is a constant string. * * For example, a JIT, upon encountering a call to String.indexOf(String), * where the needle is a constant string, may compute the values cache, md2 * and lastChar, and change the call to the following method. */ @FindBugsSuppressWarnings("UPM_UNCALLED_PRIVATE_METHOD") @SuppressWarnings("unused") private static int indexOf(String haystackString, String needleString, int cache, int md2, char lastChar) { char[] haystack = haystackString.value; int haystackOffset = haystackString.offset; int haystackLength = haystackString.count; char[] needle = needleString.value; int needleOffset = needleString.offset; int needleLength = needleString.count; int needleLengthMinus1 = needleLength - 1; int haystackEnd = haystackOffset + haystackLength; outer_loop: for (int i = haystackOffset + needleLengthMinus1; i < haystackEnd;) { if (lastChar == haystack[i]) { for (int j = 0; j < needleLengthMinus1; ++j) { if (needle[j + needleOffset] != haystack[i + j - needleLengthMinus1]) { int skip = 1; if ((cache & (1 << haystack[i])) == 0) { skip += j; } i += Math.max(md2, skip); continue outer_loop; } } return i - needleLengthMinus1 - haystackOffset; } if ((cache & (1 << haystack[i])) == 0) { i += needleLengthMinus1; } i++; } return -1; } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy