home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 1999 April / DPPCPRO0499.ISO / April / Notes / 50b2wic.exe / DATA1.CAB / NotesProgramFilesJavaSupport / rt.jar / java / lang / String.class (.txt) < prev    next >
Encoding:
Java Class File  |  1998-04-23  |  9.7 KB  |  721 lines
  1. package java.lang;
  2.  
  3. import java.io.CharConversionException;
  4. import java.io.Serializable;
  5. import java.io.UnsupportedEncodingException;
  6. import java.util.Locale;
  7. import sun.io.ByteToCharConverter;
  8. import sun.io.CharToByteConverter;
  9.  
  10. public final class String implements Serializable {
  11.    private char[] value;
  12.    private int offset;
  13.    private int count;
  14.    private static final long serialVersionUID = -6849794470754667710L;
  15.  
  16.    public String() {
  17.       this.value = new char[0];
  18.    }
  19.  
  20.    public String(String var1) {
  21.       this.count = var1.length();
  22.       this.value = new char[this.count];
  23.       var1.getChars(0, this.count, this.value, 0);
  24.    }
  25.  
  26.    public String(char[] var1) {
  27.       this.count = var1.length;
  28.       this.value = new char[this.count];
  29.       System.arraycopy(var1, 0, this.value, 0, this.count);
  30.    }
  31.  
  32.    public String(char[] var1, int var2, int var3) {
  33.       if (var2 < 0) {
  34.          throw new StringIndexOutOfBoundsException(var2);
  35.       } else if (var3 < 0) {
  36.          throw new StringIndexOutOfBoundsException(var3);
  37.       } else if (var2 > var1.length - var3) {
  38.          throw new StringIndexOutOfBoundsException(var2 + var3);
  39.       } else {
  40.          this.value = new char[var3];
  41.          this.count = var3;
  42.          System.arraycopy(var1, var2, this.value, 0, var3);
  43.       }
  44.    }
  45.  
  46.    /** @deprecated */
  47.    public String(byte[] var1, int var2, int var3, int var4) {
  48.       if (var3 < 0) {
  49.          throw new StringIndexOutOfBoundsException(var3);
  50.       } else if (var4 < 0) {
  51.          throw new StringIndexOutOfBoundsException(var4);
  52.       } else if (var3 > var1.length - var4) {
  53.          throw new StringIndexOutOfBoundsException(var3 + var4);
  54.       } else {
  55.          char[] var5 = new char[var4];
  56.          this.count = var4;
  57.          this.value = var5;
  58.          if (var2 == 0) {
  59.             for(int var8 = var4; var8-- > 0; var5[var8] = (char)(var1[var8 + var3] & 255)) {
  60.             }
  61.  
  62.          } else {
  63.             var2 <<= 8;
  64.  
  65.             for(int var6 = var4; var6-- > 0; var5[var6] = (char)(var2 | var1[var6 + var3] & 255)) {
  66.             }
  67.  
  68.          }
  69.       }
  70.    }
  71.  
  72.    /** @deprecated */
  73.    public String(byte[] var1, int var2) {
  74.       this(var1, var2, 0, var1.length);
  75.    }
  76.  
  77.    private String(byte[] var1, int var2, int var3, ByteToCharConverter var4) {
  78.       int var5 = var4.getMaxCharsPerByte() * var3;
  79.       this.value = new char[var5];
  80.  
  81.       try {
  82.          this.count = var4.convert(var1, var2, var2 + var3, this.value, 0, var5);
  83.          this.count += var4.flush(this.value, var4.nextCharIndex(), var5);
  84.       } catch (CharConversionException var7) {
  85.          this.count = var4.nextCharIndex();
  86.       }
  87.  
  88.       if (this.count < var5) {
  89.          char[] var6 = new char[this.count];
  90.          System.arraycopy(this.value, 0, var6, 0, this.count);
  91.          this.value = var6;
  92.       }
  93.  
  94.    }
  95.  
  96.    public String(byte[] var1, int var2, int var3, String var4) throws UnsupportedEncodingException {
  97.       this(var1, var2, var3, ByteToCharConverter.getConverter(var4));
  98.    }
  99.  
  100.    public String(byte[] var1, String var2) throws UnsupportedEncodingException {
  101.       this(var1, 0, var1.length, (String)var2);
  102.    }
  103.  
  104.    public String(byte[] var1, int var2, int var3) {
  105.       this(var1, var2, var3, ByteToCharConverter.getDefault());
  106.    }
  107.  
  108.    public String(byte[] var1) {
  109.       this(var1, 0, var1.length, (ByteToCharConverter)ByteToCharConverter.getDefault());
  110.    }
  111.  
  112.    public String(StringBuffer var1) {
  113.       synchronized(var1){}
  114.  
  115.       try {
  116.          var1.setShared();
  117.          this.value = var1.getValue();
  118.          this.offset = 0;
  119.          this.count = var1.length();
  120.       } catch (Throwable var4) {
  121.          throw var4;
  122.       }
  123.  
  124.    }
  125.  
  126.    private String(int var1, int var2, char[] var3) {
  127.       this.value = var3;
  128.       this.offset = var1;
  129.       this.count = var2;
  130.    }
  131.  
  132.    public int length() {
  133.       return this.count;
  134.    }
  135.  
  136.    public char charAt(int var1) {
  137.       if (var1 >= 0 && var1 < this.count) {
  138.          return this.value[var1 + this.offset];
  139.       } else {
  140.          throw new StringIndexOutOfBoundsException(var1);
  141.       }
  142.    }
  143.  
  144.    public void getChars(int var1, int var2, char[] var3, int var4) {
  145.       if (var1 < 0) {
  146.          throw new StringIndexOutOfBoundsException(var1);
  147.       } else if (var2 > this.count) {
  148.          throw new StringIndexOutOfBoundsException(var2);
  149.       } else if (var1 > var2) {
  150.          throw new StringIndexOutOfBoundsException(var2 - var1);
  151.       } else {
  152.          System.arraycopy(this.value, this.offset + var1, var3, var4, var2 - var1);
  153.       }
  154.    }
  155.  
  156.    /** @deprecated */
  157.    public void getBytes(int var1, int var2, byte[] var3, int var4) {
  158.       if (var1 < 0) {
  159.          throw new StringIndexOutOfBoundsException(var1);
  160.       } else if (var2 > this.count) {
  161.          throw new StringIndexOutOfBoundsException(var2);
  162.       } else if (var1 > var2) {
  163.          throw new StringIndexOutOfBoundsException(var2 - var1);
  164.       } else {
  165.          int var5 = var4;
  166.          int var6 = this.offset + var2;
  167.          int var7 = this.offset + var1;
  168.  
  169.          for(char[] var8 = this.value; var7 < var6; var3[var5++] = (byte)var8[var7++]) {
  170.          }
  171.  
  172.       }
  173.    }
  174.  
  175.    private byte[] getBytes(CharToByteConverter var1) {
  176.       var1.reset();
  177.       int var2 = var1.getMaxBytesPerChar() * this.count;
  178.       byte[] var3 = new byte[var2];
  179.  
  180.       int var4;
  181.       try {
  182.          var4 = var1.convert(this.value, this.offset, this.offset + this.count, var3, 0, var2);
  183.          var4 += var1.flush(var3, var1.nextByteIndex(), var2);
  184.       } catch (CharConversionException var6) {
  185.          var4 = var1.nextByteIndex();
  186.       }
  187.  
  188.       if (var4 < var2) {
  189.          byte[] var5 = new byte[var4];
  190.          System.arraycopy(var3, 0, var5, 0, var4);
  191.          return var5;
  192.       } else {
  193.          return var3;
  194.       }
  195.    }
  196.  
  197.    public byte[] getBytes(String var1) throws UnsupportedEncodingException {
  198.       return this.getBytes(CharToByteConverter.getConverter(var1));
  199.    }
  200.  
  201.    public byte[] getBytes() {
  202.       return this.getBytes(CharToByteConverter.getDefault());
  203.    }
  204.  
  205.    public boolean equals(Object var1) {
  206.       if (this == var1) {
  207.          return true;
  208.       } else {
  209.          if (var1 != null && var1 instanceof String) {
  210.             String var2 = (String)var1;
  211.             int var3 = this.count;
  212.             if (var3 == var2.count) {
  213.                char[] var4 = this.value;
  214.                char[] var5 = var2.value;
  215.                int var6 = this.offset;
  216.                int var7 = var2.offset;
  217.  
  218.                while(var3-- != 0) {
  219.                   if (var4[var6++] != var5[var7++]) {
  220.                      return false;
  221.                   }
  222.                }
  223.  
  224.                return true;
  225.             }
  226.          }
  227.  
  228.          return false;
  229.       }
  230.    }
  231.  
  232.    public boolean equalsIgnoreCase(String var1) {
  233.       return var1 != null && var1.count == this.count && this.regionMatches(true, 0, var1, 0, this.count);
  234.    }
  235.  
  236.    public int compareTo(String var1) {
  237.       int var2 = this.count;
  238.       int var3 = var1.count;
  239.       int var4 = Math.min(var2, var3);
  240.       char[] var5 = this.value;
  241.       char[] var6 = var1.value;
  242.       int var7 = this.offset;
  243.       int var8 = var1.offset;
  244.  
  245.       while(var4-- != 0) {
  246.          char var9 = var5[var7++];
  247.          char var10 = var6[var8++];
  248.          if (var9 != var10) {
  249.             return var9 - var10;
  250.          }
  251.       }
  252.  
  253.       return var2 - var3;
  254.    }
  255.  
  256.    public boolean regionMatches(int var1, String var2, int var3, int var4) {
  257.       char[] var5 = this.value;
  258.       int var6 = this.offset + var1;
  259.       char[] var7 = var2.value;
  260.       int var8 = var2.offset + var3;
  261.       if (var3 >= 0 && var1 >= 0 && var1 <= this.count - var4 && var3 <= var2.count - var4) {
  262.          while(var4-- > 0) {
  263.             if (var5[var6++] != var7[var8++]) {
  264.                return false;
  265.             }
  266.          }
  267.  
  268.          return true;
  269.       } else {
  270.          return false;
  271.       }
  272.    }
  273.  
  274.    public boolean regionMatches(boolean var1, int var2, String var3, int var4, int var5) {
  275.       char[] var6 = this.value;
  276.       int var7 = this.offset + var2;
  277.       char[] var8 = var3.value;
  278.       int var9 = var3.offset + var4;
  279.       if (var4 >= 0 && var2 >= 0 && var2 <= this.count - var5 && var4 <= var3.count - var5) {
  280.          while(true) {
  281.             if (var5-- <= 0) {
  282.                return true;
  283.             }
  284.  
  285.             char var10 = var6[var7++];
  286.             char var11 = var8[var9++];
  287.             if (var10 != var11) {
  288.                if (!var1) {
  289.                   break;
  290.                }
  291.  
  292.                char var12 = Character.toUpperCase(var10);
  293.                char var13 = Character.toUpperCase(var11);
  294.                if (var12 != var13 && Character.toLowerCase(var12) != Character.toLowerCase(var13)) {
  295.                   break;
  296.                }
  297.             }
  298.          }
  299.  
  300.          return false;
  301.       } else {
  302.          return false;
  303.       }
  304.    }
  305.  
  306.    public boolean startsWith(String var1, int var2) {
  307.       char[] var3 = this.value;
  308.       int var4 = this.offset + var2;
  309.       char[] var5 = var1.value;
  310.       int var6 = var1.offset;
  311.       int var7 = var1.count;
  312.       if (var2 >= 0 && var2 <= this.count - var7) {
  313.          do {
  314.             --var7;
  315.             if (var7 < 0) {
  316.                return true;
  317.             }
  318.          } while(var3[var4++] == var5[var6++]);
  319.  
  320.          return false;
  321.       } else {
  322.          return false;
  323.       }
  324.    }
  325.  
  326.    public boolean startsWith(String var1) {
  327.       return this.startsWith(var1, 0);
  328.    }
  329.  
  330.    public boolean endsWith(String var1) {
  331.       return this.startsWith(var1, this.count - var1.count);
  332.    }
  333.  
  334.    public int hashCode() {
  335.       int var1 = 0;
  336.       int var2 = this.offset;
  337.       char[] var3 = this.value;
  338.       int var4 = this.count;
  339.       if (var4 < 16) {
  340.          for(int var5 = var4; var5 > 0; --var5) {
  341.             var1 = var1 * 37 + var3[var2++];
  342.          }
  343.       } else {
  344.          int var7 = var4 / 8;
  345.  
  346.          for(int var6 = var4; var6 > 0; var2 += var7) {
  347.             var1 = var1 * 39 + var3[var2];
  348.             var6 -= var7;
  349.          }
  350.       }
  351.  
  352.       return var1;
  353.    }
  354.  
  355.    public int indexOf(int var1) {
  356.       return this.indexOf(var1, 0);
  357.    }
  358.  
  359.    public int indexOf(int var1, int var2) {
  360.       int var3 = this.offset + this.count;
  361.       char[] var4 = this.value;
  362.       if (var2 < 0) {
  363.          var2 = 0;
  364.       } else if (var2 >= this.count) {
  365.          return -1;
  366.       }
  367.  
  368.       for(int var5 = this.offset + var2; var5 < var3; ++var5) {
  369.          if (var4[var5] == var1) {
  370.             return var5 - this.offset;
  371.          }
  372.       }
  373.  
  374.       return -1;
  375.    }
  376.  
  377.    public int lastIndexOf(int var1) {
  378.       return this.lastIndexOf(var1, this.count - 1);
  379.    }
  380.  
  381.    public int lastIndexOf(int var1, int var2) {
  382.       int var3 = this.offset;
  383.       char[] var4 = this.value;
  384.  
  385.       for(int var5 = this.offset + (var2 >= this.count ? this.count - 1 : var2); var5 >= var3; --var5) {
  386.          if (var4[var5] == var1) {
  387.             return var5 - this.offset;
  388.          }
  389.       }
  390.  
  391.       return -1;
  392.    }
  393.  
  394.    public int indexOf(String var1) {
  395.       return this.indexOf(var1, 0);
  396.    }
  397.  
  398.    public int indexOf(String var1, int var2) {
  399.       char[] var3 = this.value;
  400.       char[] var4 = var1.value;
  401.       int var5 = this.offset + (this.count - var1.count);
  402.       if (var2 >= this.count) {
  403.          return -1;
  404.       } else {
  405.          if (var2 < 0) {
  406.             var2 = 0;
  407.          }
  408.  
  409.          if (var1.count == 0) {
  410.             return var2;
  411.          } else {
  412.             int var6 = var1.offset;
  413.             char var7 = var4[var6];
  414.             int var8 = this.offset + var2;
  415.  
  416.             while(true) {
  417.                label38:
  418.                while(var8 > var5 || var3[var8] == var7) {
  419.                   if (var8 > var5) {
  420.                      return -1;
  421.                   }
  422.  
  423.                   int var9 = var8 + 1;
  424.                   int var10 = var9 + var1.count - 1;
  425.                   int var11 = var6 + 1;
  426.  
  427.                   while(var9 < var10) {
  428.                      if (var3[var9++] != var4[var11++]) {
  429.                         ++var8;
  430.                         continue label38;
  431.                      }
  432.                   }
  433.  
  434.                   return var8 - this.offset;
  435.                }
  436.  
  437.                ++var8;
  438.             }
  439.          }
  440.       }
  441.    }
  442.  
  443.    public int lastIndexOf(String var1) {
  444.       return this.lastIndexOf(var1, this.count);
  445.    }
  446.  
  447.    public int lastIndexOf(String var1, int var2) {
  448.       int var3 = this.count - var1.count;
  449.       if (var2 < 0) {
  450.          return -1;
  451.       } else {
  452.          if (var2 > var3) {
  453.             var2 = var3;
  454.          }
  455.  
  456.          if (var1.count == 0) {
  457.             return var2;
  458.          } else {
  459.             char[] var4 = this.value;
  460.             char[] var5 = var1.value;
  461.             int var6 = var1.offset + var1.count - 1;
  462.             char var7 = var5[var6];
  463.             int var8 = this.offset + var1.count - 1;
  464.             int var9 = var8 + var2;
  465.  
  466.             while(true) {
  467.                label38:
  468.                while(var9 < var8 || var4[var9] == var7) {
  469.                   if (var9 < var8) {
  470.                      return -1;
  471.                   }
  472.  
  473.                   int var10 = var9 - 1;
  474.                   int var11 = var10 - (var1.count - 1);
  475.                   int var12 = var6 - 1;
  476.  
  477.                   while(var10 > var11) {
  478.                      if (var4[var10--] != var5[var12--]) {
  479.                         --var9;
  480.                         continue label38;
  481.                      }
  482.                   }
  483.  
  484.                   return var11 - this.offset + 1;
  485.                }
  486.  
  487.                --var9;
  488.             }
  489.          }
  490.       }
  491.    }
  492.  
  493.    public String substring(int var1) {
  494.       return this.substring(var1, this.length());
  495.    }
  496.  
  497.    public String substring(int var1, int var2) {
  498.       if (var1 < 0) {
  499.          throw new StringIndexOutOfBoundsException(var1);
  500.       } else if (var2 > this.count) {
  501.          throw new StringIndexOutOfBoundsException(var2);
  502.       } else if (var1 > var2) {
  503.          throw new StringIndexOutOfBoundsException(var2 - var1);
  504.       } else {
  505.          return var1 == 0 && var2 == this.count ? this : new String(this.offset + var1, var2 - var1, this.value);
  506.       }
  507.    }
  508.  
  509.    public String concat(String var1) {
  510.       int var2 = var1.length();
  511.       if (var2 == 0) {
  512.          return this;
  513.       } else {
  514.          char[] var3 = new char[this.count + var2];
  515.          this.getChars(0, this.count, var3, 0);
  516.          var1.getChars(0, var2, var3, this.count);
  517.          return new String(0, this.count + var2, var3);
  518.       }
  519.    }
  520.  
  521.    public String replace(char var1, char var2) {
  522.       if (var1 != var2) {
  523.          int var3 = this.count;
  524.          int var4 = -1;
  525.          char[] var5 = this.value;
  526.          int var6 = this.offset;
  527.  
  528.          do {
  529.             ++var4;
  530.          } while(var4 < var3 && var5[var6 + var4] != var1);
  531.  
  532.          if (var4 < var3) {
  533.             char[] var7 = new char[var3];
  534.  
  535.             for(int var8 = 0; var8 < var4; ++var8) {
  536.                var7[var8] = var5[var6 + var8];
  537.             }
  538.  
  539.             while(var4 < var3) {
  540.                char var9 = var5[var6 + var4];
  541.                var7[var4] = var9 == var1 ? var2 : var9;
  542.                ++var4;
  543.             }
  544.  
  545.             return new String(0, var3, var7);
  546.          }
  547.       }
  548.  
  549.       return this;
  550.    }
  551.  
  552.    public String toLowerCase(Locale var1) {
  553.       char[] var2 = new char[this.count];
  554.       int var4 = this.count;
  555.       int var5 = this.offset;
  556.       char[] var6 = this.value;
  557.       if (var1.getLanguage().equals("tr")) {
  558.          for(int var3 = 0; var3 < var4; ++var3) {
  559.             char var7 = var6[var5 + var3];
  560.             if (var7 == 'I') {
  561.                var2[var3] = 305;
  562.             } else if (var7 == 304) {
  563.                var2[var3] = 'i';
  564.             } else {
  565.                var2[var3] = Character.toLowerCase(var7);
  566.             }
  567.          }
  568.       } else {
  569.          for(int var8 = 0; var8 < var4; ++var8) {
  570.             var2[var8] = Character.toLowerCase(var6[var5 + var8]);
  571.          }
  572.       }
  573.  
  574.       return new String(var2);
  575.    }
  576.  
  577.    public String toLowerCase() {
  578.       return this.toLowerCase(Locale.getDefault());
  579.    }
  580.  
  581.    public String toUpperCase(Locale var1) {
  582.       char[] var2 = new char[this.count];
  583.       int var4 = 0;
  584.       int var5 = this.count;
  585.       int var6 = this.offset;
  586.       char[] var7 = this.value;
  587.       if (var1.getLanguage().equals("tr")) {
  588.          for(int var3 = 0; var3 < var5; ++var3) {
  589.             char var8 = var7[var6 + var3];
  590.             if (var8 == 'i') {
  591.                var2[var3 + var4] = 304;
  592.             } else if (var8 == 305) {
  593.                var2[var3 + var4] = 'I';
  594.             } else if (var8 == 223) {
  595.                char[] var9 = new char[var2.length + 1];
  596.                System.arraycopy(var2, 0, var9, 0, var3 + 1 + var4);
  597.                var9[var3 + var4] = 'S';
  598.                ++var4;
  599.                var9[var3 + var4] = 'S';
  600.                var2 = var9;
  601.             } else {
  602.                var2[var3 + var4] = Character.toUpperCase(var8);
  603.             }
  604.          }
  605.       } else {
  606.          for(int var10 = 0; var10 < var5; ++var10) {
  607.             char var11 = var7[var6 + var10];
  608.             if (var11 == 223) {
  609.                char[] var12 = new char[var2.length + 1];
  610.                System.arraycopy(var2, 0, var12, 0, var10 + 1 + var4);
  611.                var12[var10 + var4] = 'S';
  612.                ++var4;
  613.                var12[var10 + var4] = 'S';
  614.                var2 = var12;
  615.             } else {
  616.                var2[var10 + var4] = Character.toUpperCase(var11);
  617.             }
  618.          }
  619.       }
  620.  
  621.       return new String(var2);
  622.    }
  623.  
  624.    public String toUpperCase() {
  625.       return this.toUpperCase(Locale.getDefault());
  626.    }
  627.  
  628.    public String trim() {
  629.       int var1 = this.count;
  630.       int var2 = 0;
  631.       int var3 = this.offset;
  632.  
  633.       char[] var4;
  634.       for(var4 = this.value; var2 < var1 && var4[var3 + var2] <= ' '; ++var2) {
  635.       }
  636.  
  637.       while(var2 < var1 && var4[var3 + var1 - 1] <= ' ') {
  638.          --var1;
  639.       }
  640.  
  641.       return var2 <= 0 && var1 >= this.count ? this : this.substring(var2, var1);
  642.    }
  643.  
  644.    public String toString() {
  645.       return this;
  646.    }
  647.  
  648.    public char[] toCharArray() {
  649.       int var1 = this.length();
  650.       char[] var2 = new char[var1];
  651.       this.getChars(0, var1, var2, 0);
  652.       return var2;
  653.    }
  654.  
  655.    public static String valueOf(Object var0) {
  656.       return var0 == null ? "null" : var0.toString();
  657.    }
  658.  
  659.    public static String valueOf(char[] var0) {
  660.       return new String(var0);
  661.    }
  662.  
  663.    public static String valueOf(char[] var0, int var1, int var2) {
  664.       return new String(var0, var1, var2);
  665.    }
  666.  
  667.    public static String copyValueOf(char[] var0, int var1, int var2) {
  668.       return new String(var0, var1, var2);
  669.    }
  670.  
  671.    public static String copyValueOf(char[] var0) {
  672.       return copyValueOf(var0, 0, var0.length);
  673.    }
  674.  
  675.    public static String valueOf(boolean var0) {
  676.       return var0 ? "true" : "false";
  677.    }
  678.  
  679.    public static String valueOf(char var0) {
  680.       char[] var1 = new char[]{var0};
  681.       return new String(0, 1, var1);
  682.    }
  683.  
  684.    public static String valueOf(int var0) {
  685.       return Integer.toString(var0, 10);
  686.    }
  687.  
  688.    public static String valueOf(long var0) {
  689.       return Long.toString(var0, 10);
  690.    }
  691.  
  692.    public static String valueOf(float var0) {
  693.       return Float.toString(var0);
  694.    }
  695.  
  696.    public static String valueOf(double var0) {
  697.       return Double.toString(var0);
  698.    }
  699.  
  700.    public native String intern();
  701.  
  702.    int utfLength() {
  703.       int var1 = this.offset + this.count;
  704.       int var2 = 0;
  705.       char[] var3 = this.value;
  706.  
  707.       for(int var4 = this.offset; var4 < var1; ++var4) {
  708.          char var5 = var3[var4];
  709.          if (var5 >= 1 && var5 <= 127) {
  710.             ++var2;
  711.          } else if (var5 > 2047) {
  712.             var2 += 3;
  713.          } else {
  714.             var2 += 2;
  715.          }
  716.       }
  717.  
  718.       return var2;
  719.    }
  720. }
  721.