Как разделить строку на Java
у меня есть строка, "004-034556"
, что я хочу разделить на две строки:
string1="004";
string2="034556";
это означает, что первая строка будет содержать символы перед '-'
, а вторая строка будет содержать символы после '-'
. Я также хочу проверить, имеет ли строка '-'
в нем. Если нет, я сделаю исключение. Как я могу это сделать?
30 ответов
просто используйте соответствующий метод: 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()
.
если вы хотите сохранить разделенный символ в результирующих частях, а затем использовать положительный lookaround. Если вы хотите, чтобы разделенный символ оказался в левой части, используйте положительный lookbehind с префиксом ?<=
группы по шаблону.
String string = "004-034556";
String[] parts = string.split("(?<=-)");
String part1 = parts[0]; // 004-
String part2 = parts[1]; // 034556
если вы хотите, чтобы разделенный символ оказался в правой части, используйте положительный lookahead, префикс ?=
группы по шаблону.
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
альтернативой обработке строки напрямую было бы использование регулярного выражения с захватом групп. Это имеет то преимущество, что это делает его простым, чтобы подразумевать более сложные ограничения на ввод. Например, следующее разбивает строку на две части и гарантирует, что обе состоят только из цифр:
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+)
скобки обозначают группы захвата; строка, которая соответствовала этой части регулярного выражения, может быть доступна соответствием.метод group (), как показано. \D соответствует и одной десятичной цифре, а + означает " соответствует одному или нескольким предыдущим выражениям). The - не имеет особого значения, поэтому просто соответствует этому символу на входе. Обратите внимание, что вам нужно дважды избежать обратных косых черт при записи этого как строки 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 части. Первым элементом в массиве будет часть, содержащая материал перед -
, а второй элемент массива будет содержать часть вашей строки после -
.
если длина массива не равна 2, то строка не была в формате:string-string
.
Проверьте split()
метод String
класса.
https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#split-java.lang.String-int-
// 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]);
}
String[] out = string.split("-");
должен делать то, что вы хотите. Класс String имеет много методов для работы со строкой.
требования оставили место для устного перевода. Я рекомендую написать метод,
public final static String[] mySplit(final String s)
, которые инкапсулируют эту функцию. Конечно, вы можете использовать String.расщеплять.(.) как уже упоминалось в других ответах на вопрос об осуществлении.
вы должны написать юнит-тесты для входных строк и желаемых результатов и поведения.
хорошие тестовые кандидаты должны включать:
- "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("\^");
предполагая, что
- вам действительно не нужны регулярные выражения для вашего split
- вы уже используете apache commons lang в своем приложении
самый простой способ-это использовать StringUtils#split (java.ленг.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.апаш.палата общин.ленг.StringUtils' split метод, который может разделить строки на основе символа или строки, которую вы хотите разделить.
метод подписи:
public static String[] split(String str, char separatorChar);
в вашем случае, вы хотите разделить строку, когда есть "-".
вы можете просто сделать следующее:
String str = "004-034556";
String split[] = StringUtils.split(str,"-");
выход:
004
034556
предположим, что если -
не существует в строку, она возвращает заданную строку, и вы не получите никаких исключений.
С Java 8:
List<String> stringList = Pattern.compile("-")
.splitAsStream("004-034556")
.collect(Collectors.toList());
stringList.forEach(s -> System.out.println(s));
строка разделена несколькими символами с помощью 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.
для простых случаев использования String.split()
должен делать свою работу. Если вы используете guava, есть также Splitter класс, который позволяет связывать различные строковые операции и поддерживает CharMatcher:
Splitter.on('-')
.trimResults()
.omitEmptyStrings()
.split(string);
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);
}
}
самый быстрый способ, который также потребляет меньше ресурсов могут быть:
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 textStr[] = yourString.split("\r?\n");
вы можете разделить строку на дефис / символ, используя следующую инструкцию:
String textStr[] = yourString.split("-");
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]);
}
}
}
один из способов сделать это-запустить строку в цикле 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. The строка#split () способ использует 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: Поскольку вы должны разделить два числа специальным символом, вы можете использовать regex
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());
}
подводя итог: существует по крайней мере пять способов разбить строку на Java:
-
строку.split ():
String[] parts ="10,20".split(",");
-
узор.compile(regexp).splitAsStream(вход):
List<String> strings = Pattern.compile("\|") .splitAsStream("010|020202") .collect(Collectors.toList());
-
StringTokenizer (устаревший класс):
StringTokenizer strings = new StringTokenizer("Welcome to EXPLAINJAVA.COM!", "."); while(strings.hasMoreTokens()){ String substring = strings.nextToken(); System.out.println(substring); }
-
Google Guava Splitter:
Iterable<String> result = Splitter.on(",").split("1,2,3,4");
-
Apache Commons StringUtils:
String[] strings = StringUtils.split("1,2,3,4", ",");
так что вы можете выберите лучший вариант для вас в зависимости от того, что вам нужно, например, тип возврата (массив, список или iterable).
здесь большой обзор этих методов и наиболее распространенных примеров (как в Сплит на точка, тире, вопросительный знак и т. д.)
Проверьте 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 string, но я немного оптимизировал код.
String str="004-034556"
String[] sTemp=str.split("-");// '-' is a delimiter
string1=004 // sTemp[0];
string2=034556//sTemp[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 () - лучший вариант, который может быть использован в вашем случае. Альтернативным методом может быть использование метода substring().
чтобы разделить строку, используйте String.split(regex)
:
String phone = "004-034556";
String[] output = phone.split("-");
System.out.println(output[0]);
System.out.println(output[1]);
выход:
004
034556
Я просто хотел написать алгоритм вместо использования встроенных функций 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 (регулярное выражение). Просмотрите следующие примеры :
String data = "004-034556";
String[] output = data.split("-");
System.out.println(output[0]);
System.out.println(output[1]);
выход
004
034556
Примечание. Это разделение (регулярное выражение) принимает регулярное выражение в качестве аргумента, не забудьте избежать специальных символов регулярного выражения, таких как точка/точка.
из документации:
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
String string = "004^034556-34";
String[] parts = string.split(Pattern.quote("^"));
Если у вас есть специальный символ, то вы можете использовать Patter.цитата. Если у вас просто есть dash ( - ), то вы можете сократить код:
String string = "004-34";
String[] parts = string.split("-");
Если вы пытаетесь добавить специальный символ тире (^) тогда ошибка будет генерировать ArrayIndexOutOfBoundsException. Для этого вы должны использовать Pattern.quote
.