关于 Java BigInteger

发布于 2024-12-28 00:22:24 字数 972 浏览 3 评论 0原文

我是 Java 新手，刚刚使用 BigInteger 编写了一个程序。

public static void main(String[] args) {
  BigInteger n = new BigInteger("5");
  BigInteger i = new BigInteger("2");
  while (lesserOrEqual(i,n) {
    System.out.println("n.mod(i) = "+n.mod(i));
    if (n.mod(i) == ZERO) {
      n = n.divide(i);
    }
    else {
      i.add(ONE);
  }
  System.out.println("n = "+n);
  System.out.println("i = "+i);
}


public static boolean lesserOrEqual(BigInteger m, BigInteger n) `{
  if (m.compareTo(n) == -1 || m.compareTo(n) == 0)
    return true;
  return false;
}

ZERO 和 ONE 分别定义为 BigInteger 0、1 类型。

我希望“i=2”除“n=5”，如果“n mod i == 0”，否则“i++”，直到“n”小于或等于“i”。

我认为输出必须是

n.mod(i) = 1
n = 5
i = 3
n.mod(i) = 2
n = 5
i = 4
n.mod(i) = 1
n = 5
i = 5
n.mod(i) = 0
n = 1
i = 5

，并且使用原始类型 int 的等效代码，我得到了预期的结果。

但这与 BigInteger 会进入无限循环

n.mod(i) = 1
n = 5
i = 2
...

有谁知道为什么会这样？

原文

I'm new to Java and just code a program with BigInteger.

public static void main(String[] args) {
  BigInteger n = new BigInteger("5");
  BigInteger i = new BigInteger("2");
  while (lesserOrEqual(i,n) {
    System.out.println("n.mod(i) = "+n.mod(i));
    if (n.mod(i) == ZERO) {
      n = n.divide(i);
    }
    else {
      i.add(ONE);
  }
  System.out.println("n = "+n);
  System.out.println("i = "+i);
}


public static boolean lesserOrEqual(BigInteger m, BigInteger n) `{
  if (m.compareTo(n) == -1 || m.compareTo(n) == 0)
    return true;
  return false;
}

ZERO and ONE are defined of the type BigInteger 0, 1, respectively.

I want "i=2" to divide "n=5", if "n mod i == 0", else "i++", until "n" to be lesser or equal to "i".

I think the output must be

n.mod(i) = 1
n = 5
i = 3
n.mod(i) = 2
n = 5
i = 4
n.mod(i) = 1
n = 5
i = 5
n.mod(i) = 0
n = 1
i = 5

and with the equivalent code with primitive type int, I have the result as expected.

but this with BigInteger goes to infinite loop

n.mod(i) = 1
n = 5
i = 2
...

Does anyone know why it is so?

分享到QQ

分享到微博

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

发布评论

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

献世佛 2025-01-04 00:22:24

BigInteger 类将整数表示为不可变对象。

这里有两点。

不要使用 == 来测试两个 BigInteger 是否相等
要更改 BigInteger 变量的值，您必须执行 i = i.add(ONE) ; 而不仅仅是 i.add(ONE);。

不使用 == 比较 BigInteger 的原因是，您不是检查数值相等，而是检查它们是否是内存中的同一对象。

考虑使用String。

String a = "a";
String b = "b";

String x = a + b;
String y = "ab";

在上面的示例中，x.equals(y) 为 true，因为它们包含相同数量且顺序完全相同的字符。然而，x == y 并不成立，因为它们是内存中的不同对象。

需要将算术运算的结果分配给变量的原因是 BigInteger 是不可变的。因此算术运算不能改变它正在操作的对象的值，但它可以创建一个新的 BigInteger （它返回）。这就是为什么您必须将算术运算的结果分配给您想要保存它的变量。

顺便说一句，您的 lesserThanOrEqual 的快捷方式是这样的。

boolean result = m.compareTo(n) <= 0;

基本上

m == n 变成 m.compareTo(n) == 0
m != n 变成 m.compareTo(n) != 0
m < n 变为 m.compareTo(n) 0
米> n 变为 m.compareTo(n) > 0
m <= n 变为 m.compareTo(n) <= 0
m >= n 变为 m.compareTo(n) >= 0

The BigInteger class represents integers as immutable objects.

There are two points here.

Don't use == to test if two BigIntegers are equal
To change the value of a BigInteger variable you must do i = i.add(ONE); and not just i.add(ONE);.

The reason not to use == to compare BigIntegers is because instead of checking for numerical equality you are checking that they are the same object in memory.

Consider with Strings.

String a = "a";
String b = "b";

String x = a + b;
String y = "ab";

In the above example x.equals(y) is true because they contain the same number of characters in exactly the same order. However, x == y is not true because they are different objects in memory.

The reason you need to to assign the result of arithmetic operations to a variable is because BigInteger is immutable. Thus arithmetic operations cannot change the value of the object it is operating on, but it can create a new BigInteger (which it returns). Which is why you must assign the result of the arithmetic operation to the variable you want it saved in.

As an aside a shortcut for your lesserThanOrEqual to is this.