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