Java8 (devrait être)
Soudain, c'est un problème.
Voici le code Java. Qu'arrivera-t-il au résultat de l'exécution?
Première question! Deden ♪
String test = "a-i-u-e-o";
String[] tests = test.split("-");
System.out.println(tests.length);
System.out.println(java.util.Arrays.toString(tests));
5 [a, i, u, e, o]
Avez-vous répondu correctement?
Suivant. Quels sont les résultats ici?
String test = "--o";
String[] tests = test.split("-");
System.out.println(tests.length);
System.out.println(java.util.Arrays.toString(tests));
3 [, , o]
Avez-vous répondu correctement? S'il y a une délimitation au début, elle se comportera comme ceci.
Le suivant est ici. Quels sont les résultats ici? Je pense que vous pouvez vous y attendre d'une manière ou d'une autre.
String test = "a----o";
String[] tests = test.split("-");
System.out.println(tests.length);
System.out.println(java.util.Arrays.toString(tests));
5 [a, , , , o]
Avez-vous répondu correctement?
Eh bien le dernier. Quels sont les résultats ici? Si vous avez répondu correctement jusqu'à présent, Je suis sûr que </ font> est facile. Allons croustillant.
String test = "a--";
String[] tests = test.split("-");
System.out.println(tests.length);
System.out.println(java.util.Arrays.toString(tests));
1 [a]
Avez-vous répondu correctement? Félicitations à ceux qui ont répondu correctement: tada: Il était regrettable que la personne soit partie ... (´ ・ ω ・ `)
Au fait, ma réaction quand j'ai vu ces comportements était comme ça.
？？？？？？？？？？？？？？？？？？？？？？？？？？ Hein ...? Ah, ouais ... Hmm (´_ ゝ ｀) Pourquoi n'est-ce pas?
Ce qui suit est une vue d'ensemble de ce qui a été publié jusqu'à présent.
/*
* Java Playground
* https://code.sololearn.com
*/
class Main {
public static void main(String[ ] args) {
{
String test = "a-i-u-e-o";
String[] tests = test.split("-");
System.out.println(tests.length); // 5
System.out.println(java.util.Arrays.toString(tests)); // [a,i,u,e,o]
}
{
String test = "a-";
String[] tests = test.split("-");
System.out.println(tests.length); // 1
System.out.println(java.util.Arrays.toString(tests)); // [a]
}
{
String test = "-o";
String[] tests = test.split("-");
System.out.println(tests.length); // 2
System.out.println(java.util.Arrays.toString(tests)); // [,o]
}
{
String test = "a--";
String[] tests = test.split("-");
System.out.println(tests.length); // 1
System.out.println(java.util.Arrays.toString(tests)); // [a]
}
{
String test = "--o";
String[] tests = test.split("-");
System.out.println(tests.length); // 3
System.out.println(java.util.Arrays.toString(tests)); // [,,o]
}
{
String test = "a----o";
String[] tests = test.split("-");
System.out.println(tests.length); // 5
System.out.println(java.util.Arrays.toString(tests)); // [a,,,,o]
}
}
}
Qu'est-ce que tu penses. Je Honnêtement, je pense que ça fait du mal Gefun Gefun </ font> Je voulais qu'il soit clair s'il faut ignorer le ciel ou non. Cependant, il peut y avoir une raison à ce comportement. [^ 1]
Au fait, le comportement de la division semble être différent pour chaque langue, alors soyez prudent lorsque vous traitez avec plusieurs langues. À titre d'exemple, voici un exemple de Golang relativement facile à comprendre.
/*
* Golang Playground
* https://play.golang.org/
*/
package main
import (
"fmt"
"strings"
)
func main() {
{
test := "a-i-u-e-o"
tests := strings.Split(test, "-")
fmt.Println(len(tests)) // 5
fmt.Println(tests) // [a i u e o]
}
{
test := "a-"
tests := strings.Split(test, "-")
fmt.Println(len(tests)) // 2
fmt.Println(tests) // [a ]
}
{
test := "-o"
tests := strings.Split(test, "-")
fmt.Println(len(tests)) // 2
fmt.Println(tests) // [ o]
}
{
test := "a--"
tests := strings.Split(test, "-")
fmt.Println(len(tests)) // 3
fmt.Println(tests) // [a ]
}
{
test := "--o"
tests := strings.Split(test, "-")
fmt.Println(len(tests)) // 3
fmt.Println(tests) // [ o]
}
{
test := "a----o"
tests := strings.Split(test, "-")
fmt.Println(len(tests)) // 5
fmt.Println(tests) // [a o]
}
}
Après avoir vu le comportement de Java, cela semble simple ...
Java split semble ignorer le délimiteur le plus à droite, donc Si vous souhaitez imiter le même comportement dans Golang, vous souhaiterez peut-être supprimer le délimiteur le plus à droite, puis fractionner. Je ne sais pas s'il y a une demande, mais je vais coller un échantillon. Je ne sais pas s'il y a une demande.
package main
import (
"fmt"
"strings"
)
func main() {
{
test := "a-i-u-e-o"
tests := javaSplit(test, "-")
fmt.Println(len(tests)) // 5
fmt.Println(tests) // [a i u e o]
}
{
test := "a-"
tests := javaSplit(test, "-")
fmt.Println(len(tests)) // 1
fmt.Println(tests) // [a]
}
{
test := "-o"
tests := javaSplit(test, "-")
fmt.Println(len(tests)) // 2
fmt.Println(tests) // [ o]
}
{
test := "a--"
tests := javaSplit(test, "-")
fmt.Println(len(tests)) // 1
fmt.Println(tests) // [a]
}
{
test := "--o"
tests := javaSplit(test, "-")
fmt.Println(len(tests)) // 3
fmt.Println(tests) // [ o]
}
{
test := "a----o"
tests := javaSplit(test, "-")
fmt.Println(len(tests)) // 5
fmt.Println(tests) // [a o]
}
}
//Chaîne Java#split(delimiter)Imiter
func javaSplit(str string, delimiter string) []string {
return strings.Split(strings.TrimRight(str, delimiter), delimiter)
}
Eh bien, si vous voulez que Java se comporte comme Golang ...? ~~ Ah ... .. .Veuillez faire de votre mieux! ~~
[Une addition]
Eh bien, si vous voulez que Java se comporte comme Golang ...?
@ saka1029 m'a appris!
Dois-je spécifier un nombre négatif pour le deuxième argument? ([String.split (String, int)](https://docs.oracle.com/javase/jp/13/docs/api/java.base/java/lang/String.html#split (java.lang.) Chaîne, int))))
String[] test = "a--".split("-", -1); System.out.println(test.length); // -> 3 System.out.println(Arrays.toString(test)); // -> [a, , ]
public String[] split(String regex, int limit)
Le paramètre> limit contrôle le nombre de fois où ce modèle est appliqué, affectant ainsi la longueur du tableau résultant.
- Si la "limite" est positive, le modèle s'applique à la plupart des "limites". -Une fois que la longueur du tableau ne dépasse pas la "limite", toutes les entrées au-delà du dernier délimiteur correspondant sont incluses dans la dernière entrée du tableau.
- Si la "limite" est zéro, le modèle est appliqué autant de fois que possible, le tableau peut être de n'importe quelle longueur, et toutes les chaînes vides suivantes sont supprimées.
- Si "Limit" est négatif, le motif sera appliqué chaque fois que possible et la longueur du tableau sera arbitraire.
Exactement ça! Yay! ~~ Ou plutôt, lisez javadoc avant d'écrire ~~ Le lien est java13 doc, mais java8 Est le même.
J'apprécierais si vous pouviez commenter si vous avez quelque chose comme "C'est mauvais ici" ou "Ce mec!" ₍₍ (ง ˘ω˘) ว ⁾⁾ Zéro ne me dit rien ...
[^ 1]: Il ne fait aucun doute qu'il s'agit d'une spécification pour le moment. https://docs.oracle.com/javase/jp/8/docs/api/java/lang/String.html#split-java.lang.String-