So teilen Sie eine Zeichenfolge in Java

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

string1="004";
string2="034556";

Das heißt, die erste Zeichenfolge enthält die Zeichen vor '-'und die zweite Zeichenfolge enthält die Zeichen nach '-'. Ich möchte auch überprüfen, ob die Zeichenfolge enthalten ist '-'. Wenn nicht, werde ich eine Ausnahme auslösen. Wie kann ich das machen?

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 ein regulärer Ausdruck ist. Denken Sie daher daran, bei Bedarf Sonderzeichen zu maskieren.

Es gibt 12 Zeichen mit besonderen Bedeutungen: den Backslash \, das Caret ^, das Dollarzeichen $, den Punkt oder Punkt ., den vertikalen Balken oder das Rohrsymbol |, das Fragezeichen ?, das Sternchen oder den 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.

Wenn Sie also z. B. Punkt / Punkt teilen möchten, .was " beliebiges Zeichen " in Regex bedeutet, verwenden Sie entweder einen umgekehrten Schrägstrich\ , um das einzelne Sonderzeichen so zu umgehen split("\\."), oder verwenden Sie die Zeichenklasse[] , um Literalzeichen wie diese darzustellen split("[.]"), oder verwenden Sie Pattern#quote()to entkomme der ganzen Schnur so 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 dazu String#matches()stattdessen.

Wenn Sie das geteilte Zeichen in den resultierenden Teilen beibehalten möchten , verwenden Sie einen positiven Lookaround . Wenn Sie möchten, dass das geteilte Zeichen auf der linken Seite landet, verwenden Sie ein positives Lookbehind, indem Sie ?<=dem Muster eine Gruppe 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 landet, verwenden Sie einen positiven Lookahead, indem Sie ?=dem Muster eine Gruppe 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 begrenzen möchten, können Sie die gewünschte Anzahl als zweites Argument der split()Methode angeben.

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

Eine Alternative zur direkten Verarbeitung der Zeichenfolge wäre die Verwendung eines regulären Ausdrucks mit Erfassungsgruppen. Dies hat den Vorteil, dass es einfacher ist, komplexere Einschränkungen für die Eingabe zu implizieren. Im Folgenden wird beispielsweise die Zeichenfolge in zwei Teile aufgeteilt und sichergestellt, dass beide nur aus Ziffern bestehen:

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

Da das Muster in diesem Fall festgelegt ist, kann es im Voraus kompiliert und als statisches Element gespeichert werden (im Beispiel zum Laden der Klasse initialisiert). Der reguläre Ausdruck lautet:

(\d+)-(\d+)

Die Klammern kennzeichnen die Erfassungsgruppen. Auf die Zeichenfolge, die mit diesem Teil des regulären Ausdrucks übereinstimmt, kann wie gezeigt mit der Match.group () -Methode zugegriffen werden. Das \ d stimmt mit einer einzelnen Dezimalstelle überein, und das + bedeutet "mit einem oder mehreren der vorherigen Ausdrücke übereinstimmen". Das - hat keine besondere Bedeutung, stimmt also nur mit diesem Zeichen in der Eingabe überein. Beachten Sie, dass Sie die Backslashes doppelt maskieren müssen Wenn Sie dies als Java-Zeichenfolge schreiben. Einige andere Beispiele:

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

Dadurch wird Ihre Saite in zwei Teile geteilt. Das erste Element im Array ist der Teil, der das Material vor dem enthält -, und das zweite Element im Array enthält den Teil Ihres Strings nach dem -.

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

Überprüfen Sie die split()Methode in der StringKlasse.

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

String[] out = string.split("-");

sollte tun, was du willst. Die String-Klasse verfügt über viele Methoden zum Arbeiten mit String.

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

Mit Java 8:

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

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

Die Anforderungen ließen Interpretationsspielraum. Ich empfehle eine Methode zu schreiben,

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

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

Sie sollten einige Unit-Tests für Eingabezeichenfolgen und die gewünschten Ergebnisse und Verhaltensweisen schreiben.

