Jak podzielić ciąg znaków w Javie

Alternatywą dla bezpośredniego przetwarzania ciągu znaków byłoby użycie wyrażenia regularnego z przechwytywaniem grup. Ma to tę zaletę, że ułatwia sugerowanie bardziej wyrafinowanych ograniczeń na wejściu. Na przykład poniższy tekst dzieli łańcuch na dwie części i zapewnia, że obie składają się tylko z cyfr:

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");
    }
}

Ponieważ wzorzec jest stały w tym przypadku, może być wcześniej skompilowany i zapisany jako statyczny element (zainicjowany w czasie ładowania klasy w przykład). Wyrażenie regularne to:

(\d+)-(\d+)

Nawiasy oznaczają grupy przechwytywania; łańcuch, który pasował do tej części wyrażenia regularnego, może być dostępny przez dopasowanie.metoda group (), jak pokazano. \D dopasowuje i pojedynczą cyfrę dziesiętną, a + oznacza " dopasuj jedno lub więcej z poprzedniego wyrażenia). - Nie ma specjalnego znaczenia, więc po prostu pasuje do tego znaku na wejściu. Zauważ, że podczas pisania tego jako ciągu Java musisz dwukrotnie unikać ukośników wstecznych. Inne przykłady:

([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");

To podzieli Twój łańcuch na 2 części. Pierwszy element tablicy będzie częścią zawierającą rzeczy przed -, a drugi element tablicy będzie zawierał część twojego ciągu znaków po -.

Jeżeli długość tablicy nie jest równa 2, wtedy łańcuch nie był w formacie: string-string.

Sprawdź metodę split() w klasie 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("-");

Wymagania pozostawiły miejsce na interpretację. Polecam napisanie metody,

public final static String[] mySplit(final String s)

Który enkapsuluje tę funkcję. Oczywiście możesz użyć sznurka.split(..), jak wspomniano w innych odpowiedziach dotyczących realizacji.

Powinieneś napisać kilka testów jednostkowych dla ciągów wejściowych oraz pożądanych wyników i zachowania.

Dobrymi kandydatami do testów powinny być:

 - "0022-3333"
 - "-"
 - "5555-"
 - "-333"
 - "3344-"
 - "--"
 - ""
 - "553535"
 - "333-333-33"
 - "222--222"
 - "222--"
 - "--4555"

Poprzez zdefiniowanie wyników testu można określić zachowanie.

Na przykład, jeśli "-333" powinien powrócić w [,333] lub jeśli jest to błąd. Czy {[4] } można rozdzielić na [333,333-33] or [333-333,33] czy jest to błąd? I tak dalej.

Możesz spróbować również tak

 String concatenated_String="hi^Hello";

 String split_string_array[]=concatenated_String.split("\\^");

Zakładając, że

• naprawdę nie potrzebujesz wyrażeń regularnych do podziału
• zdarza Ci się już używać Apache commons lang w swojej aplikacji

Najprostszym sposobem jest użycie StringUtils#split (java.lang.String, char) . Jest to wygodniejsze niż to dostarczane przez Javę po wyjęciu z pudełka, jeśli nie potrzebujesz wyrażeń regularnych. Jak mówi instrukcja, działa tak:

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"]

Polecam użycie commong-lang, ponieważ zazwyczaj zawiera wiele rzeczy, które są użyteczne. Jeśli jednak nie potrzebujesz go do niczego innego niż robienie Splitu, implementacja siebie lub unikanie wyrażeń regularnych jest lepszą opcją.

Użyj org.Apacz.commons.lang.StringUtils ' split metoda, która może podzielić ciągi znaków na podstawie znaku lub Ciągu, który chcesz podzielić.

Podpis metody:

public static String[] split(String str, char separatorChar);

W Twoim przypadku, chcesz podzielić łańcuch, gdy jest" -".

Możesz po prostu wykonać następujące czynności:

String str = "004-034556";

String split[] = StringUtils.split(str,"-");

Wyjście:

004
034556

Załóżmy, że jeśli - nie istnieje w Twoim łańcuchu, zwróci on podany łańcuch i nie otrzymasz żadnego wyjątku.

Z Java 8:

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

    stringList.forEach(s -> System.out.println(s));

Podział łańcuchów z wieloma znakami za pomocą 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]);
        }
     }
  }

Wyjście:

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

Ale nie oczekuj tego samego wyjścia we wszystkich wersjach JDK. Widziałem jeden błąd , który istnieje w niektórych wersjach JDK, gdzie pierwszy łańcuch null został zignorowany. Ten błąd nie występuje w najnowszej wersji JDK, ale występuje w niektórych wersjach między późnymi wersjami JDK 1.7 i wczesnymi wersjami 1.8.

Dla prostych przypadków użyciaString.split() powinno się udać. Jeśli używasz guava, istnieje również Klasa Splitter , która pozwala na łączenie różnych operacji łańcuchowych i obsługuje 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);
    }
}

Najszybszym sposobem, który również zużywa najmniej zasobów może być:

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 '-'
}

Możesz podzielić ciąg znaków przez podział linii, używając następującej instrukcji:

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

