Java >> Tutoriel Java >  >> Java

Opérateur ternaire Java avec exemples

L'opérateur ternaire Java vous permet de créer une instruction if sur une seule ligne. Vrai ou faux peut être le résultat d'un opérateur ternaire. Que l'instruction soit évaluée comme vraie ou fausse, elle renvoie un certain résultat.

Les opérateurs sont les blocs de construction fondamentaux de tous les langages de programmation. Java possède également une variété d'opérateurs qui peuvent être utilisés pour accomplir divers calculs et fonctions, qu'ils soient logiques, arithmétiques, relationnels ou autres. Ils sont classés en fonction des fonctionnalités qu'ils offrent. Voici plusieurs exemples :

  • Opérateurs arithmétiques
  • Opérateurs unaires
  • Opérateur ternaire
  • Opérateurs au niveau du bit
  • Opérateurs de quart
  • Opérateur d'affectation
  • Opérateurs relationnels
  • Opérateurs logiques

Opérateur ternaire Java avec exemples

Cet article couvre tout ce qu'il y a à savoir sur les opérateurs arithmétiques.

Il y a trois parties dans la définition du ternaire. Trois opérandes constituent l'opérateur ternaire (?:). Les expressions booléennes sont évaluées avec lui. L'opérateur choisit la valeur à affecter à la variable. C'est le seul opérateur conditionnel qui prend trois arguments. Elle peut remplacer une expression if-else. Il simplifie, simplifie et simplifie le code. Un opérateur ternaire ne peut pas être utilisé pour remplacer un code qui utilise une instruction if-else.

Opérateur Ternaire

Le seul opérateur conditionnel en Java qui prend trois opérandes est l'opérateur ternaire. C'est un substitut à une ligne de l'instruction if-then-else couramment utilisée en Java. Nous pouvons utiliser l'opérateur ternaire au lieu des conditions if-else ou des opérateurs ternaires imbriqués pour échanger les conditions.

Bien que l'opérateur conditionnel suive le même algorithme que l'instruction if-else, il prend moins de place et facilite l'écriture la plus courte possible des instructions if-else.

La syntaxe de l'opérateur ternaire est la suivante :

resultant_variable = First_Expression ? Second_Expression: Third_Expression

Son expression fonctionne de la même manière que l'instruction if-else dans la mesure où Second_Expression est exécuté si First_Expression est vrai et Third_Expression est exécuté si First_Expression est faux.

if(First_Expression)
{
    resultant_variable = Second_Expression;
}
else
{
    resultant_variable = Third_Expression;
}

Vous trouverez ci-dessous une démonstration simple de l'opérateur ternaire de Java.

varNumOne = 25;
varNumTwo = 35;

final_result=(varNumOne>varNumTwo) ? (varNumOne+varNumTwo):(varNumOne-varNumTwo)

Since num1<varNumTwo,

// performing the second operation
final_result = varNumOne-varNumTwo = -10

Quand l'opérateur ternaire doit-il être utilisé ?

L'opérateur ternaire en Java peut être utilisé pour remplacer certaines phrases if…else. Par exemple, le code suivant peut être modifié comme suit.

class codeIfElse {

  public static void main(String[] args) {
    
    // creation of the variable
    int gradeVar = 68;

    if( gradeVar > 0) {
      System.out.println("Congratulations. You have a Positive Trend");
    }
    else {
      System.out.println("Sorry. You have a Negative Trend");
    }
  }
}

avec

class codeTernary {

  public static void main(String[] args) {
    
    // creation of the variable
    int gradeVar = 68;

    String resultantFeedback = ( gradeVar > 0) ? "Congratulations. You have a Positive Trend" : "Sorry. You have a Negative Trend";
    System.out.println(resultantFeedback);
  }
}

Les deux programmes donnent le même résultat dans ce cas. D'autre part, l'opérateur ternaire rend notre code plus lisible et ordonné. Notez que l'opérateur ternaire ne doit être utilisé que si la phrase résultante est brève.

Imbrication des opérateurs ternaires en Java

Un opérateur ternaire peut également être utilisé à l'intérieur d'un autre opérateur ternaire. En Java, il est connu sous le nom d'opérateur ternaire imbriqué. Voici un programme qui utilise l'opérateur ternaire imbriqué pour découvrir le plus grand des trois nombres.

class codeNestedTernary {

