Jak podzielić ciąg w Javie

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ć?

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

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

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-

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

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

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

W Javie 8:

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

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

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.

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

 String concatenated_String="hi^Hello";

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

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.

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.

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

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

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.

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

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

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

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

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

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.

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

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 .

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

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

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.

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

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

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

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

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.

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

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