Jak podzielić ciąg w Javie

1639

Mam ciąg, "004-034556"który chcę podzielić na dwa ciągi:

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

Oznacza to, że pierwszy ciąg będzie zawierał znaki przed '-', a drugi ciąg będzie zawierał znaki po '-'. Chcę również sprawdzić, czy łańcuch ma '-'w sobie. Jeśli nie, wyrzucę wyjątek. W jaki sposób mogę to zrobić?

riyana
źródło

Odpowiedzi:

2931

Wystarczy użyć odpowiedniej metody: String#split().

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

Pamiętaj, że to wyrażenie regularne , więc pamiętaj, aby w razie potrzeby unikać znaków specjalnych .

tam jest 12 znaków ze szczególnych znaczeń: odwrotny ukośnik \, daszek ^, znak dolara $, okres lub kropka ., bar lub rura pionowa symbol |, znak zapytania ?, gwiazdka lub gwiazda *, znak plus +, nawiasem otwierającym (, nawiasem zamykającym )oraz otwierający nawias kwadratowy [, otwierający nawias klamrowy. {Te znaki specjalne są często nazywane „metaznakami”.

Tak więc, jeśli chcesz podzielić na przykład okres / kropka ., która oznacza „ dowolny znak ” w regex, użyć backslash\ uciec indywidualny znak specjalny jak tak split("\\.")lub użyć klasę postaci[] reprezentować znaki liter (y) jak tak split("[.]")lub wykorzystanie Pattern#quote()do uciec tak cały łańcuch split(Pattern.quote(".")).

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

Aby wcześniej sprawdzić, czy ciąg zawiera określone znaki, po prostu użyj String#contains().

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

Uwaga: nie przyjmuje wyrażenia regularnego. W tym celu użyj String#matches()zamiast tego.

Jeśli chcesz zachować podzielony znak w wynikowych częściach, skorzystaj z pozytywnego wyglądu . Jeśli chcesz, aby rozdzielony znak znalazł się po lewej stronie, użyj pozytywnego wyglądu za prefiksem ?<=grupy na wzorze.

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

Jeśli chcesz, aby rozdzielony znak znalazł się po prawej stronie, użyj pozytywnego spojrzenia w przód, poprzedzając ?=grupę wzorem.

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

Jeśli chcesz ograniczyć liczbę wynikowych części, możesz podać żądaną liczbę jako drugi argument split()metody.

String string = "004-034556-42";
String[] parts = string.split("-", 2);
String part1 = parts[0]; // 004
String part2 = parts[1]; // 034556-42
BalusC
źródło
27
Dlaczego używasz symboli skrótu do wyznaczania metod String?
Crowie
94
@Crowie: javadoc-style.
BalusC
9
Przypadek narożny: jeśli nie można go znaleźć reugalr expression, zwraca tablicę jednego elementu z całym ciągiem znaków.
klimat
2
Nie mogę uwierzyć, że taka głosowana wersja jest właśnie taka. 1) part2 nie jest tym, czego chce plakat, jeśli oryginalny ciąg zawiera dwa „-” 2) Brak obsługi błędów, jak wspomniano w pytaniu. 3) Niska wydajność. Wyszukiwanie pojedynczych znaków wymaga konstruowania i dopasowywania wyrażeń regularnych. Utworzono dodatkową tablicę itp.
David
1
@David: 1) To nie jest objęte pytaniem. 2) Nie rzuca wyjątków. 3) OP pyta, jak podzielić, a nie jak utworzyć podciąg. 4) Zrób sobie przerwę, oddychaj głęboko i
wyrzuć z siebie
79

Alternatywą dla bezpośredniego przetwarzania łańcucha byłoby użycie wyrażenia regularnego z grupami przechwytującymi. Ma to tę zaletę, że ułatwia nakładanie bardziej wyrafinowanych ograniczeń na dane wejściowe. Na przykład poniższy ciąg dzieli ciąg na dwie części i zapewnia, że ​​obie składają się tylko z cyfr:

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

Ponieważ wzorzec jest ustalony w tym przypadku, można go wcześniej skompilować i zapisać jako element statyczny (w przykładzie zainicjowany podczas ładowania klasy). Wyrażenie regularne to:

(\d+)-(\d+)

Nawiasy oznaczają grupy przechwytujące; ciąg pasujący do tej części wyrażenia regularnego można uzyskać za pomocą metody Match.group (), jak pokazano. \ D dopasowuje i pojedyncza cyfra dziesiętna, a + oznacza „dopasuj jedno lub więcej poprzednich wyrażeń). - nie ma specjalnego znaczenia, więc po prostu dopasowuje ten znak na wejściu. Zauważ, że musisz podwójnie uciec z ukośnikami odwrotnymi podczas pisania tego jako ciąg Java. Kilka innych przykładów:

