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

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

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

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

1448
14 авг. '10 в 6:01
источник поделиться
34 ответов
  • 1
  • 2

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

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

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

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

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

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

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

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

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

String string = "004-034556-42";
String[] parts = string.split("-", 2);
String part1 = parts[0]; // 004
String part2 = parts[1]; // 034556-42
2601
14 авг. '10 в 6:05
источник

Связанные вопросы


Похожие вопросы

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

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
71
14 авг. '10 в 14:28
источник
String[] result = yourString.split("-");
if (result.length != 2) 
     throw new IllegalArgumentException("String not in correct format");

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

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

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

https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#split-java.lang.String-int-

40
14 авг. '10 в 6:06
источник
// 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]);
}
27
16 нояб. '12 в 9:30
источник
String[] out = string.split("-");

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

25
14 авг. '10 в 6:06
источник

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

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

18
14 авг. '10 в 9:57
источник

С Java 8:

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

    stringList.forEach(s -> System.out.println(s));
17
01 дек. '16 в 12:32
источник

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

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

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

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

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

String str = "004-034556";

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

Вывод:

004
034556

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

15
01 июля '14 в 7:35
источник

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

 String concatenated_String="hi^Hello";

 String split_string_array[]=concatenated_String.split("\\^");
15
15 янв. '13 в 12:58
источник

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

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

15
25 марта '14 в 9:43
источник

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

Splitter.on('-')
       .trimResults()
       .omitEmptyStrings()
       .split(string);
13
13 мая '15 в 16:38
источник

String Split с несколькими символами с использованием 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.

13
02 дек. '15 в 14:07
источник

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

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 '-'
}
11
20 марта '14 в 7:37
источник

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

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

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

10
13 дек. '17 в 17:20
источник
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);
    }
}
10
15 марта '14 в 21:17
источник
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]);
    }
  }
}
9
02 окт. '16 в 6:31
источник

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

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

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

String textStr[] = yourString.split("-");
9
01 сент. '14 в 16:39
источник

Вы можете использовать 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("-");
    }
}
8
09 янв. '17 в 20:28
источник

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

ПУТЬ 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);
        }
    }
}
7
03 марта '17 в 12:39
источник

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

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 и ранее. Также проверьте этот question.

7
18 мая '16 в 8:17
источник

Один из способов сделать это - запустить 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
7
04 окт. '15 в 21:24
источник

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

StringTokenizer st = new StringTokenizer("004-034556", "-");
while(st.hasMoreTokens())
{
    System.out.println(st.nextToken());
}
6
17 апр. '17 в 6:53
источник

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

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

4
09 мая '16 в 16:36
источник
String str="004-034556"
String[] sTemp=str.split("-");// '-' is a delimiter

string1=004 // sTemp[0];
string2=034556//sTemp[1];
4
20 нояб. '16 в 7:43
источник

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

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

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

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

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

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

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

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

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

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

3
20 нояб. '18 в 15:08
источник

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

    }
}
1
07 дек. '18 в 11:48
источник

Я просто хотел написать алгоритм вместо использования встроенных функций 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;
}
1
10 янв. '18 в 9:28
источник

И как я могу разделить имя с двумя методами и с классом? Один метод для имени и второй для других имен с массивом для их хранения? Я знаю, как вынести имя, но как поместить другие имена в массив и вернуться в этот массив?

Заранее спасибо!

0
16 апр. '19 в 14:10
источник
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() - лучший вариант, который может быть использован в вашем случае. Альтернативный метод может использоваться подстрокой().

0
24 февр. '17 в 13:12
источник

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

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

Вывод:

004
034556
0
08 апр. '17 в 0:57
источник
  • 1
  • 2

Посмотрите другие вопросы по меткам или Задайте вопрос