Faire un nombre négatif positif

Question

J'ai une méthode Java dans laquelle je fais la somme d'un ensemble de nombres. Cependant, je veux que tous les nombres négatifs soient traités comme des positifs. Donc (1) + (2) + (1) + (- 1) devrait être égal à 5.

Je suis sûr qu'il existe un moyen très simple de le faire - je ne sais pas comment.

Answer 1

Il suffit d'appeler Math.abs . Par exemple:

int x = Math.abs(-5);

Qui définira x sur 5.

Answer 2

Le concept que vous décrivez s'appelle " valeur absolue " et Java a une fonction appelée Math.abs pour le faire à votre place. Ou vous pouvez éviter l'appel de fonction et le faire vous-même:

number = (number < 0 ? -number : number);

ou

if (number < 0)
    number = -number;

Answer 3

Vous recherchez une valeur absolue, mec. Math.abs(-5) renvoie 5 ...

Answer 4

Utilisez la abs fonction:

int sum=0;
for(Integer i : container)
  sum+=Math.abs(i);

Answer 5

  

Ce code n'est pas sûr d'être appelé sur des nombres positifs.

int x = -20
int y = x + (2*(-1*x));
// Therefore y = -20 + (40) = 20

Answer 6

Voulez-vous parler de valeurs absolues?

Math.abs (...) est la fonction que vous voulez probablement.

Answer 7

Vous souhaitez insérer chaque numéro dans Math.abs(). par exemple

System.out.println(Math.abs(-1));

imprime & "; 1 &";.

Si vous voulez éviter d'écrire la partie Math., vous pouvez inclure Math util de manière statique. Il suffit d'écrire

import static java.lang.Math.abs;

avec vos importations, et vous pouvez vous référer à la abs() - fonction simplement en écrivant

System.out.println(abs(-1));

Answer 8

Essayez ceci (le négatif devant le x est valide car il s'agit d'un opérateur unaire, trouvez-en plus ici ):

int answer = -x;

Avec cela, vous pouvez transformer un positif en négatif et un négatif en positif.

Toutefois , si vous souhaitez uniquement rendre un nombre négatif positif, essayez ceci:

int answer = Math.abs(x);

OU , si vous préférez ne pas utiliser la méthode abs () pour une raison quelconque, essayez ceci:

int answer = Math.sqrt(Math.pow(x, 2));

J'espère que ça aide! Bonne chance!

Answer 9

La façon la plus simple de procéder consiste à envelopper chaque numéro dans un appel Math.abs (), de manière à ajouter:

Math.abs(1) + Math.abs(2) + Math.abs(1) + Math.abs(-1)

avec des changements de logique pour refléter la structure de votre code. Verbose, peut-être, mais il fait ce que tu veux.

Answer 10

Lorsque vous devez 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 deux manières de nier une valeur:

1. Par, bien, en annulant sa valeur: value = (-value);
2. En le multipliant par & "100% négatif &"; ou & "-1 &" :: value = value * (-1);

Les deux sont en réalité les deux faces d’une même pièce. C'est simplement que vous ne vous en souvenez généralement pas. value = 1 * (-value); est en fait Math class.

Eh bien, pour ce qui est de 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 value = Math.abs(value);: Math.abs()

Oui, le faire sans value = (value < 0) ? (-value) : value; n'est qu'une ligne de code avec des calculs très simples, mais pourquoi donner à votre code une apparence laide? Il suffit d’utiliser la fonction ? : fournie par Java! Ils le fournissent pour une raison!

Si vous devez absolument ignorer la fonction, vous pouvez utiliser negativeValue = (-Math.abs(value));, qui est simplement une version plus compacte du code que j'ai mentionné dans la section logique (3ème), en utilisant Opérateur ternaire (<=>) .

De plus, il peut arriver que vous souhaitiez toujours représenter une perte ou une absence dans une fonction pouvant recevoir à la fois 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: <=>

Dans cette optique, et si vous envisagez une combinaison de plusieurs nombres comme le vôtre, il serait intéressant de mettre en oeuvre 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 & "; utils &"; bibliothèque, en divisant d’abord ces fonctions en leurs composants centraux et en maintenant la fonction finale simplement comme un nid d’appels aux fonctions désormais divisées des composants centraux:

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));
}

Answer 11

Pourquoi ne pas multiply that number with -1 ?

Comme ceci:

//Given x as the number, if x is less than 0, return 0 - x, otherwise return x:
return (x <= 0.0F) ? 0.0F - x : x;

Answer 12

Je recommanderais les solutions suivantes:

sans amusement des bibliothèques:

    value = (value*value)/value

avec lib fun:

   value = Math.abs(value);

Answer 13

Si vous êtes intéressé par la mécanique du complément à deux, voici la manière absolument inefficace, mais illustrative, de bas niveau utilisée:

private static int makeAbsolute(int number){
     if(number >=0){
        return number;
     } else{
        return (~number)+1;
     }
}

Answer 14

String s = "-1139627840";
BigInteger bg1 = new BigInteger(s);
System.out.println(bg1.abs());

Alternativement:

int i = -123;
System.out.println(Math.abs(i));

Answer 15

La fonction de bibliothèque Math.abs() peut être utilisée.
int x=-5; retourne la valeur absolue de l'argument

  

  
• si l'argument est négatif, il retourne la négation de l'argument.
  
• si l'argument est positif, il retourne le nombre tel quel.
  

exemple:

1. System.out.println(Math.abs(x));
int y=6;

Sortie: 5

2. System.out.println(Math.abs(y));
   <=>

Sortie: 6

Answer 16

J'avais besoin de la valeur absolue d'un long, et j'ai examiné profondément Math.abs et découvert que si mon argument est inférieur à LONG.MIN_VAL, qui est -9223372036854775808l, la fonction abs ne renverra pas une valeur absolue mais uniquement le minimum. valeur. Dans ce cas, si votre code utilise cette valeur abs plus loin, il pourrait y avoir un problème.

Answer 17

ne faites pas cela

nombre = (nombre < 0? -numéro: nombre);

ou

if (numéro < 0) nombre = -numéro;

ce sera un bug lorsque vous exécuterez find bug sur votre code, il le signalera sous la forme RV_NEGATING_RESULT_OF