Faça um número negativo positivo

StackOverflow https://stackoverflow.com/questions/493494

  •  20-08-2019
  •  | 
  •  

Pergunta

Eu tenho um método Java em que eu estou somando um conjunto de números. No entanto, quero quaisquer números negativos para ser tratado como positivos. Então (1) + (2) + (1) + (- 1) deve ser igual a 5.

Eu tenho certeza que é uma maneira muito fácil de fazer isso - eu só não sei como

.
Foi útil?

Solução

Apenas chamada Math.abs . Por exemplo: 

int x = Math.abs(-5);

que irá definir x para 5.

Outras dicas

O conceito que você está descrevendo é chamado de "valor absoluto", e Java tem uma função chamada Math.abs para fazer isso por você. Ou você pode evitar a chamada de função e fazê-lo sozinho: 

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

ou 

if (number < 0)
    number = -number;

Você está procurando valor absoluto, companheiro. Math.abs(-5) retornos 5 ...

Use a função abs: 

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

Este código é não seguro para ser chamado em números positivos. 

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

Você está perguntando sobre os valores absolutos?

Math.abs (...) é a função que você provavelmente quer.

Você quer envolva cada número em Math.abs(). por exemplo. 

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

imprime "1".

Se você quer evitar escrever o-parte Math., você pode incluir o Math util estaticamente. Basta escrever 

import static java.lang.Math.abs;

juntamente com suas importações, e você pode se referir à função abs() apenas por escrever 

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

Tente isto (o negativo em frente à x é válido uma vez que é um operador unário, encontrar mais aqui ): 

int answer = -x;

Com isso, você pode transformar um positivo para um negativo e um negativo para um positivo.

No entanto , se você quiser apenas para fazer um número negativo positivo, em seguida, tente o seguinte: 

int answer = Math.abs(x);

ou , se você preferir não usar o método abs (), por algum motivo, em seguida, tente o seguinte: 

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

Espero que ajude! Boa sorte!

O mais fácil, se detalhado maneira de fazer isso é envolver cada número em um Math.abs () chamada, para que você gostaria de acrescentar: 

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

com as mudanças lógicas para refletir como seu código está estruturado. Detalhado, talvez, mas ele faz o que quiser.

Quando você precisa para representar um valor sem o conceito de uma perda ou ausência (valor negativo), que é chamado de "valor absoluto".

A lógica para obter o valor absoluto é muito simples:. "If it's positive, maintain it. If it's negative, negate it"

O que isto significa é que sua lógica e código deve funcionar como o seguinte: 

//If value is negative...
if ( value < 0 ) {
  //...negate it (make it a negative negative-value, thus a positive value).
  value = negate(value);
}

Existem 2 maneiras que você pode negar um valor:

  1. por, bem, negando o valor da TI: value = (-value);
  2. multiplicando-o por "100% negativo", ou "-1": value = value * (-1);

Ambos são realmente dois lados da mesma moeda. É só que você normalmente não lembre-se que value = (-value); é realmente value = 1 * (-value);.

Bem, como para como você realmente fazê-lo em Java, é muito simples, porque Java já fornece uma função para que, no Math class: value = Math.abs(value);

Sim, fazê-lo sem Math.abs() é apenas uma linha de código com a matemática muito simples, mas por que fazer seu olhar código feio? Basta usar a função Math.abs() fornecida Java! Eles fornecem-lo por uma razão!

Se você absolutamente necessário para ignorar a função, você pode usar value = (value < 0) ? (-value) : value;, que é simplesmente uma versão mais compacta do código mencionado no (3) seção lógica, usando o operador ternário (? :) .

Além disso, pode haver situações em que você deseja representar sempre a perda ou ausência, em uma função que pode receber tanto os valores positivos e negativos.

Em vez de fazer alguma verificação complicado, você pode simplesmente obter o valor absoluto, e negá-lo: negativeValue = (-Math.abs(value));

Com isso em mente, e considerando um caso com uma soma de vários números como a sua, seria uma boa ideia para implementar uma função: 

int getSumOfAllAbsolutes(int[] values){
  int total = 0;
  for(int i=0; i<values.lenght; i++){
    total += Math.abs(values[i]);
  }
  return total;
}

Dependendo da probabilidade de que você pode precisar de código relacionado novamente, ele também pode ser uma boa idéia para adicioná-los aos seus próprios "utils" biblioteca, dividir essas funções em seus componentes básicos em primeiro lugar, e manter a função final simplesmente como um ninho de chamadas para os componentes principais funções agora-split: 

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

Por que você não multiply that number with -1 ?

Como esta: 

//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;

Eu recomendaria as seguintes soluções:

sem diversão lib: 

    value = (value*value)/value

com diversão lib: 

   value = Math.abs(value);

Se você estiver interessado na mecânica do complemento de dois, aqui é a maneira absolutamente ineficiente, mas ilustrativo de baixo nível isso é feito: 

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

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

Como alternativa: 

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

Biblioteca Math.abs() função pode ser usada.
Math.abs() retorna o valor absoluto do argumento

  • Se o argumento for negativo, ele retorna a negação do argumento.
  • Se o argumento é positivo, ele retorna o número como ela é.

por exemplo:

  1. int x=-5;
    System.out.println(Math.abs(x));

Output: 5

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

Saída: 6

Eu precisava o valor absoluto de um longo e olhou profundamente em Math.abs e descobriu que se o meu argumento é menor que LONG.MIN_VAL que é -9223372036854775808l, então a função abs não iria retornar um valor absoluto, mas apenas o mínimo valor. Inthis caso, se o código está usando este valor abs ainda mais, em seguida, pode haver um problema.

Não fazer isso

Número = (número <0 -número: número);

ou

se (número <0) = número -número;

este será um erro quando você executar achado bug em seu código que irá relatá-lo como RV_NEGATING_RESULT_OF

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top