Gute Testkandidaten sollten Folgendes umfassen:

 - "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 zurückgegeben werden "-333"soll [,333]oder wenn es sich um einen Fehler handelt. Kann "333-333-33"getrennt werden [333,333-33] or [333-333,33]oder ist es ein Fehler? Und so weiter.

Sie können dies auch versuchen

 String concatenated_String="hi^Hello";

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

Vorausgesetzt, dass

• Sie brauchen keine regulären Ausdrücke für Ihre Trennung
• Sie verwenden Apache Commons Lang bereits in Ihrer App

Am einfachsten ist es, StringUtils # split (java.lang.String, char) zu verwenden . Dies ist praktischer als die von Java sofort bereitgestellte, wenn Sie keine regulären Ausdrücke benötigen. Wie das Handbuch sagt, funktioniert es folgendermaßen:

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 Dinge enthält, die verwendet werden können. Wenn Sie es jedoch nur für einen Split benötigen, ist es besser, sich selbst zu implementieren oder dem regulären Ausdruck zu entkommen.

Verwenden Sie die Split-Methode von org.apache.commons.lang.StringUtils, mit der Zeichenfolgen basierend auf dem Zeichen oder der Zeichenfolge, die Sie teilen möchten, aufgeteilt werden können.

Methodensignatur:

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

In Ihrem Fall möchten Sie eine Zeichenfolge teilen, wenn ein "-" vorhanden ist.

Sie können einfach wie folgt vorgehen:

String str = "004-034556";

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

Ausgabe:

004
034556

Angenommen, wenn -in Ihrer Zeichenfolge keine vorhanden ist, wird die angegebene Zeichenfolge zurückgegeben, und Sie erhalten keine Ausnahme.

Zusammenfassend: Es gibt mindestens fünf Möglichkeiten, eine Zeichenfolge in Java zu teilen:

1. String.split ():

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

2. Pattern.compile (regulärer Ausdruck) .splitAsStream (Eingabe):

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

3. StringTokenizer (Legacy-Klasse):

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

So können Sie die für Sie beste Option auswählen, je nachdem, was Sie benötigen, z. B. den Rückgabetyp (Array, Liste oder iterierbar).

Hier finden Sie eine große Übersicht über diese Methoden und die häufigsten Beispiele (Aufteilen nach Punkten, Schrägstrichen, Fragezeichen usw.).

Der schnellste Weg, der auch die geringste Ressource verbraucht, könnte sein:

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 Mit Regex mit mehreren Zeichen teilen

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 für alle JDK-Versionen dieselbe Ausgabe. Ich habe einen Fehler gesehen, der in einigen JDK-Versionen vorhanden ist, in denen die erste Nullzeichenfolge ignoriert wurde. Dieser Fehler ist in der neuesten JDK-Version nicht vorhanden, tritt jedoch in einigen Versionen zwischen späten JDK 1.7-Versionen und frühen 1.8-Versionen auf.

Für einfache Anwendungsfälle String.split()sollte die Arbeit erledigen. Wenn Sie Guave verwenden, gibt es auch eine Splitter- Klasse, die die Verkettung verschiedener Zeichenfolgenoperationen ermöglicht und CharMatcher unterstützt :

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

Mit der folgenden Anweisung können Sie eine Zeichenfolge durch einen Zeilenumbruch teilen:

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

Mit der folgenden Anweisung können Sie eine Zeichenfolge durch einen Bindestrich / ein Zeichen teilen:

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

Sie können Split () verwenden:

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

Andernfalls können Sie StringTokenizer verwenden:

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

Es gibt nur zwei Methoden, die Sie wirklich berücksichtigen müssen.

Verwenden Sie String.split für ein einstelliges Trennzeichen, oder Sie interessieren sich nicht für die Leistung

