Lorsque vous avez besoin de représenter une valeur sans le concept de perte ou d'absence (valeur négative), cela s'appelle «valeur absolue».
La logique pour obtenir la valeur absolue est très simple: "If it's positive, maintain it. If it's negative, negate it".
Cela signifie que votre logique et votre code doivent fonctionner comme suit:
//If value is negative...
if ( value < 0 ) {
//...negate it (make it a negative negative-value, thus a positive value).
value = negate(value);
}
Il existe 2 façons d'annuler une valeur:
- En niant sa valeur:
value = (-value);
- En le multipliant par "100% négatif" ou "-1":
value = value *
(-1);
Les deux sont en fait les deux faces d'une même médaille. Il est juste que vous ne vous souvenez pas généralement que value = (-value);est en réalité value = 1 * (-value);.
Eh bien, quant à la façon dont vous le faites réellement en Java, c'est très simple, car Java fournit déjà une fonction pour cela, dans le Math class:value = Math.abs(value);
Oui, le faire sans Math.abs()n'est qu'une ligne de code avec des mathématiques très simples, mais pourquoi rendre votre code laid? Utilisez simplement la Math.abs()fonction fournie par Java ! Ils le fournissent pour une raison!
Si vous devez absolument ignorer la fonction, vous pouvez utiliser value = (value < 0) ? (-value) : value;, qui est simplement une version plus compacte du code que j'ai mentionné dans la section logique (3e), en utilisant l' opérateur ternaire ( ? :) .
En outre, il peut y avoir des situations dans lesquelles vous souhaitez toujours représenter une perte ou une absence dans une fonction qui peut recevoir des valeurs positives et négatives.
Au lieu de faire une vérification compliquée, vous pouvez simplement obtenir la valeur absolue et l'annuler: negativeValue = (-Math.abs(value));
Dans cet esprit, et en considérant un cas avec une somme de plusieurs nombres comme le vôtre, ce serait une bonne idée d'implémenter une fonction:
int getSumOfAllAbsolutes(int[] values){
int total = 0;
for(int i=0; i<values.lenght; i++){
total += Math.abs(values[i]);
}
return total;
}
En fonction de la probabilité que vous ayez à nouveau besoin de code associé, il peut également être judicieux de les ajouter à votre propre bibliothèque "utils", en divisant d'abord ces fonctions en leurs composants de base et en conservant la fonction finale simplement comme un nid d'appels à les fonctions désormais divisées des composants de base:
int[] makeAllAbsolute(int[] values){
//@TIP: You can also make a reference-based version of this function, so that allocating 'absolutes[]' is not needed, thus optimizing.
int[] absolutes = values.clone();
for(int i=0; i<values.lenght; i++){
absolutes[i] = Math.abs(values[i]);
}
return absolutes;
}
int getSumOfAllValues(int[] values){
int total = 0;
for(int i=0; i<values.lenght; i++){
total += values[i];
}
return total;
}
int getSumOfAllAbsolutes(int[] values){
return getSumOfAllValues(makeAllAbsolute(values));
}