当前位置：文江博客话题详情

将负数变为正数

发布于 2024-07-13 02:51:18 字数 121 浏览 9 评论 0原文

我有一个 Java 方法，可以对一组数字求和。但是，我希望将任何负数视为正数。所以 (1)+(2)+(1)+(-1) 应该等于 5。

我确信有一个非常简单的方法可以做到这一点 - 我只是不知道如何做。

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

时光与爱终年不遇 2024-07-20 02:51:19

当您需要表示一个没有损失或缺失（负值）概念的值时，这称为“绝对值”。

获取绝对值的逻辑非常简单：“如果是正数，则维持它。如果是负数，则取反”。

这意味着您的逻辑和代码应如下所示工作：

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

有 2 种方法可以对某个值取反：

通过对它的值取反：value = (-value);
通过将其相乘通过“100% 负”或“-1”：值 = 值 * (-1);

两者实际上是同一枚硬币的两面。只是您通常不记得 value = (-value); 实际上是 value = 1 * (-value);。

好吧，至于在 Java 中实际如何做到这一点，非常简单，因为 Java 已经在 Math 类中提供了一个函数： value = Math.abs(value);< /code>

是的，不使用 Math.abs() 就只是一行非常简单的数学代码，但是为什么让你的代码看起来很丑呢？只需使用 Java 提供的 Math.abs() 函数即可！他们提供它是有原因的！

如果您绝对需要跳过该函数，可以使用 value = (value < 0) ? (-value) : value;，这只是我在逻辑（第三）部分中提到的代码的更紧凑版本，使用三元运算符 (? :)。

此外，在某些情况下，您可能希望始终表示函数中的丢失或缺失，该函数可能同时接收正值和负值。

您可以简单地获取绝对值并将其取反，而不是进行一些复杂的检查：negativeValue = (-Math.abs(value));

考虑到这一点，并考虑具有总和的情况对于像您这样的多个数字，实现一个函数是一个好主意：

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

根据您可能再次需要相关代码的可能性，将它们添加到您自己的“utils”库中，拆分这些函数也可能是一个好主意首先进入它们的核心组件，并将最终函数简单地维护为对核心组件现在拆分的函数的调用嵌套：

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

When you need to represent a value without the concept of a loss or absence (negative value), that is called "absolute value".

The logic to obtain the absolute value is very simple: "If it's positive, maintain it. If it's negative, negate it".

What this means is that your logic and code should work like the following:

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

There are 2 ways you can negate a value:

By, well, negating it's value: value = (-value);
By multiplying it by "100% negative", or "-1": value = value * (-1);

Both are actually two sides of the same coin. It's just that you usually don't remember that value = (-value); is actually value = 1 * (-value);.

Well, as for how you actually do it in Java, it's very simple, because Java already provides a function for that, in the Math class: value = Math.abs(value);

Yes, doing it without Math.abs() is just a line of code with very simple math, but why make your code look ugly? Just use Java's provided Math.abs() function! They provide it for a reason!

If you absolutely need to skip the function, you can use value = (value < 0) ? (-value) : value;, which is simply a more compact version of the code I mentioned in the logic (3rd) section, using the Ternary operator (? :).

Additionally, there might be situations where you want to always represent loss or absence within a function that might receive both positive and negative values.

Instead of doing some complicated check, you can simply get the absolute value, and negate it: negativeValue = (-Math.abs(value));

With that in mind, and considering a case with a sum of multiple numbers such as yours, it would be a nice idea to implement a function:

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

Depending on the probability you might need related code again, it might also be a good idea to add them to your own "utils" library, splitting such functions into their core components first, and maintaining the final function simply as a nest of calls to the core components' now-split functions:

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

将负数变为正数

如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

评论（23）

关于作者

相关话题

热门标签

推荐作者

qq_FjTq5B

18273202778

WordPress小学生

〃温暖了心ぐ

迷乱花海

niuniu

友情链接

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。