Comment diviser une chaîne en Java
J'ai une chaîne, "004-034556", que je veux diviser en deux chaînes:
string1="004";
string2="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: String#split() .
String string = "004-034556";
String[] parts = string.split("-");
String part1 = parts[0]; // 004
String part2 = parts[1]; // 034556
Notez que ceci prend une expression regular , donc n'oubliez pas d'échapper aux caractères spéciaux si nécessaire.
là 12 caractères ayant une signification spéciale: la barre oblique inverse
\, le caret^, le signe dollar$, le point ou le code., la barre verticale ou le symbole représentant un tuyau|, le point d'interrogation?, l'astérisque ou l'étoile*, le signe plus+, la parenthèse ouvrante(, la parenthèse fermante)et le crochet ouvrant[, l'accolade ouvrante{, ces caractères spéciaux sont souvent appelés "méta-caractères".
Donc, si vous voulez diviser par exemple point/point . qui signifie " tout caractère " dans regex, utilisez soit barre oblique inverse \ pour échapper au caractère spécial individuel tel que so split("\\."), ou utilisez character class [] pour représenter un caractère littéral (s ) comme tel split("[.]"), ou utilisez Pattern#quote() pour échapper à la chaîne entière comme ceci split(Pattern.quote(".")).
String[] parts = string.split(Pattern.quote(".")); // Split on period.
Pour tester au préalable si la chaîne contient certains caractères, utilisez simplement String#contains() .
if (string.contains("-")) {
// Split it.
} else {
throw new IllegalArgumentException("String " + string + " does not contain -");
}
Notez que cela ne prend pas une expression régulière. Pour cela, utilisez String#matches() à la place.
Si vous souhaitez conserver le caractère fractionné dans les parties résultantes, utilisez alors positive lookaround . Si vous souhaitez que le caractère divisé se retrouve dans le côté gauche, utilisez une recherche positive en préfixant le groupe ?<= dans le modèle.
String string = "004-034556";
String[] parts = string.split("(?<=-)");
String part1 = parts[0]; // 004-
String part2 = parts[1]; // 034556
Si vous souhaitez que le caractère fractionné se termine dans le côté droit, utilisez une anticipation positive en préfixant le groupe ?= dans le modèle.
String string = "004-034556";
String[] parts = string.split("(?=-)");
String part1 = parts[0]; // 004
String part2 = parts[1]; // -034556
Si vous souhaitez limiter le nombre de pièces résultantes, vous pouvez fournir le nombre souhaité en tant que deuxième argument de la méthode split().
String string = "004-034556-42";
String[] parts = string.split("-", 2);
String part1 = parts[0]; // 004
String part2 = parts[1]; // 034556-42
Une alternative au traitement direct de la chaîne serait d'utiliser une expression régulière avec des groupes de capture. Cela a l’avantage d’impliquer des contraintes plus sophistiquées en entrée. Par exemple, ce qui suit divise la chaîne en deux parties et garantit qu’elles ne sont composées que de chiffres:
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");
}
}
Comme le modèle est corrigé dans ce cas, 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 désignent les groupes de capture; la chaîne qui correspond à cette partie de l'expression rationnelle est accessible via la méthode Match.group (), comme indiqué. Le\d correspond au chiffre avec une décimale, et le + signifie "correspond à une ou plusieurs expressions précédentes). Le - n'a pas de signification particulière, donc correspond uniquement à ce caractère dans l'entrée. Notez que vous devez double-échapper les barres obliques inverses lors de l'écriture en tant que chaîne Java, voici d'autres exemples:
([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");
Cela divisera votre chaîne en 2 parties. Le premier élément du tableau sera la partie contenant les éléments précédant 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'était pas au format: string-string.
Découvrez la méthode split() dans la 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("-");
devrait faire la chose que vous voulez. La classe String a de nombreuses méthodes à utiliser avec string.
Les exigences laissaient place à l’interprétation. Je recommande d'écrire une méthode,
public final static String[] mySplit(final String s)
qui encapsulent cette fonction. Bien sûr, vous pouvez utiliser String.split (..) comme indiqué dans les autres réponses pour la mise en oeuvre.
Vous devez écrire des tests unitaires pour les chaînes d'entrée et les résultats et comportements souhaités.
Les bons candidats au test 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 être renvoyé dans [,333] ou s'il s'agit d'une erreur . "333-333-33" peut-il être séparé dans [333,333-33] or [333-333,33] ou s'agit-il d'une erreur? Etc.
Avec Java 8:
List<String> stringList = Pattern.compile("-")
.splitAsStream("004-034556")
.collect(Collectors.toList());
stringList.forEach(s -> System.out.println(s));
Utilisez org.Apache.commons.lang.StringUtils ' split méthode qui peut fractionner des chaînes en fonction du caractère ou de la chaîne que vous souhaitez fractionner.
Signature de la méthode:
public static String[] split(String str, char separatorChar);
Dans votre cas, vous voulez diviser une chaîne quand il y a un "-".
Vous pouvez simplement faire comme suit:
String str = "004-034556";
String split[] = StringUtils.split(str,"-");
Sortie:
004
034556
Supposons que si - n'existe pas dans votre chaîne, il retourne la chaîne donnée et vous n'obtiendrez aucune exception.
En admettant que
- vous n'avez pas vraiment besoin d'expressions régulières pour votre scission
- vous utilisez déjà Apache commons lang dans votre application
Le moyen le plus simple consiste à utiliser StringUtils # split (Java.lang.String, char) . C'est plus pratique que celui fourni par Java prêt à l'emploi si vous n'avez pas besoin d'expressions régulières. Comme son manuel l'indique, cela fonctionne comme ceci:
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"]
Je recommanderais d'utiliser commong-lang, car il contient généralement beaucoup de choses utilisables. Cependant, si vous n'en avez pas besoin pour autre chose que la scission, alors vous implémenter vous-même ou vous échapper de la regex est une meilleure option.
Vous pouvez essayer comme ça aussi
String concatenated_String="hi^Hello";
String split_string_array[]=concatenated_String.split("\\^");
Chaîne avec plusieurs caractères utilisant 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]);
}
}
}
Sortie:
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
Mais n'attendez pas la même sortie pour toutes les versions de JDK. J'ai vu un bogue qui existe dans certaines versions de JDK où la première chaîne nulle a été ignorée. Ce bogue n'apparaît pas dans la dernière version du JDK, mais il existe dans certaines versions entre les dernières versions de JDK 1.7 et les versions antérieures 1.8.
Pour les cas d'utilisation simples String.split() devrait faire l'affaire. Si vous utilisez goyave, il existe également une classe Splitter qui permet de chaîner différentes opérations sur les chaînes et prend en charge 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);
}
}
Le moyen le plus rapide, qui consomme également le moins de ressources, pourrait être:
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 '-'
}
Vous pouvez diviser une chaîne par un saut de ligne en utilisant l'instruction suivante:
String textStr[] = yourString.split("\\r?\\n");
Vous pouvez diviser une chaîne par un trait d'union/caractère en utilisant l'instruction suivante:
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]);
}
}
}
Pour résumer: il existe au moins cinq méthodes pour diviser une chaîne en Java:
String.split ():
String[] parts ="10,20".split(",");Pattern.compile (regexp) .splitAsStream (entrée):
List<String> strings = Pattern.compile("\\|") .splitAsStream("010|020202") .collect(Collectors.toList());StringTokenizer (classe héritée):
StringTokenizer strings = new StringTokenizer("Welcome to EXPLAINJAVA.COM!", "."); while(strings.hasMoreTokens()){ String substring = strings.nextToken(); System.out.println(substring); }Google Guava Splitter:
Iterable<String> result = Splitter.on(",").split("1,2,3,4");Apache Commons StringUtils:
String[] strings = StringUtils.split("1,2,3,4", ",");
Ainsi, vous pouvez choisir la meilleure option pour vous en fonction de vos besoins, par exemple. type de retour (tableau, liste ou itérable).
Ici est un grand aperçu de ces méthodes et des exemples les plus courants (comment scinder par points, barres obliques, points d'interrogation, etc.)
N'utilisez pas la classe StringTokenizer car il s'agit d'une classe héritée conservée pour des raisons de compatibilité. Son utilisation est déconseillée dans le nouveau code. Et nous pouvons également utiliser la méthode de scission proposée par d’autres.
String[] sampleTokens = "004-034556".split("-");
System.out.println(Arrays.toString(sampleTokens));
Et comme prévu, il imprimera:
[004, 034556]
Dans cette réponse, je souhaite également signaler un changement intervenu pour la méthode split en Java 8. La méthode String # split () utilise Pattern.split et supprime désormais les chaînes vides au début du tableau de résultats. Notez cette modification dans la documentation pour Java 8:
Lorsqu'il y a une correspondance de largeur positive au début de l'entrée séquence, une chaîne principale vide est incluse au début du tableau résultant. Une correspondance de largeur zéro au début cependant ne produit jamais une telle sous-chaîne principale vide.
Cela signifie pour l'exemple suivant:
String[] sampleTokensAgain = "004".split("");
System.out.println(Arrays.toString(sampleTokensAgain));
nous aurons trois chaînes: [0, 0, 4] et non quatre comme c'était le cas dans Java 7 et les versions antérieures. Cochez également cette question similaire.
Une façon de procéder consiste à parcourir la chaîne dans une boucle for-each et à utiliser le caractère fractionné requis.
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);
}
}
Sortie:
The split parts of the String are:
004
034556
Vous pouvez utiliser 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];
}
}
Sinon, vous pouvez utiliser 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("-");
}
}
Voici deux manières d'y parvenir.
VOIE 1: Comme vous devez diviser 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(String[] args)
{
Pattern p = Pattern.compile("[0-9]+");
Matcher m = p.matcher("004-034556");
while(m.find())
{
System.out.println(m.group());
}
}
}
VOIE 2: Utilisation de la méthode de division de chaîne
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);
}
}
}
Vous pouvez simplement utiliser StringTokenizer pour scinder une chaîne en plusieurs parties, qu’il existe un type de délimiteur:
StringTokenizer st = new StringTokenizer("004-034556", "-");
while(st.hasMoreTokens())
{
System.out.println(st.nextToken());
}
Découvrez la méthode split() dans la classe String sur 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++;
}
Ici beaucoup d'exemples pour split string mais j'ai peu de code optimisé.
String str="004-034556"
String[] sTemp=str.split("-");// '-' is a delimiter
string1=004 // sTemp[0];
string2=034556//sTemp[1];
Il ne faut vraiment envisager que deux méthodes.
Utilisez String.split si un séparateur d'un caractère ou si vous ne vous souciez pas des performances
Si les performances ne posent pas de problème ou si le délimiteur est un caractère unique qui n'est pas un caractère spécial d'expression régulière (c'est-à-dire, pas un de .$|()[{^?*+\), vous pouvez utiliser String.split.
String[] results = input.split(",");
La méthode de scission utilise une optimisation pour éviter d'utiliser une expression régulière si le séparateur est un caractère unique et non dans la liste ci-dessus. Sinon, il doit compiler une expression régulière et ce n'est pas idéal.
Utilisez Pattern.split et précompilez le motif si vous utilisez un délimiteur complexe et que vous vous souciez des performances
Si les performances posent problème et que votre délimiteur n’est pas l’un des précédents, vous devez pré-compiler un motif d’expression régulière que vous pourrez ensuite réutiliser.
// Save this somewhere
Pattern pattern = Pattern.compile("[,;:]");
/// ... later
String[] results = pattern.split(input);
Cette dernière option crée toujours un nouvel objet Matcher. Vous pouvez également mettre cet objet en cache et le réinitialiser pour chaque entrée afin d'optimiser les performances, mais cela est un peu plus compliqué et non thread-safe.
Je voulais juste écrire un algorithme au lieu d'utiliser les fonctions intégrées de 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;
}
Pour fractionner une chaîne, utilisez String.split(regex):
String phone = "004-034556";
String[] output = phone.split("-");
System.out.println(output[0]);
System.out.println(output[1]);
Sortie:
004
034556
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));
}
}
Comme mentionné par tout le monde, split () est la meilleure option à utiliser dans votre cas. Une autre méthode peut utiliser substring ().
Pour fractionner une chaîne, utilisez String.split (regex). Passez en revue les exemples suivants:
String data = "004-034556";
String[] output = data.split("-");
System.out.println(output[0]);
System.out.println(output[1]);
Sortie
004
034556
Note Cette division (regex) prend une expression rationnelle en argument, n'oubliez pas d'échapper aux caractères spéciaux de l'expression rationnelle, tels que point/période.
J'ai utilisé une chaîne appelée stringValue et se présente sous la forme suivante: "Ceux qui avaient des pièces de monnaie, qui jouissaient sous la pluie, ceux qui avaient des billets étaient occupés à chercher l'abri".
Je vais scinder la stringValue en utilisant le "," comme deux points.
Et puis, je voudrais simplement SetText () de 3 TextViews différents pour afficher cette chaîne.
String stringValue = "Those who had coins, enjoyed in the rain, those who had notes were busy looking for the shelter";
String ValueSplitByColon[] = stringValue.split(",");
String firstValue = ValueSplitByColon[0];
String secondValue = ValueSplitByColon[1];
String thirdValue = ValueSplitByColon[2];
txtV1.setText(firstValue);
txtV2.setText(secondValue;
txtV3.setText(thirdValue;
Il donne la sortie en tant que:
la valeur de txtV1 est la suivante:
la valeur de txtV2 est: -appréciée sous la pluie
la valeur de txtV3 est la suivante: -les personnes qui avaient des notes étaient occupées à chercher le refuge
vous pouvez utiliser la méthode 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 \"-\".");
}
}
}