Como dividir um texto em Java
tenho uma corda, "004-034556"
, que quero dividir em duas cordas:
string1="004";
string2="034556";
isso significa que o primeiro texto irá conter os caracteres antes de '-'
, e o segundo texto irá conter os caracteres depois de '-'
. Também quero verificar se o texto tem '-'
nele. Caso contrário, abrirei uma excepção. Como posso fazer isto?
30 answers
Usa apenas o método apropriado.: String#split()
.
String string = "004-034556";
String[] parts = string.split("-");
String part1 = parts[0]; // 004
String part2 = parts[1]; // 034556
Lembre-se que isto tem uma expressão regular , por isso lembre-se de escapar de caracteres especiais Se necessário.
Lá são 12 caracteres com significados especiais: a barra invertida
\
, o acento circunflexo^
, o sinal de dólar$
, o período ou dot.
, a barra vertical ou símbolo de pipe|
, o ponto de interrogação?
, o asterisco ou estrela*
, o sinal+
, o parêntesis de abertura(
, o parêntesis de Fecho)
, e o parêntesis quadrado de abertura[
, a bracelete encaracolado de abertura{
, estes caracteres especiais são muitas vezes chamados de "metacaracters".
Por isso, se quiser dividir por exemplo o ponto / período {[10] } que significa " qualquer carácter " na regex, use a barra invertida \
para escapar ao carácter especial individual como so split("\\.")
, ou usar a classe de caracteres []
para representar caracteres literais assim split("[.]")
, ou Pattern#quote()
para escapar de toda a cadeia assim split(Pattern.quote("."))
.
String[] parts = string.split(Pattern.quote(".")); // Split on period.
Para testar de antemão se o texto contém certos caracteres, basta usar String#contains()
.
if (string.contains("-")) {
// Split it.
} else {
throw new IllegalArgumentException("String " + string + " does not contain -");
}
Nota, Isto não tem uma expressão regular. Para isso, use String#matches()
em vez disso.
Se você gostaria de manter o caráter dividido nas partes resultantes, então faça uso deaparência positiva . No caso de você querer ter o caráter dividido para acabar na mão esquerda lado, use a aparência positiva ao prefixar ?<=
o grupo no padrão.
String string = "004-034556";
String[] parts = string.split("(?<=-)");
String part1 = parts[0]; // 004-
String part2 = parts[1]; // 034556
No caso de querer ter o carácter dividido para acabar no lado direito, use o visual positivo ao prefixar ?=
o grupo no padrão.
String string = "004-034556";
String[] parts = string.split("(?=-)");
String part1 = parts[0]; // 004
String part2 = parts[1]; // -034556
Se você gostaria de limitar o número de partes resultantes, então você pode fornecer o número desejado como o 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
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");
Isto vai dividir a tua corda em duas partes. O primeiro elemento do array será a parte que contém o material antes do -
, e o segundo elemento do array irá conter a parte do seu texto depois do -
.
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("-");
Deve fazer o que quiser. A classe String tem muitos métodos para operar com string.
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"]
Eu recomendaria a utilização de commong-lang, uma vez que normalmente contém um muitas coisas que podem ser usadas. No entanto, se você não precisa dele para nada mais do que fazer uma divisão, então implementar-se ou escapar da regex é uma opção melhor.
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);
No teu caso, queres dividir uma corda quando há um" -".
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));
Vamos ter três cordas: e não Quatro, como foi o caso em Java 7 e antes. Verifique também esta questão semelhante .
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];
}
}
Caso contrário, pode usar o 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("-");
}
}
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:
-
Fio.split():
String[] parts ="10,20".split(",");
-
Padrão.compile (regexp).splitAsStream (entrada):
List<String> strings = Pattern.compile("\\|") .splitAsStream("010|020202") .collect(Collectors.toList());
-
StringTokenizer (classe legado):
StringTokenizer strings = new StringTokenizer("Welcome to EXPLAINJAVA.COM!", "."); while(strings.hasMoreTokens()){ String substring = strings.nextToken(); System.out.println(substring); }
-
Separador De Goiaba Do Google:
Iterable<String> result = Splitter.on(",").split("1,2,3,4");
-
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:
Basicamente, podes fazer algo assim.
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
.