Opérateur de raccourci "or-assignment" (|=) en Java

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

comme exemple de la différence, ce code sera amende si text est nul:

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

(évidemment vous pouvez faire "".equals(text) pour ce cas particulier - j'essaie juste de démontrer le principe.)

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

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

pour les expressions les plus simples, utiliser | peut être plus rapide que || parce que même si cela évite de faire une comparaison, cela signifie utiliser une branche implicitement et cela peut être beaucoup plus cher.

bien qu'il puisse être exagéré pour votre problème, le Guava bibliothèque a une certaine syntaxe agréable avec Predicate s et fait court-circuit évaluation de ou/et Predicate s.

essentiellement, les comparaisons sont transformées en objets, empaquetées dans une collection, puis itérées. Pour ou prédit, le premier vrai hit retourne de l'itération, et vice versa pour et.

S'il s'agit de lisibilité, j'ai le concept de séparation des données testé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 dans l'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 performance de court-circuiter (au coût de l'allocation de tableau et appel de méthode).

Edit: Il est possible d'obtenir encore plus de lisibilité en utilisant simplement les paramètres varargs:

la signature de la méthode serait:

boolean checkIfAnyNegative(DataType ... data)

Et l'appel pourrait ressembler à ceci:

checkIfAnyNegative( defaultStock, defaultWholesale, defaultRetail, defaultDelivery );

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

/ / booléen logique ou

| bit à bit OU

| = opérateur d'inclusion et d'affectation en Bit

la raison pour laquelle |= ne shortcircit pas est parce qu'il fait un bitwise ou pas un ou logique. C'est-à-dire:

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

Tutorial pour les opérateurs java

C'est un vieux post mais afin de fournir une perspective différente pour les débutants, je voudrais donner un exemple.

je pense que le cas d'utilisation le plus courant pour un opérateur composé similaire serait += . Je suis sûr que nous avons tous écrit quelque chose comme ceci:

int a = 10;   // a = 10
a += 5;   // a = 15

Quel était le but de ceci? Il était d'éviter d'écrire la variable a deux fois dans la même ligne. (Est-ce que je manque quelque chose de supérieur ici?)

Ainsi, la ligne suivante fait exactement la même chose, en évitant de taper la variable b1 deux fois dans la même ligne.

b1 |= b2;