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

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

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

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

+1541
источник поделиться
35 ответов
  • 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
+2756
источник

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

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
+72
источник
другие ответы

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


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

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-

+41
источник
String[] out = string.split("-");

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

+28
источник
// 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]);
}
+28
источник

С Java 8:

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

    stringList.forEach(s -> System.out.println(s));
+20
источник

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

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

+19
источник

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

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

+16
источник

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

 String concatenated_String="hi^Hello";

 String split_string_array[]=concatenated_String.split("\\^");
+15
источник

Используйте метод 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
источник

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

Splitter.on('-')
       .trimResults()
       .omitEmptyStrings()
       .split(string);
+13
источник

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
источник

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

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
источник

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

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

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

+11
источник
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
источник

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

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

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

String textStr[] = yourString.split("-");
+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]);
    }
  }
}
+9
источник

Вы можете использовать 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
источник

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

Не используйте 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
источник

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

ПУТЬ 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
источник

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

StringTokenizer st = new StringTokenizer("004-034556", "-");
while(st.hasMoreTokens())
{
    System.out.println(st.nextToken());
}
+6
источник

Ознакомьтесь с методом 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
источник
String str="004-034556"
String[] sTemp=str.split("-");// '-' is a delimiter

string1=004 // sTemp[0];
string2=034556//sTemp[1];
+4
источник

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

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

+4
источник

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

Вы можете использовать метод 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
источник

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

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

И тогда я просто хотел бы установить SetText() из трех различных TextViews для отображения этой строки.

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

+1
источник
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
источник

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

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

Вывод:

004
034556
0
источник
  • 1
  • 2

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