Comment diviser une chaîne en Java

J’ai une chaîne "004-034556" que je veux diviser en deux chaînes:

 ssortingng1=004 ssortingng2=034556 

Cela signifie que la première chaîne contiendra les caractères avant '-' et que la deuxième chaîne contiendra les caractères après '-' . Je veux aussi vérifier si la chaîne contient '-' . Sinon, je vais lancer une exception. Comment puis-je faire ceci?

Utilisez simplement la méthode appropriée: Ssortingng#split() .

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

Notez que cela prend une expression régulière , donc n’oubliez pas d’échapper les caractères spéciaux si nécessaire.

il y a 12 caractères avec des significations spéciales: la barre oblique inverse \ , le curseur ^ , le signe dollar $ , le point ou le point . , le symbole barre verticale ou pipe | , le point d’interrogation ? , l’astérisque ou l’écanvas * , le signe plus + , la parenthèse ouvrante ( , la parenthèse fermante ) et le carré ouvrant [ , l’accolade ouvrante { , Ces caractères spéciaux sont souvent appelés “métacaractères”.

Donc, si vous voulez diviser par exemple par période / point . ce qui signifie ” tout caractère ” dans regex, utilisez soit la barre oblique inverse \ pour échapper au caractère spécial individuel comme si split("\\.") , soit la classe de caractère [] pour représenter le (s) caractère (s) littéral (s) split("[.]") , ou utilisez Pattern#quote() pour échapper à la chaîne entière comme si split(Pattern.quote(".")) .

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

Pour tester au préalable si la chaîne contient certains caractères, utilisez simplement Ssortingng#contains() .

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

Notez que cela ne prend pas une expression régulière. Pour cela, utilisez Ssortingng#matches() place.

Si vous souhaitez conserver le caractère scindé dans les parties résultantes, utilisez une méthode d’parsing positive . Si vous souhaitez que le caractère divisé se termine à gauche, utilisez un style de recherche positif en préfixant ?<= Groupe sur le motif.

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

Dans le cas où vous voulez que le caractère divisé se termine dans la partie droite, utilisez le style de recherche positif en préfixant ?= Groupe ?= sur le motif.

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

Si vous souhaitez limiter le nombre de parties résultantes, vous pouvez fournir le nombre souhaité comme deuxième argument de la méthode split() .

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

Une alternative à traiter directement la chaîne serait d’utiliser une expression régulière avec des groupes de capture. Cela présente l’avantage de permettre des contraintes plus complexes sur les entrées. Par exemple, les éléments suivants divisent la chaîne en deux parties et garantissent que les deux ne comportent que des chiffres:

 import java.util.regex.Pattern; import java.util.regex.Matcher; class SplitExample { private static Pattern twopart = Pattern.comstack("(\\d+)-(\\d+)"); public static void checkSsortingng(Ssortingng 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(Ssortingng[] args) { checkSsortingng("123-4567"); checkSsortingng("foo-bar"); checkSsortingng("123-"); checkSsortingng("-4567"); checkSsortingng("123-4567-890"); } } 

Comme le modèle est fixe dans cette instance, il peut être compilé à l’avance et stocké en tant que membre statique (initialisé au moment du chargement de la classe dans l’exemple). L’expression régulière est:

 (\d+)-(\d+) 

Les parenthèses indiquent les groupes de capture; La chaîne qui correspond à cette partie de l’expression rationnelle est accessible par la méthode Match.group (), comme indiqué. Les correspondances \ d et le seul chiffre décimal, et le + signifie “correspond à une ou plusieurs des expressions précédentes). Le – n’a pas de signification particulière, il suffit donc de faire correspondre ce caractère en entrée. Notez que vous devez échapper les barres obliques inverses en écrivant ceci en tant que chaîne Java.

 ([AZ]+)-([AZ]+) // Each part consists of only capital letters ([^-]+)-([^-]+) // Each part consists of characters other than - ([AZ]{2})-(\d+) // The first part is exactly two capital letters, // the second consists of digits 
 Ssortingng[] result = yourSsortingng.split("-"); if (result.length != 2) throw new IllegalArgumentException("Ssortingng not in correct format"); 

Cela divisera votre chaîne en 2 parties. Le premier élément du tableau sera la partie contenant les éléments avant le - , et le deuxième élément du tableau contiendra la partie de votre chaîne après le - .

Si la longueur du tableau n’est pas 2, la chaîne n’a pas le format suivant: ssortingng-ssortingng .

Découvrez la méthode split() dans la classe Ssortingng .

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

 // This leaves the regexes issue out of question // But we must remember that each character in the Delimiter Ssortingng is treated // like a single delimiter public static Ssortingng[] SplitUsingTokenizer(Ssortingng subject, Ssortingng delimiters) { SsortingngTokenizer strTkn = new SsortingngTokenizer(subject, delimiters); ArrayList arrLis = new ArrayList(subject.length()); while(strTkn.hasMoreTokens()) arrLis.add(strTkn.nextToken()); return arrLis.toArray(new Ssortingng[0]); } 
 Ssortingng[] out = ssortingng.split("-"); 

devrait faire ce que vous voulez. La classe Ssortingng a de nombreuses méthodes pour fonctionner avec ssortingng.

Les exigences ont laissé place à l’interprétation. Je recommande d’écrire une méthode,

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

qui encapsulent cette fonction. Bien sûr, vous pouvez utiliser Ssortingng.split (..) comme mentionné dans les autres réponses pour l’implémentation.

Vous devez écrire des tests unitaires pour les chaînes d’entrée et les résultats et comportements souhaités.

Les bons candidats doivent inclure:

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

En définissant les résultats de test correspondants, vous pouvez spécifier le comportement.

Par exemple, si "-333" doit renvoyer dans [,333] ou s’il s’agit d’une erreur. Peut "333-333-33" être séparé dans [333,333-33] or [333-333,33] ou est-ce une erreur? Etc.

En admettant que

  • vous n’avez pas vraiment besoin d’expressions régulières pour votre split
  • vous utilisez déjà apache commons lang dans votre application

Le plus simple est d’utiliser SsortingngUtils # split (java.lang.Ssortingng, char) . C’est plus pratique que celui fourni par Java si vous n’avez pas besoin d’expressions régulières. Comme le dit son manuel, cela fonctionne comme ceci:

 A null input Ssortingng returns null. SsortingngUtils.split(null, *) = null SsortingngUtils.split("", *) = [] SsortingngUtils.split("abc", '.') = ["a", "b", "c"] SsortingngUtils.split("a..bc", '.') = ["a", "b", "c"] SsortingngUtils.split("a:b:c", '.') = ["a:b:c"] SsortingngUtils.split("abc", ' ') = ["a", "b", "c"] 

Je recommande d’utiliser commong-lang, car il contient généralement beaucoup de choses utilisables. Cependant, si vous n’en avez pas besoin autrement que de faire une scission, il est préférable de vous implémenter ou d’échapper à la regex.

Utilisez la méthode de division org.apache.commons.lang.SsortingngUtils qui peut diviser les chaînes en fonction du caractère ou de la chaîne que vous souhaitez diviser.

Signature de la méthode:

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

Dans votre cas, vous voulez diviser une chaîne quand il y a un “-“.

Vous pouvez simplement faire comme suit:

 Ssortingng str = "004-034556"; Ssortingng split[] = SsortingngUtils.split(str,"-"); 

Sortie:

 004 034556 

Supposons que si - n’existe pas dans votre chaîne, il renvoie la chaîne donnée et vous n’obtiendrez aucune exception.

Vous pouvez essayer comme ça aussi

  Ssortingng concatenated_Ssortingng="hi^Hello"; Ssortingng split_ssortingng_array[]=concatenated_Ssortingng.split("\\^"); 

Avec Java 8:

  List ssortingngList = Pattern.comstack("-") .splitAsStream("004-034556") .collect(Collectors.toList()); ssortingngList.forEach(s -> System.out.println(s)); 

Chaîne divisée avec plusieurs caractères à l’aide de Regex

 public class SsortingngSplitTest { public static void main(Ssortingng args[]) { Ssortingng s = " ;Ssortingng; Ssortingng; Ssortingng; Ssortingng, Ssortingng; Ssortingng;;Ssortingng;Ssortingng; Ssortingng; Ssortingng; ;Ssortingng;Ssortingng;Ssortingng;Ssortingng"; //Ssortingng[] strs = s.split("[,\\s\\;]"); Ssortingng[] strs = s.split("[,\\;]"); System.out.println("Subssortingngs length:"+strs.length); for (int i=0; i < strs.length; i++) { System.out.println("Str["+i+"]:"+strs[i]); } } } 

Sortie:

 Subssortingngs length:17 Str[0]: Str[1]:Ssortingng Str[2]: Ssortingng Str[3]: Ssortingng Str[4]: Ssortingng Str[5]: Ssortingng Str[6]: Ssortingng Str[7]: Str[8]:Ssortingng Str[9]:Ssortingng Str[10]: Ssortingng Str[11]: Ssortingng Str[12]: Str[13]:Ssortingng Str[14]:Ssortingng Str[15]:Ssortingng Str[16]:Ssortingng 

Mais ne vous attendez pas à la même sortie sur toutes les versions de JDK. J'ai vu un bug qui existe dans certaines versions de JDK où la première chaîne nulle a été ignorée. Ce bogue n'est pas présent dans la dernière version du JDK, mais il existe dans certaines versions entre les versions JDK 1.7 tardives et 1.8.

Pour les cas d’utilisation simples, Ssortingng.split() devrait faire le travail. Si vous utilisez guava, il existe également une classe Splitter qui permet de chaîner différentes opérations de chaîne et supporte CharMatcher :

 Splitter.on('-') .sortingmResults() .omitEmptySsortingngs() .split(ssortingng); 
 public class SplitTest { public static Ssortingng[] split(Ssortingng text, Ssortingng delimiter) { java.util.List parts = new java.util.ArrayList(); text += delimiter; for (int i = text.indexOf(delimiter), j=0; i != -1;) { Ssortingng temp = text.subssortingng(j,i); if(temp.sortingm().length() != 0) { parts.add(temp); } j = i + delimiter.length(); i = text.indexOf(delimiter,j); } return parts.toArray(new Ssortingng[0]); } public static void main(Ssortingng[] args) { Ssortingng str = "004-034556"; Ssortingng delimiter = "-"; Ssortingng result[] = split(str, delimiter); for(Ssortingng s:result) System.out.println(s); } } 

Vous pouvez diviser une chaîne par un saut de ligne en utilisant l’instruction suivante:

 Ssortingng textStr[] = yourSsortingng.split("\\r?\\n"); 

Vous pouvez fractionner une chaîne par un trait d’union / un caractère en utilisant l’instruction suivante:

 Ssortingng textStr[] = yourSsortingng.split("-"); 
 import java.io.*; public class BreakSsortingng { public static void main(Ssortingng args[]) { Ssortingng ssortingng = "004-034556-1234-2341"; Ssortingng[] parts = ssortingng.split("-"); for(int i=0;i 

Le moyen le plus rapide, qui consum également le moins de ressources, pourrait être:

 Ssortingng s = "abc-def"; int p = s.indexOf('-'); if (p >= 0) { Ssortingng left = s.subssortingng(0, p); Ssortingng right = s.subssortingng(p + 1); } else { // s does not contain '-' } 

Une façon de procéder consiste à parcourir la chaîne dans une boucle for-each et à utiliser le caractère fractionné requirejs.

 public class SsortingngSplitTest { public static void main(Ssortingng[] arg){ Ssortingng str = "004-034556"; Ssortingng split[] = str.split("-"); System.out.println("The split parts of the Ssortingng are"); for(Ssortingng s:split) System.out.println(s); } } 

Sortie:

 The split parts of the Ssortingng are: 004 034556 

N’utilisez pas la classe SsortingngTokenizer car il s’agit d’une classe héritée qui est conservée pour des raisons de compatibilité, et son utilisation est déconseillée dans le nouveau code. Et nous pouvons également utiliser la méthode du partage comme suggéré par d’autres.

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

Et comme prévu, il imprimera:

 [004, 034556] 

Dans cette réponse, je souhaite également souligner un changement intervenu dans la méthode de split en Java 8 . La méthode Ssortingng # split () utilise Pattern.split , et maintenant, elle supprimera les chaînes vides au début du tableau de résultats. Notez ce changement dans la documentation de Java 8:

Lorsqu’il existe une correspondance de largeur positive au début de la séquence d’entrée, une sous-chaîne de début vide est incluse au début du tableau résultant. Une correspondance de largeur nulle au début ne produit cependant jamais une telle sous-chaîne principale vide.

Cela signifie pour l’exemple suivant:

 Ssortingng[] sampleTokensAgain = "004".split(""); System.out.println(Arrays.toSsortingng(sampleTokensAgain)); 

nous aurons trois chaînes de caractères: [0, 0, 4] et non quatre comme cela était le cas dans Java 7 et avant. Vérifiez également cette question similaire.

Vous pouvez utiliser Split ():

 import java.io.*; public class Splitting { public static void main(Ssortingng args[]) { Ssortingng Str = new Ssortingng("004-034556"); Ssortingng[] SplittoArray = Str.split("-"); Ssortingng ssortingng1 = SplittoArray[0]; Ssortingng ssortingng2 = SplittoArray[1]; } } 

Sinon, vous pouvez utiliser SsortingngTokenizer:

 import java.util.*; public class Splitting { public static void main(Ssortingng[] args) { SsortingngTokenizer Str = new SsortingngTokenizer("004-034556"); Ssortingng ssortingng1 = Str.nextToken("-"); Ssortingng ssortingng2 = Str.nextToken("-"); } } 

Voici deux manières de l’atteindre.

WAY 1: Comme vous devez séparer deux nombres par un caractère spécial, vous pouvez utiliser regex

 import java.util.regex.Matcher; import java.util.regex.Pattern; public class TrialClass { public static void main(Ssortingng[] args) { Pattern p = Pattern.comstack("[0-9]+"); Matcher m = p.matcher("004-034556"); while(m.find()) { System.out.println(m.group()); } } } 

WAY 2: Utilisation de la méthode de division en chaîne

 public class TrialClass { public static void main(Ssortingng[] args) { Ssortingng temp = "004-034556"; Ssortingng [] arrSsortingng = temp.split("-"); for(Ssortingng splitSsortingng:arrSsortingng) { System.out.println(splitSsortingng); } } } 

Vous pouvez simplement utiliser SsortingngTokenizer pour diviser une chaîne en deux parties ou plus, qu’il y ait des types de délimiteurs:

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

Découvrez la méthode split() dans la classe Ssortingng sur javadoc.

https://docs.oracle.com/javase/7/docs/api/java/lang/Ssortingng.html#split(java.lang.Ssortingng)

 Ssortingng data = "004-034556-1212-232-232"; int cnt = 1; for (Ssortingng item : data.split("-")) { System.out.println("ssortingng "+cnt+" = "+item); cnt++; } 

Voici de nombreux exemples de split ssortingng mais j’ai peu de code optimisé.

 Ssortingng str="004-034556" Ssortingng[] sTemp=str.split("-");// '-' is a delimiter ssortingng1=004 // sTemp[0]; ssortingng2=034556//sTemp[1]; 

En résumé: il y a au moins cinq façons de diviser une chaîne en Java:

  1. Ssortingng.split ():

     Ssortingng[] parts ="10,20".split(","); 
  2. Pattern.comstack (regexp) .splitAsStream (input):

     List ssortingngs = Pattern.comstack("\\|") .splitAsStream("010|020202") .collect(Collectors.toList()); 
  3. SsortingngTokenizer (classe héritée):

     SsortingngTokenizer ssortingngs = new SsortingngTokenizer("Welcome to EXPLAINJAVA.COM!", "."); while(ssortingngs.hasMoreTokens()){ Ssortingng subssortingng = ssortingngs.nextToken(); System.out.println(subssortingng); } 
  4. Google Guava Splitter:

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

     Ssortingng[] ssortingngs = SsortingngUtils.split("1,2,3,4", ","); 

Vous pouvez donc choisir la meilleure option en fonction de vos besoins, par exemple le type de retour (tableau, liste ou itérable).

Voici un aperçu de ces méthodes et des exemples les plus courants (comment séparer par point, barre oblique, point d’interrogation, etc.)

 Ssortingng s="004-034556"; for(int i=0;i 

Comme mentionné par tout le monde, split () est la meilleure option qui peut être utilisée dans votre cas. Une autre méthode peut utiliser la sous-chaîne ().

Pour diviser une chaîne, utilisez Ssortingng.split(regex) :

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

Sortie:

 004 034556 

Je voulais juste écrire un algorithme au lieu d’utiliser les fonctions intégrées de Java:

 public static List split(Ssortingng str, char c){ List 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.toSsortingng()); sb = new SsortingngBuilder(); } } } if(sb.length() >0){ list.add(sb.toSsortingng()); } return list; } 

Pour diviser une chaîne, utilisez Ssortingng.split (regex). Passez en revue les exemples suivants:

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

Sortie

 004 034556 

Remarque Ce split (regex) prend une regex comme argument, n’oubliez pas d’échapper aux caractères spéciaux de regex, comme le point / point.

De la documentation:

public Ssortingng[] split(Ssortingng regex,int limit) Partage cette chaîne autour des correspondances de l’expression régulière donnée . Le tableau renvoyé par cette méthode contient chaque sous-chaîne de cette chaîne qui est terminée par une autre souschaîne qui correspond à l’expression donnée ou qui se termine par la fin de la chaîne. Les sous-chaînes du tableau sont dans l’ ordre dans lequel elles apparaissent dans cette chaîne. Si l’expression ne correspond à aucune partie de l’entrée, le tableau résultant n’a qu’un seul élément , à savoir cette chaîne.

En gros, vous pouvez faire quelque chose comme ceci:

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

Sortie:

 123 456 789 123 
  Ssortingng ssortingng = "004^034556-34"; Ssortingng[] parts = ssortingng.split(Pattern.quote("^")); 

Si vous avez un caractère spécial, vous pouvez utiliser Patter.quote. Si vous avez simplement un tiret (-) alors vous pouvez raccourcir le code:

  Ssortingng ssortingng = "004-34"; Ssortingng[] parts = ssortingng.split("-"); 

Si vous essayez d’append un autre caractère spécial à la place d’un tiret (^), l’erreur générera ArrayIndexOutOfBoundsException . Pour cela, vous devez utiliser Pattern.quote .