Możesz podzielić łańcuch za pomocą myślnika / znaku za pomocą następującej instrukcji:

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]);
    }
  }
}

Jednym ze sposobów na to jest uruchomienie łańcucha w pętli for-each i użycie wymaganego znaku split.

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);
    }
}

Wyjście:

The split parts of the String are:
004
034556

Proszę nie używać klasyStringTokenizer , ponieważ jest to klasa dziedziczona, która jest zachowana ze względu na kompatybilność, a jej użycie nie jest zalecane w nowym kodzie. Możemy również skorzystać z metody podziału, jak sugerują inni.

String[] sampleTokens = "004-034556".split("-");
System.out.println(Arrays.toString(sampleTokens));

I zgodnie z oczekiwaniami wydrukuje:

[004, 034556]

W tej odpowiedzi chcę również zwrócić uwagę na jedną zmianę, która zaszła dla split metody w Javie 8. Metoda String#split () używa Pattern.split, a teraz usunie puste łańcuchy na początku tablicy wyników. Zwróć uwagę na tę zmianę w dokumentacji dla Java 8:

Gdy na początku wejścia jest dopasowanie o dodatniej szerokości Sekwencja wtedy na początku zostanie dołączony pusty podłańcuch wiodący wynikowej tablicy. Mecz o zerową szerokość na początku jednak nigdy nie tworzy takiego pustego podciągu wiodącego.

Oznacza to dla następującego przykładu:

String[] sampleTokensAgain = "004".split("");
System.out.println(Arrays.toString(sampleTokensAgain));

Otrzymamy trzy ciągi: [0, 0, 4] i nie cztery, Jak to było w Javie 7 i wcześniej. Sprawdź również to podobne pytanie .

Możesz użyć 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];
    }
}

W przeciwnym razie możesz użyć 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("-");
    }
}

Oto dwa sposoby osiągnięcia tego.

Sposób 1: ponieważ musisz podzielić dwie liczby znakiem specjalnym, możesz użyć 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());
        }
    }
}

Sposób 2: Użycie metody podziału łańcuchów

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);
        }
    }
}

Możesz po prostu użyć StringTokenizer, aby podzielić łańcuch na dwie lub więcej części, niezależnie od tego, czy istnieją jakiekolwiek ograniczniki:

StringTokenizer st = new StringTokenizer("004-034556", "-");
while(st.hasMoreTokens())
{
    System.out.println(st.nextToken());
}

Podsumowując: istnieje co najmniej pięć sposobów na podzielenie ciągu znaków w Javie:

1. String.split ():

   String[] parts ="10,20".split(",");
   

2. Wzór.compile (regexp).splitAsStream (input):

   List<String> strings = Pattern.compile("\\|")
         .splitAsStream("010|020202")
         .collect(Collectors.toList());
   

3. StringTokenizer (Klasa legacy):

   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", ",");
   

Więc możesz wybrać najlepszą dla siebie opcję w zależności od tego, czego potrzebujesz, np. typ powrotu (tablica, lista, lub iterowalne).

Tutaj {[33] } jest duży przegląd tych metod i najczęstszych przykładów (jak podzielić przez kropkę, ukośnik, znak zapytania, itp.)

Sprawdź metodę split() w klasie String w 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++;
}

Tutaj wiele przykładów podzielonego ciągu, ale trochę zoptymalizowałem kod.

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));
    }
}

Jak wszyscy wspominają, split() jest najlepszą opcją, która może być użyta w Twoim przypadku. Alternatywną metodą może być metoda substring ().

Aby podzielić łańcuch, użyj String.split(regex):

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

Wyjście:

004
034556

Chciałem napisać algorytm zamiast używać wbudowanych funkcji Javy:

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;
}

Aby podzielić łańcuch, używa String.split (regex). Przejrzyj następujące przykłady:

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

Wyjście

004
034556

Uwaga Ten podział (regex) przyjmuje regex jako argument, pamiętaj o unikaniu znaków specjalnych regex, takich jak kropka/kropka.

Z dokumentacji:

public String[] split(String regex,int limit) dzieli ten łańcuch wokół dopasowania podanego wyrażenia regularnego. Tablica zwracana tą metodą zawiera każdy substring tego łańcucha, który jest zakończony innym substring, który pasuje do podanego wyrażenia lub jest zakończony końcem sznurek. Podłańcuchy w tablicy są w zamówienie w którym występuje w tym łańcuchu. Jeśli wyrażenie nie pasuje każda część input then wynikowa tablica ma tylko jeden element, mianowicie to sznurek.

W zasadzie można zrobić coś takiego:

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);
}

Wyjście:

123
456
789
123

 String string = "004^034556-34";
 String[] parts = string.split(Pattern.quote("^"));

Jeśli masz znak specjalny, możesz użyć Patter.cytat. Jeśli po prostu masz dash ( - ) to możesz skrócić kod:

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

Jeśli spróbujesz dodać inny znak specjalny w miejsce kreski (^) Następnie błąd wygeneruje ArrayIndexOutOfBoundsException . Do tego musisz użyć Pattern.quote.