Quelle String.java Sprache: JAVA

/*
* Copyright (c) 1994, 2022, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/

package java.lang;

import java.io.ObjectStreamField;
import java.io.UnsupportedEncodingException;
import java.lang.annotation.Native;
import java.lang.invoke.MethodHandles;
import java.lang.constant.Constable;
import java.lang.constant.ConstantDesc;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Formatter;
import java.util.List;
import java.util.Locale;
import java.util.Objects;
import java.util.Optional;
import java.util.Spliterator;
import java.util.function.Function;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

import jdk.internal.util.Preconditions;
import jdk.internal.vm.annotation.ForceInline;
import jdk.internal.vm.annotation.IntrinsicCandidate;
import jdk.internal.vm.annotation.Stable;
import sun.nio.cs.ArrayDecoder;
import sun.nio.cs.ArrayEncoder;

import sun.nio.cs.ISO_8859_1;
import sun.nio.cs.US_ASCII;
import sun.nio.cs.UTF_8;

/**
* The {@code String} class represents character strings. All
* string literals in Java programs, such as {@code "abc"}, are
* implemented as instances of this class.
* 
* Strings are constant; their values cannot be changed after they
* are created. String buffers support mutable strings.
* Because String objects are immutable they can be shared. For example:
* <blockquote><pre>
* String str = "abc";
* </pre></blockquote>
* is equivalent to:
* <blockquote><pre>
* char data[] = {'a', 'b', 'c'};
* String str = new String(data);
* </pre></blockquote>
* Here are some more examples of how strings can be used:
* <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>
* 
* The class {@code String} includes methods for examining
* individual characters of the sequence, for comparing strings, for
* searching strings, for extracting substrings, and for creating a
* copy of a string with all characters translated to uppercase or to
* lowercase. Case mapping is based on the Unicode Standard version
* specified by the {@link java.lang.Character Character} class.
* 
* The Java language provides special support for the string
* concatenation operator ( + ), and for conversion of
* other objects to strings. For additional information on string
* concatenation and conversion, see The Java Language Specification.
*
* Unless otherwise noted, passing a {@code null} argument to a constructor
* or method in this class will cause a {@link NullPointerException} to be
* thrown.
*
* A {@code String} represents a string in the UTF-16 format
* in which supplementary characters are represented by surrogate
* pairs (see the section <a href="Character.html#unicode">Unicode
* Character Representations</a> in the {@code Character} class for
* more information).
* Index values refer to {@code char} code units, so a supplementary
* character uses two positions in a {@code String}.
* The {@code String} class provides methods for dealing with
* Unicode code points (i.e., characters), in addition to those for
* dealing with Unicode code units (i.e., {@code char} values).
*
* Unless otherwise noted, methods for comparing Strings do not take locale
* into account. The {@link java.text.Collator} class provides methods for
* finer-grain, locale-sensitive String comparison.
*
* @implNote The implementation of the string concatenation operator is left to
* the discretion of a Java compiler, as long as the compiler ultimately conforms
* to The Java Language Specification. For example, the {@code javac} compiler
* may implement the operator with {@code StringBuffer}, {@code StringBuilder},
* or {@code java.lang.invoke.StringConcatFactory} depending on the JDK version. The
* implementation of string conversion is typically through the method {@code toString},
* defined by {@code Object} and inherited by all classes in Java.
*
* @author Lee Boynton
* @author Arthur van Hoff
* @author Martin Buchholz
* @author Ulf Zibis
* @see java.lang.Object#toString()
* @see java.lang.StringBuffer
* @see java.lang.StringBuilder
* @see java.nio.charset.Charset
* @since 1.0
* @jls 15.18.1 String Concatenation Operator +
*/

