Cosa fa l'operatore due punti (:)?

Apparentemente i due punti vengono utilizzati in più modi in Java. A qualcuno dispiacerebbe spiegare cosa fa?

Ad esempio qui:

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

Come scriveresti questo for-eachciclo in un modo diverso in modo da non incorporare il :?

Ci sono diversi punti in cui i due punti vengono utilizzati nel codice Java:

1) Etichetta 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
    }
} 
// i.e. jumps to here

2) Condizione ternaria ( Tutorial ):

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

3) Per ogni ciclo ( Tutorial ):

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

4) Asserzione ( Guida ):

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) Caso nell'istruzione switch ( Tutorial ):

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

6) Riferimenti ai metodi ( tutorial )

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

Arrays.sort(persons, Person::compareByAge);

Non esiste un operatore "due punti", ma i due punti vengono visualizzati in due posizioni:

1: Nell'operatore ternario, ad esempio:

int x = bigInt ? 10000 : 50;

In questo caso, l'operatore ternario funge da "se" per le espressioni. Se bigInt è vero, allora x riceverà 10000 assegnati. In caso contrario, 50. I due punti qui significano "altro".

2: In un ciclo for-each:

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

Questo imposta a turno x a ciascuno dei valori in "vals". Quindi se vals contiene [10, 20.3, 30, ...], allora x sarà 10 alla prima iterazione, 20.3 alla seconda, ecc.

Nota: dico che non è un operatore perché è solo sintassi. Non può apparire da solo in nessuna data espressione ed è solo un caso che sia l'operatore for-each sia l'operatore ternario utilizzino i due punti.

Giusto per aggiungere, se usato in un ciclo for-each, ":" può essere letto fondamentalmente come "in".

Così

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

dovrebbe essere letto "Per ogni nome IN nomi fare ..."

Come scriveresti questo ciclo for-each in modo diverso in modo da non incorporare il ":"?

Supponendo che listsia Collectionun'istanza ...

public String toString() {
   String cardString = "";
   for (Iterator<PlayingCard> it = this.list.iterator(); it.hasNext(); /**/) {
      PlayingCard c = it.next();
      cardString = cardString + c + "\n";
   }
}

Aggiungo il punto pedante che :non è un operatore in questo contesto. Un operatore esegue un'operazione in un'espressione e le cose all'interno ( ... )di forun'istruzione non sono un'espressione ... secondo JLS.

Viene utilizzato nei cicli for per iterare su un elenco di oggetti.

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

Pensalo come un for <item> in <list>in Python.

Nel tuo caso specifico,

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

this.listè una raccolta (elenco, insieme o matrice) e tale codice viene assegnato ca ciascun elemento della raccolta.

Quindi, se this.listfosse una raccolta {"2S", "3H", "4S"} cardString, alla fine sarebbe questa stringa:

2S
3H
4S

Di solito lo vedi nell'operatore di assegnazione ternaria;

Sintassi

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

esempio:

boolean isNegative = number > 0 ? false : true;

che è "equivalente" in natura a if else

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

Oltre agli esempi forniti da diversi poster,

puoi anche usare: per indicare un'etichetta per un blocco che puoi usare insieme a continua e interrompi ..

per esempio:

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

Stampa la stringa "qualcosa" tre volte.

JLabel[] labels = {new JLabel(), new JLabel(), new JLabel()};                   

for ( JLabel label : labels )                  
 {              
   label.setText("something");  

 panel.add(label);             
 }

Poiché la maggior parte dei cicli for sono molto simili, Java fornisce una scorciatoia per ridurre la quantità di codice richiesta per scrivere il ciclo chiamato per ogni ciclo.

Ecco un esempio del conciso per ogni ciclo:

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

Nell'esempio sopra, i due punti (:) possono essere letti come "in". Il ciclo per ogni ciclo può essere letto come "per ogni elemento Integer (chiamato grado) in quizGrades, stampa il valore del voto."

È usato nella nuova mano corta per / loop

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

e l'operatore ternario

list.isEmpty() ? true : false;

Il colon esiste effettivamente in combinazione con ?

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

è equivalente a:

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

Anche nel per ogni ciclo:

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

letteralmente:

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

i due punti utilizzano in for-each loop, prova questo esempio,

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