home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1995 November / PCWK1195.iso / inne / win95 / sieciowe / hotja32.lzh / hotjava / classsrc / java / lang / string.java < prev    next >
Text File  |  1995-08-11  |  26KB  |  855 lines
  1. /*
  2.  * @(#)String.java    1.37 95/05/21
  3.  *
  4.  * Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL purposes and without
  8.  * fee is hereby granted provided that this copyright notice
  9.  * appears in all copies. Please refer to the file "copyright.html"
  10.  * for further important copyright and licensing information.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  13.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  14.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  15.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  16.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  17.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  18.  */
  19.  
  20. package java.lang;
  21.  
  22. import java.util.Hashtable;
  23.  
  24. /**
  25.  * A general class of objects to represent character strings.
  26.  * Strings are constant, their values cannot be changed after creation.
  27.  * The compiler makes sure that each string constant actually results
  28.  * in a String object. Because string objects are immutable they can
  29.  * be shared. For example:
  30.  * <pre>
  31.  *    String str = "abc";
  32.  * </pre>
  33.  * is equivalent to:
  34.  * <pre>
  35.  *    char data[] = {'a', 'b', 'c'};
  36.  *    String str = new String(data);
  37.  * </pre>
  38.  * Here are some more examples of how strings can be used:
  39.  * <pre>
  40.  *     System.out.println("abc");
  41.  *     String cde = "cde";
  42.  *     System.out.println("abc" + cde);
  43.  *    String c = "abc".substring(2,1);
  44.  *    String d = cde.substring(1, 1);
  45.  * </pre>
  46.  * @see        StringBuffer
  47.  * @version     1.37, 21 May 1995
  48.  * @author     Lee Boynton
  49.  * @author    Arthur van Hoff
  50.  */
  51. public final
  52. class String extends Object {
  53.     /** The value is used for character storage. */
  54.     private char value[];
  55.  
  56.     /** The offset is the first index of the storage that is used. */
  57.     private int offset;
  58.  
  59.     /** The count is the number of characters in the string. */
  60.     private int count;
  61.  
  62.     /**
  63.      * Constructs a new empty string.
  64.      */
  65.     public String() {
  66.     value = new char[0];
  67.     }
  68.  
  69.     /**
  70.      * Constructs a new string that is a copy of the specified string.
  71.      * @param value the initial value of the String
  72.      */
  73.     public String(String value) {
  74.     count = value.length();
  75.     this.value = new char[count];
  76.     value.getChars(0, count, this.value, 0);
  77.     }
  78.  
  79.     /**
  80.      * Constructs a new string from an array of characters as its initial value.
  81.      * The character array is NOT copied. <em>Do not modify the array after
  82.      * the string is created</em>.
  83.      * @param value the initial value of the String
  84.      */
  85.     public String(char value[]) {
  86.     this.value = value;
  87.     count = value.length;
  88.     }
  89.  
  90.     /**
  91.      * Constructs a new string from a sub array of characters.
  92.      * The value of the new string will be count characters
  93.      * starting at offset.
  94.      * The character array is NOT copied. <em>Do not modify the array after
  95.      * the string is created</em>.
  96.      * @param value    the initial value of the String, an array of characters
  97.      * @param offset    the offset into the value of the string
  98.      * @param count     the length of the value of the string
  99.      */
  100.     public String(char value[], int offset, int count) {
  101.     this.value = value;
  102.     this.offset = offset;
  103.     this.count = count;
  104.     }
  105.  
  106.     /**
  107.      * Constructs a new string from a sub array of bytes.
  108.      * The high-byte of each character can be specified, it should usually be 0.
  109.      * The value of the new string will be count characters
  110.      * starting at offset.
  111.      * @param ascii    the bytes that will be converted to characters
  112.      * @param hibyte    the high byte of each UNICODE character
  113.      * @param offset    the offset into the ascii array
  114.      * @param count     the length of the string
  115.      */
  116.     public String(byte ascii[], int hibyte, int offset, int count) {
  117.     this.count = count;
  118.     value = new char[count];
  119.     hibyte <<= 8;
  120.     for (int i = 0 ; i < count ; i++) {
  121.         value[i] = (char) (hibyte | (ascii[i + offset] & 0xff));
  122.     }
  123.     }
  124.  
  125.     /**
  126.      * Constructs a new string from an array of bytes.
  127.      * The byte array transformed into UNICODE chars using hibyte
  128.      * as the upper byte of each character.
  129.      * @param ascii    the byte that will be converted to characters
  130.      * @param hibyte    the top 8 bits of each 16 bit UNICODE character
  131.      */
  132.     public String(byte ascii[], int hibyte) {
  133.     this(ascii, hibyte, 0, ascii.length);
  134.     }
  135.  
  136.     /**
  137.      * Returns the length of the string.
  138.      * The length of the string is equal to the number of 16 bit
  139.      * UNICODE characters in the string.
  140.      * @return the length of the string
  141.      */
  142.     public int length() {
  143.     return count;
  144.     }
  145.  
  146.     /**
  147.      * Returns the character at the specified index. An index ranges
  148.      * from <tt>0</tt> to <tt>length() - 1</tt>.
  149.      * @param index    the index of the desired character
  150.      * @return         the desired character
  151.      * @exception    StringIndexOutOfRangeException The index is not
  152.      *            in the range <tt>0</tt> to <tt>length()-1</tt>.
  153.      */
  154.     public char charAt(int index) {
  155.     if (index < 0 || index >= count) {
  156.         throw new StringIndexOutOfRangeException(index);
  157.     }
  158.     return value[index + offset];
  159.     }
  160.  
  161.     /**
  162.      * Copies characters from the string into an character array.
  163.      * The characters of the specified substring (determined by
  164.      * srcBegin and srcEnd) are copied into the character array,
  165.      * starting at the array's dstIndex location.
  166.      * @param srcBegin    index of the first character in the string
  167.      * @param srcEnd    end of the characters that are copied
  168.      * @param dst        the destination array
  169.      * @param dstBegin    the start offset in the destination array
  170.      */
  171.     public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
  172.     System.arraycopy(value, offset + srcBegin, dst, dstBegin, srcEnd - srcBegin);
  173.     }
  174.  
  175.     /**
  176.      * Copies characters from the string into a byte array.
  177.      * Copies the characters of the specified substring (determined by
  178.      * srcBegin and srcEnd) into the byte array, starting at the
  179.      * array's dstIndex location.
  180.      * @param srcBegin    index of the first character in the string
  181.      * @param srcEnd    end of the characters that are copied
  182.      * @param dst        the destination array
  183.      * @param dstBegin    the start offset in the destination array
  184.      */
  185.     public void getBytes(int srcBegin, int srcEnd, byte dst[], int dstBegin) {
  186.     int j = dstBegin;
  187.     int n = offset + srcEnd;
  188.     int i = offset + srcBegin;
  189.     while (i < n) {
  190.         dst[j++] = (byte)value[i++];
  191.     }
  192.     }
  193.  
  194.     /**
  195.      * Compares a string against another object.
  196.      * Returns true if the object is equal to this string; that is,
  197.      * has the same length and the same characters in the same sequence.
  198.      * @param anObject    the object to compare this string against
  199.      * @return         true if they are equal
  200.      */
  201.     public boolean equals(Object anObject) {
  202.     if ((anObject != null) && (anObject instanceof String)) {
  203.         String anotherString = (String)anObject;
  204.         if (anotherString.count != count) {
  205.         return false;
  206.         }
  207.         return startsWith(anotherString, 0);
  208.     }
  209.     return false;
  210.     }
  211.  
  212.     /**
  213.      * Compares the string against another object.
  214.      * Returns true if the object is equal to this string; that is,
  215.      * has the same length and the same characters in the same sequence.
  216.      * Upper case character are folded to lower case character before
  217.      * they are compared.
  218.      * @param anObject    the object to compare this string against
  219.      * @return         true if they are equal, ignoring case
  220.      */
  221.     public boolean equalsIgnoreCase(Object anObject) {
  222.     if ((anObject != null) && (anObject instanceof String)) {
  223.         String anotherString = (String) anObject;
  224.         return anotherString.count == count &&
  225.         regionMatches(true, 0, anotherString, 0, count);
  226.     }
  227.     return false;
  228.     }
  229.  
  230.     /**
  231.      * Compares this string against another string.
  232.      * Returns an integer that is less than, equal to, or greater than zero,
  233.      * depending on whether this string is less than, equal to, or greater
  234.      * than anotherString.
  235.      * @return         a number less than zero if this string is lexically
  236.      *            smaller, 0 if the string is equal or a number greater
  237.      *            than 0 if this string is lexically greater.
  238.      */
  239.     public int compareTo(String anotherString) {
  240.     int len1 = length(), len2 = anotherString.length();
  241.     int i, len = Math.min(len1, len2);
  242.     for (i = 0; i < len; i++) {
  243.         char c1 = charAt(i);
  244.         char c2 = anotherString.charAt(i);
  245.         if (c1 != c2) {
  246.         return c1 - c2;
  247.         }
  248.     }
  249.     return len1 - len2;
  250.     }
  251.  
  252.     /**
  253.      * Determines whether a region of one string matches a region
  254.      * of another string.
  255.      * @param toffset    where to start looking in this string
  256.      * @param other     the other string
  257.      * @param ooffset    where to start looking in the other string
  258.      * @param len       the number of characters to match
  259.      * @return          true if the region matches with the other
  260.      */
  261.     public boolean regionMatches(int toffset, String other, int ooffset, int len) {
  262.     char ta[] = value;
  263.     int to = offset + toffset;
  264.     int tlim = offset + count;
  265.     char pa[] = other.value;
  266.     int po = other.offset + ooffset;
  267.     int plim = po + other.count;
  268.     if (ooffset < 0 || toffset < 0 ||
  269.             to + len > tlim || po + len > plim)
  270.         return false;
  271.     while (--len >= 0)
  272.         if (ta[to++] != pa[po++])
  273.             return false;
  274.     return true;
  275.     }
  276.  
  277.     private static char UTRT[]; /* case folding translation table lower=>upper */
  278.     private static char LTRT[]; /* case folding translation table upper=>lower */
  279.     static {
  280.         char utrt[] = new char[256];
  281.         char ltrt[] = new char[256];
  282.         int i;
  283.         for (i = 0; i<256; i++) {
  284.             utrt[i] = (char) i;
  285.         ltrt[i] = (char) i;
  286.     }
  287.         for (i = 'a'; i<='z'; i++)
  288.             utrt[i] = (char) (i + ('A' - 'a'));
  289.         /* get the accented iso-latin-1 characters right */
  290.     utrt[0xC1] = 0xE1;    /* A WITH ACUTE */
  291.     utrt[0xC2] = 0xE2;    /* A WITH CIRCUMFLEX */
  292.     utrt[0xC4] = 0xE4;    /* A WITH DIAERESIS */
  293.     utrt[0xC0] = 0xE0;    /* A WITH GRAVE */
  294.     utrt[0xC5] = 0xE5;    /* A WITH RING ABOVE */
  295.     utrt[0xC3] = 0xE3;    /* A WITH TILDE */
  296.     utrt[0xC7] = 0xE7;    /* C WITH CEDILLA */
  297.     utrt[0xC9] = 0xE9;    /* E WITH ACUTE */
  298.     utrt[0xCA] = 0xEA;    /* E WITH CIRCUMFLEX */
  299.     utrt[0xCB] = 0xEB;    /* E WITH DIAERESIS */
  300.     utrt[0xC8] = 0xE8;    /* E WITH GRAVE */
  301.     utrt[0xD0] = 0xF0;    /* ETH */
  302.     utrt[0xCD] = 0xED;    /* I WITH ACUTE */
  303.     utrt[0xCE] = 0xEE;    /* I WITH CIRCUMFLEX */
  304.     utrt[0xCF] = 0xEF;    /* I WITH DIAERESIS */
  305.     utrt[0xCC] = 0xEC;    /* I WITH GRAVE */
  306.     utrt[0xD1] = 0xF1;    /* N WITH TILDE */
  307.     utrt[0xD3] = 0xF3;    /* O WITH ACUTE */
  308.     utrt[0xD4] = 0xF4;    /* O WITH CIRCUMFLEX */
  309.     utrt[0xD6] = 0xF6;    /* O WITH DIAERESIS */
  310.     utrt[0xD2] = 0xF2;    /* O WITH GRAVE */
  311.     utrt[0xD8] = 0xF8;    /* O WITH STROKE */
  312.     utrt[0xD5] = 0xF5;    /* O WITH TILDE */
  313.     utrt[0xDE] = 0xFE;    /* THORN */
  314.     utrt[0xDA] = 0xFA;    /* U WITH ACUTE */
  315.     utrt[0xDB] = 0xFB;    /* U WITH CIRCUMFLEX */
  316.     utrt[0xDC] = 0xFC;    /* U WITH DIAERESIS */
  317.     utrt[0xD9] = 0xF9;    /* U WITH GRAVE */
  318.     utrt[0xDD] = 0xFD;    /* Y WITH ACUTE */
  319.     for (i = 0; i<256; i++) {
  320.         int c = utrt[i];
  321.         if (c != i)
  322.         ltrt[c] = (char) i;    /* inverse map */
  323.     }
  324.     UTRT = utrt;
  325.     LTRT = ltrt;
  326.     }
  327.  
  328.     /**
  329.      * Determines whether a region of one string matches a region
  330.      * of another string.  Upper case characters are considered equivalent
  331.      * to lower case letters.
  332.      * @param ignoreCase if true, case is ignored
  333.      * @param toffset    where to start looking in this string
  334.      * @param other     the other string
  335.      * @param ooffset    where to start looking in the other string
  336.      * @param len       the number of characters to match
  337.      * @return          true if the region matches with the other
  338.      */
  339.     public boolean regionMatches(boolean ignoreCase,
  340.                          int toffset,
  341.                            String other, int ooffset, int len) {
  342.     char ta[] = value;
  343.     int to = offset + toffset;
  344.     int tlim = offset + count;
  345.     char pa[] = other.value;
  346.     char trt[] = UTRT;
  347.     int po = other.offset + ooffset;
  348.     int plim = po + other.count;
  349.     if (ooffset < 0 || toffset < 0 ||
  350.         to + len > tlim || po + len > plim)
  351.         return false;
  352.     while (--len >= 0) {
  353.         int c1 = ta[to++];
  354.         int c2 = pa[po++];
  355.         if (c1 != c2
  356.             && (!ignoreCase ||
  357.             c1 > 256 || c2 > 256 ||
  358.             trt[c1] != trt[c2]))
  359.         return false;
  360.     }
  361.     return true;
  362.     }
  363.  
  364.     /**
  365.      * Determines whether a string starts with some prefix.
  366.      * @param prefix    the prefix
  367.      * @param toffset    where to start looking
  368.      * @return         true if the string starts with the prefix
  369.      */
  370.     public boolean startsWith(String prefix, int toffset) {
  371.     char ta[] = value;
  372.     int to = offset + toffset;
  373.     int tlim = offset + count;
  374.     char pa[] = prefix.value;
  375.     int po = prefix.offset;
  376.     int pc = prefix.count;
  377.     int plim = po + pc;
  378.     if ((toffset < 0) || (to + pc > tlim)) {
  379.         return false;
  380.     }
  381.     while (--pc >= 0) {
  382.         if (ta[to++] != pa[po++]) {
  383.             return false;
  384.         }
  385.     }
  386.     return true;
  387.     }
  388.  
  389.     /**
  390.      * Determines whether a string starts with some prefix.
  391.      * @param prefix    the prefix
  392.      * @return         true if the string starts with the prefix
  393.      */
  394.     public boolean startsWith(String prefix) {
  395.     return startsWith(prefix, 0);
  396.     }
  397.  
  398.     /**
  399.      * Determines whether a string ends with some suffix.
  400.      * @param suffix    the suffix
  401.      * @return         true if the string ends with the suffix
  402.      */
  403.     public boolean endsWith(String suffix) {
  404.     return startsWith(suffix, count - suffix.count);
  405.     }
  406.  
  407.     /**
  408.      * Returns a hashcode of the string. This is a large
  409.      * number composed of the character values in the string.
  410.      * @return the hash code
  411.      */
  412.     public int hashCode() {
  413.     int h = 0;
  414.     int off = offset;
  415.     char val[] = value;
  416.     int len = count;
  417.  
  418.     if (len < 16) {
  419.         for (int i = len ; i > 0; i--) {
  420.         h = (h * 37) + val[off++];
  421.         }
  422.     } else {
  423.         // only sample some characters
  424.         int skip = len / 8;
  425.         for (int i = len ; i > 0; i -= skip, off += skip) {
  426.         h = (h * 39) + val[off];
  427.         }
  428.     }
  429.     return h;
  430.     }
  431.  
  432.     /**
  433.      * Returns the index of the first occurrence of aCharacter.
  434.      * @param ch    the character
  435.      * @return     the index if the character is found, -1 otherwise
  436.      */
  437.     public int indexOf(int ch) {
  438.     return indexOf(ch, 0);
  439.     }
  440.  
  441.     /**
  442.      * Returns the index of the first occurrence of ch, starting
  443.      * the search at fromIndex.
  444.      * @param ch    the character
  445.      * @param fromIndex    the index to start the search from
  446.      * @return     the index if the character is found, -1 otherwise
  447.      */
  448.     public int indexOf(int ch, int fromIndex) {
  449.     int i, max = length();
  450.     for (i = fromIndex; i < max; i++) {
  451.         if (charAt(i) == ch) {
  452.         return i;
  453.         }
  454.     }
  455.     return -1;
  456.     }
  457.  
  458.     /**
  459.      * Returns the index of the last occurrence of ch in a string.
  460.      * The string is searched backwards starting at the last character.
  461.      * @param ch    the character
  462.      * @return     the index if the character is found, -1 otherwise
  463.      */
  464.     public int lastIndexOf(int ch) {
  465.     return lastIndexOf(ch, length() - 1);
  466.     }
  467.  
  468.     /**
  469.      * Returns the index of the last occurrence of ch in a string.
  470.      * The string is searched backwards starting at fromIndex.
  471.      * @param ch    the character
  472.      * @param fromIndex    the index to start the search from
  473.      * @return     the index if the character is found, -1 otherwise
  474.      */
  475.     public int lastIndexOf(int ch, int fromIndex) {
  476.     for (int i = fromIndex; i >= 0; i--) {
  477.         if (charAt(i) == ch) {
  478.         return i;
  479.         }
  480.     }
  481.     return -1;
  482.     }
  483.  
  484.     /**
  485.      * Returns the index of the first occurrence of a substring.
  486.      * @param str     the substring
  487.      * @return         the index if the substring is found, -1 otherwise
  488.      */
  489.     public int indexOf(String str) {
  490.     return indexOf(str, 0);
  491.     }
  492.  
  493.     /**
  494.      * Returns the index of the first occurrence of a substring. The
  495.      * search is started at fromIndex.
  496.      * @param str     the substring
  497.      * @param fromIndex    the index to start the search from
  498.      * @return         the index if the substring is found, -1 otherwise
  499.      */
  500.     public int indexOf(String str, int fromIndex) {
  501.     int max1 = str.length();
  502.     int max2 = length();
  503.     if (max1 <= 0) {
  504.         return fromIndex;
  505.     }
  506.  
  507.     int c0 = str.charAt(0);
  508.  test:    for (int i = fromIndex; i + max1 <= max2; i++) {
  509.         if (charAt(i) == c0) {
  510.         for (int k = 1; k<max1; k++)
  511.             if (charAt(i+k) != str.charAt(k)) {
  512.                 continue test;
  513.             }
  514.         return i;
  515.         }
  516.     }
  517.     return -1;
  518.     }
  519.  
  520.     /**
  521.      * Returns the index of the last occurrence of a substring.
  522.      * The string is searched backwards.
  523.      * @param str     the substring
  524.      * @return         the index if the substring is found, -1 otherwise
  525.      */
  526.     public int lastIndexOf(String str) {
  527.     return lastIndexOf(str, length() - 1);
  528.     }
  529.  
  530.     /**
  531.      * Returns the index of the last occurrence of a substring.
  532.      * The string is searched backwards starting at fromIndex.
  533.      * @param str     the substring
  534.      * @param fromIndex    the index to start the search from
  535.      * @return         the index if the substring is found, -1 otherwise
  536.      */
  537.     public int lastIndexOf(String str, int fromIndex) {
  538.     int max1 = str.length();
  539.     int i = fromIndex, max2 = length();
  540.     int result = -1;
  541.     while (i - max1 + 1 >= 0) {
  542.         int j = i--;
  543.         int k = max1 - 1;
  544.         char c = str.charAt(k--);
  545.         result = lastIndexOf(c, j--);
  546.         if (result >= 0) {
  547.         while (k >= 0) {
  548.             if (str.charAt(k--) != charAt(j--)) {
  549.             k++;
  550.             j++;
  551.             break;
  552.             }
  553.         }
  554.         if (k == -1 || j == -1) {
  555.             return result - max1 + 1;
  556.         }
  557.         }
  558.     }
  559.     return -1;
  560.     }
  561.  
  562.     /**
  563.      * Returns the substring of a String. The substring is specified
  564.      * by a beginIndex (inclusive) and the end of the string.
  565.      * @param beginIndex begin index, inclusive
  566.      * @return the substring upto the end of the string
  567.      */
  568.     public String substring(int beginIndex) {
  569.     return substring(beginIndex, length());
  570.     }
  571.  
  572.     /**
  573.      * Returns the substring of a String. The substring is specified
  574.      * by a beginIndex (inclusive) and an endIndex (exclusive).
  575.      * @param beginIndex begin index, inclusive
  576.      * @param endIndex end index, exclusive
  577.      * @return the substring
  578.      */
  579.     public String substring(int beginIndex, int endIndex) {
  580.     if (beginIndex > endIndex) {
  581.         int tmp = beginIndex;
  582.         beginIndex = endIndex;
  583.         endIndex = tmp;
  584.     }
  585.     if (beginIndex < 0) {
  586.         throw new StringIndexOutOfRangeException(beginIndex);
  587.     } else if (endIndex > count) {
  588.         throw new StringIndexOutOfRangeException(endIndex);
  589.     }
  590.     return (beginIndex == 0 && endIndex == count
  591.         ? this
  592.         : new String(value, offset + beginIndex, endIndex - beginIndex));
  593.     }
  594.  
  595.     /**
  596.      * Concatenates a string.
  597.      * @param str    the string which is concatenated to the end of this string
  598.      * @return the resulting string
  599.      */
  600.     public String concat(String str) {
  601.     int otherLen = str.length();
  602.     if (otherLen == 0)
  603.         return this;
  604.     char buf[] = new char[count + otherLen];
  605.     getChars(0, count, buf, 0);
  606.     str.getChars(0, otherLen, buf, count);
  607.     return new String(buf);
  608.     }
  609.  
  610.     /**
  611.      * Converts a string by replacing occurences of oldChar with newChar.
  612.      * @param oldChar    the old character
  613.      * @param newChar    the new character
  614.      * @return        the resulting string
  615.      */
  616.     public String replace(char oldChar, char newChar) {
  617.     if (oldChar != newChar) {
  618.         int len = count;
  619.         int i = -1;
  620.         while (++i < len)
  621.         if (value[offset + i] == oldChar)
  622.             break;
  623.         if (i < len) {
  624.         char buf[] = new char[len];
  625.         for (int j = 0; j<i; j++)
  626.             buf[j] = value[offset+j];
  627.         while (i < len) {
  628.             char c = value[offset + i];
  629.             buf[i] = (c == oldChar) ? newChar : c;
  630.             i++;
  631.         }
  632.         return new String(buf);
  633.         }
  634.     }
  635.     return this;
  636.     }
  637.  
  638.     /**
  639.      * Converts a string to lower case.
  640.      * @return the string, converted to lowercase
  641.      * @see Character#toLowerCase
  642.      * @see String#toUpperCase
  643.      */
  644.     public String toLowerCase() {
  645.     int len = count;
  646.     char trt[] = LTRT;
  647.     int i, c;
  648.     for (i = 0; i<len; i++) {
  649.         c = value[offset+i];
  650.         if (c<256 && trt[c] != c)
  651.         break;
  652.     }
  653.     if (i>=len)
  654.         return this;
  655.     char buf[] = new char[len];
  656.     for (i = 0; i < len; i++) {
  657.         c = value[offset+i];
  658.         buf[i] = c < 256 ? trt[c] : (char) c;
  659.     }
  660.     return new String(buf);
  661.     }
  662.  
  663.     /**
  664.      * Converts a string to upper case.
  665.      * @return the string, converted to lowercase
  666.      * @see Character#toUpperCase
  667.      * @see String#toLowerCase
  668.      */
  669.     public String toUpperCase() {
  670.     int len = count;
  671.     char trt[] = UTRT;
  672.     int i, c;
  673.     for (i = 0; i<len; i++) {
  674.         c = value[offset+i];
  675.         if (c<256 && trt[c] != c)
  676.         break;
  677.     }
  678.     if (i>=len)
  679.         return this;
  680.     char buf[] = new char[len];
  681.     for (i = 0; i < len; i++) {
  682.         c = value[offset+i];
  683.         buf[i] = c < 256 ? trt[c] : (char)c;
  684.     }
  685.     return new String(buf);
  686.     }
  687.  
  688.     /**
  689.      * Trims leading and trailing whitespace from a string.
  690.      * @return the string, with whitespace removed.
  691.      */
  692.     public String trim() {
  693.     int len = count;
  694.     int st = 0;
  695.     while (st < len && value[offset+st] <= ' ')
  696.         st++;
  697.     while (st < len && value[offset+len-1] <= ' ')
  698.         len--;
  699.     return st>0 || len<count ? substring(st, len) : this;
  700.     }
  701.  
  702.     /**
  703.      * Converts this string to a string.
  704.      * @return the string itself
  705.      */
  706.     public String toString() {
  707.     return this;
  708.     }
  709.  
  710.     /**
  711.      * Converts to a character array. This creates a new array.
  712.      * @return     an array of characters
  713.      */
  714.     public char toCharArray()[] {
  715.     int i, max = length();
  716.     char result[] = new char[max];
  717.     getChars(0, max, result, 0);
  718.     return result;
  719.     }
  720.  
  721.     /**
  722.      * Returns a string that represents the string value of the object.
  723.      * The object may choose how to represent itself by implementing
  724.      * a "toString()" method.
  725.      * @param obj    the object to be converted
  726.      * @return     the resulting string
  727.      */
  728.     public static String valueOf(Object obj) {
  729.     return (obj == null) ? "<Null Object>" : obj.toString();
  730.     }
  731.  
  732.     /**
  733.      * Returns a string that is equivalent to the given character array.
  734.      * Uses the original array as the body of the string (ie. it doesn't
  735.      * copy it to a new array).
  736.      * @param data    the character array
  737.      * @return     the resulting string
  738.      */
  739.     public static String valueOf(char data[]) {
  740.     return new String(data);
  741.     }
  742.  
  743.     /**
  744.      * Returns a string that is equivalent to the given character array.
  745.      * Uses the original array as the body of the string (ie. it doesn't
  746.      * copy it to a new array).
  747.      * @param data    the character array
  748.      * @param offset    the offset into the value of the string
  749.      * @param count     the length of the value of the string
  750.      * @return     the resulting string
  751.      */
  752.     public static String valueOf(char data[], int offset, int count) {
  753.     return new String(data, offset, count);
  754.     }
  755.  
  756.     /**
  757.      * Returns a string that is equivalent to the given character array.
  758.      * It creates a new array and copies the characters into it.
  759.      * @param data    the character array
  760.      * @param offset    the offset into the value of the string
  761.      * @param count     the length of the value of the string
  762.      * @return     the resulting string
  763.      */
  764.     public static String copyValueOf(char data[], int offset, int count) {
  765.     char str[] = new char[count];
  766.     System.arraycopy(data, offset, str, 0, count);
  767.     return new String(str);
  768.     }
  769.  
  770.     /**
  771.      * Returns a string that is equivalent to the given character array.
  772.      * It creates a new array and copies the characters into it.
  773.      * @param data    the character array
  774.      * @return     the resulting string
  775.      */
  776.     public static String copyValueOf(char data[]) {
  777.     return copyValueOf(data, 0, data.length);
  778.     }
  779.  
  780.     /**
  781.      * Returns a string object that represents the state of a boolean.
  782.      * @param b    the boolean
  783.      * @return     the resulting string
  784.      */
  785.     public static String valueOf(boolean b) {
  786.     return b ? "true" : "false";
  787.     }
  788.  
  789.     /**
  790.      * Returns a string object that represents an integer.
  791.      * @param i    the integer
  792.      * @return     the resulting string
  793.      */
  794.     public static String valueOf(int i) {
  795.     return int2String(i);
  796.     }
  797.  
  798.     /**
  799.      * Returns a string object that represents a long.
  800.      * @param l    the long
  801.      * @return     the resulting string
  802.      */
  803.     public static String valueOf(long l) {
  804.     return long2String(l);
  805.     }
  806.  
  807.     /**
  808.      * Returns a string object that represents a float.
  809.      * @param f    the float
  810.      * @return     the resulting string
  811.      */
  812.     public static String valueOf(float f) {
  813.     return float2String(f);
  814.     }
  815.  
  816.     /**
  817.      * Returns a string object that represents a double.
  818.      * @param d    the double
  819.      * @return     the resulting string
  820.      */
  821.     public static String valueOf(double d) {
  822.     return double2String(d);
  823.     }
  824.  
  825.     /**
  826.      * The set of internalized strings.
  827.      */
  828.     private static Hashtable InternSet;
  829.  
  830.     /**
  831.      * Returns a string that is equal to the current string
  832.      * bug which is guaranteed to be from the unique string pool.
  833.      * s1.intern() == s2.intern() <=> s1.equals(s2).
  834.      */
  835.     public String intern() {
  836.     if (InternSet == null) {
  837.         InternSet = new Hashtable();
  838.     }
  839.     String s = (String) InternSet.get(this);
  840.     if (s != null) {
  841.         return s;
  842.     }
  843.     InternSet.put(this, this);
  844.     return this;
  845.     }
  846.  
  847.     private static native String int2String(int i);
  848.     private static native String long2String(long l);
  849.     private static native String float2String(float f);
  850.     private static native String double2String(double d);
  851. }
  852.  
  853.  
  854.  
  855.