Que signifie ++ dans Java?

En Java, ++ signifie ajouter 1 au nombre détenu par la variable d'intérêt. Il peut s'agir de postfix ou de préfixe, comme expliqué ci-dessous. Le nombre peut être un int ou un double. Java n'a pas de pointeurs explicites, il ne peut donc pas être utilisé pour incrémenter le pointeur en java, par rapport à c++. Le ++ est connu comme l'opérateur d'incrément en Java.

Cet article explique la signification de ++ dans Java et aborde son utilisation dans l'itération, tout en faisant des comparaisons avec C++.

Postfix ++

PostFix signifie que ++ est tapé après la variable, écrivant de gauche à droite.

Entier

Le programme suivant illustre l'opération Postfix avec un INT:

classe publique TheClass
public static void main (String [] args)
int dans = 5;
int inpp = in ++;
Système.dehors.imprimer (inpp); Système.dehors.imprimer(", "); Système.dehors.imprimer (en ++);
Système.dehors.println ();

La sortie est de 5, 6. Avec le fonctionnement postfix, la valeur de la variable est renvoyée avant que l'ajout de 1 ait lieu. C'est pourquoi la sortie est de 5 et 6, et elle n'est pas 6 et 6.

Double

Le programme suivant illustre l'opération Postfix avec un double:

classe publique TheClass
public static void main (String [] args)
double dbl = 2.4;
double dblpp = dbl ++;
Système.dehors.print (dblpp); Système.dehors.imprimer(", "); Système.dehors.print (dbl ++);
Système.dehors.println ();

La sortie est 2.4, 3.4. Avec le fonctionnement postfix, la valeur de la variable est renvoyée avant d'ajouter 1 a lieu. C'est pourquoi la sortie est 2.4 et 3.4, et ce n'est pas 3.4 et 3.4.

Préfixe ++

Le préfixe signifie que ++ est tapé avant la variable, écrivant de gauche à droite.

Entier

Le programme suivant illustre l'opération de préfixe avec un int:

classe publique TheClass
public static void main (String [] args)
int dans = 5;
int inpf = ++ in;
Système.dehors.print (inpf); Système.dehors.imprimer(", "); Système.dehors.imprimer (en ++);
Système.dehors.println ();

La sortie est: 6, 6. Avec le fonctionnement du préfixe, la valeur de la variable est renvoyée après l'ajout de 1, qui a lieu. C'est pourquoi la sortie est 6 et 6, pas 5 et 6, comme dans un cas précédent.

Double

Le programme suivant illustre l'opération de préfixe avec un double:

classe publique TheClass
public static void main (String [] args)
double dbl = 2.4;
double dblpf = ++ dbl;
Système.dehors.print (dblpf); Système.dehors.imprimer(", "); Système.dehors.print (dbl ++);
Système.dehors.println ();

La sortie est 3.4, 3.4. Avec le fonctionnement du préfixe, la valeur de la variable est renvoyée après l'ajout de 1, qui a lieu. C'est pourquoi la sortie est 3.4 et 3.4, et ce n'est pas 2.4 et 3.4, comme dans un cas précédent.

Itération d'une arraylist

Chaque élément d'une ArrayList est accessible à l'aide d'une boucle pour l'incrément et de l'opérateur d'incrément ++, en tant que fol-lows:

