Quel est le signe deux-points (:) l'opérateur de faire?

Apparemment un colon est utilisé de multiples façons en Java. Quelqu'un aurait-il l'esprit expliquant ce qu'il fait?

Par exemple ici:

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

Comment écririez-vous ce for-each boucle d'une manière différente afin de ne pas incorporer le :?

D'autres l'ont déjà mentionné que cette affaire est une boucle for-each. Pour une explication plus détaillée de la façon dont il fonctionne, voir java.sun.com/j2se/1.5.0/docs/guide/language/foreach.html

InformationsquelleAutor dukevin | 2010-03-08

177

Il y a plusieurs endroits du côlon est utilisé dans du code Java:

1) Saut-hors étiquette (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) l'Affirmation (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) Méthode de référence (Tutoriel)
```
class Person {
   public static int compareByAge(Person a, Person b) {
       return a.birthday.compareTo(b.birthday);
   }}
}

Arrays.sort(persons, Person::compareByAge);
```
- nice - j'ai raté quelques! et je ne savais même pas que vous pouvez nommer des affirmations comme ça, très utile.
- Venant de .NET (C#), l'analogie la plus proche de la structure en question serait la for-each, qui vous explique en bonne intelligence.
- L'échec d'une assert ne pas "fermer le programme". Il jette un AssertionError. Il ne fera que provoquer le programme de sortie si elle est générée sur la pile de la seule non-démon fil ... et n'est pas pris.
- si vous chercher à inclure tous, alors je voudrais ajouter deux points (::) opérateur
- Aussi, un double deux-points est utilisé dans la méthode de référence.
- Qu'en est-il de ce segment de code? + equals(object2:Stock) : boolean
- Le premier exemple - saut-hors étiquette semble br un point-virgule plutôt qu'un colon.
InformationsquelleAutor Randy Sugianto 'Yuku'
34

Il n'y a pas de "colon" de l'opérateur, mais le côlon apparaît en deux endroits:

1: 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 obtiendrez 10000 lui est assigné. Si pas, 50. Le côlon signifie ici "autre chose".

2: Dans une boucle for-each:
```
double[] vals = new double[100];
//fill x with values
for (double x : vals) {
    //do something with x
}
```
Ce jeux x pour chacune des valeurs dans 'vals' à son tour. Donc, si vals contient [10, 20.3, 30, ...], alors x sera de 10 à la première itération, 20.3 sur la deuxième, etc.

Note: je dis que c'est pas un opérateur parce que c'est juste la syntaxe. Il ne peut pas apparaître dans une expression donnée par lui-même, et c'est juste de la chance que les deux pour chacun et l'opérateur ternaire utiliser un deux-points.
- seconde moitié aidé, ce devrait être la vraie réponse
- +1 pour l'explication plus détaillée de ce qu'il fait dans la boucle for-each.
InformationsquelleAutor Claudiu
17

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

Donc
```
for (String name : names) {
    //remainder omitted
}
```
doit être lu "Pour chaque nom DANS les noms de le faire ..."

InformationsquelleAutor helpermethod
15

Comment écririez-vous cette boucle for-each une manière différente, de manière à ne pas intégrer le ":"?

En supposant que list est un Collection exemple ...
```
public String toString() {
   String cardString = "";
   for (Iterator<PlayingCard> it = this.list.iterator(); it.hasNext(); /**/) {
      PlayingCard c = it.next();
      cardString = cardString + c + "\n";
   }
}
```
Je dois ajouter le pédant point que : n'est pas un opérateur dans ce contexte. Un opérateur effectue une opération dans une expression, et les trucs à l'intérieur de la ( ... ) dans un for déclaration n'est pas une expression ... selon la JLS.
- Ma question est: pourquoi? Pourquoi faire la même chose, le chemin le plus long?
- il ne veut pas le faire, il veut juste savoir comment.
- pas de devoirs, je veux savoir comment faire le long chemin afin que je puisse comprendre la logique
- En fait dans mon (mauvais) de l'université, lors de génie informatique études, ils n'ont jamais enseigné quelque chose sur le (:) dans le java sûr, je suis venu pour apprendre plus tard en regardant des exemples, et, malheureusement, il est difficile pour moi maintenant de code dans mon esprit depuis que je l'ai fait tous les projets dans l'uni le chemin le plus long
- Vous n'avez pas besoin de supposer que list est une instance de Collection; il doit être une instance de Iterable si elle est apte à être utilisé dans le renforcement de la boucle for, le sens qu'il aura la iterator() méthode que vous appelez dans votre réponse.
- Assez juste, mais dans le contexte de la question, il est très peu probable qu'il y aura quelques personnalisé / 3ème partie de la classe qui ne s'étend pas Collection. (Qui est plus probable, ce serait le cas sera un tableau ... où cela ne fonctionnera pas!)
InformationsquelleAutor Stephen C
1

Il est utilisé dans les boucles for pour parcourir une liste d'objets.
```
for (Object o: list)
{
    //o is an element of list here
}
```
Penser que c'est un for <item> in <list> en Python.

InformationsquelleAutor Mike Cialowicz
1

Dans votre cas particulier,
```
String cardString = "";
for (PlayingCard c : this.list)  //<--
{
    cardString = cardString + c + "\n";
}
```
this.list est une collection (liste, ensemble, ou un tableau), et que le code attribue c à chaque élément de la collection.

Donc, si this.list étaient une collection {"2", "3H", "4S"}, puis le cardString sur la fin serait cette chaîne:
```
2S
3H
4S
```
- merci pour votre réponse. Comment ce code pourrait-il être réécrite de façon à ne pas les ":" ?
InformationsquelleAutor Randy Sugianto 'Yuku'
1

Que vous voyez habituellement dans le ternaire opérateur d'affectation;

Syntaxe
```
variable =  `condition ? result 1 : result 2;`
```
exemple:
```
boolean isNegative = number > 0 ? false : true;
```
qui est "équivalent" dans la nature pour le si d'autre
```
if(number > 0){
    isNegative = false;
}
else{
    isNegative = true;
}
```
Autres que les exemples donnés par les différentes affiches,

vous pouvez également utiliser : pour signifier une étiquette pour un bloc que vous pouvez utiliser en conjonction 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;
          }
     }
}
```
- Je suis désolé, mais c'est un terrible exemple. Pourquoi ne pas vous écrire boolean isNegative = nombre > 0; Ternaire les conditions sont bonnes pour des choses telles que le double sgn = nombre>0 ? 1 :0;
- lol oui je ne me souviens même plus pourquoi j'ai donné cet exemple.
- Montrer un exemple comme ça reste simple et de meilleure montre comment l'opérateur conditionnel œuvres. "Pourquoi ne pas vous écrire boolean isNegative = nombre > 0;", Parce que ne pas montrer quelque chose au sujet de l'opérateur ternaire.
InformationsquelleAutor ultrajohn

Il affiche la chaîne de caractères"quelque chose" à trois reprises.

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

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

 panel.add(label);             
 }

c'est ce que dit ci-dessus en tant que boucle ForEach

InformationsquelleAutor

1

Depuis plus de boucles 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 de la concises pour chaque boucle:
```
for (Integer grade : quizGrades){
      System.out.println(grade);
 }    
```
Dans l'exemple ci-dessus, les deux-points (:) peut être lu comme "dans". Pour chaque boucle
au total peut être lu comme "pour chaque élément Entier (appelé grade), dans
quizGrades, imprimer la valeur de la catégorie."

InformationsquelleAutor Soft developer
0

Il est utilisé dans le nouveau court de main pour le/la boucle
```
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;
```
- Je ne savais pas que c'était que de nouvelles... quand il l'a fait venir?
- dans Java 5: java.sun.com/j2se/1.5.0/docs/relnotes/features.html#forloop
- oh... c'était il y a 6 ans... Pas de nouvelles de mon cadre de référence 😀
- Je suis avec piggles - six ans signifie qu'il a été autour depuis pratiquement l'aube des temps.
InformationsquelleAutor

Le côlon existe réellement en conjonction avec ?

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

est équivalent à:

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

Également dans la boucle for each:

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

littéralement:

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

InformationsquelleAutor Ritwik Bose

du côlon est d'utiliser de boucle 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);
                   }
       }
}

InformationsquelleAutor

Vous devez vous connecter pour publier un commentaire.