it-swarm.com.de

So teilen Sie einen String in Java

Ich habe einen String, "004-034556", den ich in zwei Strings aufteilen möchte:

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

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

1408
riyana

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

dort sind 12 Zeichen mit speziellen Bedeutungen: der umgekehrte Schrägstrich \, der Caret ^, der Dollarzeichen $, der Punkt oder Punkt ., das vertikale Balken- oder Pipe-Symbol |, das Fragezeichen ?, das Sternchen oder der 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. Punkt/Punkt . Das bedeutet " ein beliebiges Zeichen " in regex. Verwenden Sie entweder backslash \ , um das individuelle Sonderzeichen wie split("\\.") zu entgehen, oder verwenden Sie Zeichenklasse [] , um das Literalzeichen (s ) wie split("[.]") oder verwenden Sie Pattern#quote() , um die gesamte Zeichenfolge wie split(Pattern.quote(".")) zu entgehen.

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

Um 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 hierfür stattdessen String#matches() .

Wenn Sie den Split-Charakter in den resultierenden Teilen beibehalten möchten, verwenden Sie positive Lookaround . Wenn Sie möchten, dass das Split-Zeichen auf der linken Seite endet, verwenden Sie einen positiven Look, 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 Split-Zeichen auf der rechten Seite endet, verwenden Sie das positive 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 2. 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
2548
BalusC

Eine Alternative zur direkten Verarbeitung der Zeichenfolge wäre die Verwendung eines regulären Ausdrucks mit Erfassungsgruppen. Dies hat den Vorteil, dass es unkomplizierter ist, die Eingabe komplexer zu gestalten. 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 vorab kompiliert und als statisches Element gespeichert werden (im Beispiel zum Klassenladezeitpunkt initialisiert). Der reguläre Ausdruck lautet:

(\d+)-(\d+)

Die Klammern bezeichnen die Erfassungsgruppen. Auf die Zeichenfolge, die diesem Teil des regulären Ausdrucks entspricht, kann wie gezeigt mit der Match.group () -Methode zugegriffen werden. Die\d-Übereinstimmungen und die einzelnen Dezimalstellen, und das + bedeutet "entspricht einem oder mehreren der vorherigen Ausdrücke. Der - hat keine besondere Bedeutung, entspricht also nur diesem Zeichen in der Eingabe. Beachten Sie, dass Sie die Backslashes doppelt zwischenspeichern 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
70
Rob Hague
String[] result = yourString.split("-");
if (result.length != 2) 
     throw new IllegalArgumentException("String not in correct format");

Dadurch wird Ihre Saite in 2 Teile aufgeteilt. Das erste Element im Array ist der Teil, der das Zeug vor dem - enthält, und das 2. Element im Array enthält den Teil Ihrer Zeichenfolge nach dem -.

Wenn die Arraylänge nicht 2 ist, hat 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-

40
jjnguy
// 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]);
}
27
Mnyikka
String[] out = string.split("-");

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

24
secmask

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

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

welche diese Funktion einkapseln. 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 die Eingabezeichenfolgen sowie die gewünschten Ergebnisse und das gewünschte Verhalten schreiben.

Gute Testkandidaten sollten 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.

Wenn zum Beispiel "-333" in [,333] zurückgegeben werden soll oder wenn es ein Fehler ist . Kann "333-333-33" in [333,333-33] or [333-333,33] getrennt werden, oder ist es ein Fehler? Und so weiter.

18

Mit Java 8:

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

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

Verwenden Sie die org.Apache.commons.lang.StringUtils-Methode split, mit der Zeichenfolgen nach dem Zeichen oder der Zeichenfolge aufgeteilt werden können, die Sie teilen möchten.

Methodensignatur: 

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

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

Sie können einfach wie folgt vorgehen:

String str = "004-034556";

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

Ausgabe:

004
034556

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

15
sandeep vanama

Vorausgesetzt, dass

  • sie brauchen nicht wirklich reguläre 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 das 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 die Verwendung von Commong-Lang empfehlen, da es normalerweise eine Menge nützlicher Informationen enthält. Wenn Sie es jedoch nicht für etwas anderes als für eine Aufteilung benötigen, ist die Implementierung der eigenen Person oder die Flucht vor dem regulären Ausdruck eine bessere Option.

15
eis

Sie können es auch so versuchen

 String concatenated_String="hi^Hello";

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

Mit Regex in mehrere Zeichen aufteilen

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 die erste Nullzeichenfolge ignoriert wurde. Dieser Fehler ist in der neuesten JDK-Version nicht vorhanden, tritt jedoch in einigen Versionen zwischen den verspäteten Versionen von JDK 1.7 und den früheren Versionen von 1.8 auf.

13
Ravindra babu

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

Splitter.on('-')
       .trimResults()
       .omitEmptyStrings()
       .split(string);
13
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);
    }
}
10

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