Importer Java.user.*
classe publique TheClass
public static void main (String [] args)
Liste des tableaux Al = Nouveau ArrayList();
Al.ajouter un'); Al.ajouter ('b'); Al.ajouter ('c'); Al.ajouter ('d'); Al.ajouter ('e');
Al.ajouter ('f'); Al.ajouter ('g'); Al.ajouter ('h'); Al.ajouter ('i'); Al.ajouter ('j');
pour (int i = 0; ichar ch = al.obtenir (i);
Système.dehors.imprimer (ch); Système.dehors.imprimer(");

Système.dehors.println ();

La sortie est:

A b c d e f g h i j

La classe ArrayList est dans le java.user.* emballer. Après la création de l'objet ArrayList dans le programme, des éléments ont été ajoutés. Une boucle pour afficher les éléments. Notez que l'ArrayList n'a pas l'opérateur [], comme le vecteur en C ++. Il n'a que la méthode get (index). L'opérateur d'incrément utilisé ici est postfix, i ++ dans les parenthèses, de la boucle pour.

Comparer l'itération de Java à celle de C++

C ++ peut utiliser une boucle pour l'exemple précédent pour accéder à chaque élément de la liste avec un itera-tor. Dans ce cas, C ++ utilisera également l'opérateur d'incrément dans les parenthèses mais pour l'itérateur. En C ++, un itérateur est un pointeur d'objet de classe. L'opérateur d'incrément en C ++ déplacera le pointeur d'un ele-ment à l'autre, et non en ajoutant 1.

En Java, l'utilisation de l'itérateur est différente. L'objet Iterator en Java a la méthode suivante () qui renvoie l'élément suivant de la liste liée à l'itérateur. La méthode suivante () fait également avancer l'itérateur pour pointer vers l'élément suivant. Pour savoir si la fin de la liste est atteinte, l'objet Iterator utilise sa méthode a Suivant (), qui renvoie faux s'il n'y a plus d'élément pour être accessible.

Avec le Java Iterator, la boucle pour la boucle précédente sera re-codée dans le programme suivant:

Importer Java.user.*
classe publique TheClass
public static void main (String [] args)
Liste des tableaux Al = Nouveau ArrayList();
Al.ajouter un'); Al.ajouter ('b'); Al.ajouter ('c'); Al.ajouter ('d'); Al.ajouter ('e');
Al.ajouter ('f'); Al.ajouter ('g'); Al.ajouter ('h'); Al.ajouter ('i'); Al.ajouter ('j');
Itérateur ite = al.iterator ();
pour (; ite.Hasnext () == true; )
char ch = ite.suivant();
Système.dehors.imprimer (ch); Système.dehors.imprimer(");

Système.dehors.println ();

La sortie est:

A b c d e f g h i j

Comme prévu.

Après avoir créé l'objet Iterator, ITE, il y a la boucle pour. Notez que l'instruction d'initialisation et l'instruction d'incrément de la boucle pour. La condition de la limite de la boucle est «ite.hasnext () == true », qui indique que tant qu'au moins un élément de plus est accessible dans la liste, le corps de la boucle doit être exécuté.

La boucle pour la boucle précédente est conventionnellement mieux écrite avec une boucle de temps, au lieu de la boucle, comme dans le programme suivant:

Importer Java.user.*
classe publique TheClass
public static void main (String [] args)
Liste des tableaux Al = Nouveau ArrayList();
Al.ajouter un'); Al.ajouter ('b'); Al.ajouter ('c'); Al.ajouter ('d'); Al.ajouter ('e');
Al.ajouter ('f'); Al.ajouter ('g'); Al.ajouter ('h'); Al.ajouter ('i'); Al.ajouter ('j');
Itérateur ite = al.iterator ();
tandis que (ite.hasnext () == true)
char ch = ite.suivant();
Système.dehors.imprimer (ch); Système.dehors.imprimer(");

Système.dehors.println ();

La sortie est:

A b c d e f g h i j

Comme prévu.

La boucle while est plus pratique pour coder car l'instruction d'initialisation et l'état d'incrément étaient absents dans la boucle.

Conclusion

En Java, ++ signifie ajouter 1 au nombre détenu par la variable d'intérêt. Il peut s'agir de postfix ou de préfixe. Le nombre peut être un int ou un double. Java n'a pas de pointeurs explicites, il ne peut donc pas être utilisé pour déterminer le pointeur en java, par rapport à c++. Le ++ est connu comme l'opérateur d'incrément en Java.

Avec l'opération postfix, la valeur de la variable est retournée avant que l'ajout de 1 ait lieu. Avec le fonctionnement du préfixe, la valeur de la variable est retournée après l'ajout de 1. Nous espérons que vous avez trouvé cet article utile. Vérifiez plus d'articles sur les conseils sur les conseils et les tutoriels.