Que fait l'opérateur deux-points (:)?
Apparemment, deux points sont utilisés de différentes manières en Java. Est-ce que cela vous dérangerait d'expliquer ce que cela fait?
Par exemple ici:
String cardString = "";
for (PlayingCard c : this.list) // <--
{
cardString += c + "\n";
}
Comment écririez-vous ceci for-each _ boucle d’une manière différente pour ne pas incorporer le :?
Il y a plusieurs endroits où deux points sont utilisés dans Java code:
1) Libellé de saut ( 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
}
}
// i.e. jumps to here
2) Condition ternaire ( Tutorial ):
int a = (b < 4)? 7: 8; // if b < 4, set a to 7, else set a to 8
3) Pour chaque boucle ( Tutorial ):
String[] ss = {"hi", "there"}
for (String 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) Cas dans l'instruction switch ( 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 ( Tutorial )
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, x0000 lui seront attribués. Sinon, 50. Les deux points ici signifient "sinon".
2: Dans une boucle pour chaque:
double[] vals = new double[100];
//fill x with values
for (double x : vals) {
//do something with x
}
Cela définit x sur chacune des valeurs de 'vals' tour à tour. Donc si vals contient [10, 20.3, 30, ...], alors x sera 10 à la première itération, 20.3 à la seconde, etc.
Remarque: je dis que ce n'est pas un opérateur parce que c'est juste une syntaxe. Il ne peut pas apparaître dans une expression donnée en tant que telle, et il y a de fortes chances que l'opérateur for-each et l'opérateur ternaire utilisent tous deux un colon.
Il suffit d'ajouter que, lorsqu'il est utilisé dans une boucle for-each, le ":" peut fondamentalement être lu comme "in".
Alors
for (String name : names) {
// remainder omitted
}
devrait être lu "Pour chaque nom dans les noms faire ..."
Comment écririez-vous cette boucle pour chaque boucle d'une manière différente afin de ne pas incorporer le ":"?
En supposant que list soit une instance de Collection ...
public String toString() {
String cardString = "";
for (Iterator<PlayingCard> it = this.list.iterator(); it.hasNext(); /**/) {
PlayingCard c = it.next();
cardString = cardString + c + "\n";
}
}
Je devrais ajouter 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 la ( ... ) dans une instruction for n’est pas une expression ... selon le JLS.
Comme la plupart des boucles for sont très similaires, Java fournit un raccourci pour réduire la quantité de code nécessaire pour écrire la boucle appelée la pour chaque boucle.
Voici un exemple de concis 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 en tant que "pour chaque élément Integer (appelé grade) dans quizGrades, affichez la valeur de grade."
Il est utilisé dans les boucles pour parcourir une liste d'objets.
for (Object o: list)
{
// o is an element of list here
}
Pensez-y comme un for <item> in <list> en Python.
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);
}
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;
qui est "équivalent" dans la nature à la if else
if(number > 0){
isNegative = false;
}
else{
isNegative = true;
}
Autres que des exemples donnés par différentes affiches,
vous pouvez également utiliser: pour désigner une étiquette pour un bloc que vous pouvez utiliser conjointement avec continue et break.
par exemple:
public void someFunction(){
//an infinite loop
goBackHere: { //label
for(int i = 0; i < 10 ;i++){
if(i == 9 ) continue goBackHere;
}
}
}
Dans votre cas particulier,
String cardString = "";
for (PlayingCard c : this.list) // <--
{
cardString = cardString + c + "\n";
}
this.list est une collection (liste, ensemble ou tableau), et ce code attribue c à chaque élément de la collection.
Donc si this.list étaient une collection {"2S", "3H", "4S"} puis le cardString à la fin serait cette chaîne:
2S
3H
4S
les deux points utilisent dans pour-chaque boucle, essayez cet exemple,
import Java.util.*;
class ForEachLoop
{
public static void main(String args[])
{`enter code here`
Integer[] iray={1,2,3,4,5};
String[] 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(String[] i)
{
for(String x:i)
{
System.out.println(x);
}
}
}
Il est utilisé dans la nouvelle main courte pour/loop
final List<String> list = new ArrayList<String>();
for (final String 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)