Как разбить строку в Java

avatar
riyana
14 августа 2010 в 03:01
4279732
37
1797

У меня есть строка "004-034556", которую я хочу разделить на две строки:

string1="004";
string2="034556";

Это означает, что первая строка будет содержать символы до '-', а вторая строка будет содержать символы после '-'. Я также хочу проверить, есть ли в строке '-'. Если нет, я выброшу исключение. Как я могу это сделать?

Источник

Ответы (37)

avatar
BalusC
14 августа 2010 в 03:05
3205

Просто используйте соответствующий метод: String#split().

String string = "004-034556";
String[] parts = string.split("-");
String part1 = parts[0]; // 004
String part2 = parts[1]; // 034556

Обратите внимание, что для этого требуется регулярное выражение , поэтому не забудьте при необходимости экранировать специальные символы.

там - 12 символов со специальными значениями: обратная косая черта \, каретка ^, знак доллара $, точка или точка <84631830407> символ вертикальной черты или вертикальной черты. |, вопросительный знак ?, звездочка или звездочка *, знак плюс +, открывающая скобка (, закрывающая скобка ) и открывающая квадратная скобка 40748318 открывающая фигурная скобка {. Эти специальные символы часто называют «метасимволами».

Итак, если вы хотите разделить, например, точка / точка ., что означает «любой символ» в регулярном выражении, используйте либо обратную косую черту \, чтобы экранировать отдельный специальный символ, например, <84631830, либо 40830 символьный класс [] для представления буквальных символов, например, split("[.]"), или используйте Pattern#quote(), чтобы экранировать всю строку, например, <split(Pattern.quote("."))1830> .7463>

String[] parts = string.split(Pattern.quote(".")); // Split on period.

Чтобы заранее проверить, содержит ли строка определенный символ (символы), просто используйте String#contains().

if (string.contains("-")) {
    // Split it.
} else {
    throw new IllegalArgumentException("String " + string + " does not contain -");
}

Обратите внимание, это не требует регулярного выражения. Для этого используйте вместо него String#matches().

Если вы хотите сохранить разделенный символ в результирующих частях, используйте положительный поиск. Если вы хотите, чтобы разделенный символ попадал в левую часть, используйте положительный просмотр назад, добавив к группе префикса ?<= группу в шаблоне.

String string = "004-034556";
String[] parts = string.split("(?<=-)");
String part1 = parts[0]; // 004-
String part2 = parts[1]; // 034556

Если вы хотите, чтобы разделенный символ попадал в правую часть, используйте положительный просмотр вперед, добавив префикс ?= к группе в шаблоне.

String string = "004-034556";
String[] parts = string.split("(?=-)");
String part1 = parts[0]; // 004
String part2 = parts[1]; // -034556

Если вы хотите ограничить количество получаемых частей, вы можете указать желаемое число в качестве второго аргумента метода split().

String string = "004-034556-42";
String[] parts = string.split("-", 2);
String part1 = parts[0]; // 004
String part2 = parts[1]; // 034556-42

Crowie
1 августа 2013 в 08:56
29

Почему вы используете хэш-символы для разграничения строковых методов?

BalusC
1 августа 2013 в 12:04
97

@Crowie: в стиле javadoc.

klimat
23 мая 2016 в 12:36
9

Угловой случай: если он не может найти reugalr expression, он возвращает один массив элементов со всей строкой.

KYHSGeekCode
30 октября 2018 в 15:21
1

Вы сэкономили мне время, я забыл процитировать точку (.)!

David
17 января 2019 в 23:38
2

Не могу поверить, что эта версия получила наибольшее количество голосов. 1) часть 2 - это не то, что хочет плакат, если исходная строка содержит два "-" 2) Нет обработки ошибок, как указано в вопросе. 3) Низкая эффективность. Односимвольный поиск требует построения и сопоставления регулярных выражений. Создан дополнительный массив и т. Д.