  public static void main(String[] args) {
    
    //  Here's the declaration of variables
    int numVarOne = 7, numVarTwo = 13, numVarThree = -8;

    //To find the greatest number, use a nested ternary operator.
    int varLargestNum = ( numVarOne >= numVarTwo) ? (( numVarOne >= numVarThree) ? numVarOne : numVarThree) : (( numVarTwo >= numVarThree) ? numVarTwo : numVarThree);
    
System.out.println(" The greatest number among the three is: " + varLargestNum);
  }
}

Remarquez comment l'opérateur ternaire est utilisé dans l'exemple précédent.

 ( numVarOne >= numVarTwo) ? (( numVarOne >= numVarThree) ? numVarOne : numVarThree) : (( numVarTwo >= numVarThree) ? numVarTwo : numVarThree);

Ici,

( numVarOne>=numVarTwo) est la condition de test initiale, déterminant si numVarOne est supérieur à numVarTwo. Si la condition de début est correcte, la deuxième condition de test ( numVarOne>=numVarThree) est exécutée. En outre, lorsque la condition de début est fausse, la troisième condition de test (numVarTwo>=numVarThree) est exécutée. Notez que les opérateurs ternaires imbriqués ne sont pas recommandés. C'est parce que cela complique notre codage.

Évaluation de l'expression

Une seule des expressions de droite, expression1 ou expression2, est évaluée lors de l'exécution lors de l'utilisation d'une construction ternaire Java. Un simple cas de test JUnit peut être utilisé pour vérifier ceci :

@Test
public void codeWhenConditionIsTrue() {
    int varExp1 = 0, varExp2 = 0;
    int ternaryResult = 23 > 21 ? ++ varExp1 : ++varExp2;
    
    assertThat(varExp1).isEqualTo(1);
    assertThat(varExp2).isEqualTo(0);
    assertThat(ternaryResult).isEqualTo(1);
}

Parce que notre instruction booléenne 23> 21 est toujours vraie, la valeur de varExp2 est restée inchangée. Considérez ce qui se passe dans le cas d'une condition fausse :

@Test
public void codeWhenConditionIsFalse() {
    int varExp1 = 0, varExp2 = 0;
    int result = 19 > 21 ? ++ varExp1 : ++varExp2;

    assertThat(varExp1).isEqualTo(0);
    assertThat(varExp2).isEqualTo(1);
    assertThat(result).isEqualTo(1);
}

La valeur de varExp1 n'a pas été modifiée, mais la valeur de varExp2 a été augmentée de un.

Vérification nulle à l'aide de l'opérateur ternaire

Avant d'essayer d'invoquer la méthode d'un objet, vous pouvez utiliser l'opérateur ternaire Java comme raccourci pour les vérifications nulles. Considérez le scénario suivant :

String varResult = object != null ? object.getValue() : null;

This code is the very equivalent of the one above only that the prior is much shorter than this one:

String varResult = null;
if(object != null) {
    varResult = object.getValue();
}

Comme vous pouvez le voir, ces deux exemples de code évitent d'appeler des objets. Si la référence d'objet est nulle, object.getValue() est appelé, bien que le premier exemple de code soit un peu plus court et plus élégant.

Fonction Max utilisant l'opérateur ternaire

En utilisant un opérateur ternaire Java, vous pouvez obtenir la même capacité que la fonction Java Math max(). Voici un exemple d'utilisation d'un opérateur ternaire Java pour obtenir la fonctionnalité Math.max() :

int varNumOne = 23;
int varNumTwo = 38;

int varMaxResult = varNumOne >= varNumTwo ? varNumOne : varNumTwo;

Notez comment les conditions de l'opérateur ternaire vérifient si varNumOne est supérieur ou égal à varNumTwo. L'opérateur ternaire renvoie la valeur varNumOne si elle est vraie. Sinon, la valeur varNumTwo est renvoyée.

Fonction Min utilisant l'opérateur ternaire

Pour obtenir le même résultat qu'avec la fonction Java Math min(), utilisez l'opérateur Java ternaire. Voici un exemple d'utilisation d'un opérateur ternaire Java pour obtenir la fonctionnalité Math.min() :

int varNumOne = 23;
int varNumTwo = 38;

int varMaxResult = varNumOne <= varNumTwo ? varNumOne : varNumTwo;

Remarquez comment les conditions de l'opérateur ternaire vérifient si varNumOne est inférieur ou égal à varNumTwo. L'opérateur ternaire renvoie la valeur varNumOne si elle est vraie. Sinon, la valeur varNumTwo est renvoyée.

Fonction Abs utilisant l'opérateur ternaire

L'effet de la fonction Abs est réalisable via l'opérateur ternaire de Java comme avec la méthode Java Math abs(). Voici un exemple d'utilisation d'un opérateur ternaire Java pour obtenir la fonctionnalité Math.abs() :

