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

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

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

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

вопрос задан 14.08.2010
riyana
7357 репутация

31 ответов


  • 2390 рейтинг

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

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

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

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

    Итак, если вы хотите разделить, например, период /точку . что означает « любой символ » в регулярном выражении, используйте либо обратную косую черту \ чтобы избежать индивидуального специального символа, например split("\\.") , или использовать класс символов [] для представления буквенного символа (ов) 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
     
    ответ дан BalusC, с репутацией 823987, 14.08.2010
  • 68 рейтинг

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

     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
     
    ответ дан Rob Hague, с репутацией 1099, 14.08.2010
  • 39 рейтинг
     String[] result = yourString.split("-");
    if (result.length != 2) 
         throw new IllegalArgumentException("String not in correct format");
     

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

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

    Проверьте split() метода в классе String .

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

    ответ дан jjnguy, с репутацией 104605, 14.08.2010
  • 26 рейтинг
    // 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]);
    }
    
    ответ дан Mnyikka, с репутацией 905, 16.11.2012
  • 23 рейтинг
     String[] out = string.split("-");
     

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

    ответ дан secmask, с репутацией 3893, 14.08.2010
  • 17 рейтинг

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

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

    ответ дан Michael Konietzka, с репутацией 4615, 14.08.2010
  • 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
     

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

    ответ дан sandeep vanama, с репутацией 513, 1.07.2014
  • 15 рейтинг

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

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

    ответ дан eis, с репутацией 32965, 25.03.2014
  • 15 рейтинг

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

      String concatenated_String="hi^Hello";
    
     String split_string_array[]=concatenated_String.split("\\^");
     
    ответ дан SHUNMUGA RAJ PRABAKARAN, с репутацией 515, 15.01.2013
  • 14 рейтинг

    С Java 8:

         List<String> stringList = Pattern.compile("-")
                .splitAsStream("004-034556")
                .collect(Collectors.toList());
    
        stringList.forEach(s -> System.out.println(s));
     
    ответ дан Somaiah Kumbera, с репутацией 3943, 1.12.2016
  • 12 рейтинг

    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.

    ответ дан Ravindra babu, с репутацией 27444, 2.12.2015
  • 11 рейтинг

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

     Splitter.on('-')
           .trimResults()
           .omitEmptyStrings()
           .split(string);
     
    ответ дан Vitalii Fedorenko, с репутацией 66689, 13.05.2015
  • 10 рейтинг
    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);
        }
    }
    
    ответ дан Akhilesh Dhar Dubey, с репутацией 1598, 15.03.2014
  • 9 рейтинг

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

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

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

     String textStr[] = yourString.split("-");
     
    ответ дан RajeshVijayakumar, с репутацией 6863, 1.09.2014
  • 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]);
        }
      }
    }
    
    ответ дан Ravi Pandey, с репутацией 364, 2.10.2016
  • 9 рейтинг

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

     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 '-'
    }
     
    ответ дан David, с репутацией 360, 20.03.2014
  • 7 рейтинг

    Не используйте класс 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 и ранее. Также проверьте этот аналогичный вопрос .

    ответ дан i_am_zero, с репутацией 10225, 18.05.2016
  • 7 рейтинг

    Один из способов сделать это - запустить 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
     
    ответ дан Keshav Pradeep Ramanath, с репутацией 984, 4.10.2015
  • 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("-");
        }
    }
     
    ответ дан Sarat Chandra, с репутацией 1672, 9.01.2017
  • 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);
            }
        }
    }
     
    ответ дан Akshay Gaikwad, с репутацией 175, 3.03.2017
  • 5 рейтинг

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

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

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

    ответ дан Dmytro Shvechikov, с репутацией 245, 13.12.2017
  • 5 рейтинг

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

     StringTokenizer st = new StringTokenizer("004-034556", "-");
    while(st.hasMoreTokens())
    {
        System.out.println(st.nextToken());
    }
     
    ответ дан Rohit-Pandey, с репутацией 558, 17.04.2017
  • 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++;
    }
     

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

    ответ дан Divyesh Kanzariya, с репутацией 1814, 9.05.2016
  • 4 рейтинг
    String str="004-034556"
    String[] sTemp=str.split("-");// '-' is a delimiter
    
    string1=004 // sTemp[0];
    string2=034556//sTemp[1];
    
    ответ дан Shivanandam Sirmarigari, с репутацией 743, 20.11.2016
  • 0 рейтинг

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

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

    Вывод:

     004
    034556
     
    ответ дан KIBOU Hassan, с репутацией 159, 7.04.2017
  • 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 () - лучший вариант, который может быть использован в вашем случае. Альтернативный метод может использоваться подстрокой ().

    ответ дан SAM Jr, с репутацией 28, 24.02.2017
  • 0 рейтинг

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

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

    Вывод

     004
    034556
     

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

    ответ дан KIBOU Hassan, с репутацией 159, 8.03.2018
  • 0 рейтинг

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

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

    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
     
    ответ дан does_not_exist, с репутацией , 14.05.2017
  • -2 рейтинг
      String string = "004^034556-34";
     String[] parts = string.split(Pattern.quote("^"));
     

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

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

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

    ответ дан Aditya Singh, с репутацией 53, 22.09.2017
  • -5 рейтинг

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

      this.text=text.replace("/", "_");
                String temp[]=text.split("_");
     
    ответ дан does_not_exist, с репутацией , 7.02.2013