Frage Wie man eine Zeichenkette in Java aufteilt


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

string1=004
string2=034556

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


1278
2017-08-14 03:01


Ursprung


Antworten:


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 a regulären AusdruckAlso vergiss nicht zu entkommen spezielle Charaktere Falls benötigt.

Dort sind 12 Zeichen mit besonderen Bedeutungen: der Backslash \der Schottisch ^, das Dollarzeichen $, die Periode oder der Punkt ., das vertikale Balken- oder Rohrsymbol |das Fragezeichen ?, der Stern 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.

Wenn Sie also z.B. Punkt / Punkt . was bedeutet "irgendein Zeichen"In Regex, benutze entweder umgekehrter Schrägstrich \ so dem individuellen Sondercharakter zu entgehen split("\\.")oder verwenden Zeichenklasse [] um wörtliche Zeichen so darzustellen split("[.]")oder verwenden Pattern#quote() so wie die ganze Saite zu entkommen 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. Dafür verwenden Sie String#matches() stattdessen.

Wenn Sie das Teilungszeichen in den resultierenden Teilen beibehalten möchten, verwenden Sie es positiver Rückblick. Wenn Sie möchten, dass das geteilte Zeichen auf der linken Seite endet, verwenden Sie positives Lookbehind durch Voranstellen ?<= Gruppe auf dem Muster.

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 Vorschauen durch Voranstellen ?= Gruppe auf dem Muster.

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 Nummer als zweites Argument von angeben split() Methode.

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

2349
2017-08-14 03:05



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. Das folgende Beispiel teilt die Zeichenfolge in zwei Teile und stellt sicher, 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 zur Klassenladezeit initialisiert). Der reguläre Ausdruck ist:

(\d+)-(\d+)

Die Klammern bezeichnen die einfangenden Gruppen; Auf die Zeichenfolge, die mit diesem Teil der Regexp übereinstimmt, kann wie in der Methode Match.group () gezeigt zugegriffen werden. Die \ d stimmt mit einer einzelnen Dezimalziffer überein, und das + bedeutet "Übereinstimmung mit einem oder mehreren der vorherigen Ausdrücke. Das - hat keine spezielle Bedeutung, sondern passt nur auf dieses Zeichen in der Eingabe. Beachten Sie, dass Sie die umgekehrten Schrägstriche doppelklicken müssen wenn Sie dies als Java-String 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

68
2017-08-14 11:28



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 das Zeug vor dem -, und das zweite Element im Array enthält den Teil der Zeichenfolge nach dem -.

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

Besuche die split() Methode in der String Klasse.

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


39
2017-08-14 03:06



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

26
2017-11-16 06:30



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

sollte tun, was du willst. String-Klasse hat viele Methoden, um mit String zu arbeiten.


23
2017-08-14 03:06



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" sollte zurückkommen [,333] oder wenn es ein Fehler ist. Kann "333-333-33" in getrennt sein [333,333-33] or [333-333,33] oder ist es ein Fehler? Und so weiter.


17
2017-08-14 06:57



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 zu verwenden 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.


15
2018-03-25 06:43



Benutzen org.apache.commons.lang.StringUtils ' Split-Methode, 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, wenn - in Ihrem String nicht vorhanden ist, gibt es den angegebenen String zurück, und Sie erhalten keine Ausnahme.


15
2017-07-01 04:35



Du kannst es auch so versuchen

 String concatenated_String="hi^Hello";

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

14
2018-01-15 09:58



Mit Java 8:

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

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

14
2017-12-01 09:32