zerlegen - string splitten java




Wie man eine Zeichenkette in Java aufteilt (20)

Ich habe eine Zeichenfolge "004-034556" , die ich in zwei Strings aufteilen möchte:

string1=004
string2=034556

Das bedeutet, dass die erste Zeichenfolge die Zeichen vor '-' und die zweite Zeichenfolge die Zeichen nach '-' . Ich möchte auch überprüfen, ob die Zeichenfolge '-' . Wenn nicht, werde ich eine Ausnahme werfen. Wie kann ich das machen?



Aus der Dokumentation:

public String[] split(String regex,int limit) Teilt diese Zeichenfolge um Übereinstimmungen mit dem angegebenen regulären Ausdruck . Das Array, das von dieser Methode zurückgegeben wird, enthält jede Teilzeichenfolge dieser Zeichenfolge, die von einer anderen Teilzeichenfolge beendet wird, die mit dem angegebenen Ausdruck übereinstimmt oder am Ende der Zeichenfolge endet. Die Teilstrings im Array sind in der Reihenfolge angeordnet, in der sie in diesem String vorkommen. Wenn der Ausdruck keinem Teil der Eingabe entspricht, hat das resultierende Array nur ein Element , nämlich diese Zeichenfolge.

Grundsätzlich können Sie so etwas tun:

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

Ausgabe:

123
456
789
123

Die Anforderungen ließen Raum für Interpretationen. Ich empfehle eine Methode zu schreiben,

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

welche diese Funktion kapseln. Natürlich können Sie String.split (..) wie in den anderen Antworten für die Implementierung erwähnt verwenden.

Sie sollten einige Komponententests für Eingabezeichenfolgen und die gewünschten Ergebnisse und das Verhalten schreiben.

Gute Testkandidaten sollten beinhalten:

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

Mit der Definition der entsprechenden Testergebnisse können Sie das Verhalten festlegen.

Zum Beispiel, wenn "-333" in [,333] zurückkommt oder wenn es ein Fehler ist. Kann "333-333-33" in [333,333-33] or [333-333,33] oder ist es ein Fehler? Und so weiter.


Du kannst es auch so versuchen

 String concatenated_String="hi^Hello";

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

Eine Möglichkeit besteht darin, die Zeichenfolge in einer for-each-Schleife auszuführen und das erforderliche Teilzeichen zu verwenden.

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

Ausgabe:

The split parts of the String are:
004
034556

Für einfache Anwendungsfälle sollte String#split() die Aufgabe übernehmen. Wenn Sie Guava verwenden, gibt es auch eine Splitter Klasse, die das Verketten verschiedener String-Operationen ermöglicht und CharMatcher unterstützt:

Splitter.on('-')
       .trimResults()
       .omitEmptyStrings()
       .split(string);

Ich wollte nur einen Algorithmus schreiben anstatt Java eingebaute Funktionen zu verwenden:

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

Mit Java 8:

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

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

Sie können StringTokenizer einfach verwenden, um eine Zeichenfolge in zwei oder mehr Teile aufzuteilen, unabhängig davon, ob es Trennzeichen gibt:

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

Sie können eine Zeichenfolge durch einen Zeilenumbruch aufteilen, indem Sie die folgende Anweisung verwenden:

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

Sie können eine Zeichenfolge durch einen Bindestrich / ein Zeichen teilen, indem Sie die folgende Anweisung verwenden:

String textStr[] = yourString.split("-");

Verwenden org.apache.commons.lang.StringUtils' Split-Methode von org.apache.commons.lang.StringUtils' die Strings basierend auf dem Zeichen oder der Zeichenfolge teilen kann, die Sie teilen möchten.

Methodensignatur:

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

In Ihrem Fall möchten Sie einen String aufteilen, wenn ein "-" vorhanden ist.

Sie können einfach wie folgt vorgehen:

String str = "004-034556";

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

Ausgabe:

004
034556

Angenommen, dass in der Zeichenfolge nicht vorhanden ist, wird die angegebene Zeichenfolge zurückgegeben, und Sie erhalten keine Ausnahme.


Verwenden Sie String.split(regex) , um eine Zeichenfolge zu String.split(regex) :

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

Ausgabe:

004
034556

Verwenden Sie einfach die entsprechende Methode: String#split() .

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

Beachten Sie, dass dies einen regulären Ausdruck erfordert. Denken Sie daher daran, Sonderzeichen bei Bedarf zu entfernen.

