jdk-sandbox: comparison jdk/src/java.base/share/classes/java/util/StringJoiner.java

equal deleted inserted replaced

-:d06a6d3c66c0
+:e48157b42439
 /*
-* Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2013, 2014, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
 package java.util;
+import sun.misc.JavaLangAccess;
+import sun.misc.SharedSecrets;
 /**
 * {@code StringJoiner} is used to construct a sequence of characters separated
 * by a delimiter and optionally starting with a supplied prefix
 * and ending with a supplied suffix.
 public final class StringJoiner {
 private final String prefix;
 private final String delimiter;
 private final String suffix;
-/*
+/** Contains all the string components added so far. */
-* StringBuilder value -- at any time, the characters constructed from the
+private String[] elts;
-* prefix, the added element separated by the delimiter, but without the
-* suffix, so that we can more easily add elements without having to jigger
+/** The number of string components added so far. */
-* the suffix each time.
+private int size;
-*/
-private StringBuilder value;
+/** Total length in chars so far, excluding prefix and suffix. */
+private int len;
-/*
-* By default, the string consisting of prefix+suffix, returned by
+/**
-* toString(), or properties of value, when no elements have yet been added,
+* When overriden by the user to be non-null via {@link setEmptyValue}, the
-* i.e. when it is empty.  This may be overridden by the user to be some
+* string returned by toString() when no elements have yet been added.
-* other value including the empty String.
+* When null, prefix + suffix is used as the empty value.
 */
 private String emptyValue;
+private static final JavaLangAccess jla = SharedSecrets.getJavaLangAccess();
 /**
 * Constructs a {@code StringJoiner} with no characters in it, with no
 * {@code prefix} or {@code suffix}, and a copy of the supplied
 * {@code delimiter}.
 Objects.requireNonNull(suffix, "The suffix must not be null");
 // make defensive copies of arguments
 this.prefix = prefix.toString();
 this.delimiter = delimiter.toString();
 this.suffix = suffix.toString();
-this.emptyValue = this.prefix + this.suffix;
 }
 /**
 * Sets the sequence of characters to be used when determining the string
 * representation of this {@code StringJoiner} and no elements have been
 this.emptyValue = Objects.requireNonNull(emptyValue,
 "The empty value must not be null").toString();
 return this;
 }
+private static int getChars(String s, char[] chars, int start) {
+int len = s.length();
+s.getChars(0, len, chars, start);
+return len;
+}
 /**
 * Returns the current value, consisting of the {@code prefix}, the values
 * added so far separated by the {@code delimiter}, and the {@code suffix},
 * unless no elements have been added in which case, the
-* {@code prefix + suffix} or the {@code emptyValue} characters are returned
+* {@code prefix + suffix} or the {@code emptyValue} characters are returned.
 *
 * @return the string representation of this {@code StringJoiner}
 */
 @Override
 public String toString() {
-if (value == null) {
+final String[] elts = this.elts;
+if (elts == null && emptyValue != null) {
 return emptyValue;
-} else {
+}
-if (suffix.equals("")) {
+final int size = this.size;
-return value.toString();
+final int addLen = prefix.length() + suffix.length();
-} else {
+if (addLen == 0) {
-int initialLength = value.length();
+compactElts();
-String result = value.append(suffix).toString();
+return size == 0 ? "" : elts[0];
-// reset value to pre-append initialLength
+}
-value.setLength(initialLength);
+final String delimiter = this.delimiter;
-return result;
+final char[] chars = new char[len + addLen];
+int k = getChars(prefix, chars, 0);
+if (size > 0) {
+k += getChars(elts[0], chars, k);
+for (int i = 1; i < size; i++) {
+k += getChars(delimiter, chars, k);
+k += getChars(elts[i], chars, k);
 }
 }
+k += getChars(suffix, chars, k);
+return jla.newStringUnsafe(chars);
 }
 /**
 * Adds a copy of the given {@code CharSequence} value as the next
 * element of the {@code StringJoiner} value. If {@code newElement} is
 *
 * @param  newElement The element to add
 * @return a reference to this {@code StringJoiner}
 */
 public StringJoiner add(CharSequence newElement) {
-prepareBuilder().append(newElement);
+final String elt = String.valueOf(newElement);
+if (elts == null) {
+elts = new String[8];
+} else {
+if (size == elts.length)
+elts = Arrays.copyOf(elts, 2 * size);
+len += delimiter.length();
+}
+len += elt.length();
+elts[size++] = elt;
 return this;
 }
 /**
 * Adds the contents of the given {@code StringJoiner} without prefix and
 * @throws NullPointerException if the other {@code StringJoiner} is null
 * @return This {@code StringJoiner}
 */
 public StringJoiner merge(StringJoiner other) {
 Objects.requireNonNull(other);
-if (other.value != null) {
+if (other.elts == null) {
-final int length = other.value.length();
+return this;
-// lock the length so that we can seize the data to be appended
+}
-// before initiate copying to avoid interference, especially when
+other.compactElts();
-// merge 'this'
+return add(other.elts[0]);
-StringBuilder builder = prepareBuilder();
+}
-builder.append(other.value, other.prefix.length(), length);
-}
+private void compactElts() {
-return this;
+if (size > 1) {
-}
+final char[] chars = new char[len];
+int i = 1, k = getChars(elts[0], chars, 0);
-private StringBuilder prepareBuilder() {
+do {
-if (value != null) {
+k += getChars(delimiter, chars, k);
-value.append(delimiter);
+k += getChars(elts[i], chars, k);
-} else {
+elts[i] = null;
-value = new StringBuilder().append(prefix);
+} while (++i < size);
-}
+size = 1;
-return value;
+elts[0] = jla.newStringUnsafe(chars);
+}
 }
 /**
 * Returns the length of the {@code String} representation
 * of this {@code StringJoiner}. Note that if
 * {@code toString().length()}.
 *
 * @return the length of the current value of {@code StringJoiner}
 */
 public int length() {
-// Remember that we never actually append the suffix unless we return
+return (size == 0 && emptyValue != null) ? emptyValue.length() :
-// the full (present) value or some sub-string or length of it, so that
+len + prefix.length() + suffix.length();
-// we can add on more if we need to.
-return (value != null ? value.length() + suffix.length() :
-emptyValue.length());
 }
 }

changeset 25991	e48157b42439
parent 25967	0060a996fe1c
parent 25859	3317bb8137f4
child 32834	e1dca5fe4de3