Java: cosa fa l'operatore due punti (:)?

Question

Vorrei controllare da solo, ma non so nemmeno come si chiama. Qualcuno avrebbe in mente di spiegare cosa fa?

Non sapevo che c'erano più volte il: è apparso. Cosa fare in questo caso qui:

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

Come si scrive questo for-each ciclo un modo diverso, in modo da non incorporare il ":"?

Answer 1

Ci sono molti posti del colon viene utilizzato in codice Java:

1) etichetta di salto-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 ternario (Tutorial):

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

3) Per ciascun-loop (Tutorial):

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

4) asserzione (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) Caso in istruzione switch (Tutorial):

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

6) I 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); 

Answer 2

E 'utilizzato nella nuova mano abbreviazione di/ciclo

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

e l'operatore ternario

list.isEmpty() ? true : false; 

Answer 3

Non c'è nessun operatore "due punti", ma i due punti appare in due posti:

1: Nella operatore ternario, ad esempio:

int x = bigInt ? 10000 : 50; 

In questo caso, l'operatore ternario funge da "se" per le espressioni. Se bigInt è true, x verrà assegnato a 10000. Altrimenti, 50. Il colon qui significa "altro".

2: In una per ogni ciclo-:

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

Questo imposta x per ciascuno dei valori di 'vals' a loro volta. Quindi se vals contiene [10, 20.3, 30, ...], allora x sarà 10 sulla prima iterazione, 20.3 sulla seconda, ecc.

Nota: Io dico che non è un operatore perché è solo sintassi. 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.

Answer 4

È utilizzato in cicli for per scorrere un elenco di oggetti.

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

Si consideri come for <item> in <list> in Python.

Answer 5

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 nella per ogni ciclo:

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

letteralmente:

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

Answer 6

È di solito lo si vede nell'operatore di assegnazione ternaria;

Sintassi

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

esempio:

boolean isNegative = number > 0 ? false : true; 

che è "equivalente" in natura alla if else

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

Oltre esempi forniti diversi manifesti,

si ca n utilizzare anche: a significare un'etichetta per un blocco che può essere utilizzato in combinazione con continuare e rompere ..

ad esempio:

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

Answer 7

Nel vostro 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 erano una collezione { "2S", "3H", "4S"} poi la cardString alla fine sarebbe questa stringa:

2S 
3H 
4S 

Answer 8

Come si scrive questo per -ogni ciclo un modo diverso per non incorporare il ":"?

Supponendo che list è un'istanza Collection ...

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

---

devo aggiungere il punto saccente che : non è un operatore in questo contesto. Un operatore esegue un'operazione in un'espressione e le cose all'interno di (...) in un'istruzione for non sono un'espressione ... in base al JLS.

Answer 9

Solo per aggiungere, quando utilizzato in un ciclo for-each, il ":" può essere letto come "in".

Così

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

va letto "Per ogni nome nei nomi do ..."

Answer 10

Sarà stampa la stringa "qualcosa" per tre volte.

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

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

panel.add(label);    
} 

Answer 11

colon sta usando in 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); 
        } 
     } 
} 

Answer 12

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

Ecco un esempio di conciso per ogni ciclo:

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

Nell'esempio precedente, il colon (:) può essere letta come "in". Per ogni ciclo, può essere letto come "per ogni elemento intero (chiamato grado) in quizGrades, stampare il valore del grado".