home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 1999 April / DPPCPRO0499.ISO / April / Notes / 50b2wic.exe / DATA1.CAB / NotesProgramFilesJavaSupport / rt.jar / java / lang / StringBuffer.class (.txt) < prev    next >
Encoding:
Java Class File  |  1998-04-23  |  4.5 KB  |  299 lines
  1. package java.lang;
  2.  
  3. import java.io.Serializable;
  4.  
  5. public final class StringBuffer implements Serializable {
  6.    private char[] value;
  7.    private int count;
  8.    private boolean shared;
  9.    static final long serialVersionUID = 3388685877147921107L;
  10.  
  11.    public StringBuffer() {
  12.       this(16);
  13.    }
  14.  
  15.    public StringBuffer(int var1) {
  16.       this.value = new char[var1];
  17.       this.shared = false;
  18.    }
  19.  
  20.    public StringBuffer(String var1) {
  21.       this(var1.length() + 16);
  22.       this.append(var1);
  23.    }
  24.  
  25.    public int length() {
  26.       return this.count;
  27.    }
  28.  
  29.    public int capacity() {
  30.       return this.value.length;
  31.    }
  32.  
  33.    private final void copy() {
  34.       char[] var1 = new char[this.value.length];
  35.       System.arraycopy(this.value, 0, var1, 0, this.count);
  36.       this.value = var1;
  37.       this.shared = false;
  38.    }
  39.  
  40.    public synchronized void ensureCapacity(int var1) {
  41.       if (var1 > this.value.length) {
  42.          this.expandCapacity(var1);
  43.       }
  44.  
  45.    }
  46.  
  47.    private void expandCapacity(int var1) {
  48.       int var2 = (this.value.length + 1) * 2;
  49.       if (var1 > var2) {
  50.          var2 = var1;
  51.       }
  52.  
  53.       char[] var3 = new char[var2];
  54.       System.arraycopy(this.value, 0, var3, 0, this.count);
  55.       this.value = var3;
  56.       this.shared = false;
  57.    }
  58.  
  59.    public synchronized void setLength(int var1) {
  60.       if (var1 < 0) {
  61.          throw new StringIndexOutOfBoundsException(var1);
  62.       } else {
  63.          if (var1 > this.value.length) {
  64.             this.expandCapacity(var1);
  65.          }
  66.  
  67.          if (this.count >= var1) {
  68.             this.count = var1;
  69.             if (this.shared) {
  70.                this.copy();
  71.             }
  72.  
  73.          } else {
  74.             if (this.shared) {
  75.                this.copy();
  76.             }
  77.  
  78.             while(this.count < var1) {
  79.                this.value[this.count] = 0;
  80.                ++this.count;
  81.             }
  82.  
  83.          }
  84.       }
  85.    }
  86.  
  87.    public synchronized char charAt(int var1) {
  88.       if (var1 >= 0 && var1 < this.count) {
  89.          return this.value[var1];
  90.       } else {
  91.          throw new StringIndexOutOfBoundsException(var1);
  92.       }
  93.    }
  94.  
  95.    public synchronized void getChars(int var1, int var2, char[] var3, int var4) {
  96.       if (var1 >= 0 && var1 < this.count) {
  97.          if (var2 >= 0 && var2 <= this.count) {
  98.             if (var1 < var2) {
  99.                System.arraycopy(this.value, var1, var3, var4, var2 - var1);
  100.             }
  101.  
  102.          } else {
  103.             throw new StringIndexOutOfBoundsException(var2);
  104.          }
  105.       } else {
  106.          throw new StringIndexOutOfBoundsException(var1);
  107.       }
  108.    }
  109.  
  110.    public synchronized void setCharAt(int var1, char var2) {
  111.       if (var1 >= 0 && var1 < this.count) {
  112.          if (this.shared) {
  113.             this.copy();
  114.          }
  115.  
  116.          this.value[var1] = var2;
  117.       } else {
  118.          throw new StringIndexOutOfBoundsException(var1);
  119.       }
  120.    }
  121.  
  122.    public synchronized StringBuffer append(Object var1) {
  123.       return this.append(String.valueOf(var1));
  124.    }
  125.  
  126.    public synchronized StringBuffer append(String var1) {
  127.       if (var1 == null) {
  128.          var1 = String.valueOf(var1);
  129.       }
  130.  
  131.       int var2 = var1.length();
  132.       int var3 = this.count + var2;
  133.       if (var3 > this.value.length) {
  134.          this.expandCapacity(var3);
  135.       }
  136.  
  137.       var1.getChars(0, var2, this.value, this.count);
  138.       this.count = var3;
  139.       return this;
  140.    }
  141.  
  142.    public synchronized StringBuffer append(char[] var1) {
  143.       int var2 = var1.length;
  144.       int var3 = this.count + var2;
  145.       if (var3 > this.value.length) {
  146.          this.expandCapacity(var3);
  147.       }
  148.  
  149.       System.arraycopy(var1, 0, this.value, this.count, var2);
  150.       this.count = var3;
  151.       return this;
  152.    }
  153.  
  154.    public synchronized StringBuffer append(char[] var1, int var2, int var3) {
  155.       int var4 = this.count + var3;
  156.       if (var4 > this.value.length) {
  157.          this.expandCapacity(var4);
  158.       }
  159.  
  160.       System.arraycopy(var1, var2, this.value, this.count, var3);
  161.       this.count = var4;
  162.       return this;
  163.    }
  164.  
  165.    public StringBuffer append(boolean var1) {
  166.       return this.append(String.valueOf(var1));
  167.    }
  168.  
  169.    public synchronized StringBuffer append(char var1) {
  170.       int var2 = this.count + 1;
  171.       if (var2 > this.value.length) {
  172.          this.expandCapacity(var2);
  173.       }
  174.  
  175.       this.value[this.count++] = var1;
  176.       return this;
  177.    }
  178.  
  179.    public StringBuffer append(int var1) {
  180.       return this.append(String.valueOf(var1));
  181.    }
  182.  
  183.    public StringBuffer append(long var1) {
  184.       return this.append(String.valueOf(var1));
  185.    }
  186.  
  187.    public StringBuffer append(float var1) {
  188.       return this.append(String.valueOf(var1));
  189.    }
  190.  
  191.    public StringBuffer append(double var1) {
  192.       return this.append(String.valueOf(var1));
  193.    }
  194.  
  195.    public synchronized StringBuffer insert(int var1, Object var2) {
  196.       return this.insert(var1, String.valueOf(var2));
  197.    }
  198.  
  199.    public synchronized StringBuffer insert(int var1, String var2) {
  200.       if (var1 >= 0 && var1 <= this.count) {
  201.          int var3 = var2.length();
  202.          int var4 = this.count + var3;
  203.          if (var4 > this.value.length) {
  204.             this.expandCapacity(var4);
  205.          } else if (this.shared) {
  206.             this.copy();
  207.          }
  208.  
  209.          System.arraycopy(this.value, var1, this.value, var1 + var3, this.count - var1);
  210.          var2.getChars(0, var3, this.value, var1);
  211.          this.count = var4;
  212.          return this;
  213.       } else {
  214.          throw new StringIndexOutOfBoundsException();
  215.       }
  216.    }
  217.  
  218.    public synchronized StringBuffer insert(int var1, char[] var2) {
  219.       if (var1 >= 0 && var1 <= this.count) {
  220.          int var3 = var2.length;
  221.          int var4 = this.count + var3;
  222.          if (var4 > this.value.length) {
  223.             this.expandCapacity(var4);
  224.          } else if (this.shared) {
  225.             this.copy();
  226.          }
  227.  
  228.          System.arraycopy(this.value, var1, this.value, var1 + var3, this.count - var1);
  229.          System.arraycopy(var2, 0, this.value, var1, var3);
  230.          this.count = var4;
  231.          return this;
  232.       } else {
  233.          throw new StringIndexOutOfBoundsException();
  234.       }
  235.    }
  236.  
  237.    public StringBuffer insert(int var1, boolean var2) {
  238.       return this.insert(var1, String.valueOf(var2));
  239.    }
  240.  
  241.    public synchronized StringBuffer insert(int var1, char var2) {
  242.       int var3 = this.count + 1;
  243.       if (var3 > this.value.length) {
  244.          this.expandCapacity(var3);
  245.       } else if (this.shared) {
  246.          this.copy();
  247.       }
  248.  
  249.       System.arraycopy(this.value, var1, this.value, var1 + 1, this.count - var1);
  250.       this.value[var1] = var2;
  251.       this.count = var3;
  252.       return this;
  253.    }
  254.  
  255.    public StringBuffer insert(int var1, int var2) {
  256.       return this.insert(var1, String.valueOf(var2));
  257.    }
  258.  
  259.    public StringBuffer insert(int var1, long var2) {
  260.       return this.insert(var1, String.valueOf(var2));
  261.    }
  262.  
  263.    public StringBuffer insert(int var1, float var2) {
  264.       return this.insert(var1, String.valueOf(var2));
  265.    }
  266.  
  267.    public StringBuffer insert(int var1, double var2) {
  268.       return this.insert(var1, String.valueOf(var2));
  269.    }
  270.  
  271.    public synchronized StringBuffer reverse() {
  272.       if (this.shared) {
  273.          this.copy();
  274.       }
  275.  
  276.       int var1 = this.count - 1;
  277.  
  278.       for(int var2 = var1 - 1 >> 1; var2 >= 0; --var2) {
  279.          char var3 = this.value[var2];
  280.          this.value[var2] = this.value[var1 - var2];
  281.          this.value[var1 - var2] = var3;
  282.       }
  283.  
  284.       return this;
  285.    }
  286.  
  287.    public String toString() {
  288.       return new String(this);
  289.    }
  290.  
  291.    final void setShared() {
  292.       this.shared = true;
  293.    }
  294.  
  295.    final char[] getValue() {
  296.       return this.value;
  297.    }
  298. }
  299.