Java: cosa fa l’operatore colon (:)?

Lo guarderei da solo, ma non so nemmeno come si chiama. Qualcuno si preoccuperebbe di spiegare quello che fa?

Non sapevo che c’erano più volte il: apparso. Cosa fa qui in questo caso:

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

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

Ci sono molti posti che i due punti sono usati 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 } } // ie 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) Ciclo For-each ( 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 al metodo ( 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 appaiono in due punti:

1: nell’operatore ternario, ad esempio:

 int x = bigInt ? 10000 : 50; 

In questo caso, l’operatore ternario agisce come un “se” per le espressioni. Se bigInt è true, x verrà assegnato a 10000. Altrimenti, 50. Il colon qui significa “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 x a ciascuno dei valori in ‘vals’ a sua volta. Quindi se vals contiene [10, 20.3, 30, …], allora x sarà 10 nella prima iterazione, 20.3 nella seconda, ecc.

Nota: dico che non è un operatore perché è solo syntax. Non può apparire da sola in una determinata espressione, ed è solo un caso che sia l’operatore for-each sia l’operatore ternario utilizzino i due punti.

Solo per aggiungere, quando usato in un ciclo for-each, il “:” può essere letto come “in”.

Così

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

dovrebbe essere letto “Per ogni nome IN nomi fare …”

Come scriveresti questo per-ogni ciclo in un modo diverso in modo da non incorporare il “:”?

Supponendo che questa list sia un’istanza di Collection

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

Dovrei aggiungere il punto pedante che : non è un operatore in questo contesto. Un operatore esegue un’operazione in un’espressione e il contenuto all’interno di ( ... ) in un’istruzione for non è un’espressione … in base al JLS.

È usato in loop per iterare su un elenco di oggetti.

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

Consideralo come for in in Python.

Nel tuo caso specifico,

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

this.list è una raccolta (elenco, set o array) e il codice assegna c a ciascun elemento della raccolta.

Quindi, se this.list fosse una collection {"2S", "3H", "4S"} allora il 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 al se altro

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

Stamperà 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 di loop 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 ciascun ciclo:

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

Nell’esempio sopra, i due punti (:) possono essere letti come “in”. L’intero ciclo può essere letto come “per ogni elemento intero (chiamato grado) in quizGrades, stampare il valore del grado”.

È usato nella nuova short hand per / loop

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

e l’operatore ternario

 list.isEmpty() ? true : false; 

Il colon esiste effettivamente insieme a ?

 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) 

due punti stanno usando per ogni ciclo, 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); } } }