public final class String
 implements java.io.Serializable, Comparable<String>, CharSequence,
 Constable, ConstantDesc {

 /**
 * The value is used for character storage.
 *
 * @implNote This field is trusted by the VM, and is a subject to
 * constant folding if String instance is constant. Overwriting this
 * field after construction will cause problems.
 *
 * Additionally, it is marked with {@link Stable} to trust the contents
 * of the array. No other facility in JDK provides this functionality (yet).
 * {@link Stable} is safe here, because value is never null.
 */
 @Stable
 private final byte[] value;

 /**
 * The identifier of the encoding used to encode the bytes in
 * {@code value}. The supported values in this implementation are
 *
 * LATIN1
 * UTF16
 *
 * @implNote This field is trusted by the VM, and is a subject to
 * constant folding if String instance is constant. Overwriting this
 * field after construction will cause problems.
 */
 private final byte coder;

 /** Cache the hash code for the string */
 private int hash; // Default to 0

 /**
 * Cache if the hash has been calculated as actually being zero, enabling
 * us to avoid recalculating this.
 */
 private boolean hashIsZero; // Default to false;

 /** use serialVersionUID from JDK 1.0.2 for interoperability */
 @java.io.Serial
 private static final long serialVersionUID = -6849794470754667710L;

 /**
 * If String compaction is disabled, the bytes in {@code value} are
 * always encoded in UTF16.
 *
 * For methods with several possible implementation paths, when String
 * compaction is disabled, only one code path is taken.
 *
 * The instance field value is generally opaque to optimizing JIT
 * compilers. Therefore, in performance-sensitive place, an explicit
 * check of the static boolean {@code COMPACT_STRINGS} is done first
 * before checking the {@code coder} field since the static boolean
 * {@code COMPACT_STRINGS} would be constant folded away by an
 * optimizing JIT compiler. The idioms for these cases are as follows.
 *
 * For code such as:
 *
 * if (coder == LATIN1) { ... }
 *
 * can be written more optimally as
 *
 * if (coder() == LATIN1) { ... }
 *
 * or:
 *
 * if (COMPACT_STRINGS && coder == LATIN1) { ... }
 *
 * An optimizing JIT compiler can fold the above conditional as:
 *
 * COMPACT_STRINGS == true => if (coder == LATIN1) { ... }
 * COMPACT_STRINGS == false => if (false) { ... }
 *
 * @implNote
 * The actual value for this field is injected by JVM. The static
 * initialization block is used to set the value here to communicate
 * that this static final field is not statically foldable, and to
 * avoid any possible circular dependency during vm initialization.
 */
 static final boolean COMPACT_STRINGS;

 static {
 COMPACT_STRINGS = true;
 }

 /**
 * Class String is special cased within the Serialization Stream Protocol.
 *
 * A String instance is written into an ObjectOutputStream according to
 * <a href="{@docRoot}/../specs/serialization/protocol.html#stream-elements">
 * <cite>Java Object Serialization Specification</cite>, Section 6.2, "Stream Elements"</a>
 */
 @java.io.Serial
 private static final ObjectStreamField[] serialPersistentFields =
 new ObjectStreamField[0];

 /**
 * Initializes a newly created {@code String} object so that it represents
 * an empty character sequence. Note that use of this constructor is
 * unnecessary since Strings are immutable.
 */
 public String() {
 this.value = "".value;
 this.coder = "".coder;
 }

 /**
 * Initializes a newly created {@code String} object so that it represents
 * the same sequence of characters as the argument; in other words, the
 * newly created string is a copy of the argument string. Unless an
 * explicit copy of {@code original} is needed, use of this constructor is
 * unnecessary since Strings are immutable.
 *
 * @param original
 * A {@code String}
 */
 @IntrinsicCandidate
 public String(String original) {
 this.value = original.value;
 this.coder = original.coder;
 this.hash = original.hash;
 this.hashIsZero = original.hashIsZero;
 }

 /**
 * Allocates a new {@code String} so that it represents the sequence of
 * characters currently contained in the character array argument. The
 * contents of the character array are copied; subsequent modification of
 * the character array does not affect the newly created string.
 *
 * @param value
 * The initial value of the string
 */
 public String(char[] value) {
 this(value, 0, value.length, null);
 }

 /**
 * Allocates a new {@code String} that contains characters from a subarray
 * of the character array argument. The {@code offset} argument is the
 * index of the first character of the subarray and the {@code count}
 * argument specifies the length of the subarray. The contents of the
 * subarray are copied; subsequent modification of the character array does
 * not affect the newly created string.
 *
 * @param value
 * Array that is the source of characters
 *
 * @param offset
 * The initial offset
 *
 * @param count
 * The length
 *
 * @throws IndexOutOfBoundsException
 * If {@code offset} is negative, {@code count} is negative, or
 * {@code offset} is greater than {@code value.length - count}
 */
 public String(char[] value, int offset, int count) {
 this(value, offset, count, rangeCheck(value, offset, count));
 }

 private static Void rangeCheck(char[] value, int offset, int count) {
 checkBoundsOffCount(offset, count, value.length);
 return null;
 }

 /**
 * Allocates a new {@code String} that contains characters from a subarray
 * of the <a href="Character.html#unicode">Unicode code point</a> array
 * argument. The {@code offset} argument is the index of the first code
 * point of the subarray and the {@code count} argument specifies the
 * length of the subarray. The contents of the subarray are converted to
 * {@code char}s; subsequent modification of the {@code int} array does not
 * affect the newly created string.
 *
 * @param codePoints
 * Array that is the source of Unicode code points
 *
 * @param offset
 * The initial offset
 *
 * @param count
 * The length
 *
 * @throws IllegalArgumentException
 * If any invalid Unicode code point is found in {@code
 * codePoints}
 *
 * @throws IndexOutOfBoundsException
 * If {@code offset} is negative, {@code count} is negative, or
 * {@code offset} is greater than {@code codePoints.length - count}
 *
 * @since 1.5
 */
 public String(int[] codePoints, int offset, int count) {
 checkBoundsOffCount(offset, count, codePoints.length);
 if (count == 0) {
 this.value = "".value;
 this.coder = "".coder;
 return;
 }
 if (COMPACT_STRINGS) {
 byte[] val = StringLatin1.toBytes(codePoints, offset, count);
 if (val != null) {
 this.coder = LATIN1;
 this.value = val;
 return;
 }
 }
 this.coder = UTF16;
 this.value = StringUTF16.toBytes(codePoints, offset, count);
 }

 /**
 * Allocates a new {@code String} constructed from a subarray of an array
 * of 8-bit integer values.
 *
 * The {@code offset} argument is the index of the first byte of the
 * subarray, and the {@code count} argument specifies the length of the
 * subarray.
 *
 * Each {@code byte} in the subarray is converted to a {@code char} as
 * specified in the {@link #String(byte[],int) String(byte[],int)} constructor.
 *
 * @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} constructors that take a {@link Charset}, charset name,
 * or that use the {@link Charset#defaultCharset() default charset}.
 *
 * @param ascii
 * The bytes to be converted to characters
 *
 * @param hibyte
 * The top 8 bits of each 16-bit Unicode code unit
 *
 * @param offset
 * The initial offset
 * @param count
 * The length
 *
 * @throws IndexOutOfBoundsException
 * If {@code offset} is negative, {@code count} is negative, or
 * {@code offset} is greater than {@code ascii.length - count}
 *
 * @see #String(byte[], int)
 * @see #String(byte[], int, int, java.lang.String)
 * @see #String(byte[], int, int, java.nio.charset.Charset)
 * @see #String(byte[], int, int)
 * @see #String(byte[], java.lang.String)
 * @see #String(byte[], java.nio.charset.Charset)
 * @see #String(byte[])
 */
 @Deprecated(since="1.1")
 public String(byte[] ascii, int hibyte, int offset, int count) {
 checkBoundsOffCount(offset, count, ascii.length);
 if (count == 0) {
 this.value = "".value;
 this.coder = "".coder;
 return;
 }
 if (COMPACT_STRINGS && (byte)hibyte == 0) {
 this.value = Arrays.copyOfRange(ascii, offset, offset + count);
 this.coder = LATIN1;
 } else {
 hibyte <<= 8;
 byte[] val = StringUTF16.newBytesFor(count);
 for (int i = 0; i < count; i++) {
 StringUTF16.putChar(val, i, hibyte | (ascii[offset++] & 0xff));
 }
 this.value = val;
 this.coder = UTF16;
 }
 }

 /**
 * Allocates a new {@code String} containing characters constructed from
 * an array of 8-bit integer values. Each character c in the
 * resulting string is constructed from the corresponding component
 * b in the byte array such that:
 *
 * <blockquote><pre>
 * c == (char)(((hibyte & 0xff) << 8)
 * | (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} constructors that take a {@link Charset}, charset name,
 * or that use the {@link Charset#defaultCharset() default charset}.
 *
 * @param ascii
 * The bytes to be converted to characters
 *
 * @param hibyte
 * The top 8 bits of each 16-bit Unicode code unit
 *
 * @see #String(byte[], int, int, java.lang.String)
 * @see #String(byte[], int, int, java.nio.charset.Charset)
 * @see #String(byte[], int, int)
 * @see #String(byte[], java.lang.String)
 * @see #String(byte[], java.nio.charset.Charset)
 * @see #String(byte[])
 */
 @Deprecated(since="1.1")
 public String(byte[] ascii, int hibyte) {
 this(ascii, hibyte, 0, ascii.length);
 }

 /**
 * Constructs a new {@code String} by decoding the specified subarray of
 * bytes using the specified charset. The length of the new {@code String}
 * is a function of the charset, and hence may not be equal to the length
 * of the subarray.
 *
 * The behavior of this constructor when the given bytes are not valid
 * in the given charset is unspecified. The {@link
 * java.nio.charset.CharsetDecoder} class should be used when more control
 * over the decoding process is required.
 *
 * @param bytes
 * The bytes to be decoded into characters
 *
 * @param offset
 * The index of the first byte to decode
 *
 * @param length
 * The number of bytes to decode
 *
 * @param charsetName
 * The name of a supported {@linkplain java.nio.charset.Charset
 * charset}
 *
 * @throws UnsupportedEncodingException
 * If the named charset is not supported
 *
 * @throws IndexOutOfBoundsException
 * If {@code offset} is negative, {@code length} is negative, or
 * {@code offset} is greater than {@code bytes.length - length}
 *
 * @since 1.1
 */
 public String(byte[] bytes, int offset, int length, String charsetName)
 throws UnsupportedEncodingException {
 this(lookupCharset(charsetName), bytes, checkBoundsOffCount(offset, length, bytes.length), length);
 }

 /**
 * Constructs a new {@code String} by decoding the specified subarray of
 * bytes using the specified {@linkplain java.nio.charset.Charset charset}.
 * The length of the new {@code String} is a function of the charset, and
 * hence may not be equal to the length of the subarray.
 *
 * This method always replaces malformed-input and unmappable-character
 * sequences with this charset's default replacement string. The {@link
 * java.nio.charset.CharsetDecoder} class should be used when more control
 * over the decoding process is required.
 *
 * @param bytes
 * The bytes to be decoded into characters
 *
 * @param offset
 * The index of the first byte to decode
 *
 * @param length
 * The number of bytes to decode
 *
 * @param charset
 * The {@linkplain java.nio.charset.Charset charset} to be used to
 * decode the {@code bytes}
 *
 * @throws IndexOutOfBoundsException
 * If {@code offset} is negative, {@code length} is negative, or
 * {@code offset} is greater than {@code bytes.length - length}
 *
 * @since 1.6
 */
 public String(byte[] bytes, int offset, int length, Charset charset) {
 this(Objects.requireNonNull(charset), bytes, checkBoundsOffCount(offset, length, bytes.length), length);
 }

 /**
 * This method does not do any precondition checks on its arguments.
 * 
 * Important: parameter order of this method is deliberately changed in order to
 * disambiguate it against other similar methods of this class.
 */
 @SuppressWarnings("removal")
 private String(Charset charset, byte[] bytes, int offset, int length) {
 if (length == 0) {
 this.value = "".value;
 this.coder = "".coder;
 } else if (charset == UTF_8.INSTANCE) {
 if (COMPACT_STRINGS) {
 int dp = StringCoding.countPositives(bytes, offset, length);
 if (dp == length) {
 this.value = Arrays.copyOfRange(bytes, offset, offset + length);
 this.coder = LATIN1;
 return;
 }
 int sl = offset + length;
 byte[] dst = new byte[length];
 if (dp > 0) {
 System.arraycopy(bytes, offset, dst, 0, dp);
 offset += dp;
 }
 while (offset < sl) {
 int b1 = bytes[offset++];
 if (b1 >= 0) {
 dst[dp++] = (byte)b1;
 continue;
 }
 if ((b1 & 0xfe) == 0xc2 && offset < sl) { // b1 either 0xc2 or 0xc3
 int b2 = bytes[offset];
 if (b2 < -64) { // continuation bytes are always negative values in the range -128 to -65
 dst[dp++] = (byte)decode2(b1, b2);
 offset++;
 continue;
 }
 }
 // anything not a latin1, including the REPL
 // we have to go with the utf16
 offset--;
 break;
 }
 if (offset == sl) {
 if (dp != dst.length) {
 dst = Arrays.copyOf(dst, dp);
 }
 this.value = dst;
 this.coder = LATIN1;
 return;
 }
 byte[] buf = new byte[length << 1];
 StringLatin1.inflate(dst, 0, buf, 0, dp);
 dst = buf;
 dp = decodeUTF8_UTF16(bytes, offset, sl, dst, dp, true);
 if (dp != length) {
 dst = Arrays.copyOf(dst, dp << 1);
 }
 this.value = dst;
 this.coder = UTF16;
 } else { // !COMPACT_STRINGS
 byte[] dst = new byte[length << 1];
 int dp = decodeUTF8_UTF16(bytes, offset, offset + length, dst, 0, true);
 if (dp != length) {
 dst = Arrays.copyOf(dst, dp << 1);
 }
 this.value = dst;
 this.coder = UTF16;
 }
 } else if (charset == ISO_8859_1.INSTANCE) {
 if (COMPACT_STRINGS) {
 this.value = Arrays.copyOfRange(bytes, offset, offset + length);
 this.coder = LATIN1;
 } else {
 this.value = StringLatin1.inflate(bytes, offset, length);
 this.coder = UTF16;
 }
 } else if (charset == US_ASCII.INSTANCE) {
 if (COMPACT_STRINGS && !StringCoding.hasNegatives(bytes, offset, length)) {
 this.value = Arrays.copyOfRange(bytes, offset, offset + length);
 this.coder = LATIN1;
 } else {
 byte[] dst = new byte[length << 1];
 int dp = 0;
 while (dp < length) {
 int b = bytes[offset++];
 StringUTF16.putChar(dst, dp++, (b >= 0) ? (char) b : REPL);
 }
 this.value = dst;
 this.coder = UTF16;
 }
 } else {
 // (1)We never cache the "external" cs, the only benefit of creating
 // an additional StringDe/Encoder object to wrap it is to share the
 // de/encode() method. These SD/E objects are short-lived, the young-gen
 // gc should be able to take care of them well. But the best approach
 // is still not to generate them if not really necessary.
 // (2)The defensive copy of the input byte/char[] has a big performance
 // impact, as well as the outgoing result byte/char[]. Need to do the
 // optimization check of (sm==null && classLoader0==null) for both.
 CharsetDecoder cd = charset.newDecoder();
 // ArrayDecoder fastpaths
 if (cd instanceof ArrayDecoder ad) {
 // ascii
 if (ad.isASCIICompatible() && !StringCoding.hasNegatives(bytes, offset, length)) {
 if (COMPACT_STRINGS) {
 this.value = Arrays.copyOfRange(bytes, offset, offset + length);
 this.coder = LATIN1;
 return;
 }
 this.value = StringLatin1.inflate(bytes, offset, length);
 this.coder = UTF16;
 return;
 }

 // fastpath for always Latin1 decodable single byte
 if (COMPACT_STRINGS && ad.isLatin1Decodable()) {
 byte[] dst = new byte[length];
 ad.decodeToLatin1(bytes, offset, length, dst);
 this.value = dst;
 this.coder = LATIN1;
 return;
 }

 int en = scale(length, cd.maxCharsPerByte());
 cd.onMalformedInput(CodingErrorAction.REPLACE)
 .onUnmappableCharacter(CodingErrorAction.REPLACE);
 char[] ca = new char[en];
 int clen = ad.decode(bytes, offset, length, ca);
 if (COMPACT_STRINGS) {
 byte[] bs = StringUTF16.compress(ca, 0, clen);
 if (bs != null) {
 value = bs;
 coder = LATIN1;
 return;
 }
 }
 coder = UTF16;
 value = StringUTF16.toBytes(ca, 0, clen);
 return;
 }

 // decode using CharsetDecoder
 int en = scale(length, cd.maxCharsPerByte());
 cd.onMalformedInput(CodingErrorAction.REPLACE)
 .onUnmappableCharacter(CodingErrorAction.REPLACE);
 char[] ca = new char[en];
 if (charset.getClass().getClassLoader0() != null &&
 System.getSecurityManager() != null) {
 bytes = Arrays.copyOfRange(bytes, offset, offset + length);
 offset = 0;
 }

 int caLen;
 try {
 caLen = decodeWithDecoder(cd, ca, bytes, offset, length);
 } catch (CharacterCodingException x) {
 // Substitution is enabled, so this shouldn't happen
 throw new Error(x);
 }
 if (COMPACT_STRINGS) {
 byte[] bs = StringUTF16.compress(ca, 0, caLen);
 if (bs != null) {
 value = bs;
 coder = LATIN1;
 return;
 }
 }
 coder = UTF16;
 value = StringUTF16.toBytes(ca, 0, caLen);
 }
 }

 /*
 * Throws iae, instead of replacing, if malformed or unmappable.
 */
 static String newStringUTF8NoRepl(byte[] bytes, int offset, int length) {
 checkBoundsOffCount(offset, length, bytes.length);
 if (length == 0) {
 return "";
 }
 int dp;
 byte[] dst;
 if (COMPACT_STRINGS) {
 dp = StringCoding.countPositives(bytes, offset, length);
 int sl = offset + length;
 if (dp == length) {
 return new String(Arrays.copyOfRange(bytes, offset, offset + length), LATIN1);
 }
 dst = new byte[length];
 System.arraycopy(bytes, offset, dst, 0, dp);
 offset += dp;
 while (offset < sl) {
 int b1 = bytes[offset++];
 if (b1 >= 0) {
 dst[dp++] = (byte)b1;
 continue;
 }
 if ((b1 & 0xfe) == 0xc2 && offset < sl) { // b1 either 0xc2 or 0xc3
 int b2 = bytes[offset];
 if (b2 < -64) { // continuation bytes are always negative values in the range -128 to -65
 dst[dp++] = (byte)decode2(b1, b2);
 offset++;
 continue;
 }
 }
 // anything not a latin1, including the REPL
 // we have to go with the utf16
 offset--;
 break;
 }
 if (offset == sl) {
 if (dp != dst.length) {
 dst = Arrays.copyOf(dst, dp);
 }
 return new String(dst, LATIN1);
 }
 if (dp == 0) {
 dst = new byte[length << 1];
 } else {
 byte[] buf = new byte[length << 1];
 StringLatin1.inflate(dst, 0, buf, 0, dp);
 dst = buf;
 }
 dp = decodeUTF8_UTF16(bytes, offset, sl, dst, dp, false);
 } else { // !COMPACT_STRINGS
 dst = new byte[length << 1];
 dp = decodeUTF8_UTF16(bytes, offset, offset + length, dst, 0, false);
 }
 if (dp != length) {
 dst = Arrays.copyOf(dst, dp << 1);
 }
 return new String(dst, UTF16);
 }

 static String newStringNoRepl(byte[] src, Charset cs) throws CharacterCodingException {
 try {
 return newStringNoRepl1(src, cs);
 } catch (IllegalArgumentException e) {
 //newStringNoRepl1 throws IAE with MalformedInputException or CCE as the cause
 Throwable cause = e.getCause();
 if (cause instanceof MalformedInputException mie) {
 throw mie;
 }
 throw (CharacterCodingException)cause;
 }
 }

 @SuppressWarnings("removal")
 private static String newStringNoRepl1(byte[] src, Charset cs) {
 int len = src.length;
 if (len == 0) {
 return "";
 }
 if (cs == UTF_8.INSTANCE) {
 return newStringUTF8NoRepl(src, 0, src.length);
 }
 if (cs == ISO_8859_1.INSTANCE) {
 if (COMPACT_STRINGS)
 return new String(src, LATIN1);
 return new String(StringLatin1.inflate(src, 0, src.length), UTF16);
 }
 if (cs == US_ASCII.INSTANCE) {
 if (!StringCoding.hasNegatives(src, 0, src.length)) {
 if (COMPACT_STRINGS)
 return new String(src, LATIN1);
 return new String(StringLatin1.inflate(src, 0, src.length), UTF16);
 } else {
 throwMalformed(src);
 }
 }

 CharsetDecoder cd = cs.newDecoder();
 // ascii fastpath
 if (cd instanceof ArrayDecoder ad &&
 ad.isASCIICompatible() &&
 !StringCoding.hasNegatives(src, 0, src.length)) {
 return new String(src, 0, src.length, ISO_8859_1.INSTANCE);
 }
 int en = scale(len, cd.maxCharsPerByte());
 char[] ca = new char[en];
 if (cs.getClass().getClassLoader0() != null &&
 System.getSecurityManager() != null) {
 src = Arrays.copyOf(src, len);
 }
 int caLen;
 try {
 caLen = decodeWithDecoder(cd, ca, src, 0, src.length);
 } catch (CharacterCodingException x) {
 // throw via IAE
 throw new IllegalArgumentException(x);
 }
 if (COMPACT_STRINGS) {
 byte[] bs = StringUTF16.compress(ca, 0, caLen);
 if (bs != null) {
 return new String(bs, LATIN1);
 }
 }
 return new String(StringUTF16.toBytes(ca, 0, caLen), UTF16);
 }

 private static final char REPL = '\ufffd';

 // Trim the given byte array to the given length
 @SuppressWarnings("removal")
 private static byte[] safeTrim(byte[] ba, int len, boolean isTrusted) {
 if (len == ba.length && (isTrusted || System.getSecurityManager() == null)) {
 return ba;
 } else {
 return Arrays.copyOf(ba, len);
 }
 }

 private static int scale(int len, float expansionFactor) {
 // We need to perform double, not float, arithmetic; otherwise
 // we lose low order bits when len is larger than 2**24.
 return (int)(len * (double)expansionFactor);
 }

 private static Charset lookupCharset(String csn) throws UnsupportedEncodingException {
 Objects.requireNonNull(csn);
 try {
 return Charset.forName(csn);
 } catch (UnsupportedCharsetException | IllegalCharsetNameException x) {
 throw new UnsupportedEncodingException(csn);
 }
 }

 private static byte[] encode(Charset cs, byte coder, byte[] val) {
 if (cs == UTF_8.INSTANCE) {
 return encodeUTF8(coder, val, true);
 }
 if (cs == ISO_8859_1.INSTANCE) {
 return encode8859_1(coder, val);
 }
 if (cs == US_ASCII.INSTANCE) {
 return encodeASCII(coder, val);
 }
 return encodeWithEncoder(cs, coder, val, true);
 }

 private static byte[] encodeWithEncoder(Charset cs, byte coder, byte[] val, boolean doReplace) {
 CharsetEncoder ce = cs.newEncoder();
 int len = val.length >> coder; // assume LATIN1=0/UTF16=1;
 int en = scale(len, ce.maxBytesPerChar());
 // fastpath with ArrayEncoder implies `doReplace`.
 if (doReplace && ce instanceof ArrayEncoder ae) {
 // fastpath for ascii compatible
 if (coder == LATIN1 &&
 ae.isASCIICompatible() &&
 !StringCoding.hasNegatives(val, 0, val.length)) {
 return Arrays.copyOf(val, val.length);
 }
 byte[] ba = new byte[en];
 if (len == 0) {
 return ba;
 }

 int blen = (coder == LATIN1) ? ae.encodeFromLatin1(val, 0, len, ba)
 : ae.encodeFromUTF16(val, 0, len, ba);
 if (blen != -1) {
 return safeTrim(ba, blen, true);
 }
 }

 byte[] ba = new byte[en];
 if (len == 0) {
 return ba;
 }
 if (doReplace) {
 ce.onMalformedInput(CodingErrorAction.REPLACE)
 .onUnmappableCharacter(CodingErrorAction.REPLACE);
 }
 char[] ca = (coder == LATIN1 ) ? StringLatin1.toChars(val)
 : StringUTF16.toChars(val);
 ByteBuffer bb = ByteBuffer.wrap(ba);
 CharBuffer cb = CharBuffer.wrap(ca, 0, len);
 try {
 CoderResult cr = ce.encode(cb, bb, true);
 if (!cr.isUnderflow())
 cr.throwException();
 cr = ce.flush(bb);
 if (!cr.isUnderflow())
 cr.throwException();
 } catch (CharacterCodingException x) {
 if (!doReplace) {
 throw new IllegalArgumentException(x);
 } else {
 throw new Error(x);
 }
 }
 return safeTrim(ba, bb.position(), cs.getClass().getClassLoader0() == null);
 }

 /*
 * Throws iae, instead of replacing, if unmappable.
 */
 static byte[] getBytesUTF8NoRepl(String s) {
 return encodeUTF8(s.coder(), s.value(), false);
 }

 private static boolean isASCII(byte[] src) {
 return !StringCoding.hasNegatives(src, 0, src.length);
 }

 /*
 * Throws CCE, instead of replacing, if unmappable.
 */
 static byte[] getBytesNoRepl(String s, Charset cs) throws CharacterCodingException {
 try {
 return getBytesNoRepl1(s, cs);
 } catch (IllegalArgumentException e) {
 //getBytesNoRepl1 throws IAE with UnmappableCharacterException or CCE as the cause
 Throwable cause = e.getCause();
 if (cause instanceof UnmappableCharacterException) {
 throw (UnmappableCharacterException)cause;
 }
 throw (CharacterCodingException)cause;
 }
 }

 private static byte[] getBytesNoRepl1(String s, Charset cs) {
 byte[] val = s.value();
 byte coder = s.coder();
 if (cs == UTF_8.INSTANCE) {
 if (coder == LATIN1 && isASCII(val)) {
 return val;
 }
 return encodeUTF8(coder, val, false);
 }
 if (cs == ISO_8859_1.INSTANCE) {
 if (coder == LATIN1) {
 return val;
 }
 return encode8859_1(coder, val, false);
 }
 if (cs == US_ASCII.INSTANCE) {
 if (coder == LATIN1) {
 if (isASCII(val)) {
 return val;
 } else {
 throwUnmappable(val);
 }
 }
 }
 return encodeWithEncoder(cs, coder, val, false);
 }

 private static byte[] encodeASCII(byte coder, byte[] val) {
 if (coder == LATIN1) {
 byte[] dst = Arrays.copyOf(val, val.length);
 for (int i = 0; i < dst.length; i++) {
 if (dst[i] < 0) {
 dst[i] = '?';
 }
 }
 return dst;
 }
 int len = val.length >> 1;
 byte[] dst = new byte[len];
 int dp = 0;
 for (int i = 0; i < len; i++) {
 char c = StringUTF16.getChar(val, i);
 if (c < 0x80) {
 dst[dp++] = (byte)c;
 continue;
 }
 if (Character.isHighSurrogate(c) && i + 1 < len &&
 Character.isLowSurrogate(StringUTF16.getChar(val, i + 1))) {
 i++;
 }
 dst[dp++] = '?';
 }
 if (len == dp) {
 return dst;
 }
 return Arrays.copyOf(dst, dp);
 }

 private static byte[] encode8859_1(byte coder, byte[] val) {
 return encode8859_1(coder, val, true);
 }

 private static byte[] encode8859_1(byte coder, byte[] val, boolean doReplace) {
 if (coder == LATIN1) {
 return Arrays.copyOf(val, val.length);
 }
 int len = val.length >> 1;
 byte[] dst = new byte[len];
 int dp = 0;
 int sp = 0;
 int sl = len;
 while (sp < sl) {
 int ret = StringCoding.implEncodeISOArray(val, sp, dst, dp, len);
 sp = sp + ret;
 dp = dp + ret;
 if (ret != len) {
 if (!doReplace) {
 throwUnmappable(sp);
 }
 char c = StringUTF16.getChar(val, sp++);
 if (Character.isHighSurrogate(c) && sp < sl &&
 Character.isLowSurrogate(StringUTF16.getChar(val, sp))) {
 sp++;
 }
 dst[dp++] = '?';
 len = sl - sp;
 }
 }
 if (dp == dst.length) {
 return dst;
 }
 return Arrays.copyOf(dst, dp);
 }

 //////////////////////////////// utf8 ////////////////////////////////////

 /**
 * Decodes ASCII from the source byte array into the destination
 * char array. Used via JavaLangAccess from UTF_8 and other charset
 * decoders.
 *
 * @return the number of bytes successfully decoded, at most len
 */
 /* package-private */
 static int decodeASCII(byte[] sa, int sp, char[] da, int dp, int len) {
 int count = StringCoding.countPositives(sa, sp, len);
 while (count < len) {
 if (sa[sp + count] < 0) {
 break;
 }
 count++;
 }
 StringLatin1.inflate(sa, sp, da, dp, count);
 return count;
 }

 private static boolean isNotContinuation(int b) {
 return (b & 0xc0) != 0x80;
 }

 private static boolean isMalformed3(int b1, int b2, int b3) {
 return (b1 == (byte)0xe0 && (b2 & 0xe0) == 0x80) ||
 (b2 & 0xc0) != 0x80 || (b3 & 0xc0) != 0x80;
 }

 private static boolean isMalformed3_2(int b1, int b2) {
 return (b1 == (byte)0xe0 && (b2 & 0xe0) == 0x80) ||
 (b2 & 0xc0) != 0x80;
 }

 private static boolean isMalformed4(int b2, int b3, int b4) {
 return (b2 & 0xc0) != 0x80 || (b3 & 0xc0) != 0x80 ||
 (b4 & 0xc0) != 0x80;
 }

 private static boolean isMalformed4_2(int b1, int b2) {
 return (b1 == 0xf0 && (b2 < 0x90 || b2 > 0xbf)) ||
 (b1 == 0xf4 && (b2 & 0xf0) != 0x80) ||
 (b2 & 0xc0) != 0x80;
 }

 private static boolean isMalformed4_3(int b3) {
 return (b3 & 0xc0) != 0x80;
 }

 private static char decode2(int b1, int b2) {
 return (char)(((b1 << 6) ^ b2) ^
 (((byte) 0xC0 << 6) ^
 ((byte) 0x80 << 0)));
 }

 private static char decode3(int b1, int b2, int b3) {
 return (char)((b1 << 12) ^
 (b2 << 6) ^
 (b3 ^
 (((byte) 0xE0 << 12) ^
 ((byte) 0x80 << 6) ^
 ((byte) 0x80 << 0))));
 }

 private static int decode4(int b1, int b2, int b3, int b4) {
 return ((b1 << 18) ^
 (b2 << 12) ^
 (b3 << 6) ^
 (b4 ^
 (((byte) 0xF0 << 18) ^
 ((byte) 0x80 << 12) ^
 ((byte) 0x80 << 6) ^
 ((byte) 0x80 << 0))));
 }

 private static int decodeUTF8_UTF16(byte[] src, int sp, int sl, byte[] dst, int dp, boolean doReplace) {
 while (sp < sl) {
 int b1 = src[sp++];
 if (b1 >= 0) {
 StringUTF16.putChar(dst, dp++, (char) b1);
 } else if ((b1 >> 5) == -2 && (b1 & 0x1e) != 0) {
 if (sp < sl) {
 int b2 = src[sp++];
 if (isNotContinuation(b2)) {
 if (!doReplace) {
 throwMalformed(sp - 1, 1);
 }
 StringUTF16.putChar(dst, dp++, REPL);
 sp--;
 } else {
 StringUTF16.putChar(dst, dp++, decode2(b1, b2));
 }
 continue;
 }
 if (!doReplace) {
 throwMalformed(sp, 1); // underflow()
 }
 StringUTF16.putChar(dst, dp++, REPL);
 break;
 } else if ((b1 >> 4) == -2) {
 if (sp + 1 < sl) {
 int b2 = src[sp++];
 int b3 = src[sp++];
 if (isMalformed3(b1, b2, b3)) {
 if (!doReplace) {
 throwMalformed(sp - 3, 3);
 }
 StringUTF16.putChar(dst, dp++, REPL);
 sp -= 3;
 sp += malformed3(src, sp);
 } else {
 char c = decode3(b1, b2, b3);
 if (Character.isSurrogate(c)) {
 if (!doReplace) {
 throwMalformed(sp - 3, 3);
 }
 StringUTF16.putChar(dst, dp++, REPL);
 } else {
 StringUTF16.putChar(dst, dp++, c);
 }
 }
 continue;
 }
 if (sp < sl && isMalformed3_2(b1, src[sp])) {
 if (!doReplace) {
 throwMalformed(sp - 1, 2);
 }
 StringUTF16.putChar(dst, dp++, REPL);
 continue;
 }
 if (!doReplace) {
 throwMalformed(sp, 1);
 }
 StringUTF16.putChar(dst, dp++, REPL);
 break;
 } else if ((b1 >> 3) == -2) {
 if (sp + 2 < sl) {
 int b2 = src[sp++];
 int b3 = src[sp++];
 int b4 = src[sp++];
 int uc = decode4(b1, b2, b3, b4);
 if (isMalformed4(b2, b3, b4) ||
 !Character.isSupplementaryCodePoint(uc)) { // shortest form check
 if (!doReplace) {
 throwMalformed(sp - 4, 4);
 }
 StringUTF16.putChar(dst, dp++, REPL);
 sp -= 4;
 sp += malformed4(src, sp);
 } else {
 StringUTF16.putChar(dst, dp++, Character.highSurrogate(uc));
 StringUTF16.putChar(dst, dp++, Character.lowSurrogate(uc));
 }
 continue;
 }
 b1 &= 0xff;
 if (b1 > 0xf4 || sp < sl && isMalformed4_2(b1, src[sp] & 0xff)) {
 if (!doReplace) {
 throwMalformed(sp - 1, 1); // or 2
 }
 StringUTF16.putChar(dst, dp++, REPL);
 continue;
 }
 if (!doReplace) {
 throwMalformed(sp - 1, 1);
 }
 sp++;
 StringUTF16.putChar(dst, dp++, REPL);
 if (sp < sl && isMalformed4_3(src[sp])) {
 continue;
 }
 break;
 } else {
 if (!doReplace) {
 throwMalformed(sp - 1, 1);
 }
 StringUTF16.putChar(dst, dp++, REPL);
 }
 }
 return dp;
 }

 private static int decodeWithDecoder(CharsetDecoder cd, char[] dst, byte[] src, int offset, int length)
 throws CharacterCodingException {
 ByteBuffer bb = ByteBuffer.wrap(src, offset, length);
 CharBuffer cb = CharBuffer.wrap(dst, 0, dst.length);
 CoderResult cr = cd.decode(bb, cb, true);
 if (!cr.isUnderflow())
 cr.throwException();
 cr = cd.flush(cb);
 if (!cr.isUnderflow())
 cr.throwException();
 return cb.position();
 }

 private static int malformed3(byte[] src, int sp) {
 int b1 = src[sp++];
 int b2 = src[sp]; // no need to lookup b3
 return ((b1 == (byte)0xe0 && (b2 & 0xe0) == 0x80) ||
 isNotContinuation(b2)) ? 1 : 2;
 }

 private static int malformed4(byte[] src, int sp) {
 // we don't care the speed here
 int b1 = src[sp++] & 0xff;
 int b2 = src[sp++] & 0xff;
 if (b1 > 0xf4 ||
 (b1 == 0xf0 && (b2 < 0x90 || b2 > 0xbf)) ||
 (b1 == 0xf4 && (b2 & 0xf0) != 0x80) ||
 isNotContinuation(b2))
 return 1;
 if (isNotContinuation(src[sp]))
 return 2;
 return 3;
 }

 private static void throwMalformed(int off, int nb) {
 String msg = "malformed input off : " + off + ", length : " + nb;
 throw new IllegalArgumentException(msg, new MalformedInputException(nb));
 }

 private static void throwMalformed(byte[] val) {
 int dp = 0;
 while (dp < val.length && val[dp] >=0) { dp++; }
 throwMalformed(dp, 1);
 }

 private static void throwUnmappable(int off) {
 String msg = "malformed input off : " + off + ", length : 1";
 throw new IllegalArgumentException(msg, new UnmappableCharacterException(1));
 }

 private static void throwUnmappable(byte[] val) {
 int dp = 0;
 while (dp < val.length && val[dp] >=0) { dp++; }
 throwUnmappable(dp);
 }

 private static byte[] encodeUTF8(byte coder, byte[] val, boolean doReplace) {
 if (coder == UTF16)
 return encodeUTF8_UTF16(val, doReplace);

 if (!StringCoding.hasNegatives(val, 0, val.length))
 return Arrays.copyOf(val, val.length);

 int dp = 0;
 byte[] dst = new byte[val.length << 1];
 for (byte c : val) {
 if (c < 0) {
 dst[dp++] = (byte) (0xc0 | ((c & 0xff) >> 6));
 dst[dp++] = (byte) (0x80 | (c & 0x3f));
 } else {
 dst[dp++] = c;
 }
 }
 if (dp == dst.length)
 return dst;
 return Arrays.copyOf(dst, dp);
 }

 private static byte[] encodeUTF8_UTF16(byte[] val, boolean doReplace) {
 int dp = 0;
 int sp = 0;
 int sl = val.length >> 1;
 byte[] dst = new byte[sl * 3];
 while (sp < sl) {
 // ascii fast loop;
 char c = StringUTF16.getChar(val, sp);
 if (c >= '\u0080') {
 break;
 }
 dst[dp++] = (byte)c;
 sp++;
 }
 while (sp < sl) {
 char c = StringUTF16.getChar(val, sp++);
 if (c < 0x80) {
 dst[dp++] = (byte)c;
 } else if (c < 0x800) {
 dst[dp++] = (byte)(0xc0 | (c >> 6));
 dst[dp++] = (byte)(0x80 | (c & 0x3f));
 } else if (Character.isSurrogate(c)) {
 int uc = -1;
 char c2;
 if (Character.isHighSurrogate(c) && sp < sl &&
 Character.isLowSurrogate(c2 = StringUTF16.getChar(val, sp))) {
 uc = Character.toCodePoint(c, c2);
 }
 if (uc < 0) {
 if (doReplace) {
 dst[dp++] = '?';
 } else {
 throwUnmappable(sp - 1);
 }
 } else {
 dst[dp++] = (byte)(0xf0 | ((uc >> 18)));
 dst[dp++] = (byte)(0x80 | ((uc >> 12) & 0x3f));
 dst[dp++] = (byte)(0x80 | ((uc >> 6) & 0x3f));
 dst[dp++] = (byte)(0x80 | (uc & 0x3f));
 sp++; // 2 chars
 }
 } else {
 // 3 bytes, 16 bits
 dst[dp++] = (byte)(0xe0 | ((c >> 12)));
 dst[dp++] = (byte)(0x80 | ((c >> 6) & 0x3f));
 dst[dp++] = (byte)(0x80 | (c & 0x3f));
 }
 }
 if (dp == dst.length) {
 return dst;
 }
 return Arrays.copyOf(dst, dp);
 }

 /**
 * Constructs a new {@code String} by decoding the specified array of bytes
 * using the specified {@linkplain java.nio.charset.Charset charset}. The
 * length of the new {@code String} is a function of the charset, and hence
 * may not be equal to the length of the byte array.
 *
 * The behavior of this constructor when the given bytes are not valid
 * in the given charset is unspecified. The {@link
 * java.nio.charset.CharsetDecoder} class should be used when more control
 * over the decoding process is required.
 *
 * @param bytes
 * The bytes to be decoded into characters
 *
 * @param charsetName
 * The name of a supported {@linkplain java.nio.charset.Charset
 * charset}
 *
 * @throws UnsupportedEncodingException
 * If the named charset is not supported
 *
 * @since 1.1
 */
 public String(byte[] bytes, String charsetName)
 throws UnsupportedEncodingException {
 this(lookupCharset(charsetName), bytes, 0, bytes.length);
 }

 /**
 * Constructs a new {@code String} by decoding the specified array of
 * bytes using the specified {@linkplain java.nio.charset.Charset charset}.
 * The length of the new {@code String} is a function of the charset, and
 * hence may not be equal to the length of the byte array.
 *
 * This method always replaces malformed-input and unmappable-character
 * sequences with this charset's default replacement string. The {@link
 * java.nio.charset.CharsetDecoder} class should be used when more control
 * over the decoding process is required.
 *
 * @param bytes
 * The bytes to be decoded into characters
 *
 * @param charset
 * The {@linkplain java.nio.charset.Charset charset} to be used to
 * decode the {@code bytes}
 *
 * @since 1.6
 */
 public String(byte[] bytes, Charset charset) {
 this(Objects.requireNonNull(charset), bytes, 0, bytes.length);
 }

 /**
 * Constructs a new {@code String} by decoding the specified subarray of
 * bytes using the {@link Charset#defaultCharset() default charset}.
 * The length of the new {@code String} is a function of the charset,
 * and hence may not be equal to the length of the subarray.
 *
 * The behavior of this constructor when the given bytes are not valid
 * in the default charset is unspecified. The {@link
 * java.nio.charset.CharsetDecoder} class should be used when more control
 * over the decoding process is required.
 *
 * @param bytes
 * The bytes to be decoded into characters
 *
 * @param offset
 * The index of the first byte to decode
 *
 * @param length
 * The number of bytes to decode
 *
 * @throws IndexOutOfBoundsException
 * If {@code offset} is negative, {@code length} is negative, or
 * {@code offset} is greater than {@code bytes.length - length}
 *
 * @since 1.1
 */
 public String(byte[] bytes, int offset, int length) {
 this(Charset.defaultCharset(), bytes, checkBoundsOffCount(offset, length, bytes.length), length);
 }

 /**
 * Constructs a new {@code String} by decoding the specified array of bytes
 * using the {@link Charset#defaultCharset() default charset}. The length
 * of the new {@code String} is a function of the charset, and hence may not
 * be equal to the length of the byte array.
 *
 * The behavior of this constructor when the given bytes are not valid
 * in the default charset is unspecified. The {@link
 * java.nio.charset.CharsetDecoder} class should be used when more control
 * over the decoding process is required.
 *
 * @param bytes
 * The bytes to be decoded into characters
 *
 * @since 1.1
 */
 public String(byte[] bytes) {
 this(Charset.defaultCharset(), bytes, 0, bytes.length);
 }

 /**
 * Allocates a new string that contains the sequence of characters
 * currently contained in the string buffer argument. The contents of the
 * string buffer are copied; subsequent modification of the string buffer
 * does not affect the newly created string.
 *
 * @param buffer
 * A {@code StringBuffer}
 */
 public String(StringBuffer buffer) {
 this(buffer.toString());
 }

 /**
 * Allocates a new string that contains the sequence of characters
 * currently contained in the string builder argument. The contents of the
 * string builder are copied; subsequent modification of the string builder
 * does not affect the newly created string.
 *
 * This constructor is provided to ease migration to {@code
 * StringBuilder}. Obtaining a string from a string builder via the {@code
 * toString} method is likely to run faster and is generally preferred.
 *
 * @param builder
 * A {@code StringBuilder}
 *
 * @since 1.5
 */
 public String(StringBuilder builder) {
 this(builder, null);
 }

 /**
 * Returns the length of this string.
 * The length is equal to the number of <a href="Character.html#unicode">Unicode
 * code units</a> in the string.
 *
 * @return the length of the sequence of characters represented by this
 * object.
 */
 public int length() {
 return value.length >> coder();
 }

 /**
 * Returns {@code true} if, and only if, {@link #length()} is {@code 0}.
 *
 * @return {@code true} if {@link #length()} is {@code 0}, otherwise
 * {@code false}
 *
 * @since 1.6
 */
 @Override
 public boolean isEmpty() {
 return value.length == 0;
 }

 /**
 * Returns the {@code char} value at the
 * specified index. An index ranges from {@code 0} to
 * {@code length() - 1}. The first {@code char} value of the sequence
 * is at index {@code 0}, the next at index {@code 1},
 * and so on, as for array indexing.
 *
 * If the {@code char} value specified by the index is a
 * <a href="Character.html#unicode">surrogate</a>, the surrogate
 * value is returned.
 *
 * @param index the index of the {@code char} value.
 * @return the {@code char} value at the specified index of this string.
 * The first {@code char} value is at index {@code 0}.
 * @throws IndexOutOfBoundsException if the {@code index}
 * argument is negative or not less than the length of this
 * string.
 */
 public char charAt(int index) {
 if (isLatin1()) {
 return StringLatin1.charAt(value, index);
 } else {
 return StringUTF16.charAt(value, index);
 }
 }

 /**
 * Returns the character (Unicode code point) at the specified
 * index. The index refers to {@code char} values
 * (Unicode code units) and ranges from {@code 0} to
 * {@link #length()}{@code - 1}.
 *
 * If the {@code char} value specified at the given index
 * is in the high-surrogate range, the following index is less
 * than the length of this {@code String}, and the
 * {@code char} value at the following index is in the
 * low-surrogate range, then the supplementary code point
 * corresponding to this surrogate pair is returned. Otherwise,
 * the {@code char} value at the given index is returned.
 *
 * @param index the index to the {@code char} values
 * @return the code point value of the character at the
 * {@code index}
 * @throws IndexOutOfBoundsException if the {@code index}
 * argument is negative or not less than the length of this
 * string.
 * @since 1.5
 */
 public int codePointAt(int index) {
 if (isLatin1()) {
 checkIndex(index, value.length);
 return value[index] & 0xff;
 }
 int length = value.length >> 1;
 checkIndex(index, length);
 return StringUTF16.codePointAt(value, index, length);
 }

 /**
 * Returns the character (Unicode code point) before the specified
 * index. The index refers to {@code char} values
 * (Unicode code units) and ranges from {@code 1} to {@link
 * CharSequence#length() length}.
 *
 * If the {@code char} value at {@code (index - 1)}
 * is in the low-surrogate range, {@code (index - 2)} is not
 * negative, and the {@code char} value at {@code (index -
 * 2)} is in the high-surrogate range, then the
 * supplementary code point value of the surrogate pair is
 * returned. If the {@code char} value at {@code index -
 * 1} is an unpaired low-surrogate or a high-surrogate, the
 * surrogate value is returned.
 *
 * @param index the index following the code point that should be returned
 * @return the Unicode code point value before the given index.
 * @throws IndexOutOfBoundsException if the {@code index}
 * argument is less than 1 or greater than the length
 * of this string.
 * @since 1.5
 */
 public int codePointBefore(int index) {
 int i = index - 1;
 checkIndex(i, length());
 if (isLatin1()) {
 return (value[i] & 0xff);
 }
 return StringUTF16.codePointBefore(value, index);
 }

 /**
 * Returns the number of Unicode code points in the specified text
 * range of this {@code String}. The text range begins at the
 * specified {@code beginIndex} and extends to the
 * {@code char} at index {@code endIndex - 1}. Thus the
 * length (in {@code char}s) of the text range is
 * {@code endIndex-beginIndex}. Unpaired surrogates within
 * the text range count as one code point each.
 *
 * @param beginIndex the index to the first {@code char} of
 * the text range.
 * @param endIndex the index after the last {@code char} of
 * the text range.
 * @return the number of Unicode code points in the specified text
 * range
 * @throws IndexOutOfBoundsException if the
 * {@code beginIndex} is negative, or {@code endIndex}
 * is larger than the length of this {@code String}, or
 * {@code beginIndex} is larger than {@code endIndex}.
 * @since 1.5
 */
 public int codePointCount(int beginIndex, int endIndex) {
 Objects.checkFromToIndex(beginIndex, endIndex, length());
 if (isLatin1()) {
 return endIndex - beginIndex;
 }
 return StringUTF16.codePointCount(value, beginIndex, endIndex);
 }

 /**
 * Returns the index within this {@code String} that is
 * offset from the given {@code index} by
 * {@code codePointOffset} code points. Unpaired surrogates
 * within the text range given by {@code index} and
 * {@code codePointOffset} count as one code point each.
 *
 * @param index the index to be offset
 * @param codePointOffset the offset in code points
 * @return the index within this {@code String}
 * @throws IndexOutOfBoundsException if {@code index}
 * is negative or larger than the length of this
 * {@code String}, or if {@code codePointOffset} is positive
 * and the substring starting with {@code index} has fewer
 * than {@code codePointOffset} code points,
 * or if {@code codePointOffset} is negative and the substring
 * before {@code index} has fewer than the absolute value
 * of {@code codePointOffset} code points.
 * @since 1.5
 */
 public int offsetByCodePoints(int index, int codePointOffset) {
 return Character.offsetByCodePoints(this, index, codePointOffset);
 }

 /**
 * Copies characters from this string into the destination character
 * array.
 * 
 * The first character to be copied is at index {@code srcBegin};
 * the last character to be copied is at index {@code srcEnd-1}
 * (thus the total number of characters to be copied is
 * {@code srcEnd-srcBegin}). The characters are copied into the
 * subarray of {@code dst} starting at index {@code dstBegin}
 * and ending at index:
 * <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.
 * @throws IndexOutOfBoundsException If any of the following
 * is true:
 * <ul><li>{@code srcBegin} is negative.
 * <li>{@code srcBegin} is greater than {@code srcEnd}
 * <li>{@code srcEnd} is greater than the length of this
 * string
 * <li>{@code dstBegin} is negative
 * <li>{@code dstBegin+(srcEnd-srcBegin)} is larger than
 * {@code dst.length}</ul>
 */
 public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) {
 checkBoundsBeginEnd(srcBegin, srcEnd, length());
 checkBoundsOffCount(dstBegin, srcEnd - srcBegin, dst.length);
 if (isLatin1()) {
 StringLatin1.getChars(value, srcBegin, srcEnd, dst, dstBegin);
 } else {
 StringUTF16.getChars(value, srcBegin, srcEnd, dst, dstBegin);
 }
 }

 /**
 * Copies characters from this string into the destination byte array. Each
 * byte receives the 8 low-order bits of the corresponding character. The
 * eight high-order bits of each character are not copied and do not
 * participate in the transfer in any way.
 *
 * The first character to be copied is at index {@code srcBegin}; the
--> --------------------

--> maximum size reached

--> --------------------

quality92%

¤ Dauer der Verarbeitung: 0.111 Sekunden (vorverarbeitet) ¤

Versionsinformation zu Columbo

Bemerkung:

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Anfrage:

Dauer der Verarbeitung:

Sekunden

sprechenden Kalenders