J'essaie de comprendre le fonctionnement de la méthode de scission et d'avoir une légère confusion à ce sujet. Dans cet exemple, donné dans les pages de documentation d'Oracle,
String str = "boo:and:foo";
String[] str1 = str.split("o",2);
Output
b
o:and:foo
Ceci est facile à comprendre, que la chaîne a été littéralement divisée à la suite du premier "o"
mais pour
String[] str1 = str.split("o",3);
Output:
b
:and:foo
Comment cela sort-il en tant que tel?
Réponses:
3 pour la réponse № 1Ce que je comprends de la documentation:
Le paramètre limit contrôle le nombre de fois où le motif est appliquée et affecte donc la longueur du tableau résultant. Si la limite n est supérieure à zéro alors lamotif sera appliqué à la plupart des n - 1 fois, la longueur du tableau ne sera pas supérieure à n, et la dernière entrée du tableau contiendra toutes les entrées au-delà de la dernière mise en correspondance délimiteur. Si n est non positif, le motif seraappliqué comme autant de fois que possible et le tableau peut avoir n'importe quelle longueur. Si n est zéro alors le motif sera appliqué autant de fois que possible, le tableau peut avoir n'importe quelle longueur et les chaînes vides qui suivront seront ignorées.
Cela signifie concevoir ou couper en n fois sur une chaîne de caractères, analysons donc un par un pour mieux comprendre:
Limite 1
String[] spl1 = str.split("o", 1);
Cela signifie le scinder ou le couper sur une seule chaîne de la chaîne o dans ce cas, vous obtiendrez toute votre contribution:
[boo:and:foo]
1
Limite 2
String[] spl1 = str.split("o", 2);
Ce qui signifie le couper une fois sur o donc je vais mettre une pause dans le premier o
boo:and:foo
-----^
dans ce cas, vous obtiendrez deux résultats:
[b,o:and:foo]
1 2
Limite 3
String[] spl1 = str.split("o", 3);
Ce qui signifie le couper deux fois le premier o et sur le second o
boo:and:foo
1----^^--------------2
dans ce cas, vous obtiendrez trois résultats:
[b, ,:and:foo]
1 2 3
Limite 4
String[] spl1 = str.split("o", 4);
Ce qui signifie le couper trois fois sur les premier, deuxième et troisième o
boo:and:foo
1_____^^ ^
|___2 |___3
dans ce cas, vous obtiendrez quatre résultats:
[b, ,:and:f,o]
1 2 3 4
Limite 5
String[] spl1 = str.split("o", 5);
Ce qui signifie le couper quatre fois sur les premier, deuxième, troisième et quatrième o
boo:and:foo
1_____^^ ^^
|___2 ||___4
|____3
dans ce cas, vous obtiendrez cinq résultats:
[b, ,:and:f, , ]
1 2 3 4 5
Juste une simple animation pour mieux comprendre:
1 pour la réponse № 2
Le deuxième paramètre représente le nombre de fois que le motif doit être appliqué.
De Java Docs:
Le paramètre limit contrôle le nombre de foisle motif est appliquée et affecte donc la longueur du tableau résultant. Si la limite n est supérieure à zéro, le motif sera appliqué à la plupart des n - 1 fois, la longueur du tableau ne sera pas supérieure à n, et la dernière entrée du tableau contiendra toutes les entrées au-delà de la dernière mise en correspondance délimiteur. Si n est non positif, le motif sera appliqué comme autant de fois que possible et le tableau peut avoir n'importe quelle longueur. Si n est zéro alors le motif sera appliqué autant de fois que possible, le tableau peut avoir n'importe quelle longueur et les chaînes vides qui suivront seront ignorées.
Exemple:
1) si la limite est fixée à zéro (str.split ("o", 0)) alors, selon java docs, le motif sera appliqué autant de fois que possible pour donner le résultat suivant:
[b,,: et: f]
2) mais si vous définissez la limite sur une valeur non nulle (e.g. 1 ou 2), le motif sera appliqué n-1 fois (par exemple, pour la limite 1, le motif sera appliqué 0 fois et pour 2, il s'appliquera 1 fois). Le résultat sera donc inférieur à:
[boo: and: foo] // pour str.split ("o", 1) appliqué 0 fois.
[b, o: et: toto] // pour str.split ("o", 2) appliqué 1 fois.
[b,,: et: toto] // pour str.split ("o", 3) appliqué 2 fois.
0 pour la réponse № 3
Le deuxième argument est le nombre de fois que l'expression régulière est appliquée à la chaîne. Donc, si la limite est 3, vous obtenez b,,:and:foo: Fractionner la chaîne en jeton au point d’occurrence du motif. Notez que la limite peut être supérieure au nombre d'occurrences de l'expression rationnelle dans la chaîne réelle.
0 pour la réponse № 4
String[] split(String regex, int limit)
Le second paramètre limite le nombre de chaînes renvoyées après la division.
Par exemple split("anydelimiter", 3) renverrait le tableau de seulement 3 chaînes même si le délimiteur est présent dans la chaîne plus de 3 fois.
Si la limite est négative, le tableau retournéaurait autant de sous-chaînes que possible, mais lorsque la limite est zéro, le tableau retourné aurait toutes les sous-chaînes à l'exclusion des chaînes vides de fin.
0 pour la réponse № 5
La demande de méthode pour deux paramètres split(String regex, int limit).
regex - l'expression régulière délimitante;
limit - le seuil de résultat.
0 pour la réponse № 6
**regex** − the delimiting regular expression
String Str = new String("boo:and:foo:com:boo");
System.out.println("Return value1: ");
for (String retval : Str.split(":", 2)) {
System.out.println(retval);
}
System.out.println();
System.out.println("Return value2: ");
for (String retval : Str.split(":", 3)) {
System.out.println(retval);
}
System.out.println();
System.out.println("Return value3: ");
for (String retval : Str.split(":", 0)) {
System.out.println(retval);
}
System.out.println();
System.out.println("Return value4: ");
for (String retval : Str.split(":")) {
System.out.println(retval);
}
}
Testez vous-même chaque valeur1,2,3,4
0 pour la réponse № 7
voici la documentation pour limite
<p> The <tt>limit</tt> parameter controls the number of times the
* pattern is applied and therefore affects the length of the resulting
* array. If the limit <i>n</i> is greater than zero then the pattern
* will be applied at most <i>n</i> - 1 times, the array"s
* length will be no greater than <i>n</i>, and the array"s last entry
* will contain all input beyond the last matched delimiter. If <i>n</i>
* is non-positive then the pattern will be applied as many times as
* possible and the array can have any length. If <i>n</i> is zero then
* the pattern will be applied as many times as possible, the array can
* have any length, and trailing empty strings will be discarded.
et le code source de la méthode split de la classe String.
public String[] split(String regex, int limit) {
/* fastpath if the regex is a
(1)one-char String and this character is not one of the
RegEx"s meta characters ".$|()[{^?*+\", or
(2)two-char String and the first char is the backslash and
the second is not the ascii digit or ascii letter.
*/
char ch = 0;
if (((regex.value.length == 1 &&
".$|()[{^?*+\".indexOf(ch = regex.charAt(0)) == -1) ||
(regex.length() == 2 &&
regex.charAt(0) == "\" &&
(((ch = regex.charAt(1))-"0")|("9"-ch)) < 0 &&
((ch-"a")|("z"-ch)) < 0 &&
((ch-"A")|("Z"-ch)) < 0)) &&
(ch < Character.MIN_HIGH_SURROGATE ||
ch > Character.MAX_LOW_SURROGATE))
{
int off = 0;
int next = 0;
boolean limited = limit > 0;
ArrayList<String> list = new ArrayList<>();
while ((next = indexOf(ch, off)) != -1) {
if (!limited || list.size() < limit - 1) {
list.add(substring(off, next));
off = next + 1;
} else { // last one
//assert (list.size() == limit - 1);
list.add(substring(off, value.length));
off = value.length;
break;
}
}
// If no match was found, return this
if (off == 0)
return new String[]{this};
// Add remaining segment
if (!limited || list.size() < limit)
list.add(substring(off, value.length));
// Construct result
int resultSize = list.size();
if (limit == 0)
while (resultSize > 0 && list.get(resultSize - 1).length() == 0)
resultSize--;
String[] result = new String[resultSize];
return list.subList(0, resultSize).toArray(result);
}
return Pattern.compile(regex).split(this, limit);
}
voir cette portion de code
boolean limited = limit > 0;
ArrayList<String> list = new ArrayList<>();
while ((next = indexOf(ch, off)) != -1) {
if (!limited || list.size() < limit - 1) {
list.add(substring(off, next));
off = next + 1;
} else { // last one
//assert (list.size() == limit - 1);
list.add(substring(off, value.length));
off = value.length;
break;
}
}
la taille de la liste résultante sera au maximum.