Как разбить массив строк?

Question

Намерение состоит в том, чтобы взять текущую строку (строку, содержащую запятые), заменить пробел на "" (пробел) и, наконец, сохранить разделенные элементы String в массиве.

Почему это не работает?

String[] textLine = currentInputLine.replace("\\s", "").split(",");

Answer 1

В регулярном выражении против методов без регулярных выражений

Класс String имеет следующие методы:

• Методы без регулярных выражений:
  • String replace(char oldChar, char newChar)
  • String replace(CharSequence target, CharSequence replacement)
  • boolean startsWith(String prefix)
  • boolean endsWith(String suffix)
  • boolean contains(CharSequence s)
• Методы регулярных выражений:
  • String replaceAll(String regex, String replacement)
  • String replaceFirst(String regex, String replacement)
  • String[] split(String regex)
  • boolean matches(String regex)

Итак, здесь мы видим непосредственную причину вашей проблемы: вы используете шаблон регулярных выражений в методе без регулярных выражений.Вместо replace вы хотите использовать replaceAll.

Другие распространенные ошибки:

• split(".") (когда подразумевается буквальный период)
• matches("pattern") - это целое -строк матча!
  • Нет contains("pattern");используйте matches(".*pattern.*") вместо

---

На Guava Splitter

В зависимости от ваших потребностей, комбинации String.replaceAll и split могут сделатьработа адекватно.Однако для этой цели более специализированным инструментом является Splitter от Guava.

Вот пример, демонстрирующий разницу:

public static void main(String[] args) {
    String text = "  one, two, , five (three sir!) ";

    dump(text.replaceAll("\\s", "").split(","));
    // prints "[one] [two] [] [five(threesir!)] "

    dump(Splitter.on(",").trimResults().omitEmptyStrings().split(text));
    // prints "[one] [two] [five (three sir!)] "
}

static void dump(String... ss) {
    dump(Arrays.asList(ss));
}
static void dump(Iterable<String> ss) {
    for (String s : ss) {
        System.out.printf("[%s] ", s);
    }
    System.out.println();       
}

Обратите внимание, что String.split не может пропускать пустые строки в начале / середине возвращаемого массива.Он может пропускать только завершающие только пустые строки.Также обратите внимание, что replaceAll может чрезмерно "обрезать" пробелы.Вы можете сделать регулярное выражение более сложным, чтобы оно ограничивало только разделитель, но решение Splitter определенно более читабельно и проще в использовании.

Гуава также имеет (среди многихдругие замечательные вещи) очень удобно Joiner.

System.out.println(
    Joiner.on("... ").skipNulls().join("Oh", "My", null, "God")
);
// prints "Oh... My... God"

Answer 2

Я думаю, вы хотите заменить все, а не заменить.

И replaceAll("\\s","") удалит все пробелы, а не только лишние. Если это не то, что вы хотите, вы должны попробовать replaceAll("\\s+","\\s") или что-то в этом роде.

Answer 3

То, что вы написали, не соответствует коду:

Намерение - взять текущую строку, содержащую запятые, сохранить усеченные значения всего пространства и сохранить строку в массиве.

Он показывает, что с помощью кода вы хотите удалить все пробелы и разбить полученную строку на запятые (не описано). Это можно сделать, как предположил Пол Томблин.

String[] currentLineArray = currentInputLine.replaceAll("\\s", "").split(",");

Если вы хотите разделить запятые и удалить начальные и конечные пробелы (обрезку) из полученных частей, используйте:

String[] currentLineArray = currentInputLine.trim().split("\\s*,\\s*");

(trim() необходим для удаления начальных пробелов первой части и конечных пробелов из последней части )

Answer 4

Если вам нужно выполнить эту операцию несколько раз, я бы предложил вместо этого использовать java.util.regex.Pattern и java.util.regex.Matcher.

final Pattern pattern = Pattern.compile( regex);
for(String inp: inps) {
    final Matcher matcher = pattern.matcher( inpString);
    return matcher.replaceAll( replacementString); 
}

Компиляция регулярного выражения является дорогостоящей операцией, и повторное использование String replaceAll не рекомендуется, поскольку каждый вызов включает в себя компиляцию регулярного выражения с последующей заменой.