Que fait l'opérateur deux-points (:)?

Apparemment, un deux-points est utilisé de plusieurs manières en Java. Quelqu'un voudrait-il expliquer ce qu'il fait?

Par exemple ici:

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

Comment écririez-vous cette for-eachboucle différemment pour ne pas incorporer le :?

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

1) Étiquette de saut ( Tutoriel ):

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 ( Tutoriel ):

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

3) Pour chaque boucle ( Tutoriel ):

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 ( Tutoriel ):

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

6) Références de méthode ( 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 assignés. Sinon, 50. Le signe deux-points signifie ici "autre".

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 de «vals» à son tour. Donc, si vals contient [10, 20.3, 30, ...], alors x sera 10 sur la première itération, 20.3 sur la seconde, etc.

Remarque: je dis que ce n'est pas un opérateur parce que c'est juste de la syntaxe. Il ne peut apparaître dans aucune expression donnée par lui-même, et c'est juste une chance que l'opérateur for-each et l'opérateur ternaire utilisent un deux-points.

Juste pour ajouter, lorsqu'il est utilisé dans une boucle for-each, le ":" peut être lu comme "in".

Donc

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

doit être lu "Pour chaque nom dans les noms font ..."

Comment écririez-vous cette boucle pour chaque boucle d'une manière différente afin de ne pas incorporer le ":"?

En supposant que ce listsoit une Collectioninstance ...

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 qui :n'est pas un opérateur dans ce contexte. Un opérateur effectue une opération dans une expression, et les éléments contenus ( ... )dans une forinstruction ne sont pas une expression ... selon le JLS.

Il est utilisé dans les boucles for pour parcourir une liste d'objets.

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

Considérez-le comme un for <item> in <list>en Python.

Dans votre cas particulier,

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

this.listest une collection (liste, ensemble ou tableau), et ce code est affecté cà chaque élément de la collection.

Donc, si this.listc'était une collection {"2S", "3H", "4S"} alors le cardStringà 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;

qui est de nature «équivalente» au if else

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

Outre les 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;
          }
     }
}

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 for sont très similaires, Java fournit un raccourci pour réduire la quantité de code nécessaire pour écrire la boucle appelée pour chaque boucle.

Voici un exemple du 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 dans son ensemble peut être lu comme "pour chaque élément entier (appelé grade) dans quizGrades, imprimez la valeur de la note."

Il est utilisé dans la nouvelle main courte for / 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 colon existe en fait 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){ ... }

au sens propre:

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

deux points utilise une boucle in for-each, 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);
                   }
       }
}