BalusC
18 января 2019 в 09:11
6

@David: 1) Это не рассматривается в вопросе. 2) Не вызывает исключений. 3) OP спрашивает, как разбить, а не как подстроку. 4) Сделайте перерыв, глубоко вдохните и выбросьте весь негатив в голову :)

avatar
Joseph Kohilan
26 ноября 2021 в 12:00
0

Если вы проверяете буквенно-цифровые значения, измените регулярное выражение на [A-Za-z0-9]+-[A-Za-z0-9]+

    public static final Pattern VALIDATE_PATTERN = Pattern.compile("[0-9]+-[0-9]+");

public static String[] validateString(String str) {
    if(VALIDATE_PATTERN.matcher(str).find()) {
        String[] output = str.split("-");
        if(output.length != 2) {
            throw new RuntimeException("Invalid string format");
        }
        return output;
    } else {
        throw new RuntimeException("Invalid string format");
    }
}
avatar
java code point
26 ноября 2021 в 11:19
-1
String s = "TnGeneral|DOMESTIC";
String a[]=s.split("\\|");
System.out.println(a.toString());
System.out.println(a[0]);
System.out.println(a[1]);

Вывод:

TnGeneral
DOMESTIC
avatar
Grim
25 апреля 2020 в 23:16
-1

Я просмотрел все ответы и заметил, что все они либо имеют стороннюю лицензию, либо основаны на регулярных выражениях.

Вот хорошая тупая реализация, которую я использую:

/**
 * Separates a string into pieces using
 * case-sensitive-non-regex-char-separators.
 * <p>
 * &nbsp;&nbsp;<code>separate("12-34", '-') = "12", "34"</code><br>
 * &nbsp;&nbsp;<code>separate("a-b-", '-') = "a", "b", ""</code>
 * <p>
 * When the separator is the first character in the string, the first result is
 * an empty string. When the separator is the last character in the string the
 * last element will be an empty string. One separator after another in the
 * string will create an empty.
 * <p>
 * If no separators are set the source is returned.
 * <p>
 * This method is very fast, but it does not focus on memory-efficiency. The memory
 * consumption is approximately double the size of the string. This method is
 * thread-safe but not synchronized.
 *
 * @param source    The string to split, never <code>null</code>.
 * @param separator The character to use as splitting.
 * @return The mutable array of pieces.
 * @throws NullPointerException When the source or separators are <code>null</code>.
 */
public final static String[] separate(String source, char... separator) throws NullPointerException {
    String[] resultArray = {};
    boolean multiSeparators = separator.length > 1;
    if (!multiSeparators) {
        if (separator.length == 0) {
            return new String[] { source };
        }
    }
    int charIndex = source.length();
    int lastSeparator = source.length();
    while (charIndex-- > -1) {
        if (charIndex < 0 || (multiSeparators ? Arrays.binarySearch(separator, source.charAt(charIndex)) >= 0 : source.charAt(charIndex) == separator[0])) {
            String piece = source.substring(charIndex + 1, lastSeparator);
            lastSeparator = charIndex;
            String[] tmp = new String[resultArray.length + 1];
            System.arraycopy(resultArray, 0, tmp, 1, resultArray.length);
            tmp[0] = piece;
            resultArray = tmp;
        }
    }
    return resultArray;
}
Grim
17 января 2021 в 10:03
0

Почему голосование против? Пожалуйста, объясни.

avatar
Pramesh Bhalala
26 августа 2019 в 13:58
0

Я использовал строку с названием stringValue и имеет форму примерно такой: «Те, у кого были монеты, наслаждались дождем, те, у кого были записи, были заняты поисками убежища».

Я разделю stringValue, используя "," в качестве двоеточия.

И затем я просто хотел бы SetText () трех разных TextView для отображения этой строки.

String stringValue = "Those who had coins, enjoyed in the rain, those who had notes were busy looking for the shelter";
String ValueSplitByColon[] = stringValue.split(",");

