Opérateur de raccourci "ou-affectation" (| =) en Java

Question

J'ai un long jeu de comparaisons à faire en Java, et j'aimerais savoir si un ou plusieurs d'entre eux sont vrais. La chaîne de comparaisons était longue et difficile à lire, donc je l'ai cassé pour la lisibilité, et suis allé automatiquement à utiliser un opérateur de raccourci |= plutôt que negativeValue = negativeValue || boolean.

boolean negativeValue = false; 
negativeValue |= (defaultStock < 0); 
negativeValue |= (defaultWholesale < 0); 
negativeValue |= (defaultRetail < 0); 
negativeValue |= (defaultDelivery < 0); 

Je me attends negativeValue pour être vrai si l'un de la valeur par défaut < quelque chose > valeurs sont négatives. Est-ce valide? Va-t-il faire ce que j'attends? Je ne pouvais pas le voir mentionné sur le site de Sun ou sur stackoverflow, mais Eclipse ne semble pas avoir de problème avec cela et le code se compile et s'exécute.

---

De même, si je voulais effectuer plusieurs intersections logiques, pourrais-je utiliser &= au lieu de &&?

Answer 1

Le |= est un opérateur d'affectation composé (JLS 15.26.2) pour l'opérateur logique booléen | (JLS 15.22.2); ne pas être confondu avec le conditionnel ou || (JLS 15.24). Il y a également &= et ^= correspondant à la version d'affectation de composé de la logique booléenne & et ^ respectivement.

En d'autres termes, pour boolean b1, b2, ces deux sont équivalentes:

b1 |= b2; 
b1 = b1 | b2; 

La différence entre les opérateurs logiques (& et |) par rapport à leurs homologues conditionnelles (&& et ||) est que le premier ne le font pas "court-circuit"; ce dernier fait. C'est:

• & et |toujours évaluer les deux opérandes
• && et || évaluer le droit opérande sous condition; l'opérande de droite n'est évalué que si sa valeur peut affecter le résultat de l'opération binaire.Cela signifie que l'opérande droit ne soit pas évalué lorsque:
  • L'opérande gauche de && évalue à false
    • (parce que peu importe ce que l'opérande de droite correspond à, l'expression entière est false)
  • L'opérande gauche de || est évaluée à true
    • (car pas m Atter ce que l'opérande de droite correspond à, l'expression entière est true)

Pour en revenir à votre question initiale, oui, cette construction est valide, et en |= est pas exactement un raccourci équivalent pour = et ||, il calcule ce que vous voulez. Puisque le côté droit de l'opérateur |= dans votre utilisation est une simple opération de comparaison d'entiers, le fait que | ne soit pas court-circuit est insignifiant.

Il existe des cas dans lesquels un court-circuit est souhaité, voire nécessaire, mais votre scénario n'en fait pas partie.

Il est regrettable que contrairement à d'autres langages, Java n'a pas &&= et ||=. Cela a été discuté dans la question Why doesn't Java have compound assignment versions of the conditional-and and conditional-or operators? (&&=, ||=).

Answer 2

Ce n'est pas un opérateur de "raccourci" (ou de court-circuit) dans la façon dont || et & & sont (en ce qu'ils n'évalueront pas le RHS s'ils connaissent déjà le résultat basé sur le LHS) mais il fera ce que vous voulez en termes de fonctionnant.

À titre d'exemple de la différence, ce code sera bien si text est nulle:

boolean nullOrEmpty = text == null || text.equals("") 

alors que ce ne sera pas:

boolean nullOrEmpty = false; 
nullOrEmpty |= text == null; 
nullOrEmpty |= text.equals(""); // Throws exception if text is null 

(vous pourriez faire "".equals(text) Il est évident que pour ce particulier cas - j'essaye juste de démontrer le principe.)

Answer 3

List<Integer> params = Arrays.asList (defaultStock, defaultWholesale, 
             defaultRetail, defaultDelivery); 
int minParam = Collections.min (params); 
negativeValue = minParam < 0; 

Answer 4

Vous pourriez juste avoir une déclaration. Exprimé sur plusieurs lignes, il se lit comme suit presque exactement comme votre code d'échantillon, seulement moins impératif:

boolean negativeValue 
    = defaultStock < 0 
    | defaultWholesale < 0 
    | defaultRetail < 0 
    | defaultDelivery < 0; 

Pour les expressions les plus simples, en utilisant | peut être plus rapide que || parce que même si elle évite de faire une comparaison, cela signifie implicitement à l'aide d'une branche et cela peut être beaucoup plus cher.

Answer 5

Bien que cela puisse être excessif pour votre problème, la bibliothèque Guava a une syntaxe agréable avec Predicate s et fait une évaluation de court-circuit de ou/et Predicate s. Essentiellement, les comparaisons sont transformées en objets, empaquetées dans une collection, puis itérées. Pour les prédicats, le premier hit vrai revient de l'itération, et vice versa pour et.

Answer 6

|| logique booléenne OU
| OU bitwise

| = opérateur OR et y compris au niveau du bit affectation

La raison pour laquelle | = ne shortcircit pas est parce qu'il ne Bitwise ou non un OU logique. C'est-à-dire:

 

C |= 2 is same as C = C | 2 

Tutorial for java operators

Answer 7

S'il est sur la lisibilité, j'ai le concept de séparation testé les données de la logique de test.Exemple de code:

// declare data 
DataType [] dataToTest = new DataType[] { 
    defaultStock, 
    defaultWholesale, 
    defaultRetail, 
    defaultDelivery 
} 

// define logic 
boolean checkIfAnyNegative(DataType [] data) { 
    boolean negativeValue = false; 
    int i = 0; 
    while (!negativeValue && i < data.length) { 
     negativeValue = data[i++] < 0; 
    } 
    return negativeValue; 
} 

Le code semble plus verbeux et explicite. Vous pouvez même créer un tableau en appel de méthode, comme ceci:

checkIfAnyNegative(new DataType[] { 
    defaultStock, 
    defaultWholesale, 
    defaultRetail, 
    defaultDelivery 
}); 

Il est plus lisible que « chaîne de comparaison », et a également l'avantage de la performance de court-circuit (au coût de l'allocation de tableau et appel de méthode).

Edit: lisibilité encore plus peut être simplement obtenue en utilisant des paramètres varargs:

signature de la méthode serait:

boolean checkIfAnyNegative(DataType ... data) 

Et l'appel pourrait ressembler à ceci:

checkIfAnyNegative(defaultStock, defaultWholesale, defaultRetail, defaultDelivery);