Java Collection Concatenate concat(Collection items)

Description

Concatenate a collection of strings

License

Open Source License

Parameter

Parameter	Description
items	The collection of strings to concatenate

Declaration

public static String concat(Collection<String> items) 

Method Source Code

//package com.java2s;
/**//from   w w  w .j a  v  a  2 s.c  om
 * Aptana Studio
 * Copyright (c) 2005-2012 by Appcelerator, Inc. All Rights Reserved.
 * Licensed under the terms of the GNU Public License (GPL) v3 (with exceptions).
 * Please see the license.html included with this distribution for details.
 * Any modifications to this file must keep this entire header intact.
 */

import java.util.Collection;

public class Main {
    /**
     * EMPTY
     */
    public static final String EMPTY = "";

    /**
     * Concatenate a collection of strings
     * 
     * @param items
     *            The collection of strings to concatenate
     * @return
     */
    public static String concat(Collection<String> items) {
        return (items != null) ? join(null, items.toArray(new String[items.size()])) : null;
    }

    /**
     * Concatenate a list of strings.
     * 
     * @param items
     *            The list of strings to concatenate
     * @return
     */
    public static String concat(String... items) {
        return join(null, items);
    }

    /**
     * Create a string by concatenating the elements of a collection using a delimiter between each item
     * 
     * @param delimiter
     *            The text to place between each element in the array
     * @param items
     *            The collection of items to join
     * @return The resulting string
     */
    public static String join(String delimiter, Collection<String> items) {
        return (items != null) ? join(delimiter, items.toArray(new String[items.size()])) : null;
    }

    /**
     * Create a string by concatenating the elements of a collection using a delimiter between each item
     * 
     * @param delimiter
     *            The text to place between each element in the array
     * @param items
     *            The array of items
     * @return The resulting string
     */
    public static String join(String delimiter, Object... items) {
        String[] s = new String[items.length];
        for (int i = 0; i < items.length; i++) {
            Object item = items[i];
            if (item == null) {
                s[i] = "null"; //$NON-NLS-1$

            } else {
                s[i] = item.toString();
            }
        }
        return join(delimiter, s);
    }

    /**
     * Create a string by concatenating the elements of a collection using a delimiter between each item
     * 
     * @param delimiter
     *            The text to place between each element in the array
     * @param items
     *            The array of chars
     * @return The resulting string
     */
    public static String join(String delimiter, char... items) {
        String[] strings = new String[items.length];
        for (int i = 0; i < items.length; i++) {
            strings[i] = new String(items, i, 1);
        }
        return join(delimiter, strings);
    }

    /**
     * Create a string by concatenating the elements of a string array using a delimiter between each item
     * 
     * @param delimiter
     *            The text to place between each element in the array
     * @param items
     *            The array of items to join
     * @return The resulting string
     */
    public static String join(String delimiter, String... items) {
        String result = null;

        if (items != null) {
            switch (items.length) {
            case 0: {
                result = EMPTY;
                break;
            }

            case 1: {
                result = items[0];
                break;
            }

            // NOTE: consider adding additional cases here, probably for at least 2, by unrolling the loop from the
            // default section below

            default: {
                int lastIndex = items.length - 1;

                // determine length of the delimiter
                int delimiterLength = (delimiter != null) ? delimiter.length() : 0;

                // determine the length of the resulting string, starting with the length of all delimiters
                int targetLength = (lastIndex) * delimiterLength;

                // now add in the length of each item in our list of items
                for (int i = 0; i <= lastIndex; i++) {
                    targetLength += items[i].length();
                }

                // build the resulting character array
                int offset = 0;
                char[] accumulator = new char[targetLength];

                // NOTE: We test for delimiter length here to avoid having a conditional within the for-loops in the
                // true/false blocks. Moving the conditional inside the for-loop barely improved the performance of
                // this implementation from the StringBuilder version we had before
                if (delimiterLength != 0) {
                    // copy all items (except last) and all delimiters
                    for (int i = 0; i < lastIndex; i++) {
                        String item = items[i];

                        // cache current item's length
                        int length = item.length();

                        // copy the item into the accumulator
                        item.getChars(0, length, accumulator, offset);
                        offset += length;

                        // copy in the delimiter
                        delimiter.getChars(0, delimiterLength, accumulator, offset);
                        offset += delimiterLength;
                    }

                    String item = items[lastIndex];
                    item.getChars(0, item.length(), accumulator, offset);
                } else {
                    // NOTE: use classic iteration to avoid the overhead of an iterator
                    for (int i = 0; i <= lastIndex; i++) {
                        String item = items[i];

                        // cache current item's length
                        int length = item.length();

                        // copy the item into the accumulator
                        item.getChars(0, length, accumulator, offset);
                        offset += length;
                    }
                }

                // convert the result to a String and return that value
                result = new String(accumulator);
            }
            }
        }

        return result;
    }
}

Related

1. concat(boolean removeDuplicates, Collection firstCollection, Collection... collections)
2. concat(Collection> classes, String separator)
3. concat(Collection collection, String delimiter)
4. concat(Collection c)
5. concat(Collection parts, int start, String defaultText)
6. concat(Collection pieces, String delim)
7. concat(Collection a, Collection b)
8. concat(Collection a, int offset, String sep, String start, String end)