home *** CD-ROM | disk | FTP | other *** search
/ PC Online 1997 October / PCO1097.ISO / FilesBBS / WIN95 / IAVAZIP.EXE / DATA.Z / rt.jar / java / lang / String.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-05-19  |  9.4 KB  |  668 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.  
  168.          for(int var7 = this.offset + var1; var7 < var6; var3[var5++] = (byte)this.value[var7++]) {
  169.          }
  170.  
  171.       }
  172.    }
  173.  
  174.    private byte[] getBytes(CharToByteConverter var1) {
  175.       var1.reset();
  176.       int var2 = var1.getMaxBytesPerChar() * this.count;
  177.       byte[] var3 = new byte[var2];
  178.  
  179.       int var4;
  180.       try {
  181.          var4 = var1.convert(this.value, this.offset, this.offset + this.count, var3, 0, var2);
  182.          var4 += var1.flush(var3, var1.nextByteIndex(), var2);
  183.       } catch (CharConversionException var6) {
  184.          var4 = var1.nextByteIndex();
  185.       }
  186.  
  187.       if (var4 < var2) {
  188.          byte[] var5 = new byte[var4];
  189.          System.arraycopy(var3, 0, var5, 0, var4);
  190.          return var5;
  191.       } else {
  192.          return var3;
  193.       }
  194.    }
  195.  
  196.    public byte[] getBytes(String var1) throws UnsupportedEncodingException {
  197.       return this.getBytes(CharToByteConverter.getConverter(var1));
  198.    }
  199.  
  200.    public byte[] getBytes() {
  201.       return this.getBytes(CharToByteConverter.getDefault());
  202.    }
  203.  
  204.    public boolean equals(Object var1) {
  205.       if (var1 != null && var1 instanceof String) {
  206.          String var2 = (String)var1;
  207.          int var3 = this.count;
  208.          if (var3 == var2.count) {
  209.             char[] var4 = this.value;
  210.             char[] var5 = var2.value;
  211.             int var6 = this.offset;
  212.             int var7 = var2.offset;
  213.  
  214.             while(var3-- != 0) {
  215.                if (var4[var6++] != var5[var7++]) {
  216.                   return false;
  217.                }
  218.             }
  219.  
  220.             return true;
  221.          }
  222.       }
  223.  
  224.       return false;
  225.    }
  226.  
  227.    public boolean equalsIgnoreCase(String var1) {
  228.       return var1 != null && var1.count == this.count && this.regionMatches(true, 0, var1, 0, this.count);
  229.    }
  230.  
  231.    public int compareTo(String var1) {
  232.       int var2 = this.count;
  233.       int var3 = var1.count;
  234.       int var4 = Math.min(var2, var3);
  235.       char[] var5 = this.value;
  236.       char[] var6 = var1.value;
  237.       int var7 = this.offset;
  238.       int var8 = var1.offset;
  239.  
  240.       while(var4-- != 0) {
  241.          char var9 = var5[var7++];
  242.          char var10 = var6[var8++];
  243.          if (var9 != var10) {
  244.             return var9 - var10;
  245.          }
  246.       }
  247.  
  248.       return var2 - var3;
  249.    }
  250.  
  251.    public boolean regionMatches(int var1, String var2, int var3, int var4) {
  252.       char[] var5 = this.value;
  253.       int var6 = this.offset + var1;
  254.       char[] var7 = var2.value;
  255.       int var8 = var2.offset + var3;
  256.       if (var3 >= 0 && var1 >= 0 && var1 <= this.count - var4 && var3 <= var2.count - var4) {
  257.          while(var4-- > 0) {
  258.             if (var5[var6++] != var7[var8++]) {
  259.                return false;
  260.             }
  261.          }
  262.  
  263.          return true;
  264.       } else {
  265.          return false;
  266.       }
  267.    }
  268.  
  269.    public boolean regionMatches(boolean var1, int var2, String var3, int var4, int var5) {
  270.       char[] var6 = this.value;
  271.       int var7 = this.offset + var2;
  272.       char[] var8 = var3.value;
  273.       int var9 = var3.offset + var4;
  274.       if (var4 >= 0 && var2 >= 0 && var2 <= this.count - var5 && var4 <= var3.count - var5) {
  275.          while(true) {
  276.             if (var5-- <= 0) {
  277.                return true;
  278.             }
  279.  
  280.             char var10 = var6[var7++];
  281.             char var11 = var8[var9++];
  282.             if (var10 != var11) {
  283.                if (!var1) {
  284.                   break;
  285.                }
  286.  
  287.                char var12 = Character.toUpperCase(var10);
  288.                char var13 = Character.toUpperCase(var11);
  289.                if (var12 != var13 && Character.toLowerCase(var12) != Character.toLowerCase(var13)) {
  290.                   break;
  291.                }
  292.             }
  293.          }
  294.  
  295.          return false;
  296.       } else {
  297.          return false;
  298.       }
  299.    }
  300.  
  301.    public boolean startsWith(String var1, int var2) {
  302.       char[] var3 = this.value;
  303.       int var4 = this.offset + var2;
  304.       char[] var5 = var1.value;
  305.       int var6 = var1.offset;
  306.       int var7 = var1.count;
  307.       if (var2 >= 0 && var2 <= this.count - var7) {
  308.          do {
  309.             --var7;
  310.             if (var7 < 0) {
  311.                return true;
  312.             }
  313.          } while(var3[var4++] == var5[var6++]);
  314.  
  315.          return false;
  316.       } else {
  317.          return false;
  318.       }
  319.    }
  320.  
  321.    public boolean startsWith(String var1) {
  322.       return this.startsWith(var1, 0);
  323.    }
  324.  
  325.    public boolean endsWith(String var1) {
  326.       return this.startsWith(var1, this.count - var1.count);
  327.    }
  328.  
  329.    public int hashCode() {
  330.       int var1 = 0;
  331.       int var2 = this.offset;
  332.       char[] var3 = this.value;
  333.       int var4 = this.count;
  334.       if (var4 < 16) {
  335.          for(int var5 = var4; var5 > 0; --var5) {
  336.             var1 = var1 * 37 + var3[var2++];
  337.          }
  338.       } else {
  339.          int var7 = var4 / 8;
  340.  
  341.          for(int var6 = var4; var6 > 0; var2 += var7) {
  342.             var1 = var1 * 39 + var3[var2];
  343.             var6 -= var7;
  344.          }
  345.       }
  346.  
  347.       return var1;
  348.    }
  349.  
  350.    public int indexOf(int var1) {
  351.       return this.indexOf(var1, 0);
  352.    }
  353.  
  354.    public int indexOf(int var1, int var2) {
  355.       int var3 = this.offset + this.count;
  356.       char[] var4 = this.value;
  357.       if (var2 < 0) {
  358.          var2 = 0;
  359.       } else if (var2 >= this.count) {
  360.          return -1;
  361.       }
  362.  
  363.       for(int var5 = this.offset + var2; var5 < var3; ++var5) {
  364.          if (var4[var5] == var1) {
  365.             return var5 - this.offset;
  366.          }
  367.       }
  368.  
  369.       return -1;
  370.    }
  371.  
  372.    public int lastIndexOf(int var1) {
  373.       return this.lastIndexOf(var1, this.count - 1);
  374.    }
  375.  
  376.    public int lastIndexOf(int var1, int var2) {
  377.       int var3 = this.offset;
  378.       char[] var4 = this.value;
  379.  
  380.       for(int var5 = this.offset + (var2 >= this.count ? this.count - 1 : var2); var5 >= var3; --var5) {
  381.          if (var4[var5] == var1) {
  382.             return var5 - this.offset;
  383.          }
  384.       }
  385.  
  386.       return -1;
  387.    }
  388.  
  389.    public int indexOf(String var1) {
  390.       return this.indexOf(var1, 0);
  391.    }
  392.  
  393.    public int indexOf(String var1, int var2) {
  394.       char[] var3 = this.value;
  395.       char[] var4 = var1.value;
  396.       int var5 = this.offset + (this.count - var1.count);
  397.       if (var2 < 0) {
  398.          var2 = 0;
  399.       } else if (var2 >= this.count) {
  400.          return -1;
  401.       }
  402.  
  403.       int var6 = this.offset + (var2 < 0 ? 0 : var2);
  404.  
  405.       label34:
  406.       while(var6 <= var5) {
  407.          int var7 = var1.count;
  408.          int var8 = var6;
  409.          int var9 = var1.offset;
  410.  
  411.          while(var7-- != 0) {
  412.             if (var3[var8++] != var4[var9++]) {
  413.                ++var6;
  414.                continue label34;
  415.             }
  416.          }
  417.  
  418.          return var6 - this.offset;
  419.       }
  420.  
  421.       return -1;
  422.    }
  423.  
  424.    public int lastIndexOf(String var1) {
  425.       return this.lastIndexOf(var1, this.count);
  426.    }
  427.  
  428.    public int lastIndexOf(String var1, int var2) {
  429.       if (var2 < 0) {
  430.          return -1;
  431.       } else {
  432.          if (var2 > this.count - var1.count) {
  433.             var2 = this.count - var1.count;
  434.          }
  435.  
  436.          if (var1.count == 0) {
  437.             return var2;
  438.          } else {
  439.             char[] var3 = this.value;
  440.             char[] var4 = var1.value;
  441.  
  442.             for(int var5 = this.offset + var2; var5 >= this.offset; --var5) {
  443.                int var6 = var1.count;
  444.                int var7 = var5;
  445.                int var8 = var1.offset;
  446.  
  447.                while(var3[var7++] == var4[var8++]) {
  448.                   --var6;
  449.                   if (var6 <= 0) {
  450.                      return var5 - this.offset;
  451.                   }
  452.                }
  453.             }
  454.  
  455.             return -1;
  456.          }
  457.       }
  458.    }
  459.  
  460.    public String substring(int var1) {
  461.       return this.substring(var1, this.length());
  462.    }
  463.  
  464.    public String substring(int var1, int var2) {
  465.       if (var1 < 0) {
  466.          throw new StringIndexOutOfBoundsException(var1);
  467.       } else if (var2 > this.count) {
  468.          throw new StringIndexOutOfBoundsException(var2);
  469.       } else if (var1 > var2) {
  470.          throw new StringIndexOutOfBoundsException(var2 - var1);
  471.       } else {
  472.          return var1 == 0 && var2 == this.count ? this : new String(this.offset + var1, var2 - var1, this.value);
  473.       }
  474.    }
  475.  
  476.    public String concat(String var1) {
  477.       int var2 = var1.length();
  478.       if (var2 == 0) {
  479.          return this;
  480.       } else {
  481.          char[] var3 = new char[this.count + var2];
  482.          this.getChars(0, this.count, var3, 0);
  483.          var1.getChars(0, var2, var3, this.count);
  484.          return new String(0, this.count + var2, var3);
  485.       }
  486.    }
  487.  
  488.    public String replace(char var1, char var2) {
  489.       if (var1 != var2) {
  490.          int var3 = this.count;
  491.          int var4 = -1;
  492.  
  493.          do {
  494.             ++var4;
  495.          } while(var4 < var3 && this.value[this.offset + var4] != var1);
  496.  
  497.          if (var4 < var3) {
  498.             char[] var5 = new char[var3];
  499.  
  500.             for(int var6 = 0; var6 < var4; ++var6) {
  501.                var5[var6] = this.value[this.offset + var6];
  502.             }
  503.  
  504.             while(var4 < var3) {
  505.                char var7 = this.value[this.offset + var4];
  506.                var5[var4] = var7 == var1 ? var2 : var7;
  507.                ++var4;
  508.             }
  509.  
  510.             return new String(0, var3, var5);
  511.          }
  512.       }
  513.  
  514.       return this;
  515.    }
  516.  
  517.    public String toLowerCase(Locale var1) {
  518.       StringBuffer var2 = new StringBuffer();
  519.       int var4 = this.count;
  520.       if (var1.getLanguage().equals("tr")) {
  521.          for(int var3 = 0; var3 < var4; ++var3) {
  522.             char var5 = this.value[this.offset + var3];
  523.             if (var5 == 'I') {
  524.                var2.append('─▒');
  525.             } else if (var5 == 304) {
  526.                var2.append('i');
  527.             } else {
  528.                var2.append(Character.toLowerCase(var5));
  529.             }
  530.          }
  531.       } else {
  532.          for(int var6 = 0; var6 < var4; ++var6) {
  533.             var2.append(Character.toLowerCase(this.value[this.offset + var6]));
  534.          }
  535.       }
  536.  
  537.       return var2.toString();
  538.    }
  539.  
  540.    public String toLowerCase() {
  541.       return this.toLowerCase(Locale.getDefault());
  542.    }
  543.  
  544.    public String toUpperCase(Locale var1) {
  545.       StringBuffer var2 = new StringBuffer();
  546.       int var4 = this.count;
  547.       if (var1.getLanguage().equals("tr")) {
  548.          for(int var3 = 0; var3 < var4; ++var3) {
  549.             char var5 = this.value[this.offset + var3];
  550.             if (var5 == 'i') {
  551.                var2.append('─░');
  552.             } else if (var5 == 305) {
  553.                var2.append('I');
  554.             } else if (var5 == 223) {
  555.                var2.append("SS");
  556.             } else {
  557.                var2.append(Character.toUpperCase(var5));
  558.             }
  559.          }
  560.       } else {
  561.          for(int var6 = 0; var6 < var4; ++var6) {
  562.             char var7 = this.value[this.offset + var6];
  563.             if (var7 == 223) {
  564.                var2.append("SS");
  565.             } else {
  566.                var2.append(Character.toUpperCase(var7));
  567.             }
  568.          }
  569.       }
  570.  
  571.       return var2.toString();
  572.    }
  573.  
  574.    public String toUpperCase() {
  575.       return this.toUpperCase(Locale.getDefault());
  576.    }
  577.  
  578.    public String trim() {
  579.       int var1 = this.count;
  580.  
  581.       int var2;
  582.       for(var2 = 0; var2 < var1 && this.value[this.offset + var2] <= ' '; ++var2) {
  583.       }
  584.  
  585.       while(var2 < var1 && this.value[this.offset + var1 - 1] <= ' ') {
  586.          --var1;
  587.       }
  588.  
  589.       return var2 <= 0 && var1 >= this.count ? this : this.substring(var2, var1);
  590.    }
  591.  
  592.    public String toString() {
  593.       return this;
  594.    }
  595.  
  596.    public char[] toCharArray() {
  597.       int var1 = this.length();
  598.       char[] var2 = new char[var1];
  599.       this.getChars(0, var1, var2, 0);
  600.       return var2;
  601.    }
  602.  
  603.    public static String valueOf(Object var0) {
  604.       return var0 == null ? "null" : var0.toString();
  605.    }
  606.  
  607.    public static String valueOf(char[] var0) {
  608.       return new String(var0);
  609.    }
  610.  
  611.    public static String valueOf(char[] var0, int var1, int var2) {
  612.       return new String(var0, var1, var2);
  613.    }
  614.  
  615.    public static String copyValueOf(char[] var0, int var1, int var2) {
  616.       return new String(var0, var1, var2);
  617.    }
  618.  
  619.    public static String copyValueOf(char[] var0) {
  620.       return copyValueOf(var0, 0, var0.length);
  621.    }
  622.  
  623.    public static String valueOf(boolean var0) {
  624.       return var0 ? "true" : "false";
  625.    }
  626.  
  627.    public static String valueOf(char var0) {
  628.       char[] var1 = new char[]{var0};
  629.       return new String(0, 1, var1);
  630.    }
  631.  
  632.    public static String valueOf(int var0) {
  633.       return Integer.toString(var0, 10);
  634.    }
  635.  
  636.    public static String valueOf(long var0) {
  637.       return Long.toString(var0, 10);
  638.    }
  639.  
  640.    public static String valueOf(float var0) {
  641.       return Float.toString(var0);
  642.    }
  643.  
  644.    public static String valueOf(double var0) {
  645.       return Double.toString(var0);
  646.    }
  647.  
  648.    public native String intern();
  649.  
  650.    int utfLength() {
  651.       int var1 = this.offset + this.count;
  652.       int var2 = 0;
  653.  
  654.       for(int var3 = this.offset; var3 < var1; ++var3) {
  655.          char var4 = this.value[var3];
  656.          if (var4 >= 1 && var4 <= 127) {
  657.             ++var2;
  658.          } else if (var4 > 2047) {
  659.             var2 += 3;
  660.          } else {
  661.             var2 += 2;
  662.          }
  663.       }
  664.  
  665.       return var2;
  666.    }
  667. }
  668.