Como dividir um texto em Java

Uma alternativa ao processamento directo do texto seria usar uma expressão regular com grupos de captura. Isto tem a vantagem de tornar simples implicar restrições mais sofisticadas na entrada. Por exemplo, o seguinte divide a cadeia em duas partes, e garante que ambas consistem apenas de dígitos:

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

Como o padrão é fixo neste caso, pode ser compilado antecipadamente e armazenado como um membro estático (inicializado na classe Tempo de carga no exemplo). A expressão regular é:

(\d+)-(\d+)

Os parêntesis indicam os grupos de captura; o texto que corresponde a essa parte da expressão regular pode ser acedido pela correspondência.método do grupo (), como mostrado. O \d corresponde e um único algarismo decimal, e o + significa "corresponde a uma ou mais das expressões anteriores"). O - não tem nenhum significado especial, então apenas corresponde a esse personagem na entrada. Lembre-se que precisa de escapar duas vezes das barras invertidas ao escrever isto como um texto Java. Outros exemplos:

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

Se o comprimento do array não for 2, então o texto não estava no formato: string-string.

Verifica o método split() na classe String.

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

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

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

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

Que encapsulam esta função. Claro que podes usar fio.dividir(..) como mencionado nas outras respostas para a implementação.

Você deve escrever alguns testes de unidade para cadeias de entrada e os resultados e comportamento desejados.

Os bons candidatos devem incluir:

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

Com a definição dos resultados dos testes, pode especificar o comportamento.

Para exemplo, se "-333" deve retornar em [,333] ou se for um erro. Pode "333-333-33" ser separado em [333,333-33] or [333-333,33] ou é um erro? E assim por diante.

Também podes tentar assim

 String concatenated_String="hi^Hello";

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

Assumindo que

Não precisas de expressões regulares para a tua divisão. Por acaso já usa o Apache commons lang na sua aplicação.

A maneira mais fácil é usar StringUtils#split (java.idioma.String, char) . Isso é mais conveniente do que o fornecido por Java fora da caixa se você não precisa de Expressões Regulares. Como diz o manual, funciona assim:

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

Utilizar org.Apache.comuns.idioma.O método de divisão do StringUtils ' pode dividir cadeias de caracteres com base no carácter ou cadeia de caracteres que deseja dividir.

Assinatura do Método:

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

Pode simplesmente fazer o seguinte:

String str = "004-034556";

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

Resultado:

004
034556

Suponha que se - não existe na sua cadeia de caracteres, devolve a cadeia de caracteres indicada, e não irá obter nenhuma excepção.

Com Java 8:

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

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

texto dividido com vários caracteres usando a expressão regular

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

Resultado:

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

Mas não espere o mesmo resultado em todas as versões do JDK. Eu vi um bug que existe em algumas versões JDK onde a primeira string nula foi ignorada. Este bug não está presente na última versão do JDK, mas existe em algumas versões entre JDK 1.7 versões tardias e 1.8 versões anteriores.

Para casos de Utilização simplesString.split() deve fazer o trabalho. Se você usar goiaba, também existe uma classeSplitter que permite acordes de diferentes operações de texto e suporta 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);
    }
}

A maneira mais rápida, que também consome o menor recurso, pode ser:

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

Você pode dividir um texto por uma quebra de linha usando a seguinte declaração:

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

Pode dividir um texto por um hífen / carácter usando a seguinte declaração:

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

Uma maneira de fazer isto é executar através da cadeia de caracteres em um para-cada ciclo e usar o carácter dividido necessário.

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

Resultado:

The split parts of the String are:
004
034556

Por favor, não use a classe StringTokenizer porque é uma classe legada que é mantida por razões de compatibilidade, e seu uso é desencorajado em novo código. E nós podemos fazer uso do método split como sugerido por outros também.

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

E como esperado irá imprimir:

[004, 034556]

Nesta resposta também quero salientar uma alteração que ocorreu para o método split no Java 8 . O método String#split () faz uso de Pattern.split, e agora vai remover os textos vazios no início da lista de resultados. Notice this change in documentation for Java 8:

Quando há uma correspondência de largura positiva no início da entrada sequência em seguida, um sub-texto inicial vazio é incluído no início da matriz resultante. Uma correspondência de largura zero no início, no entanto nunca produz um substrato tão vazio.

Significa para o seguinte exemplo:

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

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

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

Modo 1: como tem de dividir dois números por um carácter especial, pode usar a regex

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

Modo 2: Usando o método de separação de texto

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

Pode simplesmente usar o StringTokenizer para dividir uma cadeia em duas ou mais partes, quer exista algum tipo de Delimitadores:

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

Para resumir: existem pelo menos cinco maneiras de dividir uma cadeia de caracteres em Java:

1. Fio.split():

   String[] parts ="10,20".split(",");
   

2. Padrão.compile (regexp).splitAsStream (entrada):

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

3. StringTokenizer (classe legado):

   StringTokenizer strings = new StringTokenizer("Welcome to EXPLAINJAVA.COM!", ".");
   while(strings.hasMoreTokens()){
       String substring = strings.nextToken();
       System.out.println(substring);
   }
   

4. Separador De Goiaba Do Google:

   Iterable<String> result = Splitter.on(",").split("1,2,3,4");
   

5. Apache Commons StringUtils:

   String[] strings = StringUtils.split("1,2,3,4", ",");
   

Então você pode escolher a melhor opção para você, dependendo do que você precisa, por exemplo, tipo de retorno (array, list, or iterable).

Aqui é uma grande visão geral destes métodos e os exemplos mais comuns (como dividir por ponto, barra, ponto de interrogação, etc.)

Confira o método split() na classe String em 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++;
}

Aqui muitos exemplos para string dividida, mas eu pouco código otimizado.

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

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

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

Como mencionado por todos, split() é a melhor opção que pode ser usada no seu caso. Um método alternativo pode ser usando substring().

Para dividir um texto, use String.split(regex):

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

Resultado:

004
034556

Eu só queria escrever um algoritmo em vez de usar funções incorporadas em 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;
}

Para dividir um texto, usa o texto.split (regex). Reveja os seguintes exemplos:

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

Saída

004
034556

Nota Esta divisão (regex) toma um regex como argumento, lembre-se de escapar dos caracteres especiais regex, como ponto/período.

Da documentação:

public String[] split(String regex,int limit) divide este texto em torno das correspondências da expressão regular indicada. A matriz devolvida por este método contém cada substring of this string that is terminated by another substring that corresponde à expressão indicada ou é terminada no fim do cadeia. Os substratos na matriz estão no ordem em que ocorrer nesta corda. Se a expressão não corresponde a nenhuma parte do entrada então a matriz resultante tem apenas um elemento, ou seja, cadeia.

String s = "123-456-789-123"; // The String to be split
String[] array = s.split("-"); // Split according to the hyphen and put them in an array
for(String subString : array){ // Cycle through the array
   System.out.println(subString);
}

Resultado:

123
456
789
123

 String string = "004^034556-34";
 String[] parts = string.split(Pattern.quote("^"));

Se tem um carácter especial, pode usar o Patter.cotacao. Se você simplesmente tem dash ( - ), então você pode encurtar o código:

 String string = "004-34";
 String[] parts = string.split("-");

Se tentar adicionar outro carácter especial no lugar do traço (^) Então o erro irá gerar ArrayIndexOutOfBoundsException . Para isso tem de usar Pattern.quote.