So teilen Sie eine Zeichenfolge in Java

1640

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?

Riyana
quelle

Antworten:

2933

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
BalusC
quelle
27
Warum verwenden Sie Hash-Symbole, um die Methoden von String abzugrenzen?
Crowie
94
@ Crowie: Javadoc-Stil.
BalusC
9
Eckfall: Wenn es nicht gefunden werden kann, reugalr expressionwird ein Elementarray mit ganzer Zeichenfolge zurückgegeben.
klimat
2
Ich kann nicht glauben, dass die am meisten gewählte Version so ist. 1) Teil2 ist nicht das, was das Poster will, wenn die ursprüngliche Zeichenfolge zwei "-" enthält. 2) Keine Fehlerbehandlung, wie in der Frage erwähnt. 3) Geringe Effizienz. Eine Suche nach einzelnen Zeichen erfordert die Konstruktion und den Abgleich regulärer Ausdrücke. Zusätzliches Array erstellt usw.
David
1
@ David: 1) Das wird in der Frage nicht behandelt. 2) Es werden keine Ausnahmen ausgelöst. 3) OP fragt, wie geteilt werden soll, nicht wie Teilzeichenfolgen. 4)
Machen
79

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
Rob Hague
quelle
Dies ist eine großartige Lösung, jedoch sollte der erste Teil m.group(1)der zweite Teil sein m.group(2), da m.group(0)tatsächlich das vollständige Übereinstimmungsmuster zurückgegeben wird. Ich denke, ich erinnere mich auch daran group(0), dass früher das erste Match statt des vollständigen Musters war. Vielleicht hat sich dies in einem kürzlich durchgeführten Update der Java-Version geändert.
ptstone
1
Vielen Dank. Wenn Sie sich docs.oracle.com/javase/7/docs/api/java/util/regex/… ansehen, haben Sie Recht - wie bei den meisten anderen Regexp-Bibliotheken ist Gruppe 0 die vollständige Übereinstimmung, und die erfassten Gruppen beginnen bei 1. Wie Sie sagen, vermute ich, dass sich dies geändert hat, seit ich die Antwort ursprünglich geschrieben habe, aber ich werde sie auf jeden Fall aktualisieren, um das aktuelle Verhalten widerzuspiegeln.
Rob Hague
42
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-

jjnguy
quelle
5
Dies akzeptiert "-555" als Eingabe und gibt [, 555] zurück. Die Anforderungen sind nicht so klar definiert, ob es gültig wäre, dies zu akzeptieren. Ich empfehle, einige Unit-Tests zu schreiben, um das gewünschte Verhalten zu definieren.
Michael Konietzka
Wahrscheinlich am sichersten zu ändern (result.length! = 2) in (result.length <2)
Onkel Iroh
29
String[] out = string.split("-");

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

secmask
quelle
29
// 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]);
}
Mnyikka
quelle
60
In JavaDoc heißt es eindeutig: "Es StringTokenizerhandelt sich um eine Legacy-Klasse, die aus Kompatibilitätsgründen beibehalten wird, obwohl von ihrer Verwendung in neuem Code abgeraten wird . Es wird empfohlen, dass jeder, der diese Funktionalität sucht , stattdessen die splitMethode Stringoder das java.util.regexPaket verwendet."
Bvdb
23

Mit Java 8:

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

    stringList.forEach(s -> System.out.println(s));
Somaiah Kumbera
quelle
2
Wenn Sie Leerzeichen entfernen möchten, fügen Sie .map(String::trim)nach demsplit
Roland
18

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.

Michael Konietzka
quelle
4
Nützliche Ratschläge, aber eigentlich keine Antwort auf die Frage. Wenn Sie eine andere Antwort mit Details unterstützen, wird ein Kommentar bevorzugt.
Chris Mountford
Verwenden Sie: split (String regex, int limit) und NOT split (String regex) als Referenz unter geeksforgeeks.org/split-string-java-examples
Ryan Augustine
16

Sie können dies auch versuchen

 String concatenated_String="hi^Hello";

 String split_string_array[]=concatenated_String.split("\\^");
SHUNMUGA RAJ PRABAKARAN
quelle
16

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.

eis
quelle
15

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.

Sandeep Vanama
quelle
14

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.).

Dmytro Shvechikov
quelle
13

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 '-'
}
David
quelle
6
Die knappste Ressource ist oft die Zeit und Aufmerksamkeit des Programmierers. Dieser Code verbraucht mehr von dieser Ressource als Alternativen.
Chris Mountford
Sie haben eine Menge eingebauter Ressourcen, die Sie verwenden können, wo die Leistung wirklich berücksichtigt wird, fehlt dieser Lösung die Zeit für die Ausführung der Leistung
J Sanchez
1
Dies ist nicht komplexer als die Regex-Version, um eine einfache Aufteilung auf ein einzelnes Zeichen mit Fehlerprüfung durchzuführen.
TekHedd
Bravo! Endlich eine Antwort auf diese Frage, die keinen regulären Ausdruck verwendet! Die Verwendung eines regulären Ausdrucks für diese einfache Aufgabe ist eher ein Headscratcher. Gut zu sehen, dass es noch gesunde Programmierer auf dieser Erde gibt :-)
Gabriel Magana
Es gibt nur ein "-", eine Ausnahme ist erwünscht und das Ergebnis sollte zu string1 und string2 gehen. Mach string1 = s.substring(0, s.indexOf("-")); string2 = s.substring(s.indexOf("-") + 1);daraus. Sie erhalten das StringIndexOutOfBoundsExceptionautomatisch, wenn es kein "-" gab.
Kaplan
13

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.

Ravindra Babu
quelle
13

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);
Vitalii Fedorenko
quelle
10
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);
    }
}
Akhilesh Dhar Dubey
quelle
9

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("-");
RajeshVijayakumar
quelle
9
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]);
    }
  }
}
Ravi Pandey
quelle
4
Wenn ich Ratschläge teilen darf, wie bringt Ihre Antwort mehr Wert als die bereits akzeptierte Lösung? stackoverflow.com/a/3481842/420096 In solchen Situationen können Sie über die vorhandene Lösung abstimmen, insbesondere wenn dies ein klarer Trivialfall wie dieser ist.
Sombriks
8

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("-");
    }
}
Sarat Chandra
quelle
8

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.

rghome
quelle
7

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
Keshav Pradeep Ramanath
quelle
7

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 .

akhil_mittal
quelle
7

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);
        }
    }
}
Akshay Gaikwad
quelle
6

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());
}
Rohit-Pandey
quelle
4

Ü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.

Divyesh Kanzariya
quelle
Ersetzen -durch |und sehen, was passiert :)
R So
In diesem Fall überprüfen Sie stackoverflow.com/questions/10796160/…
R So
4
String str="004-034556"
String[] sTemp=str.split("-");// '-' is a delimiter

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

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;
}
Keiner
quelle
1

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 \"-\".");
        }
    }
}
Jamith
quelle
1

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.

KIBOU Hassan
quelle
0
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.

SAM Jr.
quelle
0

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
KIBOU Hassan
quelle