rev 10947 : 8055723: Replace concat String to append in StringBuilder parameters

   1 /*
   2  * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 /*
  27  * (C) Copyright Taligent, Inc. 1996, 1997 - All Rights Reserved
  28  * (C) Copyright IBM Corp. 1996 - 1998 - All Rights Reserved
  29  *
  30  *   The original version of this source code and documentation is copyrighted
  31  * and owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These
  32  * materials are provided under terms of a License Agreement between Taligent
  33  * and Sun. This technology is protected by multiple US and International
  34  * patents. This notice and attribution to Taligent may not be removed.
  35  *   Taligent is a registered trademark of Taligent, Inc.
  36  *
  37  */
  38 
  39 package java.text;
  40 
  41 import java.io.InvalidObjectException;
  42 import java.io.IOException;
  43 import java.io.ObjectInputStream;
  44 import java.util.Arrays;
  45 
  46 /**
  47  * A <code>ChoiceFormat</code> allows you to attach a format to a range of numbers.
  48  * It is generally used in a <code>MessageFormat</code> for handling plurals.
  49  * The choice is specified with an ascending list of doubles, where each item
  50  * specifies a half-open interval up to the next item:
  51  * <blockquote>
  52  * <pre>
  53  * X matches j if and only if limit[j] &le; X &lt; limit[j+1]
  54  * </pre>
  55  * </blockquote>
  56  * If there is no match, then either the first or last index is used, depending
  57  * on whether the number (X) is too low or too high.  If the limit array is not
  58  * in ascending order, the results of formatting will be incorrect.  ChoiceFormat
  59  * also accepts <code>\u221E</code> as equivalent to infinity(INF).
  60  *
  61  * <p>
  62  * <strong>Note:</strong>
  63  * <code>ChoiceFormat</code> differs from the other <code>Format</code>
  64  * classes in that you create a <code>ChoiceFormat</code> object with a
  65  * constructor (not with a <code>getInstance</code> style factory
  66  * method). The factory methods aren't necessary because <code>ChoiceFormat</code>
  67  * doesn't require any complex setup for a given locale. In fact,
  68  * <code>ChoiceFormat</code> doesn't implement any locale specific behavior.
  69  *
  70  * <p>
  71  * When creating a <code>ChoiceFormat</code>, you must specify an array of formats
  72  * and an array of limits. The length of these arrays must be the same.
  73  * For example,
  74  * <ul>
  75  * <li>
  76  *     <em>limits</em> = {1,2,3,4,5,6,7}<br>
  77  *     <em>formats</em> = {"Sun","Mon","Tue","Wed","Thur","Fri","Sat"}
  78  * <li>
  79  *     <em>limits</em> = {0, 1, ChoiceFormat.nextDouble(1)}<br>
  80  *     <em>formats</em> = {"no files", "one file", "many files"}<br>
  81  *     (<code>nextDouble</code> can be used to get the next higher double, to
  82  *     make the half-open interval.)
  83  * </ul>
  84  *
  85  * <p>
  86  * Here is a simple example that shows formatting and parsing:
  87  * <blockquote>
  88  * <pre>{@code
  89  * double[] limits = {1,2,3,4,5,6,7};
  90  * String[] dayOfWeekNames = {"Sun","Mon","Tue","Wed","Thur","Fri","Sat"};
  91  * ChoiceFormat form = new ChoiceFormat(limits, dayOfWeekNames);
  92  * ParsePosition status = new ParsePosition(0);
  93  * for (double i = 0.0; i <= 8.0; ++i) {
  94  *     status.setIndex(0);
  95  *     System.out.println(i + " -> " + form.format(i) + " -> "
  96  *                              + form.parse(form.format(i),status));
  97  * }
  98  * }</pre>
  99  * </blockquote>
 100  * Here is a more complex example, with a pattern format:
 101  * <blockquote>
 102  * <pre>{@code
 103  * double[] filelimits = {0,1,2};
 104  * String[] filepart = {"are no files","is one file","are {2} files"};
 105  * ChoiceFormat fileform = new ChoiceFormat(filelimits, filepart);
 106  * Format[] testFormats = {fileform, null, NumberFormat.getInstance()};
 107  * MessageFormat pattform = new MessageFormat("There {0} on {1}");
 108  * pattform.setFormats(testFormats);
 109  * Object[] testArgs = {null, "ADisk", null};
 110  * for (int i = 0; i < 4; ++i) {
 111  *     testArgs[0] = new Integer(i);
 112  *     testArgs[2] = testArgs[0];
 113  *     System.out.println(pattform.format(testArgs));
 114  * }
 115  * }</pre>
 116  * </blockquote>
 117  * <p>
 118  * Specifying a pattern for ChoiceFormat objects is fairly straightforward.
 119  * For example:
 120  * <blockquote>
 121  * <pre>{@code
 122  * ChoiceFormat fmt = new ChoiceFormat(
 123  *      "-1#is negative| 0#is zero or fraction | 1#is one |1.0<is 1+ |2#is two |2<is more than 2.");
 124  * System.out.println("Formatter Pattern : " + fmt.toPattern());
 125  *
 126  * System.out.println("Format with -INF : " + fmt.format(Double.NEGATIVE_INFINITY));
 127  * System.out.println("Format with -1.0 : " + fmt.format(-1.0));
 128  * System.out.println("Format with 0 : " + fmt.format(0));
 129  * System.out.println("Format with 0.9 : " + fmt.format(0.9));
 130  * System.out.println("Format with 1.0 : " + fmt.format(1));
 131  * System.out.println("Format with 1.5 : " + fmt.format(1.5));
 132  * System.out.println("Format with 2 : " + fmt.format(2));
 133  * System.out.println("Format with 2.1 : " + fmt.format(2.1));
 134  * System.out.println("Format with NaN : " + fmt.format(Double.NaN));
 135  * System.out.println("Format with +INF : " + fmt.format(Double.POSITIVE_INFINITY));
 136  * }</pre>
 137  * </blockquote>
 138  * And the output result would be like the following:
 139  * <blockquote>
 140  * <pre>{@code
 141  * Format with -INF : is negative
 142  * Format with -1.0 : is negative
 143  * Format with 0 : is zero or fraction
 144  * Format with 0.9 : is zero or fraction
 145  * Format with 1.0 : is one
 146  * Format with 1.5 : is 1+
 147  * Format with 2 : is two
 148  * Format with 2.1 : is more than 2.
 149  * Format with NaN : is negative
 150  * Format with +INF : is more than 2.
 151  * }</pre>
 152  * </blockquote>
 153  *
 154  * <h3><a name="synchronization">Synchronization</a></h3>
 155  *
 156  * <p>
 157  * Choice formats are not synchronized.
 158  * It is recommended to create separate format instances for each thread.
 159  * If multiple threads access a format concurrently, it must be synchronized
 160  * externally.
 161  *
 162  *
 163  * @see          DecimalFormat
 164  * @see          MessageFormat
 165  * @author       Mark Davis
 166  */
 167 public class ChoiceFormat extends NumberFormat {
 168 
 169     // Proclaim serial compatibility with 1.1 FCS
 170     private static final long serialVersionUID = 1795184449645032964L;
 171 
 172     /**
 173      * Sets the pattern.
 174      * @param newPattern See the class description.
 175      */
 176     public void applyPattern(String newPattern) {
 177         StringBuffer[] segments = new StringBuffer[2];
 178         for (int i = 0; i < segments.length; ++i) {
 179             segments[i] = new StringBuffer();
 180         }
 181         double[] newChoiceLimits = new double[30];
 182         String[] newChoiceFormats = new String[30];
 183         int count = 0;
 184         int part = 0;
 185         double startValue = 0;
 186         double oldStartValue = Double.NaN;
 187         boolean inQuote = false;
 188         for (int i = 0; i < newPattern.length(); ++i) {
 189             char ch = newPattern.charAt(i);
 190             if (ch=='\'') {
 191                 // Check for "''" indicating a literal quote
 192                 if ((i+1)<newPattern.length() && newPattern.charAt(i+1)==ch) {
 193                     segments[part].append(ch);
 194                     ++i;
 195                 } else {
 196                     inQuote = !inQuote;
 197                 }
 198             } else if (inQuote) {
 199                 segments[part].append(ch);
 200             } else if (ch == '<' || ch == '#' || ch == '\u2264') {
 201                 if (segments[0].length() == 0) {
 202                     throw new IllegalArgumentException();
 203                 }
 204                 try {
 205                     String tempBuffer = segments[0].toString();
 206                     if (tempBuffer.equals("\u221E")) {
 207                         startValue = Double.POSITIVE_INFINITY;
 208                     } else if (tempBuffer.equals("-\u221E")) {
 209                         startValue = Double.NEGATIVE_INFINITY;
 210                     } else {
 211                         startValue = Double.valueOf(segments[0].toString()).doubleValue();
 212                     }
 213                 } catch (Exception e) {
 214                     throw new IllegalArgumentException();
 215                 }
 216                 if (ch == '<' && startValue != Double.POSITIVE_INFINITY &&
 217                         startValue != Double.NEGATIVE_INFINITY) {
 218                     startValue = nextDouble(startValue);
 219                 }
 220                 if (startValue <= oldStartValue) {
 221                     throw new IllegalArgumentException();
 222                 }
 223                 segments[0].setLength(0);
 224                 part = 1;
 225             } else if (ch == '|') {
 226                 if (count == newChoiceLimits.length) {
 227                     newChoiceLimits = doubleArraySize(newChoiceLimits);
 228                     newChoiceFormats = doubleArraySize(newChoiceFormats);
 229                 }
 230                 newChoiceLimits[count] = startValue;
 231                 newChoiceFormats[count] = segments[1].toString();
 232                 ++count;
 233                 oldStartValue = startValue;
 234                 segments[1].setLength(0);
 235                 part = 0;
 236             } else {
 237                 segments[part].append(ch);
 238             }
 239         }
 240         // clean up last one
 241         if (part == 1) {
 242             if (count == newChoiceLimits.length) {
 243                 newChoiceLimits = doubleArraySize(newChoiceLimits);
 244                 newChoiceFormats = doubleArraySize(newChoiceFormats);
 245             }
 246             newChoiceLimits[count] = startValue;
 247             newChoiceFormats[count] = segments[1].toString();
 248             ++count;
 249         }
 250         choiceLimits = new double[count];
 251         System.arraycopy(newChoiceLimits, 0, choiceLimits, 0, count);
 252         choiceFormats = new String[count];
 253         System.arraycopy(newChoiceFormats, 0, choiceFormats, 0, count);
 254     }
 255 
 256     /**
 257      * Gets the pattern.
 258      *
 259      * @return the pattern string
 260      */
 261     public String toPattern() {
 262         StringBuilder result = new StringBuilder();
 263         for (int i = 0; i < choiceLimits.length; ++i) {
 264             if (i != 0) {
 265                 result.append('|');
 266             }
 267             // choose based upon which has less precision
 268             // approximate that by choosing the closest one to an integer.
 269             // could do better, but it's not worth it.
 270             double less = previousDouble(choiceLimits[i]);
 271             double tryLessOrEqual = Math.abs(Math.IEEEremainder(choiceLimits[i], 1.0d));
 272             double tryLess = Math.abs(Math.IEEEremainder(less, 1.0d));
 273 
 274             if (tryLessOrEqual < tryLess) {
 275                 result.append(choiceLimits[i]);
 276                 result.append('#');
 277             } else {
 278                 if (choiceLimits[i] == Double.POSITIVE_INFINITY) {
 279                     result.append("\u221E");
 280                 } else if (choiceLimits[i] == Double.NEGATIVE_INFINITY) {
 281                     result.append("-\u221E");
 282                 } else {
 283                     result.append(less);
 284                 }
 285                 result.append('<');
 286             }
 287             // Append choiceFormats[i], using quotes if there are special characters.
 288             // Single quotes themselves must be escaped in either case.
 289             String text = choiceFormats[i];
 290             boolean needQuote = text.indexOf('<') >= 0
 291                 || text.indexOf('#') >= 0
 292                 || text.indexOf('\u2264') >= 0
 293                 || text.indexOf('|') >= 0;
 294             if (needQuote) result.append('\'');
 295             if (text.indexOf('\'') < 0) result.append(text);
 296             else {
 297                 for (int j=0; j<text.length(); ++j) {
 298                     char c = text.charAt(j);
 299                     result.append(c);
 300                     if (c == '\'') result.append(c);
 301                 }
 302             }
 303             if (needQuote) result.append('\'');
 304         }
 305         return result.toString();
 306     }
 307 
 308     /**
 309      * Constructs with limits and corresponding formats based on the pattern.
 310      *
 311      * @param newPattern the new pattern string
 312      * @see #applyPattern
 313      */
 314     public ChoiceFormat(String newPattern)  {
 315         applyPattern(newPattern);
 316     }
 317 
 318     /**
 319      * Constructs with the limits and the corresponding formats.
 320      *
 321      * @param limits limits in ascending order
 322      * @param formats corresponding format strings
 323      * @see #setChoices
 324      */
 325     public ChoiceFormat(double[] limits, String[] formats) {
 326         setChoices(limits, formats);
 327     }
 328 
 329     /**
 330      * Set the choices to be used in formatting.
 331      * @param limits contains the top value that you want
 332      * parsed with that format, and should be in ascending sorted order. When
 333      * formatting X, the choice will be the i, where
 334      * limit[i] &le; X {@literal <} limit[i+1].
 335      * If the limit array is not in ascending order, the results of formatting
 336      * will be incorrect.
 337      * @param formats are the formats you want to use for each limit.
 338      * They can be either Format objects or Strings.
 339      * When formatting with object Y,
 340      * if the object is a NumberFormat, then ((NumberFormat) Y).format(X)
 341      * is called. Otherwise Y.toString() is called.
 342      */
 343     public void setChoices(double[] limits, String formats[]) {
 344         if (limits.length != formats.length) {
 345             throw new IllegalArgumentException(
 346                 "Array and limit arrays must be of the same length.");
 347         }
 348         choiceLimits = Arrays.copyOf(limits, limits.length);
 349         choiceFormats = Arrays.copyOf(formats, formats.length);
 350     }
 351 
 352     /**
 353      * Get the limits passed in the constructor.
 354      * @return the limits.
 355      */
 356     public double[] getLimits() {
 357         double[] newLimits = Arrays.copyOf(choiceLimits, choiceLimits.length);
 358         return newLimits;
 359     }
 360 
 361     /**
 362      * Get the formats passed in the constructor.
 363      * @return the formats.
 364      */
 365     public Object[] getFormats() {
 366         Object[] newFormats = Arrays.copyOf(choiceFormats, choiceFormats.length);
 367         return newFormats;
 368     }
 369 
 370     // Overrides
 371 
 372     /**
 373      * Specialization of format. This method really calls
 374      * <code>format(double, StringBuffer, FieldPosition)</code>
 375      * thus the range of longs that are supported is only equal to
 376      * the range that can be stored by double. This will never be
 377      * a practical limitation.
 378      */
 379     public StringBuffer format(long number, StringBuffer toAppendTo,
 380                                FieldPosition status) {
 381         return format((double)number, toAppendTo, status);
 382     }
 383 
 384     /**
 385      * Returns pattern with formatted double.
 386      * @param number number to be formatted and substituted.
 387      * @param toAppendTo where text is appended.
 388      * @param status ignore no useful status is returned.
 389      */
 390    public StringBuffer format(double number, StringBuffer toAppendTo,
 391                                FieldPosition status) {
 392         // find the number
 393         int i;
 394         for (i = 0; i < choiceLimits.length; ++i) {
 395             if (!(number >= choiceLimits[i])) {
 396                 // same as number < choiceLimits, except catchs NaN
 397                 break;
 398             }
 399         }
 400         --i;
 401         if (i < 0) i = 0;
 402         // return either a formatted number, or a string
 403         return toAppendTo.append(choiceFormats[i]);
 404     }
 405 
 406     /**
 407      * Parses a Number from the input text.
 408      * @param text the source text.
 409      * @param status an input-output parameter.  On input, the
 410      * status.index field indicates the first character of the
 411      * source text that should be parsed.  On exit, if no error
 412      * occurred, status.index is set to the first unparsed character
 413      * in the source text.  On exit, if an error did occur,
 414      * status.index is unchanged and status.errorIndex is set to the
 415      * first index of the character that caused the parse to fail.
 416      * @return A Number representing the value of the number parsed.
 417      */
 418     public Number parse(String text, ParsePosition status) {
 419         // find the best number (defined as the one with the longest parse)
 420         int start = status.index;
 421         int furthest = start;
 422         double bestNumber = Double.NaN;
 423         double tempNumber = 0.0;
 424         for (int i = 0; i < choiceFormats.length; ++i) {
 425             String tempString = choiceFormats[i];
 426             if (text.regionMatches(start, tempString, 0, tempString.length())) {
 427                 status.index = start + tempString.length();
 428                 tempNumber = choiceLimits[i];
 429                 if (status.index > furthest) {
 430                     furthest = status.index;
 431                     bestNumber = tempNumber;
 432                     if (furthest == text.length()) break;
 433                 }
 434             }
 435         }
 436         status.index = furthest;
 437         if (status.index == start) {
 438             status.errorIndex = furthest;
 439         }
 440         return new Double(bestNumber);
 441     }
 442 
 443     /**
 444      * Finds the least double greater than {@code d}.
 445      * If {@code NaN}, returns same value.
 446      * <p>Used to make half-open intervals.
 447      *
 448      * @param d the reference value
 449      * @return the least double value greather than {@code d}
 450      * @see #previousDouble
 451      */
 452     public static final double nextDouble (double d) {
 453         return nextDouble(d,true);
 454     }
 455 
 456     /**
 457      * Finds the greatest double less than {@code d}.
 458      * If {@code NaN}, returns same value.
 459      *
 460      * @param d the reference value
 461      * @return the greatest double value less than {@code d}
 462      * @see #nextDouble
 463      */
 464     public static final double previousDouble (double d) {
 465         return nextDouble(d,false);
 466     }
 467 
 468     /**
 469      * Overrides Cloneable
 470      */
 471     public Object clone()
 472     {
 473         ChoiceFormat other = (ChoiceFormat) super.clone();
 474         // for primitives or immutables, shallow clone is enough
 475         other.choiceLimits = choiceLimits.clone();
 476         other.choiceFormats = choiceFormats.clone();
 477         return other;
 478     }
 479 
 480     /**
 481      * Generates a hash code for the message format object.
 482      */
 483     public int hashCode() {
 484         int result = choiceLimits.length;
 485         if (choiceFormats.length > 0) {
 486             // enough for reasonable distribution
 487             result ^= choiceFormats[choiceFormats.length-1].hashCode();
 488         }
 489         return result;
 490     }
 491 
 492     /**
 493      * Equality comparision between two
 494      */
 495     public boolean equals(Object obj) {
 496         if (obj == null) return false;
 497         if (this == obj)                      // quick check
 498             return true;
 499         if (getClass() != obj.getClass())
 500             return false;
 501         ChoiceFormat other = (ChoiceFormat) obj;
 502         return (Arrays.equals(choiceLimits, other.choiceLimits)
 503              && Arrays.equals(choiceFormats, other.choiceFormats));
 504     }
 505 
 506     /**
 507      * After reading an object from the input stream, do a simple verification
 508      * to maintain class invariants.
 509      * @throws InvalidObjectException if the objects read from the stream is invalid.
 510      */
 511     private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
 512         in.defaultReadObject();
 513         if (choiceLimits.length != choiceFormats.length) {
 514             throw new InvalidObjectException(
 515                     "limits and format arrays of different length.");
 516         }
 517     }
 518 
 519     // ===============privates===========================
 520 
 521     /**
 522      * A list of lower bounds for the choices.  The formatter will return
 523      * <code>choiceFormats[i]</code> if the number being formatted is greater than or equal to
 524      * <code>choiceLimits[i]</code> and less than <code>choiceLimits[i+1]</code>.
 525      * @serial
 526      */
 527     private double[] choiceLimits;
 528 
 529     /**
 530      * A list of choice strings.  The formatter will return
 531      * <code>choiceFormats[i]</code> if the number being formatted is greater than or equal to
 532      * <code>choiceLimits[i]</code> and less than <code>choiceLimits[i+1]</code>.
 533      * @serial
 534      */
 535     private String[] choiceFormats;
 536 
 537     /*
 538     static final long SIGN          = 0x8000000000000000L;
 539     static final long EXPONENT      = 0x7FF0000000000000L;
 540     static final long SIGNIFICAND   = 0x000FFFFFFFFFFFFFL;
 541 
 542     private static double nextDouble (double d, boolean positive) {
 543         if (Double.isNaN(d) || Double.isInfinite(d)) {
 544                 return d;
 545             }
 546         long bits = Double.doubleToLongBits(d);
 547         long significand = bits & SIGNIFICAND;
 548         if (bits < 0) {
 549             significand |= (SIGN | EXPONENT);
 550         }
 551         long exponent = bits & EXPONENT;
 552         if (positive) {
 553             significand += 1;
 554             // FIXME fix overflow & underflow
 555         } else {
 556             significand -= 1;
 557             // FIXME fix overflow & underflow
 558         }
 559         bits = exponent | (significand & ~EXPONENT);
 560         return Double.longBitsToDouble(bits);
 561     }
 562     */
 563 
 564     static final long SIGN                = 0x8000000000000000L;
 565     static final long EXPONENT            = 0x7FF0000000000000L;
 566     static final long POSITIVEINFINITY    = 0x7FF0000000000000L;
 567 
 568     /**
 569      * Finds the least double greater than {@code d} (if {@code positive} is
 570      * {@code true}), or the greatest double less than {@code d} (if
 571      * {@code positive} is {@code false}).
 572      * If {@code NaN}, returns same value.
 573      *
 574      * Does not affect floating-point flags,
 575      * provided these member functions do not:
 576      *          Double.longBitsToDouble(long)
 577      *          Double.doubleToLongBits(double)
 578      *          Double.isNaN(double)
 579      *
 580      * @param d        the reference value
 581      * @param positive {@code true} if the least double is desired;
 582      *                 {@code false} otherwise
 583      * @return the least or greater double value
 584      */
 585     public static double nextDouble (double d, boolean positive) {
 586 
 587         /* filter out NaN's */
 588         if (Double.isNaN(d)) {
 589             return d;
 590         }
 591 
 592         /* zero's are also a special case */
 593         if (d == 0.0) {
 594             double smallestPositiveDouble = Double.longBitsToDouble(1L);
 595             if (positive) {
 596                 return smallestPositiveDouble;
 597             } else {
 598                 return -smallestPositiveDouble;
 599             }
 600         }
 601 
 602         /* if entering here, d is a nonzero value */
 603 
 604         /* hold all bits in a long for later use */
 605         long bits = Double.doubleToLongBits(d);
 606 
 607         /* strip off the sign bit */
 608         long magnitude = bits & ~SIGN;
 609 
 610         /* if next double away from zero, increase magnitude */
 611         if ((bits > 0) == positive) {
 612             if (magnitude != POSITIVEINFINITY) {
 613                 magnitude += 1;
 614             }
 615         }
 616         /* else decrease magnitude */
 617         else {
 618             magnitude -= 1;
 619         }
 620 
 621         /* restore sign bit and return */
 622         long signbit = bits & SIGN;
 623         return Double.longBitsToDouble (magnitude | signbit);
 624     }
 625 
 626     private static double[] doubleArraySize(double[] array) {
 627         int oldSize = array.length;
 628         double[] newArray = new double[oldSize * 2];
 629         System.arraycopy(array, 0, newArray, 0, oldSize);
 630         return newArray;
 631     }
 632 
 633     private String[] doubleArraySize(String[] array) {
 634         int oldSize = array.length;
 635         String[] newArray = new String[oldSize * 2];
 636         System.arraycopy(array, 0, newArray, 0, oldSize);
 637         return newArray;
 638     }
 639 
 640 }
--- EOF ---