1 /* 2 * Copyright 1994-2006 Sun Microsystems, Inc. All Rights Reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Sun designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Sun in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, 22 * CA 95054 USA or visit www.sun.com if you need additional information or 23 * have any questions. 24 */ 25 26 package java.lang; 27 28 import java.io.ObjectStreamClass; 29 import java.io.ObjectStreamField; 30 import java.io.UnsupportedEncodingException; 31 import java.nio.charset.Charset; 32 import java.util.ArrayList; 33 import java.util.Arrays; 34 import java.util.Comparator; 35 import java.util.Formatter; 36 import java.util.Locale; 37 import java.util.regex.Matcher; 38 import java.util.regex.Pattern; 39 import java.util.regex.PatternSyntaxException; 40 41 42 /** 43 * The <code>String</code> class represents character strings. All 44 * string literals in Java programs, such as <code>"abc"</code>, are 45 * implemented as instances of this class. 46 * <p> 47 * Strings are constant; their values cannot be changed after they 48 * are created. String buffers support mutable strings. 49 * Because String objects are immutable they can be shared. For example: 50 * <p><blockquote><pre> 51 * String str = "abc"; 52 * </pre></blockquote><p> 53 * is equivalent to: 54 * <p><blockquote><pre> 55 * char data[] = {'a', 'b', 'c'}; 56 * String str = new String(data); 57 * </pre></blockquote><p> 58 * Here are some more examples of how strings can be used: 59 * <p><blockquote><pre> 60 * System.out.println("abc"); 61 * String cde = "cde"; 62 * System.out.println("abc" + cde); 63 * String c = "abc".substring(2,3); 64 * String d = cde.substring(1, 2); 65 * </pre></blockquote> 66 * <p> 67 * The class <code>String</code> includes methods for examining 68 * individual characters of the sequence, for comparing strings, for 69 * searching strings, for extracting substrings, and for creating a 70 * copy of a string with all characters translated to uppercase or to 71 * lowercase. Case mapping is based on the Unicode Standard version 72 * specified by the {@link java.lang.Character Character} class. 73 * <p> 74 * The Java language provides special support for the string 75 * concatenation operator ( + ), and for conversion of 76 * other objects to strings. String concatenation is implemented 77 * through the <code>StringBuilder</code>(or <code>StringBuffer</code>) 78 * class and its <code>append</code> method. 79 * String conversions are implemented through the method 80 * <code>toString</code>, defined by <code>Object</code> and 81 * inherited by all classes in Java. For additional information on 82 * string concatenation and conversion, see Gosling, Joy, and Steele, 83 * <i>The Java Language Specification</i>. 84 * 85 * <p> Unless otherwise noted, passing a <tt>null</tt> argument to a constructor 86 * or method in this class will cause a {@link NullPointerException} to be 87 * thrown. 88 * 89 * <p>A <code>String</code> represents a string in the UTF-16 format 90 * in which <em>supplementary characters</em> are represented by <em>surrogate 91 * pairs</em> (see the section <a href="Character.html#unicode">Unicode 92 * Character Representations</a> in the <code>Character</code> class for 93 * more information). 94 * Index values refer to <code>char</code> code units, so a supplementary 95 * character uses two positions in a <code>String</code>. 96 * <p>The <code>String</code> class provides methods for dealing with 97 * Unicode code points (i.e., characters), in addition to those for 98 * dealing with Unicode code units (i.e., <code>char</code> values). 99 * 100 * @author Lee Boynton 101 * @author Arthur van Hoff 102 * @see java.lang.Object#toString() 103 * @see java.lang.StringBuffer 104 * @see java.lang.StringBuilder 105 * @see java.nio.charset.Charset 106 * @since JDK1.0 107 */ 108 109 public final class String 110 implements java.io.Serializable, Comparable<String>, CharSequence 111 { 112 /** The value is used for character storage. */ 113 private final char value[]; 114 115 /** The offset is the first index of the storage that is used. */ 116 private final int offset; 117 118 /** The count is the number of characters in the String. */ 119 private final int count; 120 121 /** Cache the hash code for the string */ 122 private int hash; // Default to 0 123 124 /** use serialVersionUID from JDK 1.0.2 for interoperability */ 125 private static final long serialVersionUID = -6849794470754667710L; 126 127 /** 128 * Class String is special cased within the Serialization Stream Protocol. 129 * 130 * A String instance is written initially into an ObjectOutputStream in the 131 * following format: 132 * <pre> 133 * <code>TC_STRING</code> (utf String) 134 * </pre> 135 * The String is written by method <code>DataOutput.writeUTF</code>. 136 * A new handle is generated to refer to all future references to the 137 * string instance within the stream. 138 */ 139 private static final ObjectStreamField[] serialPersistentFields = 140 new ObjectStreamField[0]; 141 142 /** 143 * Initializes a newly created {@code String} object so that it represents 144 * an empty character sequence. Note that use of this constructor is 145 * unnecessary since Strings are immutable. 146 */ 147 public String() { 148 this.offset = 0; 149 this.count = 0; 150 this.value = new char[0]; 151 } 152 153 /** 154 * Initializes a newly created {@code String} object so that it represents 155 * the same sequence of characters as the argument; in other words, the 156 * newly created string is a copy of the argument string. Unless an 157 * explicit copy of {@code original} is needed, use of this constructor is 158 * unnecessary since Strings are immutable. 159 * 160 * @param original 161 * A {@code String} 162 */ 163 public String(String original) { 164 int size = original.count; 165 char[] originalValue = original.value; 166 char[] v; 167 if (originalValue.length > size) { 168 // The array representing the String is bigger than the new 169 // String itself. Perhaps this constructor is being called 170 // in order to trim the baggage, so make a copy of the array. 171 int off = original.offset; 172 v = Arrays.copyOfRange(originalValue, off, off+size); 173 } else { 174 // The array representing the String is the same 175 // size as the String, so no point in making a copy. 176 v = originalValue; 177 } 178 this.offset = 0; 179 this.count = size; 180 this.value = v; 181 } 182 183 /** 184 * Allocates a new {@code String} so that it represents the sequence of 185 * characters currently contained in the character array argument. The 186 * contents of the character array are copied; subsequent modification of 187 * the character array does not affect the newly created string. 188 * 189 * @param value 190 * The initial value of the string 191 */ 192 public String(char value[]) { 193 int size = value.length; 194 this.offset = 0; 195 this.count = size; 196 this.value = Arrays.copyOf(value, size); 197 } 198 199 /** 200 * Allocates a new {@code String} that contains characters from a subarray 201 * of the character array argument. The {@code offset} argument is the 202 * index of the first character of the subarray and the {@code count} 203 * argument specifies the length of the subarray. The contents of the 204 * subarray are copied; subsequent modification of the character array does 205 * not affect the newly created string. 206 * 207 * @param value 208 * Array that is the source of characters 209 * 210 * @param offset 211 * The initial offset 212 * 213 * @param count 214 * The length 215 * 216 * @throws IndexOutOfBoundsException 217 * If the {@code offset} and {@code count} arguments index 218 * characters outside the bounds of the {@code value} array 219 */ 220 public String(char value[], int offset, int count) { 221 if (offset < 0) { 222 throw new StringIndexOutOfBoundsException(offset); 223 } 224 if (count < 0) { 225 throw new StringIndexOutOfBoundsException(count); 226 } 227 // Note: offset or count might be near -1>>>1. 228 if (offset > value.length - count) { 229 throw new StringIndexOutOfBoundsException(offset + count); 230 } 231 this.offset = 0; 232 this.count = count; 233 this.value = Arrays.copyOfRange(value, offset, offset+count); 234 } 235 236 /** 237 * Allocates a new {@code String} that contains characters from a subarray 238 * of the <a href="Character.html#unicode">Unicode code point</a> array 239 * argument. The {@code offset} argument is the index of the first code 240 * point of the subarray and the {@code count} argument specifies the 241 * length of the subarray. The contents of the subarray are converted to 242 * {@code char}s; subsequent modification of the {@code int} array does not 243 * affect the newly created string. 244 * 245 * @param codePoints 246 * Array that is the source of Unicode code points 247 * 248 * @param offset 249 * The initial offset 250 * 251 * @param count 252 * The length 253 * 254 * @throws IllegalArgumentException 255 * If any invalid Unicode code point is found in {@code 256 * codePoints} 257 * 258 * @throws IndexOutOfBoundsException 259 * If the {@code offset} and {@code count} arguments index 260 * characters outside the bounds of the {@code codePoints} array 261 * 262 * @since 1.5 263 */ 264 public String(int[] codePoints, int offset, int count) { 265 if (offset < 0) { 266 throw new StringIndexOutOfBoundsException(offset); 267 } 268 if (count < 0) { 269 throw new StringIndexOutOfBoundsException(count); 270 } 271 // Note: offset or count might be near -1>>>1. 272 if (offset > codePoints.length - count) { 273 throw new StringIndexOutOfBoundsException(offset + count); 274 } 275 276 // Pass 1: Compute precise size of char[] 277 int n = 0; 278 for (int i = offset; i < offset + count; i++) { 279 int c = codePoints[i]; 280 if (c >= Character.MIN_CODE_POINT && 281 c < Character.MIN_SUPPLEMENTARY_CODE_POINT) 282 n += 1; 283 else if (Character.isSupplementaryCodePoint(c)) 284 n += 2; 285 else throw new IllegalArgumentException(Integer.toString(c)); 286 } 287 288 // Pass 2: Allocate and fill in char[] 289 char[] v = new char[n]; 290 for (int i = offset, j = 0; i < offset + count; i++) { 291 int c = codePoints[i]; 292 if (c < Character.MIN_SUPPLEMENTARY_CODE_POINT) { 293 v[j++] = (char) c; 294 } else { 295 Character.toSurrogates(c, v, j); 296 j += 2; 297 } 298 } 299 300 this.value = v; 301 this.count = v.length; 302 this.offset = 0; 303 } 304 305 /** 306 * Allocates a new {@code String} constructed from a subarray of an array 307 * of 8-bit integer values. 308 * 309 * <p> The {@code offset} argument is the index of the first byte of the 310 * subarray, and the {@code count} argument specifies the length of the 311 * subarray. 312 * 313 * <p> Each {@code byte} in the subarray is converted to a {@code char} as 314 * specified in the method above. 315 * 316 * @deprecated This method does not properly convert bytes into characters. 317 * As of JDK 1.1, the preferred way to do this is via the 318 * {@code String} constructors that take a {@link 319 * java.nio.charset.Charset}, charset name, or that use the platform's 320 * default charset. 321 * 322 * @param ascii 323 * The bytes to be converted to characters 324 * 325 * @param hibyte 326 * The top 8 bits of each 16-bit Unicode code unit 327 * 328 * @param offset 329 * The initial offset 330 * @param count 331 * The length 332 * 333 * @throws IndexOutOfBoundsException 334 * If the {@code offset} or {@code count} argument is invalid 335 * 336 * @see #String(byte[], int) 337 * @see #String(byte[], int, int, java.lang.String) 338 * @see #String(byte[], int, int, java.nio.charset.Charset) 339 * @see #String(byte[], int, int) 340 * @see #String(byte[], java.lang.String) 341 * @see #String(byte[], java.nio.charset.Charset) 342 * @see #String(byte[]) 343 */ 344 @Deprecated 345 public String(byte ascii[], int hibyte, int offset, int count) { 346 checkBounds(ascii, offset, count); 347 char value[] = new char[count]; 348 349 if (hibyte == 0) { 350 for (int i = count ; i-- > 0 ;) { 351 value[i] = (char) (ascii[i + offset] & 0xff); 352 } 353 } else { 354 hibyte <<= 8; 355 for (int i = count ; i-- > 0 ;) { 356 value[i] = (char) (hibyte | (ascii[i + offset] & 0xff)); 357 } 358 } 359 this.offset = 0; 360 this.count = count; 361 this.value = value; 362 } 363 364 /** 365 * Allocates a new {@code String} containing characters constructed from 366 * an array of 8-bit integer values. Each character <i>c</i>in the 367 * resulting string is constructed from the corresponding component 368 * <i>b</i> in the byte array such that: 369 * 370 * <blockquote><pre> 371 * <b><i>c</i></b> == (char)(((hibyte & 0xff) << 8) 372 * | (<b><i>b</i></b> & 0xff)) 373 * </pre></blockquote> 374 * 375 * @deprecated This method does not properly convert bytes into 376 * characters. As of JDK 1.1, the preferred way to do this is via the 377 * {@code String} constructors that take a {@link 378 * java.nio.charset.Charset}, charset name, or that use the platform's 379 * default charset. 380 * 381 * @param ascii 382 * The bytes to be converted to characters 383 * 384 * @param hibyte 385 * The top 8 bits of each 16-bit Unicode code unit 386 * 387 * @see #String(byte[], int, int, java.lang.String) 388 * @see #String(byte[], int, int, java.nio.charset.Charset) 389 * @see #String(byte[], int, int) 390 * @see #String(byte[], java.lang.String) 391 * @see #String(byte[], java.nio.charset.Charset) 392 * @see #String(byte[]) 393 */ 394 @Deprecated 395 public String(byte ascii[], int hibyte) { 396 this(ascii, hibyte, 0, ascii.length); 397 } 398 399 /* Common private utility method used to bounds check the byte array 400 * and requested offset & length values used by the String(byte[],..) 401 * constructors. 402 */ 403 private static void checkBounds(byte[] bytes, int offset, int length) { 404 if (length < 0) 405 throw new StringIndexOutOfBoundsException(length); 406 if (offset < 0) 407 throw new StringIndexOutOfBoundsException(offset); 408 if (offset > bytes.length - length) 409 throw new StringIndexOutOfBoundsException(offset + length); 410 } 411 412 /** 413 * Constructs a new {@code String} by decoding the specified subarray of 414 * bytes using the specified charset. The length of the new {@code String} 415 * is a function of the charset, and hence may not be equal to the length 416 * of the subarray. 417 * 418 * <p> The behavior of this constructor when the given bytes are not valid 419 * in the given charset is unspecified. The {@link 420 * java.nio.charset.CharsetDecoder} class should be used when more control 421 * over the decoding process is required. 422 * 423 * @param bytes 424 * The bytes to be decoded into characters 425 * 426 * @param offset 427 * The index of the first byte to decode 428 * 429 * @param length 430 * The number of bytes to decode 431 432 * @param charsetName 433 * The name of a supported {@linkplain java.nio.charset.Charset 434 * charset} 435 * 436 * @throws UnsupportedEncodingException 437 * If the named charset is not supported 438 * 439 * @throws IndexOutOfBoundsException 440 * If the {@code offset} and {@code length} arguments index 441 * characters outside the bounds of the {@code bytes} array 442 * 443 * @since JDK1.1 444 */ 445 public String(byte bytes[], int offset, int length, String charsetName) 446 throws UnsupportedEncodingException 447 { 448 if (charsetName == null) 449 throw new NullPointerException("charsetName"); 450 checkBounds(bytes, offset, length); 451 char[] v = StringCoding.decode(charsetName, bytes, offset, length); 452 this.offset = 0; 453 this.count = v.length; 454 this.value = v; 455 } 456 457 /** 458 * Constructs a new {@code String} by decoding the specified subarray of 459 * bytes using the specified {@linkplain java.nio.charset.Charset charset}. 460 * The length of the new {@code String} is a function of the charset, and 461 * hence may not be equal to the length of the subarray. 462 * 463 * <p> This method always replaces malformed-input and unmappable-character 464 * sequences with this charset's default replacement string. The {@link 465 * java.nio.charset.CharsetDecoder} class should be used when more control 466 * over the decoding process is required. 467 * 468 * @param bytes 469 * The bytes to be decoded into characters 470 * 471 * @param offset 472 * The index of the first byte to decode 473 * 474 * @param length 475 * The number of bytes to decode 476 * 477 * @param charset 478 * The {@linkplain java.nio.charset.Charset charset} to be used to 479 * decode the {@code bytes} 480 * 481 * @throws IndexOutOfBoundsException 482 * If the {@code offset} and {@code length} arguments index 483 * characters outside the bounds of the {@code bytes} array 484 * 485 * @since 1.6 486 */ 487 public String(byte bytes[], int offset, int length, Charset charset) { 488 if (charset == null) 489 throw new NullPointerException("charset"); 490 checkBounds(bytes, offset, length); 491 char[] v = StringCoding.decode(charset, bytes, offset, length); 492 this.offset = 0; 493 this.count = v.length; 494 this.value = v; 495 } 496 497 /** 498 * Constructs a new {@code String} by decoding the specified array of bytes 499 * using the specified {@linkplain java.nio.charset.Charset charset}. The 500 * length of the new {@code String} is a function of the charset, and hence 501 * may not be equal to the length of the byte array. 502 * 503 * <p> The behavior of this constructor when the given bytes are not valid 504 * in the given charset is unspecified. The {@link 505 * java.nio.charset.CharsetDecoder} class should be used when more control 506 * over the decoding process is required. 507 * 508 * @param bytes 509 * The bytes to be decoded into characters 510 * 511 * @param charsetName 512 * The name of a supported {@linkplain java.nio.charset.Charset 513 * charset} 514 * 515 * @throws UnsupportedEncodingException 516 * If the named charset is not supported 517 * 518 * @since JDK1.1 519 */ 520 public String(byte bytes[], String charsetName) 521 throws UnsupportedEncodingException 522 { 523 this(bytes, 0, bytes.length, charsetName); 524 } 525 526 /** 527 * Constructs a new {@code String} by decoding the specified array of 528 * bytes using the specified {@linkplain java.nio.charset.Charset charset}. 529 * The length of the new {@code String} is a function of the charset, and 530 * hence may not be equal to the length of the byte array. 531 * 532 * <p> This method always replaces malformed-input and unmappable-character 533 * sequences with this charset's default replacement string. The {@link 534 * java.nio.charset.CharsetDecoder} class should be used when more control 535 * over the decoding process is required. 536 * 537 * @param bytes 538 * The bytes to be decoded into characters 539 * 540 * @param charset 541 * The {@linkplain java.nio.charset.Charset charset} to be used to 542 * decode the {@code bytes} 543 * 544 * @since 1.6 545 */ 546 public String(byte bytes[], Charset charset) { 547 this(bytes, 0, bytes.length, charset); 548 } 549 550 /** 551 * Constructs a new {@code String} by decoding the specified subarray of 552 * bytes using the platform's default charset. The length of the new 553 * {@code String} is a function of the charset, and hence may not be equal 554 * to the length of the subarray. 555 * 556 * <p> The behavior of this constructor when the given bytes are not valid 557 * in the default charset is unspecified. The {@link 558 * java.nio.charset.CharsetDecoder} class should be used when more control 559 * over the decoding process is required. 560 * 561 * @param bytes 562 * The bytes to be decoded into characters 563 * 564 * @param offset 565 * The index of the first byte to decode 566 * 567 * @param length 568 * The number of bytes to decode 569 * 570 * @throws IndexOutOfBoundsException 571 * If the {@code offset} and the {@code length} arguments index 572 * characters outside the bounds of the {@code bytes} array 573 * 574 * @since JDK1.1 575 */ 576 public String(byte bytes[], int offset, int length) { 577 checkBounds(bytes, offset, length); 578 char[] v = StringCoding.decode(bytes, offset, length); 579 this.offset = 0; 580 this.count = v.length; 581 this.value = v; 582 } 583 584 /** 585 * Constructs a new {@code String} by decoding the specified array of bytes 586 * using the platform's default charset. The length of the new {@code 587 * String} is a function of the charset, and hence may not be equal to the 588 * length of the byte array. 589 * 590 * <p> The behavior of this constructor when the given bytes are not valid 591 * in the default charset is unspecified. The {@link 592 * java.nio.charset.CharsetDecoder} class should be used when more control 593 * over the decoding process is required. 594 * 595 * @param bytes 596 * The bytes to be decoded into characters 597 * 598 * @since JDK1.1 599 */ 600 public String(byte bytes[]) { 601 this(bytes, 0, bytes.length); 602 } 603 604 /** 605 * Allocates a new string that contains the sequence of characters 606 * currently contained in the string buffer argument. The contents of the 607 * string buffer are copied; subsequent modification of the string buffer 608 * does not affect the newly created string. 609 * 610 * @param buffer 611 * A {@code StringBuffer} 612 */ 613 public String(StringBuffer buffer) { 614 String result = buffer.toString(); 615 this.value = result.value; 616 this.count = result.count; 617 this.offset = result.offset; 618 } 619 620 /** 621 * Allocates a new string that contains the sequence of characters 622 * currently contained in the string builder argument. The contents of the 623 * string builder are copied; subsequent modification of the string builder 624 * does not affect the newly created string. 625 * 626 * <p> This constructor is provided to ease migration to {@code 627 * StringBuilder}. Obtaining a string from a string builder via the {@code 628 * toString} method is likely to run faster and is generally preferred. 629 * 630 * @param builder 631 * A {@code StringBuilder} 632 * 633 * @since 1.5 634 */ 635 public String(StringBuilder builder) { 636 String result = builder.toString(); 637 this.value = result.value; 638 this.count = result.count; 639 this.offset = result.offset; 640 } 641 642 643 // Package private constructor which shares value array for speed. 644 String(int offset, int count, char value[]) { 645 this.value = value; 646 this.offset = offset; 647 this.count = count; 648 } 649 650 /** 651 * Returns the length of this string. 652 * The length is equal to the number of <a href="Character.html#unicode">Unicode 653 * code units</a> in the string. 654 * 655 * @return the length of the sequence of characters represented by this 656 * object. 657 */ 658 public int length() { 659 return count; 660 } 661 662 /** 663 * Returns <tt>true</tt> if, and only if, {@link #length()} is <tt>0</tt>. 664 * 665 * @return <tt>true</tt> if {@link #length()} is <tt>0</tt>, otherwise 666 * <tt>false</tt> 667 * 668 * @since 1.6 669 */ 670 public boolean isEmpty() { 671 return count == 0; 672 } 673 674 /** 675 * Returns the <code>char</code> value at the 676 * specified index. An index ranges from <code>0</code> to 677 * <code>length() - 1</code>. The first <code>char</code> value of the sequence 678 * is at index <code>0</code>, the next at index <code>1</code>, 679 * and so on, as for array indexing. 680 * 681 * <p>If the <code>char</code> value specified by the index is a 682 * <a href="Character.html#unicode">surrogate</a>, the surrogate 683 * value is returned. 684 * 685 * @param index the index of the <code>char</code> value. 686 * @return the <code>char</code> value at the specified index of this string. 687 * The first <code>char</code> value is at index <code>0</code>. 688 * @exception IndexOutOfBoundsException if the <code>index</code> 689 * argument is negative or not less than the length of this 690 * string. 691 */ 692 public char charAt(int index) { 693 if ((index < 0) || (index >= count)) { 694 throw new StringIndexOutOfBoundsException(index); 695 } 696 return value[index + offset]; 697 } 698 699 /** 700 * Returns the character (Unicode code point) at the specified 701 * index. The index refers to <code>char</code> values 702 * (Unicode code units) and ranges from <code>0</code> to 703 * {@link #length()}<code> - 1</code>. 704 * 705 * <p> If the <code>char</code> value specified at the given index 706 * is in the high-surrogate range, the following index is less 707 * than the length of this <code>String</code>, and the 708 * <code>char</code> value at the following index is in the 709 * low-surrogate range, then the supplementary code point 710 * corresponding to this surrogate pair is returned. Otherwise, 711 * the <code>char</code> value at the given index is returned. 712 * 713 * @param index the index to the <code>char</code> values 714 * @return the code point value of the character at the 715 * <code>index</code> 716 * @exception IndexOutOfBoundsException if the <code>index</code> 717 * argument is negative or not less than the length of this 718 * string. 719 * @since 1.5 720 */ 721 public int codePointAt(int index) { 722 if ((index < 0) || (index >= count)) { 723 throw new StringIndexOutOfBoundsException(index); 724 } 725 return Character.codePointAtImpl(value, offset + index, offset + count); 726 } 727 728 /** 729 * Returns the character (Unicode code point) before the specified 730 * index. The index refers to <code>char</code> values 731 * (Unicode code units) and ranges from <code>1</code> to {@link 732 * CharSequence#length() length}. 733 * 734 * <p> If the <code>char</code> value at <code>(index - 1)</code> 735 * is in the low-surrogate range, <code>(index - 2)</code> is not 736 * negative, and the <code>char</code> value at <code>(index - 737 * 2)</code> is in the high-surrogate range, then the 738 * supplementary code point value of the surrogate pair is 739 * returned. If the <code>char</code> value at <code>index - 740 * 1</code> is an unpaired low-surrogate or a high-surrogate, the 741 * surrogate value is returned. 742 * 743 * @param index the index following the code point that should be returned 744 * @return the Unicode code point value before the given index. 745 * @exception IndexOutOfBoundsException if the <code>index</code> 746 * argument is less than 1 or greater than the length 747 * of this string. 748 * @since 1.5 749 */ 750 public int codePointBefore(int index) { 751 int i = index - 1; 752 if ((i < 0) || (i >= count)) { 753 throw new StringIndexOutOfBoundsException(index); 754 } 755 return Character.codePointBeforeImpl(value, offset + index, offset); 756 } 757 758 /** 759 * Returns the number of Unicode code points in the specified text 760 * range of this <code>String</code>. The text range begins at the 761 * specified <code>beginIndex</code> and extends to the 762 * <code>char</code> at index <code>endIndex - 1</code>. Thus the 763 * length (in <code>char</code>s) of the text range is 764 * <code>endIndex-beginIndex</code>. Unpaired surrogates within 765 * the text range count as one code point each. 766 * 767 * @param beginIndex the index to the first <code>char</code> of 768 * the text range. 769 * @param endIndex the index after the last <code>char</code> of 770 * the text range. 771 * @return the number of Unicode code points in the specified text 772 * range 773 * @exception IndexOutOfBoundsException if the 774 * <code>beginIndex</code> is negative, or <code>endIndex</code> 775 * is larger than the length of this <code>String</code>, or 776 * <code>beginIndex</code> is larger than <code>endIndex</code>. 777 * @since 1.5 778 */ 779 public int codePointCount(int beginIndex, int endIndex) { 780 if (beginIndex < 0 || endIndex > count || beginIndex > endIndex) { 781 throw new IndexOutOfBoundsException(); 782 } 783 return Character.codePointCountImpl(value, offset+beginIndex, endIndex-beginIndex); 784 } 785 786 /** 787 * Returns the index within this <code>String</code> that is 788 * offset from the given <code>index</code> by 789 * <code>codePointOffset</code> code points. Unpaired surrogates 790 * within the text range given by <code>index</code> and 791 * <code>codePointOffset</code> count as one code point each. 792 * 793 * @param index the index to be offset 794 * @param codePointOffset the offset in code points 795 * @return the index within this <code>String</code> 796 * @exception IndexOutOfBoundsException if <code>index</code> 797 * is negative or larger then the length of this 798 * <code>String</code>, or if <code>codePointOffset</code> is positive 799 * and the substring starting with <code>index</code> has fewer 800 * than <code>codePointOffset</code> code points, 801 * or if <code>codePointOffset</code> is negative and the substring 802 * before <code>index</code> has fewer than the absolute value 803 * of <code>codePointOffset</code> code points. 804 * @since 1.5 805 */ 806 public int offsetByCodePoints(int index, int codePointOffset) { 807 if (index < 0 || index > count) { 808 throw new IndexOutOfBoundsException(); 809 } 810 return Character.offsetByCodePointsImpl(value, offset, count, 811 offset+index, codePointOffset) - offset; 812 } 813 814 /** 815 * Copy characters from this string into dst starting at dstBegin. 816 * This method doesn't perform any range checking. 817 */ 818 void getChars(char dst[], int dstBegin) { 819 System.arraycopy(value, offset, dst, dstBegin, count); 820 } 821 822 /** 823 * Copies characters from this string into the destination character 824 * array. 825 * <p> 826 * The first character to be copied is at index <code>srcBegin</code>; 827 * the last character to be copied is at index <code>srcEnd-1</code> 828 * (thus the total number of characters to be copied is 829 * <code>srcEnd-srcBegin</code>). The characters are copied into the 830 * subarray of <code>dst</code> starting at index <code>dstBegin</code> 831 * and ending at index: 832 * <p><blockquote><pre> 833 * dstbegin + (srcEnd-srcBegin) - 1 834 * </pre></blockquote> 835 * 836 * @param srcBegin index of the first character in the string 837 * to copy. 838 * @param srcEnd index after the last character in the string 839 * to copy. 840 * @param dst the destination array. 841 * @param dstBegin the start offset in the destination array. 842 * @exception IndexOutOfBoundsException If any of the following 843 * is true: 844 * <ul><li><code>srcBegin</code> is negative. 845 * <li><code>srcBegin</code> is greater than <code>srcEnd</code> 846 * <li><code>srcEnd</code> is greater than the length of this 847 * string 848 * <li><code>dstBegin</code> is negative 849 * <li><code>dstBegin+(srcEnd-srcBegin)</code> is larger than 850 * <code>dst.length</code></ul> 851 */ 852 public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) { 853 if (srcBegin < 0) { 854 throw new StringIndexOutOfBoundsException(srcBegin); 855 } 856 if (srcEnd > count) { 857 throw new StringIndexOutOfBoundsException(srcEnd); 858 } 859 if (srcBegin > srcEnd) { 860 throw new StringIndexOutOfBoundsException(srcEnd - srcBegin); 861 } 862 System.arraycopy(value, offset + srcBegin, dst, dstBegin, 863 srcEnd - srcBegin); 864 } 865 866 /** 867 * Copies characters from this string into the destination byte array. Each 868 * byte receives the 8 low-order bits of the corresponding character. The 869 * eight high-order bits of each character are not copied and do not 870 * participate in the transfer in any way. 871 * 872 * <p> The first character to be copied is at index {@code srcBegin}; the 873 * last character to be copied is at index {@code srcEnd-1}. The total 874 * number of characters to be copied is {@code srcEnd-srcBegin}. The 875 * characters, converted to bytes, are copied into the subarray of {@code 876 * dst} starting at index {@code dstBegin} and ending at index: 877 * 878 * <blockquote><pre> 879 * dstbegin + (srcEnd-srcBegin) - 1 880 * </pre></blockquote> 881 * 882 * @deprecated This method does not properly convert characters into 883 * bytes. As of JDK 1.1, the preferred way to do this is via the 884 * {@link #getBytes()} method, which uses the platform's default charset. 885 * 886 * @param srcBegin 887 * Index of the first character in the string to copy 888 * 889 * @param srcEnd 890 * Index after the last character in the string to copy 891 * 892 * @param dst 893 * The destination array 894 * 895 * @param dstBegin 896 * The start offset in the destination array 897 * 898 * @throws IndexOutOfBoundsException 899 * If any of the following is true: 900 * <ul> 901 * <li> {@code srcBegin} is negative 902 * <li> {@code srcBegin} is greater than {@code srcEnd} 903 * <li> {@code srcEnd} is greater than the length of this String 904 * <li> {@code dstBegin} is negative 905 * <li> {@code dstBegin+(srcEnd-srcBegin)} is larger than {@code 906 * dst.length} 907 * </ul> 908 */ 909 @Deprecated 910 public void getBytes(int srcBegin, int srcEnd, byte dst[], int dstBegin) { 911 if (srcBegin < 0) { 912 throw new StringIndexOutOfBoundsException(srcBegin); 913 } 914 if (srcEnd > count) { 915 throw new StringIndexOutOfBoundsException(srcEnd); 916 } 917 if (srcBegin > srcEnd) { 918 throw new StringIndexOutOfBoundsException(srcEnd - srcBegin); 919 } 920 int j = dstBegin; 921 int n = offset + srcEnd; 922 int i = offset + srcBegin; 923 char[] val = value; /* avoid getfield opcode */ 924 925 while (i < n) { 926 dst[j++] = (byte)val[i++]; 927 } 928 } 929 930 /** 931 * Encodes this {@code String} into a sequence of bytes using the named 932 * charset, storing the result into a new byte array. 933 * 934 * <p> The behavior of this method when this string cannot be encoded in 935 * the given charset is unspecified. The {@link 936 * java.nio.charset.CharsetEncoder} class should be used when more control 937 * over the encoding process is required. 938 * 939 * @param charsetName 940 * The name of a supported {@linkplain java.nio.charset.Charset 941 * charset} 942 * 943 * @return The resultant byte array 944 * 945 * @throws UnsupportedEncodingException 946 * If the named charset is not supported 947 * 948 * @since JDK1.1 949 */ 950 public byte[] getBytes(String charsetName) 951 throws UnsupportedEncodingException 952 { 953 if (charsetName == null) throw new NullPointerException(); 954 return StringCoding.encode(charsetName, value, offset, count); 955 } 956 957 /** 958 * Encodes this {@code String} into a sequence of bytes using the given 959 * {@linkplain java.nio.charset.Charset charset}, storing the result into a 960 * new byte array. 961 * 962 * <p> This method always replaces malformed-input and unmappable-character 963 * sequences with this charset's default replacement byte array. The 964 * {@link java.nio.charset.CharsetEncoder} class should be used when more 965 * control over the encoding process is required. 966 * 967 * @param charset 968 * The {@linkplain java.nio.charset.Charset} to be used to encode 969 * the {@code String} 970 * 971 * @return The resultant byte array 972 * 973 * @since 1.6 974 */ 975 public byte[] getBytes(Charset charset) { 976 if (charset == null) throw new NullPointerException(); 977 return StringCoding.encode(charset, value, offset, count); 978 } 979 980 /** 981 * Encodes this {@code String} into a sequence of bytes using the 982 * platform's default charset, storing the result into a new byte array. 983 * 984 * <p> The behavior of this method when this string cannot be encoded in 985 * the default charset is unspecified. The {@link 986 * java.nio.charset.CharsetEncoder} class should be used when more control 987 * over the encoding process is required. 988 * 989 * @return The resultant byte array 990 * 991 * @since JDK1.1 992 */ 993 public byte[] getBytes() { 994 return StringCoding.encode(value, offset, count); 995 } 996 997 /** 998 * Compares this string to the specified object. The result is {@code 999 * true} if and only if the argument is not {@code null} and is a {@code 1000 * String} object that represents the same sequence of characters as this 1001 * object. 1002 * 1003 * @param anObject 1004 * The object to compare this {@code String} against 1005 * 1006 * @return {@code true} if the given object represents a {@code String} 1007 * equivalent to this string, {@code false} otherwise 1008 * 1009 * @see #compareTo(String) 1010 * @see #equalsIgnoreCase(String) 1011 */ 1012 public boolean equals(Object anObject) { 1013 if (this == anObject) { 1014 return true; 1015 } 1016 if (anObject instanceof String) { 1017 String anotherString = (String)anObject; 1018 int n = count; 1019 if (n == anotherString.count) { 1020 char v1[] = value; 1021 char v2[] = anotherString.value; 1022 int i = offset; 1023 int j = anotherString.offset; 1024 while (n-- != 0) { 1025 if (v1[i++] != v2[j++]) 1026 return false; 1027 } 1028 return true; 1029 } 1030 } 1031 return false; 1032 } 1033 1034 /** 1035 * Compares this string to the specified {@code StringBuffer}. The result 1036 * is {@code true} if and only if this {@code String} represents the same 1037 * sequence of characters as the specified {@code StringBuffer}. 1038 * 1039 * @param sb 1040 * The {@code StringBuffer} to compare this {@code String} against 1041 * 1042 * @return {@code true} if this {@code String} represents the same 1043 * sequence of characters as the specified {@code StringBuffer}, 1044 * {@code false} otherwise 1045 * 1046 * @since 1.4 1047 */ 1048 public boolean contentEquals(StringBuffer sb) { 1049 synchronized(sb) { 1050 return contentEquals((CharSequence)sb); 1051 } 1052 } 1053 1054 /** 1055 * Compares this string to the specified {@code CharSequence}. The result 1056 * is {@code true} if and only if this {@code String} represents the same 1057 * sequence of char values as the specified sequence. 1058 * 1059 * @param cs 1060 * The sequence to compare this {@code String} against 1061 * 1062 * @return {@code true} if this {@code String} represents the same 1063 * sequence of char values as the specified sequence, {@code 1064 * false} otherwise 1065 * 1066 * @since 1.5 1067 */ 1068 public boolean contentEquals(CharSequence cs) { 1069 if (count != cs.length()) 1070 return false; 1071 // Argument is a StringBuffer, StringBuilder 1072 if (cs instanceof AbstractStringBuilder) { 1073 char v1[] = value; 1074 char v2[] = ((AbstractStringBuilder)cs).getValue(); 1075 int i = offset; 1076 int j = 0; 1077 int n = count; 1078 while (n-- != 0) { 1079 if (v1[i++] != v2[j++]) 1080 return false; 1081 } 1082 return true; 1083 } 1084 // Argument is a String 1085 if (cs.equals(this)) 1086 return true; 1087 // Argument is a generic CharSequence 1088 char v1[] = value; 1089 int i = offset; 1090 int j = 0; 1091 int n = count; 1092 while (n-- != 0) { 1093 if (v1[i++] != cs.charAt(j++)) 1094 return false; 1095 } 1096 return true; 1097 } 1098 1099 /** 1100 * Compares this {@code String} to another {@code String}, ignoring case 1101 * considerations. Two strings are considered equal ignoring case if they 1102 * are of the same length and corresponding characters in the two strings 1103 * are equal ignoring case. 1104 * 1105 * <p> Two characters {@code c1} and {@code c2} are considered the same 1106 * ignoring case if at least one of the following is true: 1107 * <ul> 1108 * <li> The two characters are the same (as compared by the 1109 * {@code ==} operator) 1110 * <li> Applying the method {@link 1111 * java.lang.Character#toUpperCase(char)} to each character 1112 * produces the same result 1113 * <li> Applying the method {@link 1114 * java.lang.Character#toLowerCase(char)} to each character 1115 * produces the same result 1116 * </ul> 1117 * 1118 * @param anotherString 1119 * The {@code String} to compare this {@code String} against 1120 * 1121 * @return {@code true} if the argument is not {@code null} and it 1122 * represents an equivalent {@code String} ignoring case; {@code 1123 * false} otherwise 1124 * 1125 * @see #equals(Object) 1126 */ 1127 public boolean equalsIgnoreCase(String anotherString) { 1128 return (this == anotherString) ? true : 1129 (anotherString != null) && (anotherString.count == count) && 1130 regionMatches(true, 0, anotherString, 0, count); 1131 } 1132 1133 /** 1134 * Compares two strings lexicographically. 1135 * The comparison is based on the Unicode value of each character in 1136 * the strings. The character sequence represented by this 1137 * <code>String</code> object is compared lexicographically to the 1138 * character sequence represented by the argument string. The result is 1139 * a negative integer if this <code>String</code> object 1140 * lexicographically precedes the argument string. The result is a 1141 * positive integer if this <code>String</code> object lexicographically 1142 * follows the argument string. The result is zero if the strings 1143 * are equal; <code>compareTo</code> returns <code>0</code> exactly when 1144 * the {@link #equals(Object)} method would return <code>true</code>. 1145 * <p> 1146 * This is the definition of lexicographic ordering. If two strings are 1147 * different, then either they have different characters at some index 1148 * that is a valid index for both strings, or their lengths are different, 1149 * or both. If they have different characters at one or more index 1150 * positions, let <i>k</i> be the smallest such index; then the string 1151 * whose character at position <i>k</i> has the smaller value, as 1152 * determined by using the < operator, lexicographically precedes the 1153 * other string. In this case, <code>compareTo</code> returns the 1154 * difference of the two character values at position <code>k</code> in 1155 * the two string -- that is, the value: 1156 * <blockquote><pre> 1157 * this.charAt(k)-anotherString.charAt(k) 1158 * </pre></blockquote> 1159 * If there is no index position at which they differ, then the shorter 1160 * string lexicographically precedes the longer string. In this case, 1161 * <code>compareTo</code> returns the difference of the lengths of the 1162 * strings -- that is, the value: 1163 * <blockquote><pre> 1164 * this.length()-anotherString.length() 1165 * </pre></blockquote> 1166 * 1167 * @param anotherString the <code>String</code> to be compared. 1168 * @return the value <code>0</code> if the argument string is equal to 1169 * this string; a value less than <code>0</code> if this string 1170 * is lexicographically less than the string argument; and a 1171 * value greater than <code>0</code> if this string is 1172 * lexicographically greater than the string argument. 1173 */ 1174 public int compareTo(String anotherString) { 1175 int len1 = count; 1176 int len2 = anotherString.count; 1177 int n = Math.min(len1, len2); 1178 char v1[] = value; 1179 char v2[] = anotherString.value; 1180 int i = offset; 1181 int j = anotherString.offset; 1182 1183 if (i == j) { 1184 int k = i; 1185 int lim = n + i; 1186 while (k < lim) { 1187 char c1 = v1[k]; 1188 char c2 = v2[k]; 1189 if (c1 != c2) { 1190 return c1 - c2; 1191 } 1192 k++; 1193 } 1194 } else { 1195 while (n-- != 0) { 1196 char c1 = v1[i++]; 1197 char c2 = v2[j++]; 1198 if (c1 != c2) { 1199 return c1 - c2; 1200 } 1201 } 1202 } 1203 return len1 - len2; 1204 } 1205 1206 /** 1207 * A Comparator that orders <code>String</code> objects as by 1208 * <code>compareToIgnoreCase</code>. This comparator is serializable. 1209 * <p> 1210 * Note that this Comparator does <em>not</em> take locale into account, 1211 * and will result in an unsatisfactory ordering for certain locales. 1212 * The java.text package provides <em>Collators</em> to allow 1213 * locale-sensitive ordering. 1214 * 1215 * @see java.text.Collator#compare(String, String) 1216 * @since 1.2 1217 */ 1218 public static final Comparator<String> CASE_INSENSITIVE_ORDER 1219 = new CaseInsensitiveComparator(); 1220 private static class CaseInsensitiveComparator 1221 implements Comparator<String>, java.io.Serializable { 1222 // use serialVersionUID from JDK 1.2.2 for interoperability 1223 private static final long serialVersionUID = 8575799808933029326L; 1224 1225 public int compare(String s1, String s2) { 1226 int n1 = s1.length(); 1227 int n2 = s2.length(); 1228 int min = Math.min(n1, n2); 1229 for (int i = 0; i < min; i++) { 1230 char c1 = s1.charAt(i); 1231 char c2 = s2.charAt(i); 1232 if (c1 != c2) { 1233 c1 = Character.toUpperCase(c1); 1234 c2 = Character.toUpperCase(c2); 1235 if (c1 != c2) { 1236 c1 = Character.toLowerCase(c1); 1237 c2 = Character.toLowerCase(c2); 1238 if (c1 != c2) { 1239 // No overflow because of numeric promotion 1240 return c1 - c2; 1241 } 1242 } 1243 } 1244 } 1245 return n1 - n2; 1246 } 1247 } 1248 1249 /** 1250 * Compares two strings lexicographically, ignoring case 1251 * differences. This method returns an integer whose sign is that of 1252 * calling <code>compareTo</code> with normalized versions of the strings 1253 * where case differences have been eliminated by calling 1254 * <code>Character.toLowerCase(Character.toUpperCase(character))</code> on 1255 * each character. 1256 * <p> 1257 * Note that this method does <em>not</em> take locale into account, 1258 * and will result in an unsatisfactory ordering for certain locales. 1259 * The java.text package provides <em>collators</em> to allow 1260 * locale-sensitive ordering. 1261 * 1262 * @param str the <code>String</code> to be compared. 1263 * @return a negative integer, zero, or a positive integer as the 1264 * specified String is greater than, equal to, or less 1265 * than this String, ignoring case considerations. 1266 * @see java.text.Collator#compare(String, String) 1267 * @since 1.2 1268 */ 1269 public int compareToIgnoreCase(String str) { 1270 return CASE_INSENSITIVE_ORDER.compare(this, str); 1271 } 1272 1273 /** 1274 * Tests if two string regions are equal. 1275 * <p> 1276 * A substring of this <tt>String</tt> object is compared to a substring 1277 * of the argument other. The result is true if these substrings 1278 * represent identical character sequences. The substring of this 1279 * <tt>String</tt> object to be compared begins at index <tt>toffset</tt> 1280 * and has length <tt>len</tt>. The substring of other to be compared 1281 * begins at index <tt>ooffset</tt> and has length <tt>len</tt>. The 1282 * result is <tt>false</tt> if and only if at least one of the following 1283 * is true: 1284 * <ul><li><tt>toffset</tt> is negative. 1285 * <li><tt>ooffset</tt> is negative. 1286 * <li><tt>toffset+len</tt> is greater than the length of this 1287 * <tt>String</tt> object. 1288 * <li><tt>ooffset+len</tt> is greater than the length of the other 1289 * argument. 1290 * <li>There is some nonnegative integer <i>k</i> less than <tt>len</tt> 1291 * such that: 1292 * <tt>this.charAt(toffset+<i>k</i>) != other.charAt(ooffset+<i>k</i>)</tt> 1293 * </ul> 1294 * 1295 * @param toffset the starting offset of the subregion in this string. 1296 * @param other the string argument. 1297 * @param ooffset the starting offset of the subregion in the string 1298 * argument. 1299 * @param len the number of characters to compare. 1300 * @return <code>true</code> if the specified subregion of this string 1301 * exactly matches the specified subregion of the string argument; 1302 * <code>false</code> otherwise. 1303 */ 1304 public boolean regionMatches(int toffset, String other, int ooffset, 1305 int len) { 1306 char ta[] = value; 1307 int to = offset + toffset; 1308 char pa[] = other.value; 1309 int po = other.offset + ooffset; 1310 // Note: toffset, ooffset, or len might be near -1>>>1. 1311 if ((ooffset < 0) || (toffset < 0) || (toffset > (long)count - len) 1312 || (ooffset > (long)other.count - len)) { 1313 return false; 1314 } 1315 while (len-- > 0) { 1316 if (ta[to++] != pa[po++]) { 1317 return false; 1318 } 1319 } 1320 return true; 1321 } 1322 1323 /** 1324 * Tests if two string regions are equal. 1325 * <p> 1326 * A substring of this <tt>String</tt> object is compared to a substring 1327 * of the argument <tt>other</tt>. The result is <tt>true</tt> if these 1328 * substrings represent character sequences that are the same, ignoring 1329 * case if and only if <tt>ignoreCase</tt> is true. The substring of 1330 * this <tt>String</tt> object to be compared begins at index 1331 * <tt>toffset</tt> and has length <tt>len</tt>. The substring of 1332 * <tt>other</tt> to be compared begins at index <tt>ooffset</tt> and 1333 * has length <tt>len</tt>. The result is <tt>false</tt> if and only if 1334 * at least one of the following is true: 1335 * <ul><li><tt>toffset</tt> is negative. 1336 * <li><tt>ooffset</tt> is negative. 1337 * <li><tt>toffset+len</tt> is greater than the length of this 1338 * <tt>String</tt> object. 1339 * <li><tt>ooffset+len</tt> is greater than the length of the other 1340 * argument. 1341 * <li><tt>ignoreCase</tt> is <tt>false</tt> and there is some nonnegative 1342 * integer <i>k</i> less than <tt>len</tt> such that: 1343 * <blockquote><pre> 1344 * this.charAt(toffset+k) != other.charAt(ooffset+k) 1345 * </pre></blockquote> 1346 * <li><tt>ignoreCase</tt> is <tt>true</tt> and there is some nonnegative 1347 * integer <i>k</i> less than <tt>len</tt> such that: 1348 * <blockquote><pre> 1349 * Character.toLowerCase(this.charAt(toffset+k)) != 1350 Character.toLowerCase(other.charAt(ooffset+k)) 1351 * </pre></blockquote> 1352 * and: 1353 * <blockquote><pre> 1354 * Character.toUpperCase(this.charAt(toffset+k)) != 1355 * Character.toUpperCase(other.charAt(ooffset+k)) 1356 * </pre></blockquote> 1357 * </ul> 1358 * 1359 * @param ignoreCase if <code>true</code>, ignore case when comparing 1360 * characters. 1361 * @param toffset the starting offset of the subregion in this 1362 * string. 1363 * @param other the string argument. 1364 * @param ooffset the starting offset of the subregion in the string 1365 * argument. 1366 * @param len the number of characters to compare. 1367 * @return <code>true</code> if the specified subregion of this string 1368 * matches the specified subregion of the string argument; 1369 * <code>false</code> otherwise. Whether the matching is exact 1370 * or case insensitive depends on the <code>ignoreCase</code> 1371 * argument. 1372 */ 1373 public boolean regionMatches(boolean ignoreCase, int toffset, 1374 String other, int ooffset, int len) { 1375 char ta[] = value; 1376 int to = offset + toffset; 1377 char pa[] = other.value; 1378 int po = other.offset + ooffset; 1379 // Note: toffset, ooffset, or len might be near -1>>>1. 1380 if ((ooffset < 0) || (toffset < 0) || (toffset > (long)count - len) || 1381 (ooffset > (long)other.count - len)) { 1382 return false; 1383 } 1384 while (len-- > 0) { 1385 char c1 = ta[to++]; 1386 char c2 = pa[po++]; 1387 if (c1 == c2) { 1388 continue; 1389 } 1390 if (ignoreCase) { 1391 // If characters don't match but case may be ignored, 1392 // try converting both characters to uppercase. 1393 // If the results match, then the comparison scan should 1394 // continue. 1395 char u1 = Character.toUpperCase(c1); 1396 char u2 = Character.toUpperCase(c2); 1397 if (u1 == u2) { 1398 continue; 1399 } 1400 // Unfortunately, conversion to uppercase does not work properly 1401 // for the Georgian alphabet, which has strange rules about case 1402 // conversion. So we need to make one last check before 1403 // exiting. 1404 if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) { 1405 continue; 1406 } 1407 } 1408 return false; 1409 } 1410 return true; 1411 } 1412 1413 /** 1414 * Tests if the substring of this string beginning at the 1415 * specified index starts with the specified prefix. 1416 * 1417 * @param prefix the prefix. 1418 * @param toffset where to begin looking in this string. 1419 * @return <code>true</code> if the character sequence represented by the 1420 * argument is a prefix of the substring of this object starting 1421 * at index <code>toffset</code>; <code>false</code> otherwise. 1422 * The result is <code>false</code> if <code>toffset</code> is 1423 * negative or greater than the length of this 1424 * <code>String</code> object; otherwise the result is the same 1425 * as the result of the expression 1426 * <pre> 1427 * this.substring(toffset).startsWith(prefix) 1428 * </pre> 1429 */ 1430 public boolean startsWith(String prefix, int toffset) { 1431 char ta[] = value; 1432 int to = offset + toffset; 1433 char pa[] = prefix.value; 1434 int po = prefix.offset; 1435 int pc = prefix.count; 1436 // Note: toffset might be near -1>>>1. 1437 if ((toffset < 0) || (toffset > count - pc)) { 1438 return false; 1439 } 1440 while (--pc >= 0) { 1441 if (ta[to++] != pa[po++]) { 1442 return false; 1443 } 1444 } 1445 return true; 1446 } 1447 1448 /** 1449 * Tests if this string starts with the specified prefix. 1450 * 1451 * @param prefix the prefix. 1452 * @return <code>true</code> if the character sequence represented by the 1453 * argument is a prefix of the character sequence represented by 1454 * this string; <code>false</code> otherwise. 1455 * Note also that <code>true</code> will be returned if the 1456 * argument is an empty string or is equal to this 1457 * <code>String</code> object as determined by the 1458 * {@link #equals(Object)} method. 1459 * @since 1. 0 1460 */ 1461 public boolean startsWith(String prefix) { 1462 return startsWith(prefix, 0); 1463 } 1464 1465 /** 1466 * Tests if this string ends with the specified suffix. 1467 * 1468 * @param suffix the suffix. 1469 * @return <code>true</code> if the character sequence represented by the 1470 * argument is a suffix of the character sequence represented by 1471 * this object; <code>false</code> otherwise. Note that the 1472 * result will be <code>true</code> if the argument is the 1473 * empty string or is equal to this <code>String</code> object 1474 * as determined by the {@link #equals(Object)} method. 1475 */ 1476 public boolean endsWith(String suffix) { 1477 return startsWith(suffix, count - suffix.count); 1478 } 1479 1480 /** 1481 * Returns a hash code for this string. The hash code for a 1482 * <code>String</code> object is computed as 1483 * <blockquote><pre> 1484 * s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1] 1485 * </pre></blockquote> 1486 * using <code>int</code> arithmetic, where <code>s[i]</code> is the 1487 * <i>i</i>th character of the string, <code>n</code> is the length of 1488 * the string, and <code>^</code> indicates exponentiation. 1489 * (The hash value of the empty string is zero.) 1490 * 1491 * @return a hash code value for this object. 1492 */ 1493 public int hashCode() { 1494 int h = hash; 1495 if (h == 0) { 1496 int off = offset; 1497 char val[] = value; 1498 int len = count; 1499 1500 for (int i = 0; i < len; i++) { 1501 h = 31*h + val[off++]; 1502 } 1503 hash = h; 1504 } 1505 return h; 1506 } 1507 1508 /** 1509 * Returns the index within this string of the first occurrence of 1510 * the specified character. If a character with value 1511 * <code>ch</code> occurs in the character sequence represented by 1512 * this <code>String</code> object, then the index (in Unicode 1513 * code units) of the first such occurrence is returned. For 1514 * values of <code>ch</code> in the range from 0 to 0xFFFF 1515 * (inclusive), this is the smallest value <i>k</i> such that: 1516 * <blockquote><pre> 1517 * this.charAt(<i>k</i>) == ch 1518 * </pre></blockquote> 1519 * is true. For other values of <code>ch</code>, it is the 1520 * smallest value <i>k</i> such that: 1521 * <blockquote><pre> 1522 * this.codePointAt(<i>k</i>) == ch 1523 * </pre></blockquote> 1524 * is true. In either case, if no such character occurs in this 1525 * string, then <code>-1</code> is returned. 1526 * 1527 * @param ch a character (Unicode code point). 1528 * @return the index of the first occurrence of the character in the 1529 * character sequence represented by this object, or 1530 * <code>-1</code> if the character does not occur. 1531 */ 1532 public int indexOf(int ch) { 1533 return indexOf(ch, 0); 1534 } 1535 1536 /** 1537 * Returns the index within this string of the first occurrence of the 1538 * specified character, starting the search at the specified index. 1539 * <p> 1540 * If a character with value <code>ch</code> occurs in the 1541 * character sequence represented by this <code>String</code> 1542 * object at an index no smaller than <code>fromIndex</code>, then 1543 * the index of the first such occurrence is returned. For values 1544 * of <code>ch</code> in the range from 0 to 0xFFFF (inclusive), 1545 * this is the smallest value <i>k</i> such that: 1546 * <blockquote><pre> 1547 * (this.charAt(<i>k</i>) == ch) && (<i>k</i> >= fromIndex) 1548 * </pre></blockquote> 1549 * is true. For other values of <code>ch</code>, it is the 1550 * smallest value <i>k</i> such that: 1551 * <blockquote><pre> 1552 * (this.codePointAt(<i>k</i>) == ch) && (<i>k</i> >= fromIndex) 1553 * </pre></blockquote> 1554 * is true. In either case, if no such character occurs in this 1555 * string at or after position <code>fromIndex</code>, then 1556 * <code>-1</code> is returned. 1557 * 1558 * <p> 1559 * There is no restriction on the value of <code>fromIndex</code>. If it 1560 * is negative, it has the same effect as if it were zero: this entire 1561 * string may be searched. If it is greater than the length of this 1562 * string, it has the same effect as if it were equal to the length of 1563 * this string: <code>-1</code> is returned. 1564 * 1565 * <p>All indices are specified in <code>char</code> values 1566 * (Unicode code units). 1567 * 1568 * @param ch a character (Unicode code point). 1569 * @param fromIndex the index to start the search from. 1570 * @return the index of the first occurrence of the character in the 1571 * character sequence represented by this object that is greater 1572 * than or equal to <code>fromIndex</code>, or <code>-1</code> 1573 * if the character does not occur. 1574 */ 1575 public int indexOf(int ch, int fromIndex) { 1576 int max = offset + count; 1577 char v[] = value; 1578 1579 if (fromIndex < 0) { 1580 fromIndex = 0; 1581 } else if (fromIndex >= count) { 1582 // Note: fromIndex might be near -1>>>1. 1583 return -1; 1584 } 1585 1586 int i = offset + fromIndex; 1587 if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) { 1588 // handle most cases here (ch is a BMP code point or a 1589 // negative value (invalid code point)) 1590 for (; i < max ; i++) { 1591 if (v[i] == ch) { 1592 return i - offset; 1593 } 1594 } 1595 return -1; 1596 } 1597 1598 if (ch <= Character.MAX_CODE_POINT) { 1599 // handle supplementary characters here 1600 char[] surrogates = Character.toChars(ch); 1601 for (; i < max; i++) { 1602 if (v[i] == surrogates[0]) { 1603 if (i + 1 == max) { 1604 break; 1605 } 1606 if (v[i+1] == surrogates[1]) { 1607 return i - offset; 1608 } 1609 } 1610 } 1611 } 1612 return -1; 1613 } 1614 1615 /** 1616 * Returns the index within this string of the last occurrence of 1617 * the specified character. For values of <code>ch</code> in the 1618 * range from 0 to 0xFFFF (inclusive), the index (in Unicode code 1619 * units) returned is the largest value <i>k</i> such that: 1620 * <blockquote><pre> 1621 * this.charAt(<i>k</i>) == ch 1622 * </pre></blockquote> 1623 * is true. For other values of <code>ch</code>, it is the 1624 * largest value <i>k</i> such that: 1625 * <blockquote><pre> 1626 * this.codePointAt(<i>k</i>) == ch 1627 * </pre></blockquote> 1628 * is true. In either case, if no such character occurs in this 1629 * string, then <code>-1</code> is returned. The 1630 * <code>String</code> is searched backwards starting at the last 1631 * character. 1632 * 1633 * @param ch a character (Unicode code point). 1634 * @return the index of the last occurrence of the character in the 1635 * character sequence represented by this object, or 1636 * <code>-1</code> if the character does not occur. 1637 */ 1638 public int lastIndexOf(int ch) { 1639 return lastIndexOf(ch, count - 1); 1640 } 1641 1642 /** 1643 * Returns the index within this string of the last occurrence of 1644 * the specified character, searching backward starting at the 1645 * specified index. For values of <code>ch</code> in the range 1646 * from 0 to 0xFFFF (inclusive), the index returned is the largest 1647 * value <i>k</i> such that: 1648 * <blockquote><pre> 1649 * (this.charAt(<i>k</i>) == ch) && (<i>k</i> <= fromIndex) 1650 * </pre></blockquote> 1651 * is true. For other values of <code>ch</code>, it is the 1652 * largest value <i>k</i> such that: 1653 * <blockquote><pre> 1654 * (this.codePointAt(<i>k</i>) == ch) && (<i>k</i> <= fromIndex) 1655 * </pre></blockquote> 1656 * is true. In either case, if no such character occurs in this 1657 * string at or before position <code>fromIndex</code>, then 1658 * <code>-1</code> is returned. 1659 * 1660 * <p>All indices are specified in <code>char</code> values 1661 * (Unicode code units). 1662 * 1663 * @param ch a character (Unicode code point). 1664 * @param fromIndex the index to start the search from. There is no 1665 * restriction on the value of <code>fromIndex</code>. If it is 1666 * greater than or equal to the length of this string, it has 1667 * the same effect as if it were equal to one less than the 1668 * length of this string: this entire string may be searched. 1669 * If it is negative, it has the same effect as if it were -1: 1670 * -1 is returned. 1671 * @return the index of the last occurrence of the character in the 1672 * character sequence represented by this object that is less 1673 * than or equal to <code>fromIndex</code>, or <code>-1</code> 1674 * if the character does not occur before that point. 1675 */ 1676 public int lastIndexOf(int ch, int fromIndex) { 1677 int min = offset; 1678 char v[] = value; 1679 1680 int i = offset + ((fromIndex >= count) ? count - 1 : fromIndex); 1681 1682 if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) { 1683 // handle most cases here (ch is a BMP code point or a 1684 // negative value (invalid code point)) 1685 for (; i >= min ; i--) { 1686 if (v[i] == ch) { 1687 return i - offset; 1688 } 1689 } 1690 return -1; 1691 } 1692 1693 int max = offset + count; 1694 if (ch <= Character.MAX_CODE_POINT) { 1695 // handle supplementary characters here 1696 char[] surrogates = Character.toChars(ch); 1697 for (; i >= min; i--) { 1698 if (v[i] == surrogates[0]) { 1699 if (i + 1 == max) { 1700 break; 1701 } 1702 if (v[i+1] == surrogates[1]) { 1703 return i - offset; 1704 } 1705 } 1706 } 1707 } 1708 return -1; 1709 } 1710 1711 /** 1712 * Returns the index within this string of the first occurrence of the 1713 * specified substring. The integer returned is the smallest value 1714 * <i>k</i> such that: 1715 * <blockquote><pre> 1716 * this.startsWith(str, <i>k</i>) 1717 * </pre></blockquote> 1718 * is <code>true</code>. 1719 * 1720 * @param str any string. 1721 * @return if the string argument occurs as a substring within this 1722 * object, then the index of the first character of the first 1723 * such substring is returned; if it does not occur as a 1724 * substring, <code>-1</code> is returned. 1725 */ 1726 public int indexOf(String str) { 1727 return indexOf(str, 0); 1728 } 1729 1730 /** 1731 * Returns the index within this string of the first occurrence of the 1732 * specified substring, starting at the specified index. The integer 1733 * returned is the smallest value <tt>k</tt> for which: 1734 * <blockquote><pre> 1735 * k >= Math.min(fromIndex, this.length()) && this.startsWith(str, k) 1736 * </pre></blockquote> 1737 * If no such value of <i>k</i> exists, then -1 is returned. 1738 * 1739 * @param str the substring for which to search. 1740 * @param fromIndex the index from which to start the search. 1741 * @return the index within this string of the first occurrence of the 1742 * specified substring, starting at the specified index. 1743 */ 1744 public int indexOf(String str, int fromIndex) { 1745 return indexOf(value, offset, count, 1746 str.value, str.offset, str.count, fromIndex); 1747 } 1748 1749 /** 1750 * Code shared by String and StringBuffer to do searches. The 1751 * source is the character array being searched, and the target 1752 * is the string being searched for. 1753 * 1754 * @param source the characters being searched. 1755 * @param sourceOffset offset of the source string. 1756 * @param sourceCount count of the source string. 1757 * @param target the characters being searched for. 1758 * @param targetOffset offset of the target string. 1759 * @param targetCount count of the target string. 1760 * @param fromIndex the index to begin searching from. 1761 */ 1762 static int indexOf(char[] source, int sourceOffset, int sourceCount, 1763 char[] target, int targetOffset, int targetCount, 1764 int fromIndex) { 1765 if (fromIndex >= sourceCount) { 1766 return (targetCount == 0 ? sourceCount : -1); 1767 } 1768 if (fromIndex < 0) { 1769 fromIndex = 0; 1770 } 1771 if (targetCount == 0) { 1772 return fromIndex; 1773 } 1774 1775 char first = target[targetOffset]; 1776 int max = sourceOffset + (sourceCount - targetCount); 1777 1778 for (int i = sourceOffset + fromIndex; i <= max; i++) { 1779 /* Look for first character. */ 1780 if (source[i] != first) { 1781 while (++i <= max && source[i] != first); 1782 } 1783 1784 /* Found first character, now look at the rest of v2 */ 1785 if (i <= max) { 1786 int j = i + 1; 1787 int end = j + targetCount - 1; 1788 for (int k = targetOffset + 1; j < end && source[j] == 1789 target[k]; j++, k++); 1790 1791 if (j == end) { 1792 /* Found whole string. */ 1793 return i - sourceOffset; 1794 } 1795 } 1796 } 1797 return -1; 1798 } 1799 1800 /** 1801 * Returns the index within this string of the rightmost occurrence 1802 * of the specified substring. The rightmost empty string "" is 1803 * considered to occur at the index value <code>this.length()</code>. 1804 * The returned index is the largest value <i>k</i> such that 1805 * <blockquote><pre> 1806 * this.startsWith(str, k) 1807 * </pre></blockquote> 1808 * is true. 1809 * 1810 * @param str the substring to search for. 1811 * @return if the string argument occurs one or more times as a substring 1812 * within this object, then the index of the first character of 1813 * the last such substring is returned. If it does not occur as 1814 * a substring, <code>-1</code> is returned. 1815 */ 1816 public int lastIndexOf(String str) { 1817 return lastIndexOf(str, count); 1818 } 1819 1820 /** 1821 * Returns the index within this string of the last occurrence of the 1822 * specified substring, searching backward starting at the specified index. 1823 * The integer returned is the largest value <i>k</i> such that: 1824 * <blockquote><pre> 1825 * k <= Math.min(fromIndex, this.length()) && this.startsWith(str, k) 1826 * </pre></blockquote> 1827 * If no such value of <i>k</i> exists, then -1 is returned. 1828 * 1829 * @param str the substring to search for. 1830 * @param fromIndex the index to start the search from. 1831 * @return the index within this string of the last occurrence of the 1832 * specified substring. 1833 */ 1834 public int lastIndexOf(String str, int fromIndex) { 1835 return lastIndexOf(value, offset, count, 1836 str.value, str.offset, str.count, fromIndex); 1837 } 1838 1839 /** 1840 * Code shared by String and StringBuffer to do searches. The 1841 * source is the character array being searched, and the target 1842 * is the string being searched for. 1843 * 1844 * @param source the characters being searched. 1845 * @param sourceOffset offset of the source string. 1846 * @param sourceCount count of the source string. 1847 * @param target the characters being searched for. 1848 * @param targetOffset offset of the target string. 1849 * @param targetCount count of the target string. 1850 * @param fromIndex the index to begin searching from. 1851 */ 1852 static int lastIndexOf(char[] source, int sourceOffset, int sourceCount, 1853 char[] target, int targetOffset, int targetCount, 1854 int fromIndex) { 1855 /* 1856 * Check arguments; return immediately where possible. For 1857 * consistency, don't check for null str. 1858 */ 1859 int rightIndex = sourceCount - targetCount; 1860 if (fromIndex < 0) { 1861 return -1; 1862 } 1863 if (fromIndex > rightIndex) { 1864 fromIndex = rightIndex; 1865 } 1866 /* Empty string always matches. */ 1867 if (targetCount == 0) { 1868 return fromIndex; 1869 } 1870 1871 int strLastIndex = targetOffset + targetCount - 1; 1872 char strLastChar = target[strLastIndex]; 1873 int min = sourceOffset + targetCount - 1; 1874 int i = min + fromIndex; 1875 1876 startSearchForLastChar: 1877 while (true) { 1878 while (i >= min && source[i] != strLastChar) { 1879 i--; 1880 } 1881 if (i < min) { 1882 return -1; 1883 } 1884 int j = i - 1; 1885 int start = j - (targetCount - 1); 1886 int k = strLastIndex - 1; 1887 1888 while (j > start) { 1889 if (source[j--] != target[k--]) { 1890 i--; 1891 continue startSearchForLastChar; 1892 } 1893 } 1894 return start - sourceOffset + 1; 1895 } 1896 } 1897 1898 /** 1899 * Returns a new string that is a substring of this string. The 1900 * substring begins with the character at the specified index and 1901 * extends to the end of this string. <p> 1902 * Examples: 1903 * <blockquote><pre> 1904 * "unhappy".substring(2) returns "happy" 1905 * "Harbison".substring(3) returns "bison" 1906 * "emptiness".substring(9) returns "" (an empty string) 1907 * </pre></blockquote> 1908 * 1909 * @param beginIndex the beginning index, inclusive. 1910 * @return the specified substring. 1911 * @exception IndexOutOfBoundsException if 1912 * <code>beginIndex</code> is negative or larger than the 1913 * length of this <code>String</code> object. 1914 */ 1915 public String substring(int beginIndex) { 1916 return substring(beginIndex, count); 1917 } 1918 1919 /** 1920 * Returns a new string that is a substring of this string. The 1921 * substring begins at the specified <code>beginIndex</code> and 1922 * extends to the character at index <code>endIndex - 1</code>. 1923 * Thus the length of the substring is <code>endIndex-beginIndex</code>. 1924 * <p> 1925 * Examples: 1926 * <blockquote><pre> 1927 * "hamburger".substring(4, 8) returns "urge" 1928 * "smiles".substring(1, 5) returns "mile" 1929 * </pre></blockquote> 1930 * 1931 * @param beginIndex the beginning index, inclusive. 1932 * @param endIndex the ending index, exclusive. 1933 * @return the specified substring. 1934 * @exception IndexOutOfBoundsException if the 1935 * <code>beginIndex</code> is negative, or 1936 * <code>endIndex</code> is larger than the length of 1937 * this <code>String</code> object, or 1938 * <code>beginIndex</code> is larger than 1939 * <code>endIndex</code>. 1940 */ 1941 public String substring(int beginIndex, int endIndex) { 1942 if (beginIndex < 0) { 1943 throw new StringIndexOutOfBoundsException(beginIndex); 1944 } 1945 if (endIndex > count) { 1946 throw new StringIndexOutOfBoundsException(endIndex); 1947 } 1948 if (beginIndex > endIndex) { 1949 throw new StringIndexOutOfBoundsException(endIndex - beginIndex); 1950 } 1951 return ((beginIndex == 0) && (endIndex == count)) ? this : 1952 new String(offset + beginIndex, endIndex - beginIndex, value); 1953 } 1954 1955 /** 1956 * Returns a new character sequence that is a subsequence of this sequence. 1957 * 1958 * <p> An invocation of this method of the form 1959 * 1960 * <blockquote><pre> 1961 * str.subSequence(begin, end)</pre></blockquote> 1962 * 1963 * behaves in exactly the same way as the invocation 1964 * 1965 * <blockquote><pre> 1966 * str.substring(begin, end)</pre></blockquote> 1967 * 1968 * This method is defined so that the <tt>String</tt> class can implement 1969 * the {@link CharSequence} interface. </p> 1970 * 1971 * @param beginIndex the begin index, inclusive. 1972 * @param endIndex the end index, exclusive. 1973 * @return the specified subsequence. 1974 * 1975 * @throws IndexOutOfBoundsException 1976 * if <tt>beginIndex</tt> or <tt>endIndex</tt> are negative, 1977 * if <tt>endIndex</tt> is greater than <tt>length()</tt>, 1978 * or if <tt>beginIndex</tt> is greater than <tt>startIndex</tt> 1979 * 1980 * @since 1.4 1981 * @spec JSR-51 1982 */ 1983 public CharSequence subSequence(int beginIndex, int endIndex) { 1984 return this.substring(beginIndex, endIndex); 1985 } 1986 1987 /** 1988 * Concatenates the specified string to the end of this string. 1989 * <p> 1990 * If the length of the argument string is <code>0</code>, then this 1991 * <code>String</code> object is returned. Otherwise, a new 1992 * <code>String</code> object is created, representing a character 1993 * sequence that is the concatenation of the character sequence 1994 * represented by this <code>String</code> object and the character 1995 * sequence represented by the argument string.<p> 1996 * Examples: 1997 * <blockquote><pre> 1998 * "cares".concat("s") returns "caress" 1999 * "to".concat("get").concat("her") returns "together" 2000 * </pre></blockquote> 2001 * 2002 * @param str the <code>String</code> that is concatenated to the end 2003 * of this <code>String</code>. 2004 * @return a string that represents the concatenation of this object's 2005 * characters followed by the string argument's characters. 2006 */ 2007 public String concat(String str) { 2008 int otherLen = str.length(); 2009 if (otherLen == 0) { 2010 return this; 2011 } 2012 char buf[] = new char[count + otherLen]; 2013 getChars(0, count, buf, 0); 2014 str.getChars(0, otherLen, buf, count); 2015 return new String(0, count + otherLen, buf); 2016 } 2017 2018 /** 2019 * Returns a new string resulting from replacing all occurrences of 2020 * <code>oldChar</code> in this string with <code>newChar</code>. 2021 * <p> 2022 * If the character <code>oldChar</code> does not occur in the 2023 * character sequence represented by this <code>String</code> object, 2024 * then a reference to this <code>String</code> object is returned. 2025 * Otherwise, a new <code>String</code> object is created that 2026 * represents a character sequence identical to the character sequence 2027 * represented by this <code>String</code> object, except that every 2028 * occurrence of <code>oldChar</code> is replaced by an occurrence 2029 * of <code>newChar</code>. 2030 * <p> 2031 * Examples: 2032 * <blockquote><pre> 2033 * "mesquite in your cellar".replace('e', 'o') 2034 * returns "mosquito in your collar" 2035 * "the war of baronets".replace('r', 'y') 2036 * returns "the way of bayonets" 2037 * "sparring with a purple porpoise".replace('p', 't') 2038 * returns "starring with a turtle tortoise" 2039 * "JonL".replace('q', 'x') returns "JonL" (no change) 2040 * </pre></blockquote> 2041 * 2042 * @param oldChar the old character. 2043 * @param newChar the new character. 2044 * @return a string derived from this string by replacing every 2045 * occurrence of <code>oldChar</code> with <code>newChar</code>. 2046 */ 2047 public String replace(char oldChar, char newChar) { 2048 if (oldChar != newChar) { 2049 int len = count; 2050 int i = -1; 2051 char[] val = value; /* avoid getfield opcode */ 2052 int off = offset; /* avoid getfield opcode */ 2053 2054 while (++i < len) { 2055 if (val[off + i] == oldChar) { 2056 break; 2057 } 2058 } 2059 if (i < len) { 2060 char buf[] = new char[len]; 2061 for (int j = 0 ; j < i ; j++) { 2062 buf[j] = val[off+j]; 2063 } 2064 while (i < len) { 2065 char c = val[off + i]; 2066 buf[i] = (c == oldChar) ? newChar : c; 2067 i++; 2068 } 2069 return new String(0, len, buf); 2070 } 2071 } 2072 return this; 2073 } 2074 2075 /** 2076 * Tells whether or not this string matches the given <a 2077 * href="../util/regex/Pattern.html#sum">regular expression</a>. 2078 * 2079 * <p> An invocation of this method of the form 2080 * <i>str</i><tt>.matches(</tt><i>regex</i><tt>)</tt> yields exactly the 2081 * same result as the expression 2082 * 2083 * <blockquote><tt> {@link java.util.regex.Pattern}.{@link 2084 * java.util.regex.Pattern#matches(String,CharSequence) 2085 * matches}(</tt><i>regex</i><tt>,</tt> <i>str</i><tt>)</tt></blockquote> 2086 * 2087 * @param regex 2088 * the regular expression to which this string is to be matched 2089 * 2090 * @return <tt>true</tt> if, and only if, this string matches the 2091 * given regular expression 2092 * 2093 * @throws PatternSyntaxException 2094 * if the regular expression's syntax is invalid 2095 * 2096 * @see java.util.regex.Pattern 2097 * 2098 * @since 1.4 2099 * @spec JSR-51 2100 */ 2101 public boolean matches(String regex) { 2102 return Pattern.matches(regex, this); 2103 } 2104 2105 /** 2106 * Returns true if and only if this string contains the specified 2107 * sequence of char values. 2108 * 2109 * @param s the sequence to search for 2110 * @return true if this string contains <code>s</code>, false otherwise 2111 * @throws NullPointerException if <code>s</code> is <code>null</code> 2112 * @since 1.5 2113 */ 2114 public boolean contains(CharSequence s) { 2115 return indexOf(s.toString()) > -1; 2116 } 2117 2118 /** 2119 * Replaces the first substring of this string that matches the given <a 2120 * href="../util/regex/Pattern.html#sum">regular expression</a> with the 2121 * given replacement. 2122 * 2123 * <p> An invocation of this method of the form 2124 * <i>str</i><tt>.replaceFirst(</tt><i>regex</i><tt>,</tt> <i>repl</i><tt>)</tt> 2125 * yields exactly the same result as the expression 2126 * 2127 * <blockquote><tt> 2128 * {@link java.util.regex.Pattern}.{@link java.util.regex.Pattern#compile 2129 * compile}(</tt><i>regex</i><tt>).{@link 2130 * java.util.regex.Pattern#matcher(java.lang.CharSequence) 2131 * matcher}(</tt><i>str</i><tt>).{@link java.util.regex.Matcher#replaceFirst 2132 * replaceFirst}(</tt><i>repl</i><tt>)</tt></blockquote> 2133 * 2134 *<p> 2135 * Note that backslashes (<tt>\</tt>) and dollar signs (<tt>$</tt>) in the 2136 * replacement string may cause the results to be different than if it were 2137 * being treated as a literal replacement string; see 2138 * {@link java.util.regex.Matcher#replaceFirst}. 2139 * Use {@link java.util.regex.Matcher#quoteReplacement} to suppress the special 2140 * meaning of these characters, if desired. 2141 * 2142 * @param regex 2143 * the regular expression to which this string is to be matched 2144 * @param replacement 2145 * the string to be substituted for the first match 2146 * 2147 * @return The resulting <tt>String</tt> 2148 * 2149 * @throws PatternSyntaxException 2150 * if the regular expression's syntax is invalid 2151 * 2152 * @see java.util.regex.Pattern 2153 * 2154 * @since 1.4 2155 * @spec JSR-51 2156 */ 2157 public String replaceFirst(String regex, String replacement) { 2158 return Pattern.compile(regex).matcher(this).replaceFirst(replacement); 2159 } 2160 2161 /** 2162 * Replaces each substring of this string that matches the given <a 2163 * href="../util/regex/Pattern.html#sum">regular expression</a> with the 2164 * given replacement. 2165 * 2166 * <p> An invocation of this method of the form 2167 * <i>str</i><tt>.replaceAll(</tt><i>regex</i><tt>,</tt> <i>repl</i><tt>)</tt> 2168 * yields exactly the same result as the expression 2169 * 2170 * <blockquote><tt> 2171 * {@link java.util.regex.Pattern}.{@link java.util.regex.Pattern#compile 2172 * compile}(</tt><i>regex</i><tt>).{@link 2173 * java.util.regex.Pattern#matcher(java.lang.CharSequence) 2174 * matcher}(</tt><i>str</i><tt>).{@link java.util.regex.Matcher#replaceAll 2175 * replaceAll}(</tt><i>repl</i><tt>)</tt></blockquote> 2176 * 2177 *<p> 2178 * Note that backslashes (<tt>\</tt>) and dollar signs (<tt>$</tt>) in the 2179 * replacement string may cause the results to be different than if it were 2180 * being treated as a literal replacement string; see 2181 * {@link java.util.regex.Matcher#replaceAll Matcher.replaceAll}. 2182 * Use {@link java.util.regex.Matcher#quoteReplacement} to suppress the special 2183 * meaning of these characters, if desired. 2184 * 2185 * @param regex 2186 * the regular expression to which this string is to be matched 2187 * @param replacement 2188 * the string to be substituted for each match 2189 * 2190 * @return The resulting <tt>String</tt> 2191 * 2192 * @throws PatternSyntaxException 2193 * if the regular expression's syntax is invalid 2194 * 2195 * @see java.util.regex.Pattern 2196 * 2197 * @since 1.4 2198 * @spec JSR-51 2199 */ 2200 public String replaceAll(String regex, String replacement) { 2201 return Pattern.compile(regex).matcher(this).replaceAll(replacement); 2202 } 2203 2204 /** 2205 * Replaces each substring of this string that matches the literal target 2206 * sequence with the specified literal replacement sequence. The 2207 * replacement proceeds from the beginning of the string to the end, for 2208 * example, replacing "aa" with "b" in the string "aaa" will result in 2209 * "ba" rather than "ab". 2210 * 2211 * @param target The sequence of char values to be replaced 2212 * @param replacement The replacement sequence of char values 2213 * @return The resulting string 2214 * @throws NullPointerException if <code>target</code> or 2215 * <code>replacement</code> is <code>null</code>. 2216 * @since 1.5 2217 */ 2218 public String replace(CharSequence target, CharSequence replacement) { 2219 return Pattern.compile(target.toString(), Pattern.LITERAL).matcher( 2220 this).replaceAll(Matcher.quoteReplacement(replacement.toString())); 2221 } 2222 2223 /** 2224 * Splits this string around matches of the given 2225 * <a href="../util/regex/Pattern.html#sum">regular expression</a>. 2226 * 2227 * <p> The array returned by this method contains each substring of this 2228 * string that is terminated by another substring that matches the given 2229 * expression or is terminated by the end of the string. The substrings in 2230 * the array are in the order in which they occur in this string. If the 2231 * expression does not match any part of the input then the resulting array 2232 * has just one element, namely this string. 2233 * 2234 * <p> The <tt>limit</tt> parameter controls the number of times the 2235 * pattern is applied and therefore affects the length of the resulting 2236 * array. If the limit <i>n</i> is greater than zero then the pattern 2237 * will be applied at most <i>n</i> - 1 times, the array's 2238 * length will be no greater than <i>n</i>, and the array's last entry 2239 * will contain all input beyond the last matched delimiter. If <i>n</i> 2240 * is non-positive then the pattern will be applied as many times as 2241 * possible and the array can have any length. If <i>n</i> is zero then 2242 * the pattern will be applied as many times as possible, the array can 2243 * have any length, and trailing empty strings will be discarded. 2244 * 2245 * <p> The string <tt>"boo:and:foo"</tt>, for example, yields the 2246 * following results with these parameters: 2247 * 2248 * <blockquote><table cellpadding=1 cellspacing=0 summary="Split example showing regex, limit, and result"> 2249 * <tr> 2250 * <th>Regex</th> 2251 * <th>Limit</th> 2252 * <th>Result</th> 2253 * </tr> 2254 * <tr><td align=center>:</td> 2255 * <td align=center>2</td> 2256 * <td><tt>{ "boo", "and:foo" }</tt></td></tr> 2257 * <tr><td align=center>:</td> 2258 * <td align=center>5</td> 2259 * <td><tt>{ "boo", "and", "foo" }</tt></td></tr> 2260 * <tr><td align=center>:</td> 2261 * <td align=center>-2</td> 2262 * <td><tt>{ "boo", "and", "foo" }</tt></td></tr> 2263 * <tr><td align=center>o</td> 2264 * <td align=center>5</td> 2265 * <td><tt>{ "b", "", ":and:f", "", "" }</tt></td></tr> 2266 * <tr><td align=center>o</td> 2267 * <td align=center>-2</td> 2268 * <td><tt>{ "b", "", ":and:f", "", "" }</tt></td></tr> 2269 * <tr><td align=center>o</td> 2270 * <td align=center>0</td> 2271 * <td><tt>{ "b", "", ":and:f" }</tt></td></tr> 2272 * </table></blockquote> 2273 * 2274 * <p> An invocation of this method of the form 2275 * <i>str.</i><tt>split(</tt><i>regex</i><tt>,</tt> <i>n</i><tt>)</tt> 2276 * yields the same result as the expression 2277 * 2278 * <blockquote> 2279 * {@link java.util.regex.Pattern}.{@link java.util.regex.Pattern#compile 2280 * compile}<tt>(</tt><i>regex</i><tt>)</tt>.{@link 2281 * java.util.regex.Pattern#split(java.lang.CharSequence,int) 2282 * split}<tt>(</tt><i>str</i><tt>,</tt> <i>n</i><tt>)</tt> 2283 * </blockquote> 2284 * 2285 * 2286 * @param regex 2287 * the delimiting regular expression 2288 * 2289 * @param limit 2290 * the result threshold, as described above 2291 * 2292 * @return the array of strings computed by splitting this string 2293 * around matches of the given regular expression 2294 * 2295 * @throws PatternSyntaxException 2296 * if the regular expression's syntax is invalid 2297 * 2298 * @see java.util.regex.Pattern 2299 * 2300 * @since 1.4 2301 * @spec JSR-51 2302 */ 2303 public String[] split(String regex, int limit) { 2304 return Pattern.compile(regex).split(this, limit); 2305 } 2306 2307 /** 2308 * Splits this string around matches of the given <a 2309 * href="../util/regex/Pattern.html#sum">regular expression</a>. 2310 * 2311 * <p> This method works as if by invoking the two-argument {@link 2312 * #split(String, int) split} method with the given expression and a limit 2313 * argument of zero. Trailing empty strings are therefore not included in 2314 * the resulting array. 2315 * 2316 * <p> The string <tt>"boo:and:foo"</tt>, for example, yields the following 2317 * results with these expressions: 2318 * 2319 * <blockquote><table cellpadding=1 cellspacing=0 summary="Split examples showing regex and result"> 2320 * <tr> 2321 * <th>Regex</th> 2322 * <th>Result</th> 2323 * </tr> 2324 * <tr><td align=center>:</td> 2325 * <td><tt>{ "boo", "and", "foo" }</tt></td></tr> 2326 * <tr><td align=center>o</td> 2327 * <td><tt>{ "b", "", ":and:f" }</tt></td></tr> 2328 * </table></blockquote> 2329 * 2330 * 2331 * @param regex 2332 * the delimiting regular expression 2333 * 2334 * @return the array of strings computed by splitting this string 2335 * around matches of the given regular expression 2336 * 2337 * @throws PatternSyntaxException 2338 * if the regular expression's syntax is invalid 2339 * 2340 * @see java.util.regex.Pattern 2341 * 2342 * @since 1.4 2343 * @spec JSR-51 2344 */ 2345 public String[] split(String regex) { 2346 return split(regex, 0); 2347 } 2348 2349 /** 2350 * Converts all of the characters in this <code>String</code> to lower 2351 * case using the rules of the given <code>Locale</code>. Case mapping is based 2352 * on the Unicode Standard version specified by the {@link java.lang.Character Character} 2353 * class. Since case mappings are not always 1:1 char mappings, the resulting 2354 * <code>String</code> may be a different length than the original <code>String</code>. 2355 * <p> 2356 * Examples of lowercase mappings are in the following table: 2357 * <table border="1" summary="Lowercase mapping examples showing language code of locale, upper case, lower case, and description"> 2358 * <tr> 2359 * <th>Language Code of Locale</th> 2360 * <th>Upper Case</th> 2361 * <th>Lower Case</th> 2362 * <th>Description</th> 2363 * </tr> 2364 * <tr> 2365 * <td>tr (Turkish)</td> 2366 * <td>\u0130</td> 2367 * <td>\u0069</td> 2368 * <td>capital letter I with dot above -> small letter i</td> 2369 * </tr> 2370 * <tr> 2371 * <td>tr (Turkish)</td> 2372 * <td>\u0049</td> 2373 * <td>\u0131</td> 2374 * <td>capital letter I -> small letter dotless i </td> 2375 * </tr> 2376 * <tr> 2377 * <td>(all)</td> 2378 * <td>French Fries</td> 2379 * <td>french fries</td> 2380 * <td>lowercased all chars in String</td> 2381 * </tr> 2382 * <tr> 2383 * <td>(all)</td> 2384 * <td><img src="doc-files/capiota.gif" alt="capiota"><img src="doc-files/capchi.gif" alt="capchi"> 2385 * <img src="doc-files/captheta.gif" alt="captheta"><img src="doc-files/capupsil.gif" alt="capupsil"> 2386 * <img src="doc-files/capsigma.gif" alt="capsigma"></td> 2387 * <td><img src="doc-files/iota.gif" alt="iota"><img src="doc-files/chi.gif" alt="chi"> 2388 * <img src="doc-files/theta.gif" alt="theta"><img src="doc-files/upsilon.gif" alt="upsilon"> 2389 * <img src="doc-files/sigma1.gif" alt="sigma"></td> 2390 * <td>lowercased all chars in String</td> 2391 * </tr> 2392 * </table> 2393 * 2394 * @param locale use the case transformation rules for this locale 2395 * @return the <code>String</code>, converted to lowercase. 2396 * @see java.lang.String#toLowerCase() 2397 * @see java.lang.String#toUpperCase() 2398 * @see java.lang.String#toUpperCase(Locale) 2399 * @since 1.1 2400 */ 2401 public String toLowerCase(Locale locale) { 2402 if (locale == null) { 2403 throw new NullPointerException(); 2404 } 2405 2406 int firstUpper; 2407 2408 /* Now check if there are any characters that need to be changed. */ 2409 scan: { 2410 for (firstUpper = 0 ; firstUpper < count; ) { 2411 char c = value[offset+firstUpper]; 2412 if ((c >= Character.MIN_HIGH_SURROGATE) && 2413 (c <= Character.MAX_HIGH_SURROGATE)) { 2414 int supplChar = codePointAt(firstUpper); 2415 if (supplChar != Character.toLowerCase(supplChar)) { 2416 break scan; 2417 } 2418 firstUpper += Character.charCount(supplChar); 2419 } else { 2420 if (c != Character.toLowerCase(c)) { 2421 break scan; 2422 } 2423 firstUpper++; 2424 } 2425 } 2426 return this; 2427 } 2428 2429 char[] result = new char[count]; 2430 int resultOffset = 0; /* result may grow, so i+resultOffset 2431 * is the write location in result */ 2432 2433 /* Just copy the first few lowerCase characters. */ 2434 System.arraycopy(value, offset, result, 0, firstUpper); 2435 2436 String lang = locale.getLanguage(); 2437 boolean localeDependent = 2438 (lang == "tr" || lang == "az" || lang == "lt"); 2439 char[] lowerCharArray; 2440 int lowerChar; 2441 int srcChar; 2442 int srcCount; 2443 for (int i = firstUpper; i < count; i += srcCount) { 2444 srcChar = (int)value[offset+i]; 2445 if ((char)srcChar >= Character.MIN_HIGH_SURROGATE && 2446 (char)srcChar <= Character.MAX_HIGH_SURROGATE) { 2447 srcChar = codePointAt(i); 2448 srcCount = Character.charCount(srcChar); 2449 } else { 2450 srcCount = 1; 2451 } 2452 if (localeDependent || srcChar == '\u03A3') { // GREEK CAPITAL LETTER SIGMA 2453 lowerChar = ConditionalSpecialCasing.toLowerCaseEx(this, i, locale); 2454 } else { 2455 lowerChar = Character.toLowerCase(srcChar); 2456 } 2457 if ((lowerChar == Character.ERROR) || 2458 (lowerChar >= Character.MIN_SUPPLEMENTARY_CODE_POINT)) { 2459 if (lowerChar == Character.ERROR) { 2460 lowerCharArray = 2461 ConditionalSpecialCasing.toLowerCaseCharArray(this, i, locale); 2462 } else if (srcCount == 2) { 2463 resultOffset += Character.toChars(lowerChar, result, i + resultOffset) - srcCount; 2464 continue; 2465 } else { 2466 lowerCharArray = Character.toChars(lowerChar); 2467 } 2468 2469 /* Grow result if needed */ 2470 int mapLen = lowerCharArray.length; 2471 if (mapLen > srcCount) { 2472 char[] result2 = new char[result.length + mapLen - srcCount]; 2473 System.arraycopy(result, 0, result2, 0, 2474 i + resultOffset); 2475 result = result2; 2476 } 2477 for (int x=0; x<mapLen; ++x) { 2478 result[i+resultOffset+x] = lowerCharArray[x]; 2479 } 2480 resultOffset += (mapLen - srcCount); 2481 } else { 2482 result[i+resultOffset] = (char)lowerChar; 2483 } 2484 } 2485 return new String(0, count+resultOffset, result); 2486 } 2487 2488 /** 2489 * Converts all of the characters in this <code>String</code> to lower 2490 * case using the rules of the default locale. This is equivalent to calling 2491 * <code>toLowerCase(Locale.getDefault())</code>. 2492 * <p> 2493 * <b>Note:</b> This method is locale sensitive, and may produce unexpected 2494 * results if used for strings that are intended to be interpreted locale 2495 * independently. 2496 * Examples are programming language identifiers, protocol keys, and HTML 2497 * tags. 2498 * For instance, <code>"TITLE".toLowerCase()</code> in a Turkish locale 2499 * returns <code>"t\u0131tle"</code>, where '\u0131' is the LATIN SMALL 2500 * LETTER DOTLESS I character. 2501 * To obtain correct results for locale insensitive strings, use 2502 * <code>toLowerCase(Locale.ENGLISH)</code>. 2503 * <p> 2504 * @return the <code>String</code>, converted to lowercase. 2505 * @see java.lang.String#toLowerCase(Locale) 2506 */ 2507 public String toLowerCase() { 2508 return toLowerCase(Locale.getDefault()); 2509 } 2510 2511 /** 2512 * Converts all of the characters in this <code>String</code> to upper 2513 * case using the rules of the given <code>Locale</code>. Case mapping is based 2514 * on the Unicode Standard version specified by the {@link java.lang.Character Character} 2515 * class. Since case mappings are not always 1:1 char mappings, the resulting 2516 * <code>String</code> may be a different length than the original <code>String</code>. 2517 * <p> 2518 * Examples of locale-sensitive and 1:M case mappings are in the following table. 2519 * <p> 2520 * <table border="1" summary="Examples of locale-sensitive and 1:M case mappings. Shows Language code of locale, lower case, upper case, and description."> 2521 * <tr> 2522 * <th>Language Code of Locale</th> 2523 * <th>Lower Case</th> 2524 * <th>Upper Case</th> 2525 * <th>Description</th> 2526 * </tr> 2527 * <tr> 2528 * <td>tr (Turkish)</td> 2529 * <td>\u0069</td> 2530 * <td>\u0130</td> 2531 * <td>small letter i -> capital letter I with dot above</td> 2532 * </tr> 2533 * <tr> 2534 * <td>tr (Turkish)</td> 2535 * <td>\u0131</td> 2536 * <td>\u0049</td> 2537 * <td>small letter dotless i -> capital letter I</td> 2538 * </tr> 2539 * <tr> 2540 * <td>(all)</td> 2541 * <td>\u00df</td> 2542 * <td>\u0053 \u0053</td> 2543 * <td>small letter sharp s -> two letters: SS</td> 2544 * </tr> 2545 * <tr> 2546 * <td>(all)</td> 2547 * <td>Fahrvergnügen</td> 2548 * <td>FAHRVERGNÜGEN</td> 2549 * <td></td> 2550 * </tr> 2551 * </table> 2552 * @param locale use the case transformation rules for this locale 2553 * @return the <code>String</code>, converted to uppercase. 2554 * @see java.lang.String#toUpperCase() 2555 * @see java.lang.String#toLowerCase() 2556 * @see java.lang.String#toLowerCase(Locale) 2557 * @since 1.1 2558 */ 2559 public String toUpperCase(Locale locale) { 2560 if (locale == null) { 2561 throw new NullPointerException(); 2562 } 2563 2564 int firstLower; 2565 2566 /* Now check if there are any characters that need to be changed. */ 2567 scan: { 2568 for (firstLower = 0 ; firstLower < count; ) { 2569 int c = (int)value[offset+firstLower]; 2570 int srcCount; 2571 if ((c >= Character.MIN_HIGH_SURROGATE) && 2572 (c <= Character.MAX_HIGH_SURROGATE)) { 2573 c = codePointAt(firstLower); 2574 srcCount = Character.charCount(c); 2575 } else { 2576 srcCount = 1; 2577 } 2578 int upperCaseChar = Character.toUpperCaseEx(c); 2579 if ((upperCaseChar == Character.ERROR) || 2580 (c != upperCaseChar)) { 2581 break scan; 2582 } 2583 firstLower += srcCount; 2584 } 2585 return this; 2586 } 2587 2588 char[] result = new char[count]; /* may grow */ 2589 int resultOffset = 0; /* result may grow, so i+resultOffset 2590 * is the write location in result */ 2591 2592 /* Just copy the first few upperCase characters. */ 2593 System.arraycopy(value, offset, result, 0, firstLower); 2594 2595 String lang = locale.getLanguage(); 2596 boolean localeDependent = 2597 (lang == "tr" || lang == "az" || lang == "lt"); 2598 char[] upperCharArray; 2599 int upperChar; 2600 int srcChar; 2601 int srcCount; 2602 for (int i = firstLower; i < count; i += srcCount) { 2603 srcChar = (int)value[offset+i]; 2604 if ((char)srcChar >= Character.MIN_HIGH_SURROGATE && 2605 (char)srcChar <= Character.MAX_HIGH_SURROGATE) { 2606 srcChar = codePointAt(i); 2607 srcCount = Character.charCount(srcChar); 2608 } else { 2609 srcCount = 1; 2610 } 2611 if (localeDependent) { 2612 upperChar = ConditionalSpecialCasing.toUpperCaseEx(this, i, locale); 2613 } else { 2614 upperChar = Character.toUpperCaseEx(srcChar); 2615 } 2616 if ((upperChar == Character.ERROR) || 2617 (upperChar >= Character.MIN_SUPPLEMENTARY_CODE_POINT)) { 2618 if (upperChar == Character.ERROR) { 2619 if (localeDependent) { 2620 upperCharArray = 2621 ConditionalSpecialCasing.toUpperCaseCharArray(this, i, locale); 2622 } else { 2623 upperCharArray = Character.toUpperCaseCharArray(srcChar); 2624 } 2625 } else if (srcCount == 2) { 2626 resultOffset += Character.toChars(upperChar, result, i + resultOffset) - srcCount; 2627 continue; 2628 } else { 2629 upperCharArray = Character.toChars(upperChar); 2630 } 2631 2632 /* Grow result if needed */ 2633 int mapLen = upperCharArray.length; 2634 if (mapLen > srcCount) { 2635 char[] result2 = new char[result.length + mapLen - srcCount]; 2636 System.arraycopy(result, 0, result2, 0, 2637 i + resultOffset); 2638 result = result2; 2639 } 2640 for (int x=0; x<mapLen; ++x) { 2641 result[i+resultOffset+x] = upperCharArray[x]; 2642 } 2643 resultOffset += (mapLen - srcCount); 2644 } else { 2645 result[i+resultOffset] = (char)upperChar; 2646 } 2647 } 2648 return new String(0, count+resultOffset, result); 2649 } 2650 2651 /** 2652 * Converts all of the characters in this <code>String</code> to upper 2653 * case using the rules of the default locale. This method is equivalent to 2654 * <code>toUpperCase(Locale.getDefault())</code>. 2655 * <p> 2656 * <b>Note:</b> This method is locale sensitive, and may produce unexpected 2657 * results if used for strings that are intended to be interpreted locale 2658 * independently. 2659 * Examples are programming language identifiers, protocol keys, and HTML 2660 * tags. 2661 * For instance, <code>"title".toUpperCase()</code> in a Turkish locale 2662 * returns <code>"T\u0130TLE"</code>, where '\u0130' is the LATIN CAPITAL 2663 * LETTER I WITH DOT ABOVE character. 2664 * To obtain correct results for locale insensitive strings, use 2665 * <code>toUpperCase(Locale.ENGLISH)</code>. 2666 * <p> 2667 * @return the <code>String</code>, converted to uppercase. 2668 * @see java.lang.String#toUpperCase(Locale) 2669 */ 2670 public String toUpperCase() { 2671 return toUpperCase(Locale.getDefault()); 2672 } 2673 2674 /** 2675 * Returns a copy of the string, with leading and trailing whitespace 2676 * omitted. 2677 * <p> 2678 * If this <code>String</code> object represents an empty character 2679 * sequence, or the first and last characters of character sequence 2680 * represented by this <code>String</code> object both have codes 2681 * greater than <code>'\u0020'</code> (the space character), then a 2682 * reference to this <code>String</code> object is returned. 2683 * <p> 2684 * Otherwise, if there is no character with a code greater than 2685 * <code>'\u0020'</code> in the string, then a new 2686 * <code>String</code> object representing an empty string is created 2687 * and returned. 2688 * <p> 2689 * Otherwise, let <i>k</i> be the index of the first character in the 2690 * string whose code is greater than <code>'\u0020'</code>, and let 2691 * <i>m</i> be the index of the last character in the string whose code 2692 * is greater than <code>'\u0020'</code>. A new <code>String</code> 2693 * object is created, representing the substring of this string that 2694 * begins with the character at index <i>k</i> and ends with the 2695 * character at index <i>m</i>-that is, the result of 2696 * <code>this.substring(<i>k</i>, <i>m</i>+1)</code>. 2697 * <p> 2698 * This method may be used to trim whitespace (as defined above) from 2699 * the beginning and end of a string. 2700 * 2701 * @return A copy of this string with leading and trailing white 2702 * space removed, or this string if it has no leading or 2703 * trailing white space. 2704 */ 2705 public String trim() { 2706 int len = count; 2707 int st = 0; 2708 int off = offset; /* avoid getfield opcode */ 2709 char[] val = value; /* avoid getfield opcode */ 2710 2711 while ((st < len) && (val[off + st] <= ' ')) { 2712 st++; 2713 } 2714 while ((st < len) && (val[off + len - 1] <= ' ')) { 2715 len--; 2716 } 2717 return ((st > 0) || (len < count)) ? substring(st, len) : this; 2718 } 2719 2720 /** 2721 * This object (which is already a string!) is itself returned. 2722 * 2723 * @return the string itself. 2724 */ 2725 public String toString() { 2726 return this; 2727 } 2728 2729 /** 2730 * Converts this string to a new character array. 2731 * 2732 * @return a newly allocated character array whose length is the length 2733 * of this string and whose contents are initialized to contain 2734 * the character sequence represented by this string. 2735 */ 2736 public char[] toCharArray() { 2737 char result[] = new char[count]; 2738 getChars(0, count, result, 0); 2739 return result; 2740 } 2741 2742 /** 2743 * Returns a formatted string using the specified format string and 2744 * arguments. 2745 * 2746 * <p> The locale always used is the one returned by {@link 2747 * java.util.Locale#getDefault() Locale.getDefault()}. 2748 * 2749 * @param format 2750 * A <a href="../util/Formatter.html#syntax">format string</a> 2751 * 2752 * @param args 2753 * Arguments referenced by the format specifiers in the format 2754 * string. If there are more arguments than format specifiers, the 2755 * extra arguments are ignored. The number of arguments is 2756 * variable and may be zero. The maximum number of arguments is 2757 * limited by the maximum dimension of a Java array as defined by 2758 * the <a href="http://java.sun.com/docs/books/vmspec/">Java 2759 * Virtual Machine Specification</a>. The behaviour on a 2760 * <tt>null</tt> argument depends on the <a 2761 * href="../util/Formatter.html#syntax">conversion</a>. 2762 * 2763 * @throws IllegalFormatException 2764 * If a format string contains an illegal syntax, a format 2765 * specifier that is incompatible with the given arguments, 2766 * insufficient arguments given the format string, or other 2767 * illegal conditions. For specification of all possible 2768 * formatting errors, see the <a 2769 * href="../util/Formatter.html#detail">Details</a> section of the 2770 * formatter class specification. 2771 * 2772 * @throws NullPointerException 2773 * If the <tt>format</tt> is <tt>null</tt> 2774 * 2775 * @return A formatted string 2776 * 2777 * @see java.util.Formatter 2778 * @since 1.5 2779 */ 2780 public static String format(String format, Object ... args) { 2781 return new Formatter().format(format, args).toString(); 2782 } 2783 2784 /** 2785 * Returns a formatted string using the specified locale, format string, 2786 * and arguments. 2787 * 2788 * @param l 2789 * The {@linkplain java.util.Locale locale} to apply during 2790 * formatting. If <tt>l</tt> is <tt>null</tt> then no localization 2791 * is applied. 2792 * 2793 * @param format 2794 * A <a href="../util/Formatter.html#syntax">format string</a> 2795 * 2796 * @param args 2797 * Arguments referenced by the format specifiers in the format 2798 * string. If there are more arguments than format specifiers, the 2799 * extra arguments are ignored. The number of arguments is 2800 * variable and may be zero. The maximum number of arguments is 2801 * limited by the maximum dimension of a Java array as defined by 2802 * the <a href="http://java.sun.com/docs/books/vmspec/">Java 2803 * Virtual Machine Specification</a>. The behaviour on a 2804 * <tt>null</tt> argument depends on the <a 2805 * href="../util/Formatter.html#syntax">conversion</a>. 2806 * 2807 * @throws IllegalFormatException 2808 * If a format string contains an illegal syntax, a format 2809 * specifier that is incompatible with the given arguments, 2810 * insufficient arguments given the format string, or other 2811 * illegal conditions. For specification of all possible 2812 * formatting errors, see the <a 2813 * href="../util/Formatter.html#detail">Details</a> section of the 2814 * formatter class specification 2815 * 2816 * @throws NullPointerException 2817 * If the <tt>format</tt> is <tt>null</tt> 2818 * 2819 * @return A formatted string 2820 * 2821 * @see java.util.Formatter 2822 * @since 1.5 2823 */ 2824 public static String format(Locale l, String format, Object ... args) { 2825 return new Formatter(l).format(format, args).toString(); 2826 } 2827 2828 /** 2829 * Returns the string representation of the <code>Object</code> argument. 2830 * 2831 * @param obj an <code>Object</code>. 2832 * @return if the argument is <code>null</code>, then a string equal to 2833 * <code>"null"</code>; otherwise, the value of 2834 * <code>obj.toString()</code> is returned. 2835 * @see java.lang.Object#toString() 2836 */ 2837 public static String valueOf(Object obj) { 2838 return (obj == null) ? "null" : obj.toString(); 2839 } 2840 2841 /** 2842 * Returns the string representation of the <code>char</code> array 2843 * argument. The contents of the character array are copied; subsequent 2844 * modification of the character array does not affect the newly 2845 * created string. 2846 * 2847 * @param data a <code>char</code> array. 2848 * @return a newly allocated string representing the same sequence of 2849 * characters contained in the character array argument. 2850 */ 2851 public static String valueOf(char data[]) { 2852 return new String(data); 2853 } 2854 2855 /** 2856 * Returns the string representation of a specific subarray of the 2857 * <code>char</code> array argument. 2858 * <p> 2859 * The <code>offset</code> argument is the index of the first 2860 * character of the subarray. The <code>count</code> argument 2861 * specifies the length of the subarray. The contents of the subarray 2862 * are copied; subsequent modification of the character array does not 2863 * affect the newly created string. 2864 * 2865 * @param data the character array. 2866 * @param offset the initial offset into the value of the 2867 * <code>String</code>. 2868 * @param count the length of the value of the <code>String</code>. 2869 * @return a string representing the sequence of characters contained 2870 * in the subarray of the character array argument. 2871 * @exception IndexOutOfBoundsException if <code>offset</code> is 2872 * negative, or <code>count</code> is negative, or 2873 * <code>offset+count</code> is larger than 2874 * <code>data.length</code>. 2875 */ 2876 public static String valueOf(char data[], int offset, int count) { 2877 return new String(data, offset, count); 2878 } 2879 2880 /** 2881 * Returns a String that represents the character sequence in the 2882 * array specified. 2883 * 2884 * @param data the character array. 2885 * @param offset initial offset of the subarray. 2886 * @param count length of the subarray. 2887 * @return a <code>String</code> that contains the characters of the 2888 * specified subarray of the character array. 2889 */ 2890 public static String copyValueOf(char data[], int offset, int count) { 2891 // All public String constructors now copy the data. 2892 return new String(data, offset, count); 2893 } 2894 2895 /** 2896 * Returns a String that represents the character sequence in the 2897 * array specified. 2898 * 2899 * @param data the character array. 2900 * @return a <code>String</code> that contains the characters of the 2901 * character array. 2902 */ 2903 public static String copyValueOf(char data[]) { 2904 return copyValueOf(data, 0, data.length); 2905 } 2906 2907 /** 2908 * Returns the string representation of the <code>boolean</code> argument. 2909 * 2910 * @param b a <code>boolean</code>. 2911 * @return if the argument is <code>true</code>, a string equal to 2912 * <code>"true"</code> is returned; otherwise, a string equal to 2913 * <code>"false"</code> is returned. 2914 */ 2915 public static String valueOf(boolean b) { 2916 return b ? "true" : "false"; 2917 } 2918 2919 /** 2920 * Returns the string representation of the <code>char</code> 2921 * argument. 2922 * 2923 * @param c a <code>char</code>. 2924 * @return a string of length <code>1</code> containing 2925 * as its single character the argument <code>c</code>. 2926 */ 2927 public static String valueOf(char c) { 2928 char data[] = {c}; 2929 return new String(0, 1, data); 2930 } 2931 2932 /** 2933 * Returns the string representation of the <code>int</code> argument. 2934 * <p> 2935 * The representation is exactly the one returned by the 2936 * <code>Integer.toString</code> method of one argument. 2937 * 2938 * @param i an <code>int</code>. 2939 * @return a string representation of the <code>int</code> argument. 2940 * @see java.lang.Integer#toString(int, int) 2941 */ 2942 public static String valueOf(int i) { 2943 return Integer.toString(i, 10); 2944 } 2945 2946 /** 2947 * Returns the string representation of the <code>long</code> argument. 2948 * <p> 2949 * The representation is exactly the one returned by the 2950 * <code>Long.toString</code> method of one argument. 2951 * 2952 * @param l a <code>long</code>. 2953 * @return a string representation of the <code>long</code> argument. 2954 * @see java.lang.Long#toString(long) 2955 */ 2956 public static String valueOf(long l) { 2957 return Long.toString(l, 10); 2958 } 2959 2960 /** 2961 * Returns the string representation of the <code>float</code> argument. 2962 * <p> 2963 * The representation is exactly the one returned by the 2964 * <code>Float.toString</code> method of one argument. 2965 * 2966 * @param f a <code>float</code>. 2967 * @return a string representation of the <code>float</code> argument. 2968 * @see java.lang.Float#toString(float) 2969 */ 2970 public static String valueOf(float f) { 2971 return Float.toString(f); 2972 } 2973 2974 /** 2975 * Returns the string representation of the <code>double</code> argument. 2976 * <p> 2977 * The representation is exactly the one returned by the 2978 * <code>Double.toString</code> method of one argument. 2979 * 2980 * @param d a <code>double</code>. 2981 * @return a string representation of the <code>double</code> argument. 2982 * @see java.lang.Double#toString(double) 2983 */ 2984 public static String valueOf(double d) { 2985 return Double.toString(d); 2986 } 2987 2988 /** 2989 * Returns a canonical representation for the string object. 2990 * <p> 2991 * A pool of strings, initially empty, is maintained privately by the 2992 * class <code>String</code>. 2993 * <p> 2994 * When the intern method is invoked, if the pool already contains a 2995 * string equal to this <code>String</code> object as determined by 2996 * the {@link #equals(Object)} method, then the string from the pool is 2997 * returned. Otherwise, this <code>String</code> object is added to the 2998 * pool and a reference to this <code>String</code> object is returned. 2999 * <p> 3000 * It follows that for any two strings <code>s</code> and <code>t</code>, 3001 * <code>s.intern() == t.intern()</code> is <code>true</code> 3002 * if and only if <code>s.equals(t)</code> is <code>true</code>. 3003 * <p> 3004 * All literal strings and string-valued constant expressions are 3005 * interned. String literals are defined in §3.10.5 of the 3006 * <a href="http://java.sun.com/docs/books/jls/html/">Java Language 3007 * Specification</a> 3008 * 3009 * @return a string that has the same contents as this string, but is 3010 * guaranteed to be from a pool of unique strings. 3011 */ 3012 public native String intern(); 3013 3014 }