Es gibt 12 Zeichen mit besonderen Bedeutungen: der Backslash \ , das Caret ^ , das Dollarzeichen $ , die Periode oder der Punkt . , das vertikale Balken- oder Rohrsymbol | , das Fragezeichen ? , das Sternchen oder Stern * , das Pluszeichen + , die öffnende Klammer ( , die schließende Klammer ) und die öffnende eckige Klammer [ , die öffnende geschweifte Klammer { , Diese Sonderzeichen werden oft als "Metazeichen" bezeichnet.

Also, wenn Sie zB nach Punkt / Punkt teilen wollen . was bedeutet, " jedes Zeichen " in Regex, verwenden Sie entweder umgekehrten Schrägstrich \ , um das individuelle Sonderzeichen wie folgt zu split("\\.") , oder verwenden Sie die Zeichenklasse [] , um Zeichen wie split("\\.") darzustellen split("[.]") oder verwenden Sie Pattern#quote() , um die gesamte Zeichenfolge wie split(Pattern.quote(".")) .

String[] parts = string.split(Pattern.quote(".")); // Split on period.

Um vorher zu testen, ob die Zeichenfolge bestimmte Zeichen enthält, verwenden Sie einfach String#contains() .

if (string.contains("-")) {
    // Split it.
} else {
    throw new IllegalArgumentException("String " + string + " does not contain -");
}

Beachten Sie, dass dies keinen regulären Ausdruck erfordert. Verwenden Sie stattdessen String#matches() .

Wenn Sie das Teilungszeichen in den resultierenden Teilen beibehalten möchten , verwenden Sie eine positive Vorschau . Wenn Sie möchten, dass das geteilte Zeichen auf der linken Seite endet, verwenden Sie positives Lookbehind, indem Sie dem Muster ?<= group voranstellen.

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

Wenn Sie möchten, dass das geteilte Zeichen auf der rechten Seite endet, verwenden Sie positives Lookahead, indem Sie dem Muster " ?= group" voranstellen.

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

Wenn Sie die Anzahl der resultierenden Teile einschränken möchten, können Sie die gewünschte Zahl als zweites Argument der Methode split() angeben.

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

Vorausgesetzt, dass

  • Sie brauchen keine regulären Ausdrücke für Ihren Split
  • Sie verwenden Apache Commons lang bereits in Ihrer App

Der einfachste Weg ist die Verwendung von StringUtils # split (java.lang.String, char) . Das ist bequemer als das von Java bereitgestellte, wenn Sie keine regulären Ausdrücke benötigen. Wie sein Handbuch sagt, funktioniert es so:

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

Ich würde empfehlen, commong-lang zu verwenden, da es normalerweise viele nützliche Dinge enthält. Wenn Sie es jedoch für nichts anderes als eine Aufteilung benötigen, ist es besser, sich selbst zu implementieren oder die Regex zu umgehen.


String Split mit mehreren Zeichen mit 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]);
        }
     }
  }

Ausgabe:

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

Erwarten Sie jedoch nicht die gleiche Ausgabe für alle JDK-Versionen. Ich habe einen Fehler gesehen, der in einigen JDK-Versionen existiert, in denen der erste Null-String ignoriert wurde. Dieser Fehler ist in der neuesten JDK-Version nicht vorhanden, aber in einigen Versionen zwischen späten JDK 1.7-Versionen und frühen 1.8-Versionen ist dieser Fehler vorhanden.


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

Wenn Sie ein Sonderzeichen haben, können Sie Patter.quote verwenden. Wenn Sie einfach Bindestrich (-) haben, können Sie den Code verkürzen:

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

Wenn Sie versuchen, ein anderes Sonderzeichen anstelle von Bindestrich (^) hinzuzufügen, generiert der Fehler ArrayIndexOutOfBoundsException . Dafür musst du Pattern.quote .


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

Wie von allen erwähnt, ist split () die beste Option, die in Ihrem Fall verwendet werden kann. Eine alternative Methode kann substring () verwenden.


String str="004-034556"
String[] sTemp=str.split("-");// '-' is a delimiter

string1=004 // sTemp[0];
string2=034556//sTemp[1];

String[] result = yourString.split("-");
if (result.length != 2) 
     throw new IllegalArgumentException("String not in correct format");

Dies teilt Ihre Saite in 2 Teile. Das erste Element im Array ist der Teil, der den Inhalt vor dem - , und das zweite Element im Array enthält den Teil des Strings nach dem - .

Wenn die Array-Länge nicht 2 ist, dann hatte die Zeichenfolge nicht das Format string-string .

Überprüfen Sie die split() -Methode in der String Klasse.

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


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