У меня есть строка "004-034556"
, которую я хочу разбить на две строки:
string1="004";
string2="034556";
Это означает, что первая строка будет содержать символы до '-'
, а вторая строка будет содержать символы после '-'
. Я также хочу проверить, есть ли в нем строка '-'
. Если нет, я сделаю исключение. Как я могу это сделать?
Просто используйте соответствующий метод: 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
Альтернативой обработке строки непосредственно будет использование регулярного выражения с группами захвата. Преимущество этого заключается в том, что он делает очевидным более сложное ограничение ввода. Например, следующее разделяет строку на две части и гарантирует, что оба они состоят только из цифр:
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
m.group(1)
, вторая часть m.group(2)
, поскольку m.group(0)
фактически возвращает шаблон полного соответствия. Я думаю, что я также помню, что group(0)
была первым совпадением вместо полного шаблона, возможно, это изменилось в недавнем обновлении версии Java.
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-
// 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]);
}
StringTokenizer
- это устаревший класс, который сохраняется из соображений совместимости, хотя его использование не рекомендуется в новом коде . Рекомендуется всем, кто ищет эту функциональность, использовать вместо этого метод split
String
или пакет java.util.regex
. "
String[] out = string.split("-");
должен делать то, что вы хотите. Класс String имеет много методов для работы со строкой.
Требования оставляют место для интерпретации. Я рекомендую написать метод,
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]
или это ошибка? И так далее.
С Java 8:
List<String> stringList = Pattern.compile("-")
.splitAsStream("004-034556")
.collect(Collectors.toList());
stringList.forEach(s -> System.out.println(s));
.map(String::trim)
после split
Используйте метод org.apache.commons.lang.StringUtils, который может разделить строки на основе символа или строки, которую вы хотите разбить.
Подпись метода:
public static String[] split(String str, char separatorChar);
В вашем случае вы хотите разбить строку, когда есть "-".
Вы можете просто сделать следующее:
String str = "004-034556";
String split[] = StringUtils.split(str,"-");
Вывод:
004
034556
Предположим, что если -
не существует в вашей строке, он возвращает заданную строку, и вы не получите никакого исключения.
Предполагая, что
Самый простой способ - использовать 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, так как обычно он содержит много полезного материала. Однако, если вам это не нужно ни для чего другого, кроме разделения, тогда реализация или вытеснение регулярного выражения - лучший вариант.
Вы также можете попробовать это
String concatenated_String="hi^Hello";
String split_string_array[]=concatenated_String.split("\\^");
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.
Для простых случаев использования 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);
}
}
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]);
}
}
}
Вы можете разбить строку на разрыв строки, используя следующую инструкцию:
String textStr[] = yourString.split("\\r?\\n");
Вы можете разбить строку на дефис/символ, используя следующую инструкцию:
String textStr[] = yourString.split("-");
Самый быстрый способ, который также потребляет наименьший ресурс, может быть:
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 '-'
}
Вот два способа добиться этого.
ПУТЬ 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);
}
}
}
Вы можете использовать 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("-");
}
}
Не используйте 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.
Один из способов сделать это - запустить 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
Подводя итог: существует как минимум пять способов разделить строку на Java:
String.split():
String[] parts ="10,20".split(",");
Pattern.compile (регулярное выражение).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", ",");
Таким образом, вы можете выбрать наилучший вариант для вас в зависимости от того, что вам нужно, например, тип возвращаемого значения (массив, список или итерабельность).
Вот большой обзор этих методов и наиболее распространенных примеров (как разделить по точкам, косе, вопросительному знаку и т.д.).
Вы можете просто использовать StringTokenizer для разделения строки в двух или более частях, есть ли какие-либо разделители:
StringTokenizer st = new StringTokenizer("004-034556", "-");
while(st.hasMoreTokens())
{
System.out.println(st.nextToken());
}
String str="004-034556"
String[] sTemp=str.split("-");// '-' is a delimiter
string1=004 // sTemp[0];
string2=034556//sTemp[1];
Ознакомьтесь с методом 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, но оптимизирован небольшой код.
Я просто хотел написать алгоритм вместо использования встроенных функций 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.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
. Вы также можете кэшировать этот объект и сбросить его для каждого входа для максимальной производительности, но это несколько сложнее и не является потокобезопасным.
Чтобы разбить строку, используется 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) принимает в качестве аргумента регулярное выражение, не забудьте избежать специальных символов регулярного выражения, например, период/точка.
Чтобы разбить строку, используйте String.split(regex)
:
String phone = "004-034556";
String[] output = phone.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() - лучший вариант, который может быть использован в вашем случае. Альтернативный метод может использоваться подстрокой().
String string = "004^034556-34";
String[] parts = string.split(Pattern.quote("^"));
Если у вас есть специальный символ, вы можете использовать Patter.quote. Если у вас просто есть тире (-), вы можете сократить код:
String string = "004-34";
String[] parts = string.split("-");
Если вы попытаетесь добавить другой специальный символ вместо тире (^), тогда ошибка будет генерировать ArrayIndexOutOfBoundsException. Для этого вам нужно использовать Pattern.quote
.
Из документации:
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 containing +
, тогда он не будет разделен; вместо этого вы получите runtime error
. В этом случае сначала replace + to _
, а затем разделите:
this.text=text.replace("/", "_");
String temp[]=text.split("_");