Sie können eine Zeichenfolge durch einen Zeilenumbruch mit der folgenden Anweisung aufteilen:

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

Sie können eine Zeichenfolge mit einem Bindestrich/Zeichen mit der folgenden Anweisung aufteilen:

String textStr[] = yourString.split("-");
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]);
    }
  }
}
9
Ravi Pandey

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

  1. String.split ():

    String[] parts ="10,20".split(",");
    
  2. Pattern.compile (regexp) .splitAsStream (Eingabe):

    List<String> strings = Pattern.compile("\\|")
          .splitAsStream("010|020202")
          .collect(Collectors.toList());
    
  3. StringTokenizer (ältere 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 je nach Bedarf die beste Option auswählen, z. Rückgabetyp (Array, Liste oder iterierbar).

Hier ist ein großer Überblick über diese Methoden und die gebräuchlichsten Beispiele (wie Sie nach Punkt, Schrägstrich, Fragezeichen usw. aufteilen)

8

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

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 auf eine Änderung hinweisen, die für die split-Methode in Java 8 stattgefunden hat. Die String # split () - Methode verwendet Pattern.split und entfernt nun leere Zeichenfolgen am Anfang des Ergebnis-Arrays. Beachten Sie diese Änderung Dokumentation in Java 8:

Wenn am Anfang der Eingabe eine Übereinstimmung mit der positiven Breite vorliegt. Anschließend wird am Anfang ein leerer führender Teilstring eingefügt. des resultierenden Arrays. Eine Übereinstimmung mit Nullbreite am Anfang jedoch produziert niemals eine solche leere führende Unterkette.

Es bedeutet für das folgende Beispiel:

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

wir erhalten drei Zeichenfolgen: [0, 0, 4] und nicht vier wie in Java 7 und davor. Überprüfen Sie auch diese ähnliche Frage .

7
i_am_zero

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

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

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

WEG 1: Da Sie zwei Zahlen durch ein Sonderzeichen aufteilen 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);
        }
    }
}
7
Akshay Gaikwad

Sie können StringTokenizer einfach verwenden, um eine Zeichenfolge in zwei oder mehr Teile aufzuteilen, unabhängig davon, ob ein Typ von Trennzeichen vorhanden ist:

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

Überprüfen Sie die split()-Methode in der String-Klasse 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 Split-String, aber ich habe wenig Code optimiert.

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

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

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

Verwenden Sie String.split, wenn ein Begrenzer mit einem Zeichen auftritt oder Sie sich nicht für die Leistung interessieren

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

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

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

Verwenden Sie Pattern.split und kompilieren Sie das Pattern vorab, wenn Sie ein komplexes Trennzeichen verwenden und die Leistung beachten.

Wenn es sich bei der Leistung um ein Problem handelt und Ihr Trennzeichen nicht zu den oben genannten gehört, sollten Sie ein Muster für reguläre Ausdrücke vorkompilieren, das Sie dann erneut verwenden können.

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

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

Diese letzte Option erstellt immer noch ein neues Matcher-Objekt. 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 Thread-sicher.

2
rghome

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

Um einen String zu teilen, verwenden Sie String.split(regex):

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

Ausgabe:

004
034556
0
KIBOU Hassan
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 jedem erwähnt, ist split () die beste Option, die in Ihrem Fall verwendet werden kann. Eine alternative Methode kann substring () verwenden.

0
SAM Jr

Verwenden Sie zum Aufteilen einer Zeichenfolge 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 Für diese Aufteilung (Regex) wird ein Regex als Argument verwendet. Denken Sie daran, die Regex-Sonderzeichen, wie Punkt/Punkt, zu maskieren.

0
KIBOU Hassan

Ich habe eine Schnur namens stringValue verwendet und sie hat die Form von "Diejenigen, die Münzen hatten, im Regen genossen, die Noten hatten, waren damit beschäftigt, nach dem Unterschlupf zu suchen".

Ich werde das stringValue mit dem "," als Doppelpunkt aufteilen.

Und dann möchte ich einfach Text () von 3 verschiedenen TextViews setzen, um diesen String anzuzeigen.

String stringValue = "Those who had coins, enjoyed in the rain, those who had notes were busy looking for the shelter";
            String ValueSplitByColon[] = stringValue.split(",");

            String firstValue = ValueSplitByColon[0];
            String secondValue = ValueSplitByColon[1];
            String thirdValue = ValueSplitByColon[2];

            txtV1.setText(firstValue);
            txtV2.setText(secondValue;
            txtV3.setText(thirdValue;

Es gibt Ausgabe als:

  1. txtV1 Wert ist: - Wer hatte Münzen

  2. txtV2 Wert ist: -genossen im Regen

  3. txtV3 Wert ist: -die, die Notizen hatten, waren damit beschäftigt, den Unterstand zu suchen

0
PRAMESH BHALALA

sie können die Methodensplit verwenden

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

    }
}
0
Jamith Nimantha