Lines Matching refs:length
168 this.value = Arrays.copyOf(value, value.length);
175 * argument specifies the length of the subarray. The contents of the
186 * The length
200 if (offset > value.length - count) {
211 * length of the subarray. The contents of the subarray are converted to
222 * The length
242 if (offset > codePoints.length - count) {
278 * subarray, and the {@code count} argument specifies the length of the
299 * The length
362 this(ascii, hibyte, 0, ascii.length);
366 * and requested offset & length values used by the String(byte[],..)
369 private static void checkBounds(byte[] bytes, int offset, int length) {
370 if (length < 0)
371 throw new StringIndexOutOfBoundsException(length);
374 if (offset > bytes.length - length)
375 throw new StringIndexOutOfBoundsException(offset + length);
380 * bytes using the specified charset. The length of the new {@code String}
381 * is a function of the charset, and hence may not be equal to the length
395 * @param length
406 * If the {@code offset} and {@code length} arguments index
411 public String(byte bytes[], int offset, int length, String charsetName)
415 checkBounds(bytes, offset, length);
416 this.value = StringCoding.decode(charsetName, bytes, offset, length);
422 * The length of the new {@code String} is a function of the charset, and
423 * hence may not be equal to the length of the subarray.
436 * @param length
444 * If the {@code offset} and {@code length} arguments index
449 public String(byte bytes[], int offset, int length, Charset charset) {
452 checkBounds(bytes, offset, length);
453 this.value = StringCoding.decode(charset, bytes, offset, length);
459 * length of the new {@code String} is a function of the charset, and hence
460 * may not be equal to the length of the byte array.
481 this(bytes, 0, bytes.length, charsetName);
487 * The length of the new {@code String} is a function of the charset, and
488 * hence may not be equal to the length of the byte array.
505 this(bytes, 0, bytes.length, charset);
510 * bytes using the platform's default charset. The length of the new
512 * to the length of the subarray.
525 * @param length
529 * If the {@code offset} and the {@code length} arguments index
534 public String(byte bytes[], int offset, int length) {
535 checkBounds(bytes, offset, length);
536 this.value = StringCoding.decode(bytes, offset, length);
541 * using the platform's default charset. The length of the new {@code
543 * length of the byte array.
556 this(bytes, 0, bytes.length);
570 this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
590 this.value = Arrays.copyOf(builder.getValue(), builder.length());
615 * Returns the length of this string.
616 * The length is equal to the number of <a href="Character.html#unicode">Unicode
619 * @return the length of the sequence of characters represented by this
622 public int length() {
623 return value.length;
627 * Returns <tt>true</tt> if, and only if, {@link #length()} is <tt>0</tt>.
629 * @return <tt>true</tt> if {@link #length()} is <tt>0</tt>, otherwise
635 return value.length == 0;
641 * <code>length() - 1</code>. The first <code>char</code> value of the sequence
653 * argument is negative or not less than the length of this
657 if ((index < 0) || (index >= value.length)) {
667 * {@link #length()}<code> - 1</code>.
671 * than the length of this <code>String</code>, and the
681 * argument is negative or not less than the length of this
686 if ((index < 0) || (index >= value.length)) {
689 return Character.codePointAtImpl(value, index, value.length);
696 * CharSequence#length() length}.
710 * argument is less than 1 or greater than the length
716 if ((i < 0) || (i >= value.length)) {
727 * length (in <code>char</code>s) of the text range is
739 * is larger than the length of this <code>String</code>, or
744 if (beginIndex < 0 || endIndex > value.length || beginIndex > endIndex) {
761 * is negative or larger then the length of this
771 if (index < 0 || index > value.length) {
774 return Character.offsetByCodePointsImpl(value, 0, value.length,
783 System.arraycopy(value, 0, dst, dstBegin, value.length);
810 * <li><code>srcEnd</code> is greater than the length of this
814 * <code>dst.length</code></ul>
820 if (srcEnd > value.length) {
866 * <li> {@code srcEnd} is greater than the length of this String
869 * dst.length}
877 if (srcEnd > value.length) {
916 return StringCoding.encode(charsetName, value, 0, value.length);
939 return StringCoding.encode(charset, value, 0, value.length);
956 return StringCoding.encode(value, 0, value.length);
980 int n = value.length;
981 if (n == anotherString.value.length) {
1031 if (value.length != cs.length())
1038 int n = value.length;
1052 int n = value.length;
1064 * are of the same length and corresponding characters in the two strings
1092 && (anotherString.value.length == value.length)
1093 && regionMatches(true, 0, anotherString, 0, value.length);
1127 * this.length()-anotherString.length()
1138 int len1 = value.length;
1139 int len2 = anotherString.value.length;
1176 int n1 = s1.length();
1177 int n2 = s2.length();
1230 * and has length <tt>len</tt>. The substring of other to be compared
1231 * begins at index <tt>ooffset</tt> and has length <tt>len</tt>. The
1236 * <li><tt>toffset+len</tt> is greater than the length of this
1238 * <li><tt>ooffset+len</tt> is greater than the length of the other
1262 || (toffset > (long)value.length - len)
1263 || (ooffset > (long)other.value.length - len)) {
1282 * <tt>toffset</tt> and has length <tt>len</tt>. The substring of
1284 * has length <tt>len</tt>. The result is <tt>false</tt> if and only if
1288 * <li><tt>toffset+len</tt> is greater than the length of this
1290 * <li><tt>ooffset+len</tt> is greater than the length of the other
1332 || (toffset > (long)value.length - len)
1333 || (ooffset > (long)other.value.length - len)) {
1375 * negative or greater than the length of this
1387 int pc = prefix.value.length;
1389 if ((toffset < 0) || (toffset > value.length - pc)) {
1429 return startsWith(suffix, value.length - suffix.value.length);
1439 * <i>i</i>th character of the string, <code>n</code> is the length of
1447 if (h == 0 && value.length > 0) {
1450 for (int i = 0; i < value.length; i++) {
1511 * string may be searched. If it is greater than the length of this
1512 * string, it has the same effect as if it were equal to the length of
1526 final int max = value.length;
1557 final int max = value.length - 1;
1591 return lastIndexOf(ch, value.length - 1);
1618 * greater than or equal to the length of this string, it has
1620 * length of this string: this entire string may be searched.
1633 int i = Math.min(fromIndex, value.length - 1);
1653 int i = Math.min(fromIndex, value.length - 2);
1698 return indexOf(value, 0, value.length,
1699 str.value, 0, str.value.length, fromIndex);
1756 * is considered to occur at the index value {@code this.length()}.
1769 return lastIndexOf(str, value.length);
1789 return lastIndexOf(value, 0, value.length,
1790 str.value, 0, str.value.length, fromIndex);
1867 * length of this <code>String</code> object.
1873 int subLen = value.length - beginIndex;
1884 * Thus the length of the substring is <code>endIndex-beginIndex</code>.
1897 * <code>endIndex</code> is larger than the length of
1906 if (endIndex > value.length) {
1913 return ((beginIndex == 0) && (endIndex == value.length)) ? this
1939 * if <tt>endIndex</tt> is greater than <tt>length()</tt>,
1952 * If the length of the argument string is <code>0</code>, then this
1970 int otherLen = str.length();
1974 int len = value.length;
2011 int len = value.length;
2196 * pattern is applied and therefore affects the length of the resulting
2199 * length will be no greater than <i>n</i>, and the array's last entry
2202 * possible and the array can have any length. If <i>n</i> is zero then
2204 * have any length, and trailing empty strings will be discarded.
2272 if (((regex.value.length == 1 &&
2274 (regex.length() == 2 &&
2292 list.add(substring(off, value.length));
2293 off = value.length;
2303 list.add(substring(off, value.length));
2308 while (resultSize > 0 && list.get(resultSize - 1).length() == 0)
2363 * <code>String</code> may be a different length than the original <code>String</code>.
2416 final int len = value.length;
2487 int mapLen = lowerCharArray.length;
2489 char[] result2 = new char[result.length + mapLen - srcCount];
2532 * <code>String</code> may be a different length than the original <code>String</code>.
2581 final int len = value.length;
2650 int mapLen = upperCharArray.length;
2652 char[] result2 = new char[result.length + mapLen - srcCount];
2722 int len = value.length;
2732 return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
2747 * @return a newly allocated character array whose length is the length
2753 char result[] = new char[value.length];
2754 System.arraycopy(value, 0, result, 0, value.length);
2877 * specifies the length of the subarray. The contents of the subarray
2884 * @param count the length of the value of the <code>String</code>.
2890 * <code>data.length</code>.
2902 * @param count length of the subarray.
2940 * @return a string of length <code>1</code> containing
3066 h1 ^= SEED_MATERIAL.length * 4;
3092 h = sun.misc.Hashing.murmur3_32(HASHING_SEED, value, 0, value.length);