([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
źródło
Jest to świetne rozwiązanie, jednak pierwsza część powinna być m.group(1)drugą częścią m.group(2), ponieważ m.group(0)faktycznie zwraca pełny pasujący wzór. Wydaje mi się, że pamiętam też, że group(0)był to pierwszy mecz zamiast pełnego wzorca, może to się zmieniło w ostatniej aktualizacji wersji Java.
ptstone
1
Dzięki. Patrząc na docs.oracle.com/javase/7/docs/api/java/util/regex /... masz rację - zgodnie z większością innych bibliotek regexp, grupa 0 jest w pełni dopasowana, a przechwycone grupy zaczynają się od 1. Jak mówisz, podejrzewam, że mogło się to zmienić od czasu, gdy pierwotnie napisałem odpowiedź, ale w każdym razie zaktualizuję ją, aby odzwierciedlić obecne zachowanie.
Rob Hague,
42
String[] result = yourString.split("-");
if (result.length != 2) 
     throw new IllegalArgumentException("String not in correct format");

Spowoduje to podzielenie łańcucha na 2 części. Pierwszym elementem w tablicy będzie część zawierająca elementy przed -, a 2. element w tablicy będzie zawierał część łańcucha po -.

Jeśli długość tablicy nie jest 2, a następnie ciąg nie był w formacie: string-string.

Sprawdź split()metodę w Stringklasie.

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

jjnguy
źródło
5
Spowoduje to zaakceptowanie „-555” jako danych wejściowych i zwróci [, 555]. Wymagania nie są tak jasno określone, jeśli zaakceptowanie tego byłoby uzasadnione. Polecam napisać kilka testów jednostkowych w celu zdefiniowania pożądanego zachowania.
Michael Konietzka,
Prawdopodobnie najbezpieczniej jest zmienić (wynik. Długość! = 2) na (wynik. Długość <2)
Wujek Iroh
29
String[] out = string.split("-");

powinien robić, co chcesz. Klasa string ma wiele metod do obsługi ciągu.

secmask
źródło
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
źródło
60
JavaDoc wyraźnie stwierdza: StringTokenizerjest klasą starszą, która jest zachowywana ze względu na kompatybilność, chociaż jej użycie jest odradzane w nowym kodzie . Zaleca się, aby każdy, kto szuka tej funkcjonalności, używał splitmetody Stringlub java.util.regexpakietu”.
bvdb,
23

W Javie 8:

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

    stringList.forEach(s -> System.out.println(s));
Somaiah Kumbera
źródło
2
Jeśli chcesz usunąć białe znaki, dodaj .map(String::trim)posplit
Roland
18

Wymagania pozostawiły pole do interpretacji. Polecam napisać metodę,

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

które zawierają tę funkcję. Oczywiście możesz użyć String.split (..), jak wspomniano w innych odpowiedziach dotyczących implementacji.

Powinieneś napisać kilka testów jednostkowych dla łańcuchów wejściowych oraz pożądanych wyników i zachowania.

Dobrzy kandydaci do testu powinni obejmować:

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

Definiując odpowiednie wyniki testu, możesz określić zachowanie.

Na przykład, jeśli "-333"powinien wrócić [,333]lub jeśli jest to błąd. Czy można "333-333-33"je rozdzielić, [333,333-33] or [333-333,33]czy jest to błąd? I tak dalej.

Michael Konietzka
źródło
4
Przydatna rada, ale tak naprawdę nie jest odpowiedzią na pytanie. Jeśli popierasz szczegółowo inne odpowiedzi, preferowany jest komentarz.
Chris Mountford
Użyj: split (wyrażenie regularne, ograniczenie int) i NIE podzielone (wyrażenie regularne) w celach informacyjnych odwiedź geeksforgeeks.org/split-string-java-examples
Ryan Augustine,
16

Możesz także spróbować w ten sposób

 String concatenated_String="hi^Hello";

 String split_string_array[]=concatenated_String.split("\\^");
SHUNMUGA RAJ PRABAKARAN
źródło
16

Przy założeniu, że

  • tak naprawdę nie potrzebujesz wyrażeń regularnych do podziału
  • zdarzyło Ci się już używać apache commons lang w swojej aplikacji

Najprostszym sposobem jest użycie StringUtils # split (java.lang.String, char) . Jest to wygodniejsze niż ten dostarczany przez Javę od razu po wyjęciu z pudełka, jeśli nie potrzebujesz wyrażeń regularnych. Zgodnie z instrukcją, działa on tak:

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

Poleciłbym używanie commong-lang, ponieważ zwykle zawiera wiele użytecznych rzeczy. Jeśli jednak nie potrzebujesz tego do niczego innego niż dzielenie, lepszym rozwiązaniem jest wdrożenie siebie lub uniknięcie wyrażenia regularnego.

eis
źródło
15

Użyj metody podziału org.apache.commons.lang.StringUtils, która może dzielić ciągi znaków na podstawie znaku lub ciągu, który chcesz podzielić.

Podpis metody:

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

W twoim przypadku chcesz podzielić ciąg, gdy występuje „-”.

Możesz po prostu wykonać następujące czynności:

String str = "004-034556";

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

Wynik:

004
034556

Załóżmy, że jeśli -nie istnieje w ciągu, zwraca podany ciąg i nie otrzymasz żadnego wyjątku.

Sandeep Vanama
źródło
14

Podsumowując: istnieje co najmniej pięć sposobów podziału łańcucha w Javie:

  1. String.split ():

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

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

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

Możesz więc wybrać najlepszą dla siebie opcję w zależności od tego, czego potrzebujesz, np. Typ zwrotu (tablica, lista lub iterowalne).

Oto duży przegląd tych metod i najczęstszych przykładów (jak podzielić przez kropkę, ukośnik, znak zapytania itp.)

Dmytro Shvechikov
źródło
13

Najszybszym sposobem, który zużywa również najmniej zasobów, może być:

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
źródło
6
Najmniejszym zasobem jest często czas i uwaga programisty. Ten kod zużywa więcej tego zasobu niż alternatywy.
Chris Mountford
masz wiele wbudowanych zasobów, których możesz użyć, w których wydajność jest naprawdę brana pod uwagę, w tym rozwiązaniu brakuje czasu wykonania wydajności
J Sanchez
1
Aby wykonać prosty podział na pojedynczy znak z kontrolą błędów, nie jest to bardziej skomplikowane niż wersja wyrażenia regularnego.
tekHedd
Brawo! Wreszcie odpowiedź na to pytanie, która nie używa wyrażenia regularnego! Użycie wyrażenia regularnego w tym prostym zadaniu jest raczej chustką na głowę. Dobrze widzieć, że na tym świecie wciąż są rozsądni programiści :-)
Gabriel Magana
Jest tylko jedno „-”, pożądany jest wyjątek, a wynik powinien przejść do string1 i string2. Zrób string1 = s.substring(0, s.indexOf("-")); string2 = s.substring(s.indexOf("-") + 1);to. Otrzymasz StringIndexOutOfBoundsExceptionautomatycznie, jeśli nie było „-”.
Kaplan
13

Podział ciągów z wieloma znakami przy użyciu 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]);
        }
     }
  }

