Как разбить строку по пробелу

Мне нужно разделить мою строку по пробелам. Для этого я попытался:

str = "Hello I'm your String";
String[] splited = str.split(" ");

Но это не похоже на работу.

То, что у вас есть, должно работать. Если, однако, предоставленные места по умолчанию ... что-то еще? Вы можете использовать регулярное выражение для пробелов:

str = "Hello I'm your String";
String[] splited = str.split("\\s+");

Это приведет к тому, что любое количество последовательных пробелов разделит вашу строку на токены.

В качестве примечания, я не уверен, что слово «раскол» - это слово :) Я считаю, что состояние жертвы раскола тоже «раскол». Это одна из тех хитрых грамматических вещей :-) Не пытаясь быть разборчивым, просто решил, что я передам это!

В то время как принятый ответ хорош, имейте в виду, что в итоге вы получите пустую начальную строку, если ваша входная строка начинается с пробела. Например, с:

String str = " Hello I'm your String";
String[] splitStr = str.split("\\s+");

Результат будет:

splitStr[0] == "";
splitStr[1] == "Hello";
splitStr[2] == "I'm";
splitStr[3] == "Your";
splitStr[4] == "String";

Так что вы можете обрезать вашу строку перед тем, как ее разбить:

String str = " Hello I'm your String";
String[] splitStr = str.trim().split("\\s+");

[редактировать]

В дополнение к trimпредупреждению, вы можете рассмотреть символ неразрывного пробела Юникод ( U+00A0). Этот символ печатается как обычный пробел в строке и часто скрывается в скопированном тексте из текстовых редакторов или веб-страниц. Они не обрабатываются с помощью .trim()каких тестов для символов, которые нужно удалить c <= ' '; \sих тоже не поймаешь.

Вместо этого вы можете использовать, \p{Blank}но вам нужно также включить поддержку символов Юникода, чего splitне будет делать обычный пользователь . Например, это будет работать: Pattern.compile("\\p{Blank}", UNICODE_CHARACTER_CLASS).split(words)но это не поможет trim.

Следующее демонстрирует проблему и предоставляет решение. Для этого далеко не оптимально полагаться на регулярное выражение, но теперь, когда Java имеет 8-битное / 16-битное представление байтов, эффективное решение для этого становится довольно длинным.

public class SplitStringTest
{
    static final Pattern TRIM_UNICODE_PATTERN = Pattern.compile("^\\p{Blank}*(.*)\\p{Blank}$", UNICODE_CHARACTER_CLASS);
    static final Pattern SPLIT_SPACE_UNICODE_PATTERN = Pattern.compile("\\p{Blank}", UNICODE_CHARACTER_CLASS);

    public static String[] trimSplitUnicodeBySpace(String str)
    {
        Matcher trimMatcher = TRIM_UNICODE_PATTERN.matcher(str);
        boolean ignore = trimMatcher.matches(); // always true but must be called since it does the actual matching/grouping
        return SPLIT_SPACE_UNICODE_PATTERN.split(trimMatcher.group(1));
    }

    @Test
    void test()
    {
        String words = " Hello I'm\u00A0your String\u00A0";
        // non-breaking space here --^ and there -----^

        String[] split = words.split(" ");
        String[] trimAndSplit = words.trim().split(" ");
        String[] splitUnicode = SPLIT_SPACE_UNICODE_PATTERN.split(words);
        String[] trimAndSplitUnicode = trimSplitUnicodeBySpace(words);

        System.out.println("words: [" + words + "]");
        System.out.println("split: [" + Arrays.stream(split).collect(Collectors.joining("][")) + "]");
        System.out.println("trimAndSplit: [" + Arrays.stream(trimAndSplit).collect(Collectors.joining("][")) + "]");
        System.out.println("splitUnicode: [" + Arrays.stream(splitUnicode).collect(Collectors.joining("][")) + "]");
        System.out.println("trimAndSplitUnicode: [" + Arrays.stream(trimAndSplitUnicode).collect(Collectors.joining("][")) + "]");
    }
}

Результаты в:

