vetor - split java separador




Como dividir uma string em Java (20)

Eu tenho uma seqüência de caracteres, "004-034556" , que eu quero dividir em duas seqüências de caracteres:

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

Isso significa que a primeira string conterá os caracteres antes de '-' e a segunda string conterá os caracteres depois de '-' . Eu também quero verificar se a string tem '-' nela. Se não, vou lançar uma exceção. Como posso fazer isso?


Apenas use o método apropriado: String#split() .

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

Observe que isso exige uma expressão regular , por isso, lembre-se de escapar de caracteres especiais, se necessário.

existem 12 caracteres com significados especiais: a barra invertida \ , o cursor ^ , o sinal de dólar $ , o ponto ou ponto . , o símbolo vertical de barra ou tubo | , o ponto de interrogação ? , o asterisco ou estrela * , o sinal de mais + , o parêntese de abertura ( , o parêntese de fechamento ) e o colchete de abertura [ , a chave de abertura { , Esses caracteres especiais são geralmente chamados de "metacaracteres".

Então, se você quiser dividir por exemplo período / ponto . que significa " qualquer caractere " no regex, use qualquer barra invertida \ para escapar do caractere especial individual, como split("\\.") , ou use character class [] para representar caracteres literais como split("[.]") , ou use Pattern#quote() para escapar de toda a string como se estivesse split(Pattern.quote(".")) .

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

Para testar de antemão se a string contém certos caracteres, apenas use String#contains() .

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

Note que isso não requer uma expressão regular. Para isso, use String#matches() .

Se você quiser manter o caractere de divisão nas partes resultantes, faça uso de uma visão positiva . Caso você queira que o caractere de divisão termine no lado esquerdo, use lookbehind positivo prefixando ?<= Group no padrão.

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

Caso você queira que o caractere de divisão termine no lado direito, use lookahead positivo prefixando ?= Group no padrão.

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

Se você quiser limitar o número de partes resultantes, você pode fornecer o número desejado como segundo argumento do método split() .

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

Aqui estão duas maneiras de conseguir isso.

WAY 1: Como você tem que dividir dois números por um caractere especial, você pode usar o 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());
        }
    }
}

CAMINHO 2: Usando o método de divisão de string

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

Com o Java 8:

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

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


Existem apenas dois métodos que você realmente precisa considerar.

Use String.split se um delimitador de um caractere ou você não se importa com o desempenho

Se o desempenho não for um problema, ou se o delimitador for um caractere único que não seja um caractere especial de expressão regular (isto é, não um .$|()[{^?*+\ ), Você poderá usar String.split .

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

O método split tem uma otimização para evitar o uso de uma expressão regular se o delimitador for um único caractere e não estiver na lista acima. Caso contrário, deve compilar uma expressão regular e isso não é ideal.

Use Pattern.split e pré-compile o padrão se estiver usando um delimitador complexo e se preocupa com o desempenho

Se o desempenho é um problema e o seu delimitador não é um dos itens acima, você deve pré-compilar um padrão de expressão regular que pode ser reutilizado.

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

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

Esta última opção ainda cria um novo objeto Matcher . Você também pode armazenar em cache esse objeto e redefini-lo para cada entrada para obter o máximo desempenho, mas isso é um pouco mais complicado e não é seguro para threads.


O caminho mais rápido, que também consome menos recursos, 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 '-'
}

Para casos de uso simples, String#split() deve fazer o trabalho. Se você usa goava, existe também uma classe Splitter que permite o encadeamento de diferentes operações de strings e suporta o CharMatcher :

Splitter.on('-')
       .trimResults()
       .omitEmptyStrings()
       .split(string);

Para dividir uma string, use String.split(regex) :

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

Saída:

004
034556

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

  1. String.split ():

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

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

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

    Iterable<String> result = Splitter.on(",").split("1,2,3,4");
  5. Apache Commons StringUtils:

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

Assim, você pode escolher a melhor opção para você, dependendo do que você precisa, por exemplo, tipo de retorno (matriz, lista ou iterável).

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


Por favor, não use a classe StringTokenizer , pois é uma classe herdada que é retida por razões de compatibilidade, e seu uso é desencorajado em um novo código. E podemos usar o método split como sugerido por outros também.

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

E como esperado, será impresso:

[004, 034556]

Nesta resposta, também quero apontar 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 removerá as strings vazias no início da matriz resultante. Observe esta change na documentação do Java 8:

Quando há uma correspondência de largura positiva no início da sequência de entrada, uma substring inicial vazia é incluída no início da matriz resultante. No entanto, uma correspondência de largura zero no início nunca produz essa substring inicial vazia.

Isso significa para o seguinte exemplo:

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

nós teremos três strings: [0, 0, 4] e não quatro, como foi o caso no Java 7 e antes. Além disso, verifique essa question semelhante.


Uma maneira de fazer isso é executar o String em um loop for-each e usar o caractere de divisão 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);
    }
}

Saída:

The split parts of the String are:
004
034556

Use org.apache.commons.lang.StringUtils' método split do org.apache.commons.lang.StringUtils' que pode dividir strings com base no caractere ou string que você deseja dividir.

Assinatura do método:

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

No seu caso, você quer dividir uma string quando houver um "-".

Você pode simplesmente fazer o seguinte:

String str = "004-034556";

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

Saída:

004
034556

Suponha que se - não existir em sua string, ele retorna a string dada, e você não receberá nenhuma exceção.


Você pode simplesmente usar o StringTokenizer para dividir uma string em duas ou mais partes, se houver algum tipo de delimitador:

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

Você pode tentar assim também

 String concatenated_String="hi^Hello";

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

você pode usar o método 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 \"-\".");
        }

    }
}

Cadeia de divisão com vários caracteres usando 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]);
        }
     }
  }

Saída:

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 do JDK onde a primeira cadeia nula foi ignorada. Esse bug não está presente na versão mais recente do JDK, mas existe em algumas versões entre as versões mais recentes do JDK 1.7 e as versões anteriores do 1.8.


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

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

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

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

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

deve fazer o que quiser. A classe string tem muitos métodos para operar com string.





string