Wynik:

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

Ale nie oczekuj tego samego wyniku we wszystkich wersjach JDK. Widziałem jeden błąd występujący w niektórych wersjach JDK, w których pierwszy ciąg zerowy został zignorowany. Ten błąd nie występuje w najnowszej wersji JDK, ale występuje w niektórych wersjach między późnymi wersjami JDK 1.7 a wczesnymi wersjami 1.8.

Ravindra babu
źródło
13

W przypadku prostych zastosowań String.split()należy wykonać zadanie. Jeśli używasz guawy, istnieje również klasa Splitter, która umożliwia tworzenie łańcuchów różnych operacji na łańcuchach i obsługuje CharMatcher :

Splitter.on('-')
       .trimResults()
       .omitEmptyStrings()
       .split(string);
Vitalii Fedorenko
źródło
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
źródło
9

Możesz podzielić ciąg przez podział wiersza, używając następującej instrukcji:

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

Możesz podzielić ciąg według łącznika / znaku, używając następującej instrukcji:

String textStr[] = yourString.split("-");
RajeshVijayakumar
źródło
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
źródło
4
jeśli mogę podzielić się radą, w jaki sposób twoja odpowiedź wnosi więcej wartości niż już zaakceptowane rozwiązanie? stackoverflow.com/a/3481842/420096 w takich sytuacjach możesz oddać głos na istniejące rozwiązanie, szczególnie jeśli jest to tak trywialny przypadek jak ten.
Sombriks
8

Możesz użyć Split ():

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

W przeciwnym razie możesz użyć StringTokenizer:

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
źródło
8

Są tylko dwie metody, które naprawdę musisz wziąć pod uwagę.

Użyj String.split dla separatora jednoznakowego lub nie zależy ci na wydajności