words: [ Hello I'm your String ]
split: [][Hello][I'm your][String ]
trimAndSplit: [Hello][I'm your][String ]
splitUnicode: [][Hello][I'm][your][String]
trimAndSplitUnicode: [Hello][I'm][your][String]

Я действительно считаю, что использование регулярных выражений в скобках str.split должно решить эту проблему. Метод Java String.split () основан на регулярных выражениях, поэтому вам нужно:

str = "Hello I'm your String";
String[] splitStr = str.split("\\s+");

Используйте, Stringutils.split()чтобы разбить строку по белому шагу. Например StringUtils.split("Hello World")возвращает «Привет» и «Мир»;

Чтобы решить упомянутый случай, мы используем такой метод разбиения

String split[]= StringUtils.split("Hello I'm your String");

когда мы распечатаем массив split, результат будет:

Привет

я

ваш

строка

Для полного примера демонстрации проверьте здесь

Пытаться

String[] splited = str.split("\\s");

http://download.oracle.com/javase/tutorial/essential/regex/pre_char_classes.html

если вы не хотите использовать метод разделения String, вы можете использовать класс StringTokenizer в Java как ...

    StringTokenizer tokens = new StringTokenizer("Hello I'm your String", " ");
    String[] splited = new String[tokens.countTokens()];
    int index = 0;
    while(tokens.hasMoreTokens()){
        splited[index] = tokens.nextToken();
        ++index;
    }

Попробуй это

    String str = "This is String";
    String[] splited = str.split("\\s+");

    String split_one=splited[0];
    String split_second=splited[1];
    String split_three=splited[2];

   Log.d("Splited String ", "Splited String" + split_one+split_second+split_three);

Альтернативный способ будет:

import java.util.regex.Pattern;

...

private static final Pattern SPACE = Pattern.compile(" ");
String[] arr = SPACE.split(str); // str is the string to be split

Видел это здесь

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

Если вы хотите разделить любую строку пробелами, разделитель (специальные символы).

Во-первых, удалите пробелы, поскольку они создают большинство проблем.

str1 = "    Hello I'm your       String    ";
str2 = "    Are you serious about this question_  boy, aren't you?   ";

Сначала удалите начальное пространство, которое может быть пробелом, символом табуляции и т. Д.

String s = str1.replaceAll("^\\s+","");//starting with whitespace one or more

Теперь, если вы хотите разделить по пробелам или любым специальным символам.

String[] sa = s.split("[^\\w]+");//split by any non word char

Но поскольку w содержит [a-zA-Z_0-9], поэтому, если вы хотите разделить символом подчеркивания (_), также используйте

 String[] sa = s.split("[!,? ._'@]+");//for str2 after removing leading space

Очень простой пример ниже:

Надеюсь, поможет.

String str = "Hello I'm your String";
String[] splited = str.split(" ");
var splited = str.split(" ");
var splited1=splited[0]; //Hello
var splited2=splited[1]; //I'm
var splited3=splited[2]; //your
var splited4=splited[3]; //String

Вы можете использовать строку, используя приведенный ниже код

   String thisString="Hello world";

   String[] parts = theString.split(" ");

   String first = parts[0];//"hello"

    String second = parts[1];//"World"

Вот метод, чтобы обрезать строку, которая имеет "," или пробел

private String shorterName(String s){
        String[] sArr = s.split("\\,|\\s+");
        String output = sArr[0];

        return output;
    }

Прошло много времени с тех пор, как эти ответы были опубликованы, вот еще один более актуальный способ сделать то, что просили:

List<String> output = new ArrayList<>();
try (Scanner sc = new Scanner(inputString)) {
    while (sc.hasNext()) output.add(sc.next());
}

Теперь у вас есть список строк (который, возможно, лучше, чем массив); если вам нужен массив, вы можете сделатьoutput.toArray(new String[0]);

Не только пробел, но и мое решение также решает проблемы невидимых символов.

str = "Hello I'm your String";
String[] splited = str.split("\p{Z}");

Простая плевать строка на пробел

    String CurrentString = "First Second Last";
    String[] separated = CurrentString.split(" ");

    for (int i = 0; i < separated.length; i++) {

         if (i == 0) {
             Log.d("FName ** ", "" + separated[0].trim() + "\n ");
         } else if (i == 1) {
             Log.d("MName ** ", "" + separated[1].trim() + "\n ");
         } else if (i == 2) {
             Log.d("LName ** ", "" + separated[2].trim());
         }
     }