Java: Que fait l’opérateur deux points (:)?

Il y a plusieurs endroits où les deux points sont utilisés dans le code Java:

1) Etiquette Jump-out ( Tutorial ):

 label: for (int i = 0; i < x; i++) { for (int j = 0; j < i; j++) { if (something(i, j)) break label; // jumps out of the i loop } } // ie jumps to here 

2) condition ternaire ( tutoriel ):

 int a = (b < 4)? 7: 8; // if b < 4, set a to 7, else set a to 8 

3) Pour chaque boucle ( tutoriel ):

 Ssortingng[] ss = {"hi", "there"} for (Ssortingng s: ss) { print(s); // output "hi" , and "there" on the next iteration } 

4) Assertion ( Guide ):

 int a = factorial(b); assert a >= 0: "factorial may not be less than 0"; // throws an AssertionError with the message if the condition evaluates to false 

5) Case in switch statement ( Tutorial ):

 switch (type) { case WHITESPACE: case RETURN: break; case NUMBER: print("got number: " + value); break; default: print("syntax error"); } 

6) Références de méthodes ( tutoriel )

 class Person { public static int compareByAge(Person a, Person b) { return a.birthday.compareTo(b.birthday); }} } Arrays.sort(persons, Person::compareByAge); 

Il n’y a pas d’opérateur “deux points”, mais les deux points apparaissent à deux endroits:

1: dans l’opérateur ternaire, par exemple:

 int x = bigInt ? 10000 : 50; 

Dans ce cas, l’opérateur ternaire agit comme un “si” pour les expressions. Si bigInt est vrai, alors x recevra 10000. Sinon, 50. Le côlon signifie ici “sinon”.

2: Dans une boucle for-each:

 double[] vals = new double[100]; //fill x with values for (double x : vals) { //do something with x } 

Cela définit x à chacune des valeurs dans «vals» à tour de rôle. Donc si vals contient [10, 20.3, 30, …], alors x sera 10 à la première itération, 20.3 à la seconde, etc.

Note: je dis que ce n’est pas un opérateur car c’est juste de la syntaxe. Il ne peut pas apparaître dans une expression donnée par lui-même, et il est juste possible que l’opérateur for-each et l’opérateur ternaire utilisent tous deux un signe deux-points.

Juste pour append, lorsqu’il est utilisé dans une boucle for-each, le “:” peut fondamentalement être lu comme “in”.

Alors

 for (Ssortingng name : names) { // remainder omitted } 

doit être lu “Pour chaque nom, les noms IN font …”

Comment pourriez-vous écrire ceci pour chaque boucle d’une manière différente afin de ne pas incorporer le “:”?

En supposant que cette list soit une instance de Collection …

 public Ssortingng toSsortingng() { Ssortingng cardSsortingng = ""; for (Iterator it = this.list.iterator(); it.hasNext(); /**/) { PlayingCard c = it.next(); cardSsortingng = cardSsortingng + c + "\n"; } } 

Je devrais append le point pédant que : n’est pas un opérateur dans ce contexte. Un opérateur effectue une opération dans une expression, et le contenu de ( ... ) dans une instruction for n’est pas une expression … selon le JLS.

Il est utilisé dans les boucles pour parcourir une liste d’objects.

 for (Object o: list) { // o is an element of list here } 

Pensez-y comme un for in dans Python.

Dans votre cas spécifique,

 Ssortingng cardSsortingng = ""; for (PlayingCard c : this.list) // <-- { cardString = cardString + c + "\n"; } 

this.list est une collection (list, set ou array) et ce code assigne c à chaque élément de la collection.

Donc, si this.list était une collection {"2S", "3H", "4S"}, alors le cardSsortingng à la fin serait cette chaîne:

 2S 3H 4S 

Vous le voyez généralement dans l’opérateur d’affectation ternaire;

Syntaxe

 variable = `condition ? result 1 : result 2;` 

Exemple:

 boolean isNegative = number > 0 ? false : true; 

ce qui est “équivalent” dans la nature du sinon

 if(number > 0){ isNegative = false; } else{ isNegative = true; } 

Autre que des exemples donnés par différentes affiches,

vous pouvez également utiliser: pour indiquer une étiquette pour un bloc que vous pouvez utiliser en conjonction avec continuer et casser ..

par exemple:

 public void someFunction(){ //an infinite loop goBackHere: { //label for(int i = 0; i < 10 ;i++){ if(i == 9 ) continue goBackHere; } } } 

Il imprimera la chaîne “quelque chose” trois fois.

 JLabel[] labels = {new JLabel(), new JLabel(), new JLabel()}; for ( JLabel label : labels ) { label.setText("something"); panel.add(label); } 

Comme la plupart des boucles sont très similaires, Java fournit un raccourci pour réduire la quantité de code requirejse pour écrire la boucle appelée pour chaque boucle.

Voici un exemple de la concise pour chaque boucle:

 for (Integer grade : quizGrades){ System.out.println(grade); } 

Dans l’exemple ci-dessus, les deux points (:) peuvent être lus comme “in”. Le pour chaque boucle peut être lu comme “pour chaque élément entier (appelé grade) dans les quizGrades, imprimez la valeur de grade.”

Il est utilisé dans la nouvelle main courte pour / loop

 final List list = new ArrayList(); for (final Ssortingng s : list) { System.out.println(s); } 

et l’opérateur ternaire

 list.isEmpty() ? true : false; 

Le côlon existe réellement en conjonction avec ?

 int minVal = (a < b) ? a : b; 

est équivalent à:

 int minval; if(a < b){ minval = a;} else{ minval = b; } 

Aussi dans le pour chaque boucle:

 for(Node n : List l){ ... } 

Littéralement:

 for(Node n = l.head; n.next != null; n = n.next) 

les deux points sont utilisés pour chaque boucle, Essayez cet exemple,

 import java.util.*; class ForEachLoop { public static void main(Ssortingng args[]) {`enter code here` Integer[] iray={1,2,3,4,5}; Ssortingng[] sray={"ENRIQUE IGLESIAS"}; printME(iray); printME(sray); } public static void printME(Integer[] i) { for(Integer x:i) { System.out.println(x); } } public static void printME(Ssortingng[] i) { for(Ssortingng x:i) { System.out.println(x); } } }