StringUtils.java

Go to the documentation of this file.

/* *********************************************************************** *
 * project: org.matsim.*
 * StringUtils.java
 *                                                                         *
 * *********************************************************************** *
 *                                                                         *
 * copyright       : (C) 2007 by the members listed in the COPYING,        *
 *                   LICENSE and WARRANTY file.                            *
 * email           : info at matsim dot org                                *
 *                                                                         *
 * *********************************************************************** *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *   See also COPYING, LICENSE and WARRANTY file                           *
 *                                                                         *
 * *********************************************************************** */

package org.matsim.core.utils.misc;

public class StringUtils {

    public static String[] explode(final String str, final char delimiter, final int limit) {
        int count = 0;
        int len = str.length();
        int maxPos = 0; // the position of the last non-delimiter char in the string
        int countAtMaxPos = 0;
        int upperLimit = limit-1;
        // count how often the delimiter occurs in the string
        for (int pos = 0; pos < len; pos++) {
            if ((str.charAt(pos) == delimiter) && (limit == 0 || count < upperLimit)) {
                count++;
            } else {
                maxPos = pos;
                countAtMaxPos = count;
            }
        }

        if (count == 0) {
            String[] parts = new String[1];
            parts[0] = str;
            return parts;
        }

        // create a big enough array to hold the result
        String[] parts = new String[countAtMaxPos + 1];
        int startPos = 0;
        count = 0;
        // loop once through the string and always take the substrings between the delimiters
        for (int pos = 0; pos < maxPos; pos++) {
            if ((str.charAt(pos) == delimiter) && (limit == 0 || count < upperLimit)) {
                parts[count] = str.substring(startPos, pos);
                startPos = pos + 1;
                count++;
            }
        }
        /* Add the final part ended by the string, not by a delimiter, to our list.
         * There is always a final part because of the way maxPos and countAtMaxPos
         * are derived: maxPos points to a non-delimiter. This means there is always
         * at least one character between the last delimiter and maxPos, and that's
         * the part we are still missing... so add it! */
        parts[count] = str.substring(startPos, maxPos+1);

        return parts;
    }

    public static String[] explode(final String str, final char delimiter) {
        return explode(str, delimiter, 0);
    }
}