Incrémenter et décrémenter les opérateurs unaires en Java

Opérateurs unaires

Les opérateurs unaires sont les opérateurs de Java qui n'ont besoin que d'un seul opérande pour exécuter une fonction. Ils fonctionnent sur le même principe que les opérations unaires en mathématiques. Par exemple, vous pouvez utiliser des opérateurs unaires pour représenter une valeur positive, une valeur négative, incrémenter une valeur de 1, décrémenter une valeur de 1 ou annuler une valeur.

+x (valeur positive)
-x (valeur négative)
++x (opération d'incrémentation)
--x (opération de décrémentation)
!x (négation)

Types d'opérateurs unaires

Il existe 5 types d'opérateurs unaires

1. Unaire Plus

Il représente une valeur positive comme +x = x ou +5 = 5.

2. Moins unaire

Il représente une valeur négative comme -x = -x ou -5 = -5.

3. Incrémenter l'opérateur unaire

Il incrémente la valeur de 1 où ++x = x+1.

4. Opérateur unaire de décrémentation

Il décrémente la valeur de 1 où --x = x-1.

5. Complément logique

Il inverse logiquement la valeur d'un booléen comme si x = vrai, alors !x sera faux.

Opérateur d'incrémentation (++)

L'opérateur d'incrémentation (++) (également connu sous le nom d'opérateur unaire d'incrémentation) en Java est utilisé pour augmenter la valeur d'une variable de 1. Puisqu'il s'agit d'un type d'opérateur unaire, il peut être utilisé avec un seul opérande.

Syntaxe

La syntaxe de l'opérateur d'incrémentation est une paire de signes d'addition, c'est-à-dire ;

++x ; x++ ;

L'opérateur peut être appliqué avant ou après la variable. Les deux auront le même incrément de 1. Cependant, ils ont tous deux des utilisations distinctes et peuvent être classés dans les types suivants.

Opérateur de pré-incrémentation
Opérateur de post-incrémentation

Exemple

public class IncrementOperator {

	public static void main(String[] args) {

		int variable = 15;
		System.out.println("Original value of the variable = " + variable);

		// after using increment operator
		variable++; 	 //  increments 1, variable = 16
		System.out.println("variable++ = " + variable);

		++variable;		//  increments 1, variable = 17
		System.out.println("++variable = " + variable);
	}
}

Sortir

Valeur d'origine de la variable = 15 variable++ = 16 ++variable = 17

Opérateur de pré-incrémentation (++x;)

Si l'opérateur d'incrémentation (++) est spécifié avant la variable comme un préfixe (++x), alors il est appelé opérateur de pré-incrémentation. Dans ce cas, la valeur de la variable est d'abord incrémentée de 1, puis d'autres calculs sont effectués.

Exemple

public class PreIncrementOperator {

	public static void main(String[] args) {

		int variable = 5;
		System.out.println("Original value of the variable = " + variable);

		// using pre-increment operator
		int preIncrement = ++variable;

		System.out.println("variable = " + variable);
		System.out.println("preIncrement = " + preIncrement);
		System.out.println("++preIncrement = " + ++preIncrement);
	}
}

Sortir

Valeur d'origine de la variable = 5 variable = 6 preIncrement = 6 ++preIncrement = 7

Opérateur de post-incrémentation (x++;)

Si l'opérateur d'incrémentation (++) est spécifié après la variable comme un suffixe (x++), alors il est appelé opérateur de post-incrémentation. Dans ce cas, la valeur d'origine de la variable (sans incrément) est utilisée pour les calculs, puis elle est incrémentée de 1.

Exemple

public class PostIncrementOperator {

	public static void main(String[] args) {

		int variable = 100;
		System.out.println("Original value of the variable = " + variable);

		// using post-increment operator
		int postIncrement = variable++; // postIncrement = 100, variable = 101

		System.out.println("postIncrement = " + postIncrement);
		System.out.println("variable = " + variable + "\n");

            // postIncrement = 101
		System.out.println("postIncrement++ = " + postIncrement++);
            // postIncrement = 102
		System.out.println("postIncrement++ = " + postIncrement++);
            // postIncrement = 103
		System.out.println("postIncrement++ = " + postIncrement++);

		System.out.println("\npostIncrement = " + postIncrement);
	}
}

Sortir

Variable d'origine = 100 postIncrement = 100 variable = 101 postIncrement++ = 100 postIncrement++ = 101 postIncrement++ = 102 postIncrement = 103

Opérateur de décrémentation (--)

La décrémentation, comme son nom l'indique, est utilisée pour réduire la valeur d'une variable de 1. C'est également l'un des types d'opérateurs unaires, il peut donc être utilisé avec un seul opérande.

Syntaxe

La syntaxe de l'opérateur de décrémentation est une paire de signes négatifs, c'est-à-dire ;

--X; X--;

Tout comme l'opérateur d'incrémentation, l'opérateur de décrémentation (--) peut également être appliqué avant et après la variable. Les deux entraîneront le même décrément de 1. Ils ont tous deux des utilisations distinctes et peuvent diverger dans les autres types.

Opérateur de pré-décrémentation
Opérateur de post-décrémentation

Opérateur de pré-décrémentation (--x;)

Si l'opérateur de décrémentation (--) est mentionné avant la variable comme un préfixe (--x), alors on l'appelle un opérateur de pré-décrémentation. Dans ce cas, la valeur de la variable est d'abord décrémentée de 1, puis d'autres calculs sont effectués.

Exemple

public class PreDecrementOperator {

	public static void main(String[] args) {

		int variable = 11;
		System.out.println("Original value of the variable = " + variable);

		// using preDecrement operator
		int preDecrement = --variable;

            // variable = 10
		System.out.println("variable = " + variable);
            // preDecrement = 10
		System.out.println("preDecrement = " + preDecrement);
            // preDecrement = 9
		System.out.println("--preDecrement = " + --preDecrement);  	}
}

Sortir

Valeur d'origine de la variable = 11 variable = 10 preDecrement = 10 --preDecrement = 9

Opérateur de post-décrémentation (x--;)

Si l'opérateur de décrémentation (--) est mentionné après la variable comme un suffixe (x--), alors on l'appelle un opérateur de post-décrémentation. Dans ce cas, la valeur d'origine de la variable (sans décrémentation) est utilisée pour les calculs, puis elle est décrémentée de 1.

Exemple

public class PostDecrementOperator {

	public static void main(String[] args) {

		int variable = 75;
		System.out.println("Original value of the variable = " + variable);

		// using postDecrement operator
            // postDecrement = 75, variable = 74
		int postDecrement = variable--;
		System.out.println("postDecrement = " + postDecrement);
		System.out.println("variable = " + variable + "\n");
		// postDecrement = 74
		System.out.println("postDecrement-- = " + postDecrement--);
            // postDecrement = 73
		System.out.println("postDecrement-- = " + postDecrement--);
            // postDecrement = 72
		System.out.println("postDecrement-- = " + postDecrement--);

		System.out.println("\npostDecrement = " + postDecrement);
	}
}

Valeur originale de la variable = 75 postDecrement = 75 variable = 74 postDecrement-- = 75 postDecrement-- = 74 postDecrement-- = 73 postDecrement = 72

Conclusion

À la fin de cet article, nous espérons que vous vous serez familiarisé avec les opérateurs unaires d'incrémentation et de décrémentation en Java. Vous êtes encouragé à pratiquer les cas limites et d'autres problèmes de pratique à CodeGym pour avoir confiance en vos compétences. Pour renforcer ce que vous avez appris, nous vous suggérons de regarder une leçon vidéo de notre cours Java

Bonne chance et bon apprentissage !