String firstValue = ValueSplitByColon[0];
String secondValue = ValueSplitByColon[1];
String thirdValue = ValueSplitByColon[2];

txtV1.setText(firstValue);
txtV2.setText(secondValue;
txtV3.setText(thirdValue;

Он дает вывод как:

  1. Значение txtV1: Те, у кого были монеты

  2. Значение txtV2: наслаждаемся под дождем

  3. Значение txtV3: те, у кого были записи, были заняты поиском убежища

avatar
Jamith NImantha
7 декабря 2018 в 08:48
1

Вы можете использовать метод split:

public class Demo {
    public static void main(String args[]) {
        String str = "004-034556";

        if ((str.contains("-"))) {
            String[] temp = str.split("-");
            for (String part:temp) {
                System.out.println(part);
            }
        }
        else {
            System.out.println(str + " does not contain \"-\".");
        }
    }
}
avatar
rghome
20 ноября 2018 в 12:08
10

Есть только два метода, которые вам действительно нужно рассмотреть.

Используйте String.split для односимвольного разделителя, или вам наплевать на производительность

Если производительность не является проблемой или если разделитель представляет собой один символ, не являющийся специальным символом регулярного выражения (т.е. не один из .$|()[{^?*+\), вы можете использовать String.split.

String[] results = input.split(",");

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

Используйте Pattern.split и предварительно скомпилируйте шаблон, если вы используете сложный разделитель и заботитесь о производительности.

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

// Save this somewhere
Pattern pattern = Pattern.compile("[,;:]");

/// ... later
String[] results = pattern.split(input);

Эта последняя опция по-прежнему создает новый объект Matcher. Вы также можете кэшировать этот объект и сбрасывать его для каждого входа для максимальной производительности, но это несколько сложнее и небезопасно для потоков.

avatar
KIBOU Hassan
8 марта 2018 в 14:28
1

Для разделения строки используется String.split (регулярное выражение). Просмотрите следующие примеры:

String data = "004-034556";
String[] output = data.split("-");
System.out.println(output[0]);
System.out.println(output[1]);

Вывод

004
034556

Примечание:

Это разбиение (регулярное выражение) принимает регулярное выражение в качестве аргумента. Не забудьте экранировать специальные символы регулярного выражения, такие как точка / точка.

avatar
None
10 января 2018 в 06:28
3

Я просто хотел написать алгоритм вместо использования встроенных функций Java:

public static List<String> split(String str, char c){
    List<String> list = new ArrayList<>();
    StringBuilder sb = new StringBuilder();

    for (int i = 0; i < str.length(); i++){
        if(str.charAt(i) != c){
            sb.append(str.charAt(i));
        }
        else{
            if(sb.length() > 0){
                list.add(sb.toString());
                sb = new StringBuilder();
            }
        }
    }

    if(sb.length() >0){
        list.add(sb.toString());
    }
    return list;
}
avatar
Dmytro Shvechikov
13 декабря 2017 в 14:20
16

Подводя итог: существует как минимум пять способов разбить строку в Java:

  1. String.split ():

    String[] parts ="10,20".split(",");
    
  2. Pattern.compile (регулярное выражение) .splitAsStream (входной):

    List<String> strings = Pattern.compile("\\|")
          .splitAsStream("010|020202")
          .collect(Collectors.toList());
    
  3. StringTokenizer (унаследованный класс):

    StringTokenizer strings = new StringTokenizer("Welcome to EXPLAINJAVA.COM!", ".");
    while(strings.hasMoreTokens()){
        String substring = strings.nextToken();
        System.out.println(substring);
    }
    
  4. Google Guava Splitter:

    Iterable<String> result = Splitter.on(",").split("1,2,3,4");
    
  5. Apache Commons StringUtils:

    String[] strings = StringUtils.split("1,2,3,4", ",");
    

Таким образом, вы можете выбрать лучший вариант в зависимости от того, что вам нужно, например тип возвращаемого значения (массив, список или итерируемый).

Здесь представлен большой обзор этих методов и наиболее распространенных примеров (как разбить точку, косую черту, вопросительный знак и т. Д.)

avatar
Aditya Singh
22 сентября 2017 в 17:27
0
 String string = "004^034556-34";
 String[] parts = string.split(Pattern.quote("^"));

Если у вас есть специальный символ, вы можете использовать Patter.quote. Если у вас просто тире (-), вы можете сократить код:

 String string = "004-34";
 String[] parts = string.split("-");

Если вы попытаетесь добавить другой специальный символ вместо тире (^) , тогда будет сгенерирована ошибка ArrayIndexOutOfBoundsException . Для этого вы должны использовать Pattern.quote.

avatar
user7973776
14 мая 2017 в 12:12
-1

Из документации:

public String[] split(String regex,int limit) Разбивает эту строку вокруг совпадений с заданным регулярным выражением . Массив, возвращаемый этим методом, содержит каждый подстрока этой строки, которая заканчивается другой подстрокой , которая совпадает с заданным выражением или заканчивается концом нить. Подстроки в массиве находятся в порядке , в котором они встречаются в этой строке. Если выражение не соответствует какой-либо части input, то результирующий массив имеет только один элемент , а именно этот строка.

Обычно вы можете сделать что-то вроде этого:

String s = "123-456-789-123"; // The String to be split
String[] array = s.split("-"); // Split according to the hyphen and put them in an array
for(String subString : array){ // Cycle through the array
   System.out.println(subString);
}

Вывод:

123
456
789
123
avatar
Rohit-Pandey
17 апреля 2017 в 03:53
6

Вы можете просто использовать StringTokenizer для разделения строки на две или более частей, независимо от того, есть ли какие-либо типы разделителей:

StringTokenizer st = new StringTokenizer("004-034556", "-");
while(st.hasMoreTokens())
{
    System.out.println(st.nextToken());
}
avatar
KIBOU Hassan
7 апреля 2017 в 21:57
0

Чтобы разделить строку, используйте String.split(regex):

String phone = "004-034556";
String[] output = phone.split("-");
System.out.println(output[0]);
System.out.println(output[1]);

Вывод:

004
034556
avatar
Akshay Gaikwad
3 марта 2017 в 09:39
7

Вот два способа достичь этого.

СПОСОБ 1. Поскольку вам нужно разделить два числа с помощью специального символа, вы можете использовать регулярное выражение

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class TrialClass
{
    public static void main(String[] args)
    {
        Pattern p = Pattern.compile("[0-9]+");
        Matcher m = p.matcher("004-034556");

        while(m.find())
        {
            System.out.println(m.group());
        }
    }
}

СПОСОБ 2: Использование метода разделения строк

public class TrialClass
{
    public static void main(String[] args)
    {
        String temp = "004-034556";
        String [] arrString = temp.split("-");
        for(String splitString:arrString)
        {
            System.out.println(splitString);
        }
    }
}
avatar
SAM Jr
24 февраля 2017 в 10:12
0
String s="004-034556";
for(int i=0;i<s.length();i++)
{
    if(s.charAt(i)=='-')
    {
        System.out.println(s.substring(0,i));
        System.out.println(s.substring(i+1));
    }
}

Как уже было сказано всеми, split () - лучший вариант, который можно использовать в вашем случае. Альтернативный метод может использовать substring ().

avatar
Sarat Chandra
9 января 2017 в 17:28
8

Вы можете использовать Split ():

import java.io.*;

public class Splitting
{

    public static void main(String args[])
    {
        String Str = new String("004-034556");
        String[] SplittoArray = Str.split("-");
        String string1 = SplittoArray[0];
        String string2 = SplittoArray[1];
    }
}

В противном случае вы можете использовать StringTokenizer:

import java.util.*;
public class Splitting
{
    public static void main(String[] args)
    {
        StringTokenizer Str = new StringTokenizer("004-034556");
        String string1 = Str.nextToken("-");
        String string2 = Str.nextToken("-");
    }
}
avatar
Somaiah Kumbera
1 декабря 2016 в 09:32
26

С Java 8:

    List<String> stringList = Pattern.compile("-")
            .splitAsStream("004-034556")
            .collect(Collectors.toList());

    stringList.forEach(s -> System.out.println(s));
Roland
10 марта 2017 в 15:11
2

Если вы хотите удалить пробелы, добавьте .map(String::trim) после split

avatar
Shivanandam
20 ноября 2016 в 04:43
4
String str="004-034556"
String[] sTemp=str.split("-");// '-' is a delimiter

string1=004 // sTemp[0];
string2=034556//sTemp[1];
avatar
Ravi Pandey
2 октября 2016 в 03:31
9
import java.io.*;

public class BreakString {

  public static void main(String args[]) {

    String string = "004-034556-1234-2341";
    String[] parts = string.split("-");

    for(int i=0;i<parts.length;i++) {
      System.out.println(parts[i]);
    }
  }
}
Sombriks
2 октября 2016 в 03:51
4

Если я могу поделиться советом, как ваш ответ имеет большую ценность, чем уже принятое решение? coderhelper.com/a/3481842/420096 в таких ситуациях вы можете проголосовать за существующее решение, особенно если это такой очевидный тривиальный случай, как этот.

avatar
akhil_mittal
18 мая 2016 в 05:17
8

Пожалуйста, не используйте класс StringTokenizer, поскольку это устаревший класс, который сохранен по соображениям совместимости, и его использование не рекомендуется в новом коде. И мы можем использовать метод разделения, предложенный другими.

String[] sampleTokens = "004-034556".split("-");
System.out.println(Arrays.toString(sampleTokens));

И, как и ожидалось, он напечатает:

[004, 034556]

В этом ответе я также хочу указать на одно изменение, которое произошло для метода split в Java 8 . Метод String # split () использует Pattern.split, и теперь он удаляет пустые строки в начале массива результатов. Обратите внимание на изменение в документации для Java 8:

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

В следующем примере это означает:

String[] sampleTokensAgain = "004".split("");
System.out.println(Arrays.toString(sampleTokensAgain));

мы получим три строки: [0, 0, 4], а не четыре, как было в Java 7 и ранее. Также проверьте этот аналогичный вопрос.

avatar
Divyesh Kanzariya
9 мая 2016 в 13:36
4

Ознакомьтесь с методом split() в классе String в javadoc.

https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#split(java.lang.String)

String data = "004-034556-1212-232-232";
int cnt = 1;
for (String item : data.split("-")) {
        System.out.println("string "+cnt+" = "+item);
        cnt++;
}

Здесь много примеров для разделенной строки, но я немного оптимизировал код.

R Sun
6 октября 2019 в 18:05
0

Замените - на | и посмотрите, что произойдет :)

R Sun
6 октября 2019 в 18:09
0

В этом случае проверьте coderhelper.com/questions/10796160/…

avatar
Ravindra babu
2 декабря 2015 в 11:07
13

Разделение строки на несколько символов с использованием Regex

public class StringSplitTest {
     public static void main(String args[]) {
        String s = " ;String; String; String; String, String; String;;String;String; String; String; ;String;String;String;String";
        //String[] strs = s.split("[,\\s\\;]");
        String[] strs = s.split("[,\\;]");
        System.out.println("Substrings length:"+strs.length);
        for (int i=0; i < strs.length; i++) {
            System.out.println("Str["+i+"]:"+strs[i]);
        }
     }
  }

Вывод:

Substrings length:17
Str[0]:
Str[1]:String
Str[2]: String
Str[3]: String
Str[4]: String
Str[5]: String
Str[6]: String
Str[7]:
Str[8]:String
Str[9]:String
Str[10]: String
Str[11]: String
Str[12]:
Str[13]:String
Str[14]:String
Str[15]:String
Str[16]:String

Но не ожидайте одинакового вывода для всех версий JDK. Я видел одну ошибку, которая существует в некоторых версиях JDK, где первая пустая строка была проигнорирована. Этой ошибки нет в последней версии JDK, но она существует в некоторых версиях между поздними версиями JDK 1.7 и ранними версиями 1.8.

avatar
Keshav Pradeep Ramanath
4 октября 2015 в 18:24
8

Один из способов сделать это - пройти через String в цикле for-each и использовать требуемый символ разделения.

public class StringSplitTest {

    public static void main(String[] arg){
        String str = "004-034556";
        String split[] = str.split("-");
        System.out.println("The split parts of the String are");
        for(String s:split)
        System.out.println(s);
    }
}

Вывод:

The split parts of the String are:
004
034556
avatar
Vitalii Fedorenko
13 мая 2015 в 13:38
14

Для простых случаев использования String.split() подойдет. Если вы используете гуаву, существует также класс Splitter, который позволяет связывать различные строковые операции и поддерживает CharMatcher:

Splitter.on('-')
       .trimResults()
       .omitEmptyStrings()
       .split(string);
avatar
RajeshVijayakumar
1 сентября 2014 в 13:39
10

Вы можете разделить строку по разрыву строки, используя следующий оператор:

String textStr[] = yourString.split("\\r?\\n");

Строку можно разделить дефисом / символом, используя следующий оператор:

String textStr[] = yourString.split("-");
avatar
sandeep vanama
1 июля 2014 в 04:35
16

Используйте метод разделения org.apache.commons.lang.StringUtils, который может разбивать строки на основе символа или строки, которую вы хотите разделить.

Сигнатура метода:

public static String[] split(String str, char separatorChar);

В вашем случае вы хотите разбить строку, когда есть «-».

Вы можете просто сделать следующее:

String str = "004-034556";

String split[] = StringUtils.split(str,"-");

Вывод:

004
034556

Предположим, что если - не существует в вашей строке, он возвращает данную строку, и вы не получите никакого исключения.

avatar
eis
25 марта 2014 в 06:43
16

Предполагая, что

  • вам действительно не нужны регулярные выражения для вашего разделения
  • вы уже используете apache commons lang в своем приложении

Самый простой способ - использовать StringUtils # split (java.lang.String, char). Это удобнее, чем тот, который предоставляется Java "из коробки", если вам не нужны регулярные выражения. Как сказано в руководстве, это работает так:

A null input String returns null.

 StringUtils.split(null, *)         = null
 StringUtils.split("", *)           = []
 StringUtils.split("a.b.c", '.')    = ["a", "b", "c"]
 StringUtils.split("a..b.c", '.')   = ["a", "b", "c"]
 StringUtils.split("a:b:c", '.')    = ["a:b:c"]
 StringUtils.split("a b c", ' ')    = ["a", "b", "c"]

Я бы порекомендовал использовать commong-lang, поскольку обычно он содержит много полезного. Однако, если вам это не нужно ни для чего другого, кроме разделения, то лучше реализовать себя или избежать регулярного выражения.

avatar
David
20 марта 2014 в 04:37
14

Самый быстрый способ, который потребляет меньше всего ресурсов:

String s = "abc-def";
int p = s.indexOf('-');
if (p >= 0) {
    String left = s.substring(0, p);
    String right = s.substring(p + 1);
} else {
  // s does not contain '-'
}
Chris Mountford
24 августа 2014 в 22:45
6

Самый дефицитный ресурс - это время и внимание программиста. Этот код потребляет больше ресурсов, чем альтернативы.

J Sanchez
22 апреля 2016 в 16:50
0

у вас есть много встроенных ресурсов, которые вы можете использовать, там, где производительность действительно учитывается, этому решению не хватает времени выполнения производительности

tekHedd
16 января 2019 в 21:13
1

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

Gabriel Magana
22 марта 2019 в 01:44
0

Браво! Наконец, ответ на этот вопрос, который не использует регулярное выражение! Использование регулярного выражения для этой простой задачи - это скорее проблема. Приятно видеть, что на этой земле еще есть здравомыслящие программисты :-)

Kaplan
17 апреля 2020 в 13:53
0

Есть только один знак "-", требуется исключение, и результат должен перейти в строку1 и строку2. Сделайте из него string1 = s.substring(0, s.indexOf("-")); string2 = s.substring(s.indexOf("-") + 1);. Вы получите StringIndexOutOfBoundsException автоматически, если не было «-».

avatar
Akhilesh Dhar Dubey
15 марта 2014 в 18:17
12
public class SplitTest {

    public static String[] split(String text, String delimiter) {
        java.util.List<String> parts = new java.util.ArrayList<String>();

        text += delimiter;

        for (int i = text.indexOf(delimiter), j=0; i != -1;) {
            String temp = text.substring(j,i);
            if(temp.trim().length() != 0) {
                parts.add(temp);
            }
            j = i + delimiter.length();
            i = text.indexOf(delimiter,j);
        }

        return parts.toArray(new String[0]);
    }


    public static void main(String[] args) {
        String str = "004-034556";
        String delimiter = "-";
        String result[] = split(str, delimiter);
        for(String s:result)
            System.out.println(s);
    }
}
avatar
user2045376
7 февраля 2013 в 05:24
-8

Иногда, если вы хотите разделить string containing +, он не будет разделен; вместо этого вы получите runtime error. В этом случае сначала replace + to _, а затем разделите:

 this.text=text.replace("/", "_");
            String temp[]=text.split("_");
Max
27 марта 2013 в 16:49
16

Это потому, что аргумент для разделения является регулярным выражением. Лучшее решение - правильно экранировать регулярное выражение.

avatar
SHUNMUGA RAJ PRABAKARAN
15 января 2013 в 09:58
18

Так же можно попробовать

 String concatenated_String="hi^Hello";

 String split_string_array[]=concatenated_String.split("\\^");
avatar
Mnyikka
16 ноября 2012 в 06:30
30
// This leaves the regexes issue out of question
// But we must remember that each character in the Delimiter String is treated
// like a single delimiter        

public static String[] SplitUsingTokenizer(String subject, String delimiters) {
   StringTokenizer strTkn = new StringTokenizer(subject, delimiters);
   ArrayList<String> arrLis = new ArrayList<String>(subject.length());

   while(strTkn.hasMoreTokens())
      arrLis.add(strTkn.nextToken());

   return arrLis.toArray(new String[0]);
}
bvdb
9 сентября 2013 в 07:07
62

В JavaDoc четко указано: «StringTokenizer - это устаревший класс, который сохранен по соображениям совместимости, хотя его использование не рекомендуется в новом коде . Всем, кому нужна эта функция, рекомендуется использовать split метод String или пакет java.util.regex вместо этого. "

avatar
Rob Hague
14 августа 2010 в 11:28
83

Альтернативой прямой обработке строки было бы использование регулярного выражения с группами захвата. Это имеет то преимущество, что упрощает наложение более сложных ограничений на ввод. Например, следующий код разбивает строку на две части и гарантирует, что обе они состоят только из цифр:

import java.util.regex.Pattern;
import java.util.regex.Matcher;

class SplitExample
{
    private static Pattern twopart = Pattern.compile("(\\d+)-(\\d+)");

    public static void checkString(String s)
    {
        Matcher m = twopart.matcher(s);
        if (m.matches()) {
            System.out.println(s + " matches; first part is " + m.group(1) +
                               ", second part is " + m.group(2) + ".");
        } else {
            System.out.println(s + " does not match.");
        }
    }

    public static void main(String[] args) {
        checkString("123-4567");
        checkString("foo-bar");
        checkString("123-");
        checkString("-4567");
        checkString("123-4567-890");
    }
}

Поскольку в этом экземпляре шаблон зафиксирован, он может быть скомпилирован заранее и сохранен как статический член (инициализируется во время загрузки класса в примере). Регулярное выражение:

(\d+)-(\d+)

Круглые скобки обозначают захватывающие группы; строка, которая соответствует этой части регулярного выражения, может быть доступна с помощью метода Match.group (), как показано. \ D соответствует одной десятичной цифре, а + означает "соответствует одному или нескольким из предыдущего выражения). - не имеет особого значения, поэтому просто соответствует этому символу во входных данных. Обратите внимание, что вам нужно дважды экранировать обратную косую черту. при записи в виде строки Java. Некоторые другие примеры:

([A-Z]+)-([A-Z]+)          // Each part consists of only capital letters 
([^-]+)-([^-]+)            // Each part consists of characters other than -
([A-Z]{2})-(\d+)           // The first part is exactly two capital letters,
                           // the second consists of digits
ptstone
13 июля 2017 в 04:28
0

Это отличное решение, однако первая часть должна быть m.group(1), вторая часть - m.group(2), поскольку m.group(0) фактически возвращает полный шаблон соответствия. Думаю, я также помню, что group(0) раньше было первым совпадением, а не полным шаблоном, возможно, это изменилось в недавнем обновлении версии Java.

avatar
Michael Konietzka
14 августа 2010 в 06:57
19

Требования оставляли место для интерпретации. Рекомендую написать метод,

public final static String[] mySplit(final String s)

, которые инкапсулируют эту функцию. Конечно, вы можете использовать String.split (..), как указано в других ответах на реализацию.

Вам следует написать несколько модульных тестов для входных строк и желаемых результатов и поведения.

Хорошие кандидаты на тестирование должны включать:

 - "0022-3333"
 - "-"
 - "5555-"
 - "-333"
 - "3344-"
 - "--"
 - ""
 - "553535"
 - "333-333-33"
 - "222--222"
 - "222--"
 - "--4555"

Определив соответствующие результаты теста, вы можете указать поведение.

Например, если "-333" должен вернуться в [,333] или это ошибка. Можно ли разделить "333-333-33" на [333,333-33] or [333-333,33] или это ошибка? И так далее.

Chris Mountford
24 августа 2014 в 22:43
5

Полезный совет, но не ответ на вопрос. Если вы поддерживаете другой ответ с подробностями, комментарий предпочтительнее.

Ryan Augustine
20 сентября 2018 в 11:02
0

Используйте: split (String regex, int limit) и NOT split (String regex) для справочного посещения geeksforgeeks.org/split-string-java-examples

avatar
secmask
14 августа 2010 в 03:06
31
String[] out = string.split("-");

должен делать то, что вы хотите. Класс string имеет много методов для работы со строкой.

avatar
jjnguy
14 августа 2010 в 03:06
44

Использование:

String[] result = yourString.split("-");
if (result.length != 2) 
     throw new IllegalArgumentException("String not in correct format");

Это разделит вашу строку на две части. Первым элементом в массиве будет часть, содержащая материал до -, а второй элемент в массиве будет содержать часть вашей строки после -.

Если длина массива не равна 2, значит, строка была не в формате: string-string.

Ознакомьтесь с методом split () в классе String.

Michael Konietzka
14 августа 2010 в 06:36
5

Это примет «-555» в качестве входных данных и вернет [, 555]. Требования не определены так четко, если это действительно так. Я рекомендую написать несколько модульных тестов, чтобы определить желаемое поведение.

Uncle Iroh
10 февраля 2014 в 16:53
0

Вероятно, безопаснее всего изменить (result.length! = 2) на (result.length <2)