[Java] Un petit comportement de scission mystérieux

Environnement de l'écrivain

Java8 (devrait être)

quiz divisé

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));

Réponse

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));

Réponse

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));

Réponse

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));

Réponse

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?

Java fractionné

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]

Serpentin

Golang se sépare

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 split sample

/*
 * 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 ...

appendice

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.

Golang se comporte comme un split Java (1 membre)

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, , ]

Extrait de javadoc

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.

à la fin

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-