home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / lang / String.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  12.2 KB  |  1,057 lines
  1. package java.lang;
  2.  
  3. import java.io.ObjectStreamField;
  4. import java.io.Serializable;
  5. import java.io.UnsupportedEncodingException;
  6. import java.nio.charset.Charset;
  7. import java.util.Arrays;
  8. import java.util.Comparator;
  9. import java.util.Formatter;
  10. import java.util.Locale;
  11. import java.util.regex.Matcher;
  12. import java.util.regex.Pattern;
  13.  
  14. public final class String implements Serializable, Comparable<String>, CharSequence {
  15.    private final char[] value;
  16.    private final int offset;
  17.    private final int count;
  18.    private int hash;
  19.    private static final long serialVersionUID = -6849794470754667710L;
  20.    private static final ObjectStreamField[] serialPersistentFields = new ObjectStreamField[0];
  21.    public static final Comparator<String> CASE_INSENSITIVE_ORDER = new CaseInsensitiveComparator((1)null);
  22.  
  23.    public String() {
  24.       this.offset = 0;
  25.       this.count = 0;
  26.       this.value = new char[0];
  27.    }
  28.  
  29.    public String(String var1) {
  30.       int var2 = var1.count;
  31.       char[] var3 = var1.value;
  32.       char[] var4;
  33.       if (var3.length > var2) {
  34.          int var5 = var1.offset;
  35.          var4 = Arrays.copyOfRange(var3, var5, var5 + var2);
  36.       } else {
  37.          var4 = var3;
  38.       }
  39.  
  40.       this.offset = 0;
  41.       this.count = var2;
  42.       this.value = var4;
  43.    }
  44.  
  45.    public String(char[] var1) {
  46.       int var2 = var1.length;
  47.       this.offset = 0;
  48.       this.count = var2;
  49.       this.value = Arrays.copyOf(var1, var2);
  50.    }
  51.  
  52.    public String(char[] var1, int var2, int var3) {
  53.       if (var2 < 0) {
  54.          throw new StringIndexOutOfBoundsException(var2);
  55.       } else if (var3 < 0) {
  56.          throw new StringIndexOutOfBoundsException(var3);
  57.       } else if (var2 > var1.length - var3) {
  58.          throw new StringIndexOutOfBoundsException(var2 + var3);
  59.       } else {
  60.          this.offset = 0;
  61.          this.count = var3;
  62.          this.value = Arrays.copyOfRange(var1, var2, var2 + var3);
  63.       }
  64.    }
  65.  
  66.    public String(int[] var1, int var2, int var3) {
  67.       if (var2 < 0) {
  68.          throw new StringIndexOutOfBoundsException(var2);
  69.       } else if (var3 < 0) {
  70.          throw new StringIndexOutOfBoundsException(var3);
  71.       } else if (var2 > var1.length - var3) {
  72.          throw new StringIndexOutOfBoundsException(var2 + var3);
  73.       } else {
  74.          int var4 = 0;
  75.          int var5 = 1;
  76.          char[] var6 = new char[var3 + var5];
  77.          int var7 = var2;
  78.          int var8 = 0;
  79.  
  80.          for(int var9 = 0; var9 < var3; ++var9) {
  81.             int var10 = var1[var7++];
  82.             if (var10 < 0) {
  83.                throw new IllegalArgumentException();
  84.             }
  85.  
  86.             if (var5 <= 0 && var8 + 1 >= var6.length) {
  87.                if (var4 == 0) {
  88.                   var4 = ((-var5 + 1) * var3 << 10) / var9;
  89.                   var4 >>= 10;
  90.                   if (var4 <= 0) {
  91.                      var4 = 1;
  92.                   }
  93.                } else {
  94.                   var4 *= 2;
  95.                }
  96.  
  97.                int var11 = Math.min(var6.length + var4, var3 * 2);
  98.                var5 = var11 - var6.length - (var3 - var9);
  99.                var6 = Arrays.copyOf(var6, var11);
  100.             }
  101.  
  102.             if (var10 < 65536) {
  103.                var6[var8++] = (char)var10;
  104.             } else {
  105.                if (var10 > 1114111) {
  106.                   throw new IllegalArgumentException();
  107.                }
  108.  
  109.                Character.toSurrogates(var10, var6, var8);
  110.                var8 += 2;
  111.                --var5;
  112.             }
  113.          }
  114.  
  115.          this.offset = 0;
  116.          this.value = var6;
  117.          this.count = var8;
  118.       }
  119.    }
  120.  
  121.    /** @deprecated */
  122.    @Deprecated
  123.    public String(byte[] var1, int var2, int var3, int var4) {
  124.       checkBounds(var1, var3, var4);
  125.       char[] var5 = new char[var4];
  126.       if (var2 == 0) {
  127.          for(int var6 = var4; var6-- > 0; var5[var6] = (char)(var1[var6 + var3] & 255)) {
  128.          }
  129.       } else {
  130.          var2 <<= 8;
  131.  
  132.          for(int var8 = var4; var8-- > 0; var5[var8] = (char)(var2 | var1[var8 + var3] & 255)) {
  133.          }
  134.       }
  135.  
  136.       this.offset = 0;
  137.       this.count = var4;
  138.       this.value = var5;
  139.    }
  140.  
  141.    /** @deprecated */
  142.    @Deprecated
  143.    public String(byte[] var1, int var2) {
  144.       this(var1, var2, 0, var1.length);
  145.    }
  146.  
  147.    private static void checkBounds(byte[] var0, int var1, int var2) {
  148.       if (var2 < 0) {
  149.          throw new StringIndexOutOfBoundsException(var2);
  150.       } else if (var1 < 0) {
  151.          throw new StringIndexOutOfBoundsException(var1);
  152.       } else if (var1 > var0.length - var2) {
  153.          throw new StringIndexOutOfBoundsException(var1 + var2);
  154.       }
  155.    }
  156.  
  157.    public String(byte[] var1, int var2, int var3, String var4) throws UnsupportedEncodingException {
  158.       if (var4 == null) {
  159.          throw new NullPointerException("charsetName");
  160.       } else {
  161.          checkBounds(var1, var2, var3);
  162.          char[] var5 = StringCoding.decode(var4, var1, var2, var3);
  163.          this.offset = 0;
  164.          this.count = var5.length;
  165.          this.value = var5;
  166.       }
  167.    }
  168.  
  169.    public String(byte[] var1, int var2, int var3, Charset var4) {
  170.       if (var4 == null) {
  171.          throw new NullPointerException("charset");
  172.       } else {
  173.          checkBounds(var1, var2, var3);
  174.          char[] var5 = StringCoding.decode(var4, var1, var2, var3);
  175.          this.offset = 0;
  176.          this.count = var5.length;
  177.          this.value = var5;
  178.       }
  179.    }
  180.  
  181.    public String(byte[] var1, String var2) throws UnsupportedEncodingException {
  182.       this(var1, 0, var1.length, (String)var2);
  183.    }
  184.  
  185.    public String(byte[] var1, Charset var2) {
  186.       this(var1, 0, var1.length, (Charset)var2);
  187.    }
  188.  
  189.    public String(byte[] var1, int var2, int var3) {
  190.       checkBounds(var1, var2, var3);
  191.       char[] var4 = StringCoding.decode(var1, var2, var3);
  192.       this.offset = 0;
  193.       this.count = var4.length;
  194.       this.value = var4;
  195.    }
  196.  
  197.    public String(byte[] var1) {
  198.       this((byte[])var1, 0, var1.length);
  199.    }
  200.  
  201.    public String(StringBuffer var1) {
  202.       String var2 = var1.toString();
  203.       this.value = var2.value;
  204.       this.count = var2.count;
  205.       this.offset = var2.offset;
  206.    }
  207.  
  208.    public String(StringBuilder var1) {
  209.       String var2 = var1.toString();
  210.       this.value = var2.value;
  211.       this.count = var2.count;
  212.       this.offset = var2.offset;
  213.    }
  214.  
  215.    String(int var1, int var2, char[] var3) {
  216.       this.value = var3;
  217.       this.offset = var1;
  218.       this.count = var2;
  219.    }
  220.  
  221.    public int length() {
  222.       return this.count;
  223.    }
  224.  
  225.    public boolean isEmpty() {
  226.       return this.count == 0;
  227.    }
  228.  
  229.    public char charAt(int var1) {
  230.       if (var1 >= 0 && var1 < this.count) {
  231.          return this.value[var1 + this.offset];
  232.       } else {
  233.          throw new StringIndexOutOfBoundsException(var1);
  234.       }
  235.    }
  236.  
  237.    public int codePointAt(int var1) {
  238.       if (var1 >= 0 && var1 < this.count) {
  239.          return Character.codePointAtImpl(this.value, this.offset + var1, this.offset + this.count);
  240.       } else {
  241.          throw new StringIndexOutOfBoundsException(var1);
  242.       }
  243.    }
  244.  
  245.    public int codePointBefore(int var1) {
  246.       int var2 = var1 - 1;
  247.       if (var2 >= 0 && var2 < this.count) {
  248.          return Character.codePointBeforeImpl(this.value, this.offset + var1, this.offset);
  249.       } else {
  250.          throw new StringIndexOutOfBoundsException(var1);
  251.       }
  252.    }
  253.  
  254.    public int codePointCount(int var1, int var2) {
  255.       if (var1 >= 0 && var2 <= this.count && var1 <= var2) {
  256.          return Character.codePointCountImpl(this.value, this.offset + var1, var2 - var1);
  257.       } else {
  258.          throw new IndexOutOfBoundsException();
  259.       }
  260.    }
  261.  
  262.    public int offsetByCodePoints(int var1, int var2) {
  263.       if (var1 >= 0 && var1 <= this.count) {
  264.          return Character.offsetByCodePointsImpl(this.value, this.offset, this.count, this.offset + var1, var2) - this.offset;
  265.       } else {
  266.          throw new IndexOutOfBoundsException();
  267.       }
  268.    }
  269.  
  270.    void getChars(char[] var1, int var2) {
  271.       System.arraycopy(this.value, this.offset, var1, var2, this.count);
  272.    }
  273.  
  274.    public void getChars(int var1, int var2, char[] var3, int var4) {
  275.       if (var1 < 0) {
  276.          throw new StringIndexOutOfBoundsException(var1);
  277.       } else if (var2 > this.count) {
  278.          throw new StringIndexOutOfBoundsException(var2);
  279.       } else if (var1 > var2) {
  280.          throw new StringIndexOutOfBoundsException(var2 - var1);
  281.       } else {
  282.          System.arraycopy(this.value, this.offset + var1, var3, var4, var2 - var1);
  283.       }
  284.    }
  285.  
  286.    /** @deprecated */
  287.    @Deprecated
  288.    public void getBytes(int var1, int var2, byte[] var3, int var4) {
  289.       if (var1 < 0) {
  290.          throw new StringIndexOutOfBoundsException(var1);
  291.       } else if (var2 > this.count) {
  292.          throw new StringIndexOutOfBoundsException(var2);
  293.       } else if (var1 > var2) {
  294.          throw new StringIndexOutOfBoundsException(var2 - var1);
  295.       } else {
  296.          int var5 = var4;
  297.          int var6 = this.offset + var2;
  298.          int var7 = this.offset + var1;
  299.  
  300.          for(char[] var8 = this.value; var7 < var6; var3[var5++] = (byte)var8[var7++]) {
  301.          }
  302.  
  303.       }
  304.    }
  305.  
  306.    public byte[] getBytes(String var1) throws UnsupportedEncodingException {
  307.       if (var1 == null) {
  308.          throw new NullPointerException();
  309.       } else {
  310.          return StringCoding.encode(var1, this.value, this.offset, this.count);
  311.       }
  312.    }
  313.  
  314.    public byte[] getBytes(Charset var1) {
  315.       if (var1 == null) {
  316.          throw new NullPointerException();
  317.       } else {
  318.          return StringCoding.encode(var1, this.value, this.offset, this.count);
  319.       }
  320.    }
  321.  
  322.    public byte[] getBytes() {
  323.       return StringCoding.encode(this.value, this.offset, this.count);
  324.    }
  325.  
  326.    public boolean equals(Object var1) {
  327.       if (this == var1) {
  328.          return true;
  329.       } else {
  330.          if (var1 instanceof String) {
  331.             String var2 = (String)var1;
  332.             int var3 = this.count;
  333.             if (var3 == var2.count) {
  334.                char[] var4 = this.value;
  335.                char[] var5 = var2.value;
  336.                int var6 = this.offset;
  337.                int var7 = var2.offset;
  338.  
  339.                while(var3-- != 0) {
  340.                   if (var4[var6++] != var5[var7++]) {
  341.                      return false;
  342.                   }
  343.                }
  344.  
  345.                return true;
  346.             }
  347.          }
  348.  
  349.          return false;
  350.       }
  351.    }
  352.  
  353.    public boolean contentEquals(StringBuffer var1) {
  354.       synchronized(var1) {
  355.          return this.contentEquals((CharSequence)var1);
  356.       }
  357.    }
  358.  
  359.    public boolean contentEquals(CharSequence var1) {
  360.       if (this.count != var1.length()) {
  361.          return false;
  362.       } else {
  363.          if (var1 instanceof AbstractStringBuilder) {
  364.             char[] var2 = this.value;
  365.             char[] var3 = ((AbstractStringBuilder)var1).getValue();
  366.             int var4 = this.offset;
  367.             int var5 = 0;
  368.             int var6 = this.count;
  369.  
  370.             while(var6-- != 0) {
  371.                if (var2[var4++] != var3[var5++]) {
  372.                   return false;
  373.                }
  374.             }
  375.          }
  376.  
  377.          if (var1.equals(this)) {
  378.             return true;
  379.          } else {
  380.             char[] var7 = this.value;
  381.             int var8 = this.offset;
  382.             int var9 = 0;
  383.             int var10 = this.count;
  384.  
  385.             while(var10-- != 0) {
  386.                if (var7[var8++] != var1.charAt(var9++)) {
  387.                   return false;
  388.                }
  389.             }
  390.  
  391.             return true;
  392.          }
  393.       }
  394.    }
  395.  
  396.    public boolean equalsIgnoreCase(String var1) {
  397.       return this == var1 ? true : var1 != null && var1.count == this.count && this.regionMatches(true, 0, var1, 0, this.count);
  398.    }
  399.  
  400.    public int compareTo(String var1) {
  401.       int var2 = this.count;
  402.       int var3 = var1.count;
  403.       int var4 = Math.min(var2, var3);
  404.       char[] var5 = this.value;
  405.       char[] var6 = var1.value;
  406.       int var7 = this.offset;
  407.       int var8 = var1.offset;
  408.       if (var7 == var8) {
  409.          int var13 = var7;
  410.  
  411.          for(int var14 = var4 + var7; var13 < var14; ++var13) {
  412.             char var11 = var5[var13];
  413.             char var12 = var6[var13];
  414.             if (var11 != var12) {
  415.                return var11 - var12;
  416.             }
  417.          }
  418.       } else {
  419.          while(var4-- != 0) {
  420.             char var9 = var5[var7++];
  421.             char var10 = var6[var8++];
  422.             if (var9 != var10) {
  423.                return var9 - var10;
  424.             }
  425.          }
  426.       }
  427.  
  428.       return var2 - var3;
  429.    }
  430.  
  431.    public int compareToIgnoreCase(String var1) {
  432.       return CASE_INSENSITIVE_ORDER.compare(this, var1);
  433.    }
  434.  
  435.    public boolean regionMatches(int var1, String var2, int var3, int var4) {
  436.       char[] var5 = this.value;
  437.       int var6 = this.offset + var1;
  438.       char[] var7 = var2.value;
  439.       int var8 = var2.offset + var3;
  440.       if (var3 >= 0 && var1 >= 0 && (long)var1 <= (long)this.count - (long)var4 && (long)var3 <= (long)var2.count - (long)var4) {
  441.          while(var4-- > 0) {
  442.             if (var5[var6++] != var7[var8++]) {
  443.                return false;
  444.             }
  445.          }
  446.  
  447.          return true;
  448.       } else {
  449.          return false;
  450.       }
  451.    }
  452.  
  453.    public boolean regionMatches(boolean var1, int var2, String var3, int var4, int var5) {
  454.       char[] var6 = this.value;
  455.       int var7 = this.offset + var2;
  456.       char[] var8 = var3.value;
  457.       int var9 = var3.offset + var4;
  458.       if (var4 >= 0 && var2 >= 0 && (long)var2 <= (long)this.count - (long)var5 && (long)var4 <= (long)var3.count - (long)var5) {
  459.          while(true) {
  460.             if (var5-- <= 0) {
  461.                return true;
  462.             }
  463.  
  464.             char var10 = var6[var7++];
  465.             char var11 = var8[var9++];
  466.             if (var10 != var11) {
  467.                if (!var1) {
  468.                   break;
  469.                }
  470.  
  471.                char var12 = Character.toUpperCase(var10);
  472.                char var13 = Character.toUpperCase(var11);
  473.                if (var12 != var13 && Character.toLowerCase(var12) != Character.toLowerCase(var13)) {
  474.                   break;
  475.                }
  476.             }
  477.          }
  478.  
  479.          return false;
  480.       } else {
  481.          return false;
  482.       }
  483.    }
  484.  
  485.    public boolean startsWith(String var1, int var2) {
  486.       char[] var3 = this.value;
  487.       int var4 = this.offset + var2;
  488.       char[] var5 = var1.value;
  489.       int var6 = var1.offset;
  490.       int var7 = var1.count;
  491.       if (var2 >= 0 && var2 <= this.count - var7) {
  492.          do {
  493.             --var7;
  494.             if (var7 < 0) {
  495.                return true;
  496.             }
  497.          } while(var3[var4++] == var5[var6++]);
  498.  
  499.          return false;
  500.       } else {
  501.          return false;
  502.       }
  503.    }
  504.  
  505.    public boolean startsWith(String var1) {
  506.       return this.startsWith(var1, 0);
  507.    }
  508.  
  509.    public boolean endsWith(String var1) {
  510.       return this.startsWith(var1, this.count - var1.count);
  511.    }
  512.  
  513.    public int hashCode() {
  514.       int var1 = this.hash;
  515.       if (var1 == 0) {
  516.          int var2 = this.offset;
  517.          char[] var3 = this.value;
  518.          int var4 = this.count;
  519.  
  520.          for(int var5 = 0; var5 < var4; ++var5) {
  521.             var1 = 31 * var1 + var3[var2++];
  522.          }
  523.  
  524.          this.hash = var1;
  525.       }
  526.  
  527.       return var1;
  528.    }
  529.  
  530.    public int indexOf(int var1) {
  531.       return this.indexOf(var1, 0);
  532.    }
  533.  
  534.    public int indexOf(int var1, int var2) {
  535.       int var3 = this.offset + this.count;
  536.       char[] var4 = this.value;
  537.       if (var2 < 0) {
  538.          var2 = 0;
  539.       } else if (var2 >= this.count) {
  540.          return -1;
  541.       }
  542.  
  543.       int var5 = this.offset + var2;
  544.       if (var1 < 65536) {
  545.          while(var5 < var3) {
  546.             if (var4[var5] == var1) {
  547.                return var5 - this.offset;
  548.             }
  549.  
  550.             ++var5;
  551.          }
  552.  
  553.          return -1;
  554.       } else {
  555.          if (var1 <= 1114111) {
  556.             for(char[] var6 = Character.toChars(var1); var5 < var3; ++var5) {
  557.                if (var4[var5] == var6[0]) {
  558.                   if (var5 + 1 == var3) {
  559.                      break;
  560.                   }
  561.  
  562.                   if (var4[var5 + 1] == var6[1]) {
  563.                      return var5 - this.offset;
  564.                   }
  565.                }
  566.             }
  567.          }
  568.  
  569.          return -1;
  570.       }
  571.    }
  572.  
  573.    public int lastIndexOf(int var1) {
  574.       return this.lastIndexOf(var1, this.count - 1);
  575.    }
  576.  
  577.    public int lastIndexOf(int var1, int var2) {
  578.       int var3 = this.offset;
  579.       char[] var4 = this.value;
  580.       int var5 = this.offset + (var2 >= this.count ? this.count - 1 : var2);
  581.       if (var1 < 65536) {
  582.          while(var5 >= var3) {
  583.             if (var4[var5] == var1) {
  584.                return var5 - this.offset;
  585.             }
  586.  
  587.             --var5;
  588.          }
  589.  
  590.          return -1;
  591.       } else {
  592.          int var6 = this.offset + this.count;
  593.          if (var1 <= 1114111) {
  594.             for(char[] var7 = Character.toChars(var1); var5 >= var3; --var5) {
  595.                if (var4[var5] == var7[0]) {
  596.                   if (var5 + 1 == var6) {
  597.                      break;
  598.                   }
  599.  
  600.                   if (var4[var5 + 1] == var7[1]) {
  601.                      return var5 - this.offset;
  602.                   }
  603.                }
  604.             }
  605.          }
  606.  
  607.          return -1;
  608.       }
  609.    }
  610.  
  611.    public int indexOf(String var1) {
  612.       return this.indexOf(var1, 0);
  613.    }
  614.  
  615.    public int indexOf(String var1, int var2) {
  616.       return indexOf(this.value, this.offset, this.count, var1.value, var1.offset, var1.count, var2);
  617.    }
  618.  
  619.    static int indexOf(char[] var0, int var1, int var2, char[] var3, int var4, int var5, int var6) {
  620.       if (var6 >= var2) {
  621.          return var5 == 0 ? var2 : -1;
  622.       } else {
  623.          if (var6 < 0) {
  624.             var6 = 0;
  625.          }
  626.  
  627.          if (var5 == 0) {
  628.             return var6;
  629.          } else {
  630.             char var7 = var3[var4];
  631.             int var8 = var1 + (var2 - var5);
  632.  
  633.             for(int var9 = var1 + var6; var9 <= var8; ++var9) {
  634.                if (var0[var9] != var7) {
  635.                   do {
  636.                      ++var9;
  637.                   } while(var9 <= var8 && var0[var9] != var7);
  638.                }
  639.  
  640.                if (var9 <= var8) {
  641.                   int var10 = var9 + 1;
  642.                   int var11 = var10 + var5 - 1;
  643.  
  644.                   for(int var12 = var4 + 1; var10 < var11 && var0[var10] == var3[var12]; ++var12) {
  645.                      ++var10;
  646.                   }
  647.  
  648.                   if (var10 == var11) {
  649.                      return var9 - var1;
  650.                   }
  651.                }
  652.             }
  653.  
  654.             return -1;
  655.          }
  656.       }
  657.    }
  658.  
  659.    public int lastIndexOf(String var1) {
  660.       return this.lastIndexOf(var1, this.count);
  661.    }
  662.  
  663.    public int lastIndexOf(String var1, int var2) {
  664.       return lastIndexOf(this.value, this.offset, this.count, var1.value, var1.offset, var1.count, var2);
  665.    }
  666.  
  667.    static int lastIndexOf(char[] var0, int var1, int var2, char[] var3, int var4, int var5, int var6) {
  668.       int var7 = var2 - var5;
  669.       if (var6 < 0) {
  670.          return -1;
  671.       } else {
  672.          if (var6 > var7) {
  673.             var6 = var7;
  674.          }
  675.  
  676.          if (var5 == 0) {
  677.             return var6;
  678.          } else {
  679.             int var8 = var4 + var5 - 1;
  680.             char var9 = var3[var8];
  681.             int var10 = var1 + var5 - 1;
  682.             int var11 = var10 + var6;
  683.  
  684.             while(true) {
  685.                label38:
  686.                while(var11 < var10 || var0[var11] == var9) {
  687.                   if (var11 < var10) {
  688.                      return -1;
  689.                   }
  690.  
  691.                   int var12 = var11 - 1;
  692.                   int var13 = var12 - (var5 - 1);
  693.                   int var14 = var8 - 1;
  694.  
  695.                   while(var12 > var13) {
  696.                      if (var0[var12--] != var3[var14--]) {
  697.                         --var11;
  698.                         continue label38;
  699.                      }
  700.                   }
  701.  
  702.                   return var13 - var1 + 1;
  703.                }
  704.  
  705.                --var11;
  706.             }
  707.          }
  708.       }
  709.    }
  710.  
  711.    public String substring(int var1) {
  712.       return this.substring(var1, this.count);
  713.    }
  714.  
  715.    public String substring(int var1, int var2) {
  716.       if (var1 < 0) {
  717.          throw new StringIndexOutOfBoundsException(var1);
  718.       } else if (var2 > this.count) {
  719.          throw new StringIndexOutOfBoundsException(var2);
  720.       } else if (var1 > var2) {
  721.          throw new StringIndexOutOfBoundsException(var2 - var1);
  722.       } else {
  723.          return var1 == 0 && var2 == this.count ? this : new String(this.offset + var1, var2 - var1, this.value);
  724.       }
  725.    }
  726.  
  727.    public CharSequence subSequence(int var1, int var2) {
  728.       return this.substring(var1, var2);
  729.    }
  730.  
  731.    public String concat(String var1) {
  732.       int var2 = var1.length();
  733.       if (var2 == 0) {
  734.          return this;
  735.       } else {
  736.          char[] var3 = new char[this.count + var2];
  737.          this.getChars(0, this.count, var3, 0);
  738.          var1.getChars(0, var2, var3, this.count);
  739.          return new String(0, this.count + var2, var3);
  740.       }
  741.    }
  742.  
  743.    public String replace(char var1, char var2) {
  744.       if (var1 != var2) {
  745.          int var3 = this.count;
  746.          int var4 = -1;
  747.          char[] var5 = this.value;
  748.          int var6 = this.offset;
  749.  
  750.          do {
  751.             ++var4;
  752.          } while(var4 < var3 && var5[var6 + var4] != var1);
  753.  
  754.          if (var4 < var3) {
  755.             char[] var7 = new char[var3];
  756.  
  757.             for(int var8 = 0; var8 < var4; ++var8) {
  758.                var7[var8] = var5[var6 + var8];
  759.             }
  760.  
  761.             while(var4 < var3) {
  762.                char var9 = var5[var6 + var4];
  763.                var7[var4] = var9 == var1 ? var2 : var9;
  764.                ++var4;
  765.             }
  766.  
  767.             return new String(0, var3, var7);
  768.          }
  769.       }
  770.  
  771.       return this;
  772.    }
  773.  
  774.    public boolean matches(String var1) {
  775.       return Pattern.matches(var1, this);
  776.    }
  777.  
  778.    public boolean contains(CharSequence var1) {
  779.       return this.indexOf(var1.toString()) > -1;
  780.    }
  781.  
  782.    public String replaceFirst(String var1, String var2) {
  783.       return Pattern.compile(var1).matcher(this).replaceFirst(var2);
  784.    }
  785.  
  786.    public String replaceAll(String var1, String var2) {
  787.       return Pattern.compile(var1).matcher(this).replaceAll(var2);
  788.    }
  789.  
  790.    public String replace(CharSequence var1, CharSequence var2) {
  791.       return Pattern.compile(var1.toString(), 16).matcher(this).replaceAll(Matcher.quoteReplacement(var2.toString()));
  792.    }
  793.  
  794.    public String[] split(String var1, int var2) {
  795.       return Pattern.compile(var1).split(this, var2);
  796.    }
  797.  
  798.    public String[] split(String var1) {
  799.       return this.split(var1, 0);
  800.    }
  801.  
  802.    public String toLowerCase(Locale var1) {
  803.       if (var1 == null) {
  804.          throw new NullPointerException();
  805.       } else {
  806.          int var2 = 0;
  807.  
  808.          while(true) {
  809.             if (var2 >= this.count) {
  810.                return this;
  811.             }
  812.  
  813.             char var3 = this.value[this.offset + var2];
  814.             if (var3 >= '\ud800' && var3 <= '\udbff') {
  815.                int var4 = this.codePointAt(var2);
  816.                if (var4 != Character.toLowerCase(var4)) {
  817.                   break;
  818.                }
  819.  
  820.                var2 += Character.charCount(var4);
  821.             } else {
  822.                if (var3 != Character.toLowerCase(var3)) {
  823.                   break;
  824.                }
  825.  
  826.                ++var2;
  827.             }
  828.          }
  829.  
  830.          char[] var14 = new char[this.count];
  831.          int var15 = 0;
  832.          System.arraycopy(this.value, this.offset, var14, 0, var2);
  833.          String var5 = var1.getLanguage();
  834.          boolean var6 = var5 == "tr" || var5 == "az" || var5 == "lt";
  835.  
  836.          int var10;
  837.          for(int var11 = var2; var11 < this.count; var11 += var10) {
  838.             int var9 = this.value[this.offset + var11];
  839.             if ((char)var9 >= '\ud800' && (char)var9 <= '\udbff') {
  840.                var9 = this.codePointAt(var11);
  841.                var10 = Character.charCount(var9);
  842.             } else {
  843.                var10 = 1;
  844.             }
  845.  
  846.             int var8;
  847.             if (!var6 && var9 != 931) {
  848.                var8 = Character.toLowerCase(var9);
  849.             } else {
  850.                var8 = ConditionalSpecialCasing.toLowerCaseEx(this, var11, var1);
  851.             }
  852.  
  853.             if (var8 != -1 && var8 < 65536) {
  854.                var14[var11 + var15] = (char)var8;
  855.             } else {
  856.                char[] var7;
  857.                if (var8 == -1) {
  858.                   var7 = ConditionalSpecialCasing.toLowerCaseCharArray(this, var11, var1);
  859.                } else {
  860.                   if (var10 == 2) {
  861.                      var15 += Character.toChars(var8, var14, var11 + var15) - var10;
  862.                      continue;
  863.                   }
  864.  
  865.                   var7 = Character.toChars(var8);
  866.                }
  867.  
  868.                int var12 = var7.length;
  869.                if (var12 > var10) {
  870.                   char[] var13 = new char[var14.length + var12 - var10];
  871.                   System.arraycopy(var14, 0, var13, 0, var11 + var15);
  872.                   var14 = var13;
  873.                }
  874.  
  875.                for(int var16 = 0; var16 < var12; ++var16) {
  876.                   var14[var11 + var15 + var16] = var7[var16];
  877.                }
  878.  
  879.                var15 += var12 - var10;
  880.             }
  881.          }
  882.  
  883.          return new String(0, this.count + var15, var14);
  884.       }
  885.    }
  886.  
  887.    public String toLowerCase() {
  888.       return this.toLowerCase(Locale.getDefault());
  889.    }
  890.  
  891.    public String toUpperCase(Locale var1) {
  892.       if (var1 == null) {
  893.          throw new NullPointerException();
  894.       } else {
  895.          int var4;
  896.          for(int var2 = 0; var2 < this.count; var2 += var4) {
  897.             int var3 = this.value[this.offset + var2];
  898.             if (var3 >= 55296 && var3 <= 56319) {
  899.                var3 = this.codePointAt(var2);
  900.                var4 = Character.charCount(var3);
  901.             } else {
  902.                var4 = 1;
  903.             }
  904.  
  905.             int var5 = Character.toUpperCaseEx(var3);
  906.             if (var5 == -1 || var3 != var5) {
  907.                char[] var14 = new char[this.count];
  908.                var4 = 0;
  909.                System.arraycopy(this.value, this.offset, var14, 0, var2);
  910.                String var16 = var1.getLanguage();
  911.                boolean var6 = var16 == "tr" || var16 == "az" || var16 == "lt";
  912.  
  913.                int var10;
  914.                for(int var11 = var2; var11 < this.count; var11 += var10) {
  915.                   int var9 = this.value[this.offset + var11];
  916.                   if ((char)var9 >= '\ud800' && (char)var9 <= '\udbff') {
  917.                      var9 = this.codePointAt(var11);
  918.                      var10 = Character.charCount(var9);
  919.                   } else {
  920.                      var10 = 1;
  921.                   }
  922.  
  923.                   int var8;
  924.                   if (var6) {
  925.                      var8 = ConditionalSpecialCasing.toUpperCaseEx(this, var11, var1);
  926.                   } else {
  927.                      var8 = Character.toUpperCaseEx(var9);
  928.                   }
  929.  
  930.                   if (var8 != -1 && var8 < 65536) {
  931.                      var14[var11 + var4] = (char)var8;
  932.                   } else {
  933.                      char[] var7;
  934.                      if (var8 == -1) {
  935.                         if (var6) {
  936.                            var7 = ConditionalSpecialCasing.toUpperCaseCharArray(this, var11, var1);
  937.                         } else {
  938.                            var7 = Character.toUpperCaseCharArray(var9);
  939.                         }
  940.                      } else {
  941.                         if (var10 == 2) {
  942.                            var4 += Character.toChars(var8, var14, var11 + var4) - var10;
  943.                            continue;
  944.                         }
  945.  
  946.                         var7 = Character.toChars(var8);
  947.                      }
  948.  
  949.                      int var12 = var7.length;
  950.                      if (var12 > var10) {
  951.                         char[] var13 = new char[var14.length + var12 - var10];
  952.                         System.arraycopy(var14, 0, var13, 0, var11 + var4);
  953.                         var14 = var13;
  954.                      }
  955.  
  956.                      for(int var17 = 0; var17 < var12; ++var17) {
  957.                         var14[var11 + var4 + var17] = var7[var17];
  958.                      }
  959.  
  960.                      var4 += var12 - var10;
  961.                   }
  962.                }
  963.  
  964.                return new String(0, this.count + var4, var14);
  965.             }
  966.          }
  967.  
  968.          return this;
  969.       }
  970.    }
  971.  
  972.    public String toUpperCase() {
  973.       return this.toUpperCase(Locale.getDefault());
  974.    }
  975.  
  976.    public String trim() {
  977.       int var1 = this.count;
  978.       int var2 = 0;
  979.       int var3 = this.offset;
  980.  
  981.       char[] var4;
  982.       for(var4 = this.value; var2 < var1 && var4[var3 + var2] <= ' '; ++var2) {
  983.       }
  984.  
  985.       while(var2 < var1 && var4[var3 + var1 - 1] <= ' ') {
  986.          --var1;
  987.       }
  988.  
  989.       return var2 <= 0 && var1 >= this.count ? this : this.substring(var2, var1);
  990.    }
  991.  
  992.    public String toString() {
  993.       return this;
  994.    }
  995.  
  996.    public char[] toCharArray() {
  997.       char[] var1 = new char[this.count];
  998.       this.getChars(0, this.count, var1, 0);
  999.       return var1;
  1000.    }
  1001.  
  1002.    public static String format(String var0, Object... var1) {
  1003.       return (new Formatter()).format(var0, var1).toString();
  1004.    }
  1005.  
  1006.    public static String format(Locale var0, String var1, Object... var2) {
  1007.       return (new Formatter(var0)).format(var1, var2).toString();
  1008.    }
  1009.  
  1010.    public static String valueOf(Object var0) {
  1011.       return var0 == null ? "null" : var0.toString();
  1012.    }
  1013.  
  1014.    public static String valueOf(char[] var0) {
  1015.       return new String(var0);
  1016.    }
  1017.  
  1018.    public static String valueOf(char[] var0, int var1, int var2) {
  1019.       return new String(var0, var1, var2);
  1020.    }
  1021.  
  1022.    public static String copyValueOf(char[] var0, int var1, int var2) {
  1023.       return new String(var0, var1, var2);
  1024.    }
  1025.  
  1026.    public static String copyValueOf(char[] var0) {
  1027.       return copyValueOf(var0, 0, var0.length);
  1028.    }
  1029.  
  1030.    public static String valueOf(boolean var0) {
  1031.       return var0 ? "true" : "false";
  1032.    }
  1033.  
  1034.    public static String valueOf(char var0) {
  1035.       char[] var1 = new char[]{var0};
  1036.       return new String(0, 1, var1);
  1037.    }
  1038.  
  1039.    public static String valueOf(int var0) {
  1040.       return Integer.toString(var0, 10);
  1041.    }
  1042.  
  1043.    public static String valueOf(long var0) {
  1044.       return Long.toString(var0, 10);
  1045.    }
  1046.  
  1047.    public static String valueOf(float var0) {
  1048.       return Float.toString(var0);
  1049.    }
  1050.  
  1051.    public static String valueOf(double var0) {
  1052.       return Double.toString(var0);
  1053.    }
  1054.  
  1055.    public native String intern();
  1056. }
  1057.