Jeśli wydajność nie stanowi problemu lub jeśli separator jest pojedynczym znakiem, który nie jest znakiem specjalnym wyrażenia regularnego (tzn. Nie jest jednym z .$|()[{^?*+\), możesz użyć String.split.

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

Metoda podziału ma optymalizację, aby uniknąć używania wyrażenia regularnego, jeśli ogranicznik jest pojedynczym znakiem i nie znajduje się na powyższej liście. W przeciwnym razie musi skompilować wyrażenie regularne, co nie jest idealne.

Użyj Pattern.split i prekompiluj wzorzec, jeśli używasz złożonego ogranicznika i zależy Ci na wydajności.

Jeśli wydajność stanowi problem, a separator nie jest jednym z powyższych, należy wstępnie skompilować wzorzec wyrażeń regularnych, który można następnie wykorzystać ponownie.

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

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

Ta ostatnia opcja wciąż tworzy nowy Matcherobiekt. Możesz także buforować ten obiekt i resetować go dla każdego wejścia, aby uzyskać maksymalną wydajność, ale jest to nieco bardziej skomplikowane i nie jest bezpieczne dla wątków.

rghome
źródło
7

Jednym ze sposobów na to jest uruchomienie ciągu w pętli dla każdego z nich i użycie wymaganego znaku podziału.

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

Wynik:

The split parts of the String are:
004
034556
Keshav Pradeep Ramanath
źródło
7

Nie używaj klasy StringTokenizer, ponieważ jest to starsza klasa, która jest zachowywana ze względu na kompatybilność, a jej użycie jest odradzane w nowym kodzie. Możemy również skorzystać z metody podziału, jak sugerują inni.

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

I zgodnie z oczekiwaniami wydrukuje:

[004, 034556]

W tej odpowiedzi chcę również wskazać jedną zmianę, która miała miejsce w przypadku splitmetody w Javie 8 . Wykorzystuje metodę String # split ()Pattern.split , a teraz usunie puste ciągi na początku tablicy wyników. Zwróć uwagę na tę zmianę w dokumentacji Java 8:

Gdy na początku sekwencji wejściowej występuje dopasowanie o dodatniej szerokości, wówczas na początku wynikowej tablicy znajduje się pusty wiodący podciąg. Na początku dopasowanie zerowej szerokości nigdy nie wytwarza tak pustego wiodącego podłańcucha.

Oznacza to w poniższym przykładzie:

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

otrzymamy trzy ciągi: [0, 0, 4]a nie cztery, jak miało to miejsce w Javie 7 i wcześniejszych. Sprawdź także to podobne pytanie .

akhil_mittal
źródło
7

Oto dwa sposoby, aby to osiągnąć.

SPOSÓB 1: Ponieważ musisz podzielić dwie liczby na znak specjalny, możesz użyć wyrażenia regularnego

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

SPOSÓB 2: Korzystanie z metody podziału ciągu

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
źródło
6

Możesz po prostu użyć StringTokenizer, aby podzielić ciąg na dwie lub więcej części, niezależnie od tego, czy istnieją jakiekolwiek typy ograniczników:

StringTokenizer st = new StringTokenizer("004-034556", "-");
while(st.hasMoreTokens())
{
    System.out.println(st.nextToken());
}
Rohit-Pandey
źródło
4

Sprawdź split()metodę w Stringklasie na 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++;
}

Oto wiele przykładów podzielonego łańcucha, ale mało zoptymalizowałem kod.

Divyesh Kanzariya
źródło
Wymień -się |i zobaczyć, co się dzieje :)
R Sun
W takim przypadku sprawdź stackoverflow.com/questions/10796160/...
R Nd
4
String str="004-034556"
String[] sTemp=str.split("-");// '-' is a delimiter

string1=004 // sTemp[0];
string2=034556//sTemp[1];
siedmiodniowa żałoba
źródło
3

Chciałem tylko napisać algorytm zamiast używać wbudowanych funkcji Java:

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;
}
Żaden
źródło
1

Możesz użyć metody 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
źródło
1

Aby podzielić ciąg, używa String.split (regex). Przejrzyj następujące przykłady:

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

Wynik

004
034556

Uwaga:

Ten podział (regex) przyjmuje regex jako argument. Pamiętaj, aby uniknąć znaków specjalnych wyrażenia regularnego, takich jak kropka / kropka.

KIBOU Hassan
źródło
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));
    }
}

Jak wszyscy wspominają, split () jest najlepszą opcją, którą można zastosować w twoim przypadku. Alternatywną metodą może być użycie substring ().

SAM Jr
źródło
0

Aby podzielić ciąg, użyj String.split(regex):

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

Wynik:

004
034556
KIBOU Hassan
źródło