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

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

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

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

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

Итак, если вы хотите разделить, например, период / точка ., что означает "любой символ" в регулярном выражении, используйте либо обратная косая черта \, чтобы экранировать отдельный специальный символ, например split("\\."), или используйте символьный класс [] для представления буквальных символов, подобных этому split("[.]"), или используйте _ 20_, чтобы экранировать всю строку так split(Pattern.quote(".")).

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

Чтобы заранее проверить, содержит ли строка определенные символы, просто используйте _ 23_.

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

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

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

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

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

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

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

Использовать:

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

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

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

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

String[] out = string.split("-");

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

С Java 8:

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

    stringList.forEach(s -> System.out.println(s));

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

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] или это ошибка? И так далее.

Вы также можете попробовать это

 String concatenated_String="hi^Hello";

 String split_string_array[]=concatenated_String.split("\\^");

При условии, что

• вам действительно не нужны регулярные выражения для вашего сплита
• вы уже используете 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, поскольку обычно он содержит много полезного. Однако, если вам это не нужно ни для чего, кроме разделения, то лучше реализовать себя или избежать регулярного выражения.

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

Подпись метода:

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

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

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

String str = "004-034556";

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

Вывод:

004
034556

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

Подводя итог: существует как минимум пять способов разбить строку в 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:

   Iterable<String> result = Splitter.on(",").split("1,2,3,4");
   

5. Apache Commons StringUtils:

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

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

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

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

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 '-'
}

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

Splitter.on('-')
       .trimResults()
       .omitEmptyStrings()
       .split(string);

Разделение строки на несколько символов с помощью регулярного выражения

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.

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

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

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

String textStr[] = yourString.split("-");

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

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

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

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

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

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

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

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

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

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

Один из способов сделать это - пройти через 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

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

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

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

[004, 034556]

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

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

Это означает для следующего примера:

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

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

Вы можете использовать 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("-");
    }
}

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

СПОСОБ 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);
        }
    }
}

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

StringTokenizer st = new StringTokenizer("004-034556", "-");
while(st.hasMoreTokens())
{
    System.out.println(st.nextToken());
}

Ознакомьтесь с методом 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++;
}

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

Я просто хотел написать алгоритм вместо использования встроенных функций 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;
}

Вы можете использовать метод 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 \"-\".");
        }
    }
}

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

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

Выход

004
034556

Примечание:

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

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 ().

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

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

Выход:

004
034556

 String string = "004^034556-34";
 String[] parts = string.split(Pattern.quote("^"));

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

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

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

Я использовал строку под названием 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: те, у кого были заметки, были заняты поисками убежища.

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

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

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

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

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

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

/**
 * 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;
}

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

 this.text=text.replace("/", "_");
            String temp[]=text.split("_");