Wenn die Leistung kein Problem darstellt oder wenn das Trennzeichen ein einzelnes Zeichen ist, das kein Sonderzeichen für reguläre Ausdrücke ist (dh keines von .$|()[{^?*+\), können Sie es verwenden String.split.

String[] results = input.split(",");

Die Split-Methode verfügt über eine Optimierung, um die Verwendung eines regulären Ausdrucks zu vermeiden, wenn das Delimeter ein einzelnes Zeichen ist und nicht in der obigen Liste enthalten ist. Andernfalls muss ein regulärer Ausdruck kompiliert werden, was nicht ideal ist.

Verwenden Sie Pattern.split und kompilieren Sie das Muster vor, wenn Sie ein komplexes Trennzeichen verwenden und die Leistung wichtig ist.

Wenn die Leistung ein Problem darstellt und Ihr Trennzeichen nicht eines der oben genannten ist, sollten Sie ein Muster für reguläre Ausdrücke vorkompilieren, das Sie dann wiederverwenden können.

// Save this somewhere
Pattern pattern = Pattern.compile("[,;:]");

/// ... later
String[] results = pattern.split(input);

Diese letzte Option erstellt immer noch ein neues MatcherObjekt. Sie können dieses Objekt auch zwischenspeichern und für jede Eingabe zurücksetzen, um maximale Leistung zu erzielen. Dies ist jedoch etwas komplizierter und nicht threadsicher.

Eine Möglichkeit, dies zu tun, besteht darin, den String in einer for-each-Schleife zu durchlaufen und das erforderliche geteilte Zeichen 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

Bitte verwenden Sie keine StringTokenizer- Klasse, da es sich um eine Legacy-Klasse handelt, die aus Kompatibilitätsgründen beibehalten wird und deren Verwendung in neuem Code nicht empfohlen wird. Und wir können auch die von anderen vorgeschlagene Split-Methode verwenden.

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

Und wie erwartet wird es gedruckt:

[004, 034556]

In dieser Antwort möchte ich auch auf eine Änderungsplit hinweisen, die für die Methode in Java 8 vorgenommen wurde . Die String # split () -Methode verwendet Pattern.splitund entfernt jetzt leere Strings am Anfang des Ergebnisarrays. Beachten Sie diese Änderung in der Dokumentation für Java 8:

Wenn zu Beginn der Eingabesequenz eine Übereinstimmung mit positiver Breite vorliegt, wird am Anfang des resultierenden Arrays eine leere führende Teilzeichenfolge eingefügt. Eine Übereinstimmung mit der Breite Null am Anfang erzeugt jedoch niemals einen solchen leeren führenden Teilstring.

Dies bedeutet für das folgende Beispiel:

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

Wir werden drei Zeichenfolgen erhalten: [0, 0, 4]und nicht vier, wie dies in Java 7 und früher der Fall war. Überprüfen Sie auch diese ähnliche Frage .

Hier sind zwei Möglichkeiten, wie zwei es erreichen können.

WEG 1: Da Sie zwei Zahlen durch ein Sonderzeichen teilen müssen, können Sie Regex verwenden

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

WEG 2: Verwenden der String-Split-Methode

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

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

Überprüfen Sie die split()Methode in der StringKlasse auf 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++;
}

Hier viele Beispiele für geteilte Zeichenfolgen, aber ich habe wenig Code optimiert.

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

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

Ich wollte nur einen Algorithmus schreiben, anstatt die in Java integrierten 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;
}

Sie können die Methode verwenden 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 \"-\".");
        }
    }
}

Verwenden Sie zum Teilen eines Strings String.split (Regex). Überprüfen Sie die folgenden Beispiele:

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

Ausgabe

004
034556

Hinweis:

Diese Aufteilung (Regex) verwendet einen Regex als Argument. Denken Sie daran, die Regex-Sonderzeichen wie Punkt / Punkt zu umgehen.

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 die Verwendung von Teilzeichenfolgen () sein.

Verwenden Sie zum Teilen einer Zeichenfolge String.split(regex):

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

Ausgabe:

004
034556