O que o operador dois pontos (:) faz?

Aparentemente, dois pontos são usados ​​de várias maneiras em Java. Alguém se importaria de explicar o que ele faz?

Por exemplo aqui:

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

Como você escreveria esse for-eachloop de uma maneira diferente para não incorporar o :?

Existem vários lugares, dois pontos são usados ​​no código Java:

1) Etiqueta de salto ( 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) Condição ternária ( tutorial ):

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

3) Para cada loop ( Tutorial ):

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

4) Afirmação ( Guia ):

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 na instrução switch ( Tutorial ):

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

6) Referências de método ( tutorial )

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

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

Não há operador "dois pontos", mas os dois pontos aparecem em dois lugares:

1: No operador ternário, por exemplo:

int x = bigInt ? 10000 : 50;

Nesse caso, o operador ternário atua como um 'se' para as expressões. Se bigInt for true, então x terá 10000 atribuídos a ele. Se não, 50. Os dois pontos aqui significam "outro".

2: Em um loop for-each:

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

Isso define x para cada um dos valores em 'vals' por sua vez. Portanto, se vals contém [10, 20,3, 30, ...], então x será 10 na primeira iteração, 20,3 na segunda, etc.

Nota: digo que não é um operador porque é apenas sintaxe. Ele não pode aparecer em qualquer expressão por si só, e é apenas uma chance de que tanto o operador for-each quanto o ternário usem dois-pontos.

Apenas para adicionar, quando usado em um loop for-each, o ":" pode ser lido basicamente como "in".

então

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

deve ser lido "Para cada nome IN nomes faça ..."

Como você escreveria isso para cada loop de uma maneira diferente, de modo a não incorporar o ":"?

Supondo que listseja uma Collectioninstância ...

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

Devo acrescentar o ponto pedante de que :não é um operador neste contexto. Um operador executa uma operação em uma expressão, e o que está dentro de ( ... )uma forinstrução não é uma expressão ... de acordo com o JLS.

É usado em loops for para iterar sobre uma lista de objetos.

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

Pense nisso como for <item> in <list>em Python.

No seu caso específico,

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

this.list é uma coleção (lista, conjunto ou matriz), e esse código atribui c a cada elemento da coleção.

Portanto, se this.listfosse uma coleção {"2S", "3H", "4S"}, cardStringno final seria esta string:

2S
3H
4S

Você geralmente o vê no operador de atribuição ternário;

Sintaxe

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

exemplo:

boolean isNegative = number > 0 ? false : true;

que é "equivalente" em natureza ao if else

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

Além de exemplos dados por diferentes pôsteres,

você também pode usar: para significar um rótulo para um bloco que você pode usar em conjunto com continue e break ..

por exemplo:

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

Ele imprimirá a string "alguma coisa" três vezes.

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

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

 panel.add(label);             
 }

Como a maioria dos loops for são muito semelhantes, Java fornece um atalho para reduzir a quantidade de código necessária para escrever o loop chamado for each loop.

Aqui está um exemplo do conciso para cada loop:

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

No exemplo acima, os dois pontos (:) podem ser lidos como "em". O for each loop completamente pode ser lido como "para cada elemento inteiro (chamado nota) em quizGrades, imprima o valor da nota."

É usado no novo atalho para / loop

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

e o operador ternário

list.isEmpty() ? true : false;

O cólon realmente existe em conjunto com ?

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

é equivalente a:

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

Também em para cada loop:

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

literalmente:

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

dois pontos estão usando em for-each loop, tente este exemplo,

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