int varNumOne = 23;

int varAbsoluteResult = varNumOne >= 0? varNumOne : -varNumOne;

Notez comment l'opérateur ternaire examine si varNumOne est supérieur ou égal à 0.

L'opérateur ternaire renvoie la valeur varNumOne si elle est vraie. Sinon, elle renvoie -varNumOne, qui annule une valeur négative et la rend positive.

Exemple :opérateur ternaire d'imbrication

Il est possible d'imbriquer notre opérateur ternaire à n'importe quel nombre de niveaux que nous choisissons. En Java, cette construction est valide :

String ternaryResult = varNum > 38 ? "Number is greater than 38" :
  varNum > 8 ? "Number is greater than 8" : "Number is less than equal to 8";

We can use brackets () wherever appropriate to improve the readability of the above code:

String ternaryResult = varNum > 38 ? "Number is greater than 38"
  : ( varNum > 8 ? "Number is greater than 8" : "Number is less than equal to 8");

Veuillez garder à l'esprit que des structures ternaires aussi profondément imbriquées ne sont pas conseillées dans le monde réel. Cela est dû au fait que cela rend le code moins lisible et moins maintenable.

Exemple :programme permettant de trouver le plus grand nombre parmi deux à l'aide de l'opérateur ternaire de Java

import java.io.*;

class CodeTernary {

	public static void main(String[] args)
	{

		// The declaration of  variables
		int varNumOne = 15, varNumTwo = 98, varNumMax;

		System.out.println("The First num is: " + varNumOne);
		System.out.println("The Second num is: " + varNumTwo);

		// Largest value between  varNumOne and  varNumTwo
		varNumMax = ( varNumOne > varNumTwo) ? varNumOne : varNumTwo;

		// Printing the largest number between the two
		System.out.println("Maximum is = " + varNumMax);
	}
}

Exemple :code pour illustrer l'opérateur ternaire de Java

import java.io.*;

class CodeTernary {
	public static void main(String[] args)
	{

		// The declaration of variables
		int varNumOne = 18, varNumTwo = 65, varNumRes;

		System.out.println("First num: " + varNumOne);
		System.out.println("Second num: " + n2);

		// Executing the ternary operation in Java
		varNumRes = ( varNumOne > varNumTwo) ? ( varNumOne + varNumTwo) : ( varNumOne - varNumTwo);

		// Print the largest number
		System.out.println("The resultant values is = " + varNumRes);
	}
}

Exemple :opérateur ternaire de Java

import java.util.Scanner;

class CodeTernary {

  public static void main(String[] args) {
    
    //solicit user for input
    Scanner codeInput = new Scanner(System.in);
    System.out.println("Please input your end of semester Score: ");

    double studentsScore = codeInput.nextDouble();

    // ternary operator  is responsible for checking if
    // studentsScore is higher than 70
    String resultScore = ( studentsScore > 70) ? "Pass. Promoted to Level II" : "Fail. Cannot be promoted to Level II";

    System.out.println("Your end of  year evaluation is" + resultScore );
    codeInput.close();
  }
}

Exemple :démonstration de l'opérateur ternaire en Java

public class codeTernaryOperator  
{  

  public static void main(String args[])   
  {  
    int xVar, yVar;  
    xVar = 43;  
    yVar = (xVar == 1) ? 98: 108;  

    System.out.println("The Value of yVar is: " +  yVar);  

    yVar = (xVar == 43) ? 98: 108;  
    System.out.println("The Value of yVar is: " + yVar);  
  }  
}  

Exemple :déterminer le plus grand nombre à l'aide d'un opérateur ternaire en Java

public class codeLargestNumber  
{  
  public static void main(String args[])  
  {  
    int xVar=169;  
    int yVar=189;  
    int zVar=179;  

    int varLargestNum= (xVar > yVar) ? (xVar > zVar ? xVar : zVar) : (yVar > zVar ? yVar : zVar);  
    System.out.println("The greaterst numbers is:  "+varLargestNum);  
  }  
}  

Conclusion

À l'aide d'exemples, vous avez découvert l'opérateur ternaire et comment l'utiliser en Java dans ce didacticiel. Dans certains cas, un opérateur ternaire peut être utilisé à la place d'une instruction if…else en Java. Nous avons également utilisé un exemple pour montrer l'instruction Java if…else avant de plonger dans l'opérateur ternaire. De plus, la condition de test est évaluée par un opérateur ternaire, qui exécute ensuite un bloc de code en fonction du résultat.


Balise Java