在Java中将整数数组转换为整数数字

Question

我是这个网站的新手，如果我在这里，那是因为我在网上找不到答案，相信我：我已经谷歌了很长时间，但是我只能找到如何将数字转换为数组而不是反过来。 我正在寻找一种简单的方法或函数将整数数组转换为整数。让我举个例子，我有这个：

int[] ar = {1, 2, 3};

我希望您能提供以下内容：

int nbr = 123;

在我的想象中，它应该是这样的（尽管我知道这不是正确的方式）：

int nbr = ar.toInt(); // I know it's funny

如果你有任何想法可以帮助我实现这个，那就太好了。

- gotgot1995

---

遍历数组，将每个元素转换为字符串并放入StringBuffer中，或者直接连接成字符串。 - Thrash Bean

字符串……人们要么疯了，要么根本与计算机编程无关。我已经给所有与字符串有关的答案投了反对票。 - Manu343726

@Manu343726 这与编程有什么关系... 它获得所需的答案并且是一小段代码，不一定是最有效的，但这不是要求的。 即使是最受赞誉的答案也不适用于输入... 但这是OP提供错误输入的问题。 - Java Devil

这是我的算法：http://pastebin.com/yeymhQtA - gotgot1995

Answer 1

从0开始。循环遍历整个int数组的所有元素。将结果乘以10，然后加上数组中的当前数字。在循环结束时，你会得到你的结果。

• 结果：0
• 第1次循环：Result * 10 => 0，Result + 1 => 1
• 第2次循环：Result * 10 => 10，Result + 2 => 12
• 第3次循环：Result * 10 >= 120，Result + 3 => 123

这可以通过将基数从10（这里）更改为其他值来推广到任何基数，例如十六进制的16。

- rgettman

---

很高兴有人建议将每个数字乘以它的十位数，而不是使用 StringBuilder 并将其解析回来。 - mjgpy3

事实上，我无法使以下任何算法起作用。所以你能澄清一下上面的内容，并告诉我如何在Java中正确实现吗？ - gotgot1995

@gotgot1995 即使你成功地运行了这个方法，使用 int 类型来处理你的输入也不会正确。你的输入太大了，无法存储在 int 中。你需要使用 long 类型。 - Java Devil

如果有帮助的话，我正在使用一个像这样初始化的数组：int[] arr = {2, 15, 14, 10, 15, 21, 18}; - gotgot1995

如果你使用long而不是int，它会起作用，可以看看我编辑后的答案。 - Java Devil

Answer 2

您需要循环数组并添加正确的值。

正确的值是当前元素在数组中乘以10^位置。

所以：ar[0]*1 + ar[1]*10 + ar[2] *100 + ......

    int res=0;
    for(int i=0;i<ar.length;i++) {
         res=res*10+ar[i];
    }

或者

   for(int i=0,exp=ar.length-1;i<ar.length;i++,exp--)
        res+=ar[i]*Math.pow(10, exp);

- Alessio

---

第一种方法是我见过的最好的，谢谢。 - Shubham Shah

它将[1,0]更改为1，应该是10。 - Sophie

Answer 3

首先你需要将每个数字转换为字符串，然后将这些字符串连接起来并解析回整数。以下是一种实现方法：

int arrayToInt(int[] arr)
{
    //using a Stringbuilder is much more efficient than just using += on a String.
    //if this confuses you, just use a String and write += instead of append.
    StringBuilder s = new StringBuilder(); 

    for (int i : arr)
    {
         s.append(i); //add all the ints to a string
    }

    return Integer.parseInt(s.toString()); //parse integer out of the string
}

注意，如果数组中第一个值之后的任何一个值为负数，则会产生错误，因为减号会干扰解析。

此方法适用于所有正整数，但如果您知道数组中所有值只有一位数（就像在您的示例中一样），则可以完全避免使用字符串操作，直接使用基本运算。

int arrayToInt(int[] arr)
{
    int result = 0;

    //iterate backwards through the array so we start with least significant digits
    for (int n = arr.length - 1, i = 1; n >= 0; n --, i *= 10) 
    {
         result += Math.abs(arr[n]) * i;
    }

    if (arr[0] < 0) //if there's a negative sign in the beginning, flip the sign
    {
        result = - result;
    }

    return result;
}

这个版本如果其余数值为负数不会产生错误，但是会产生奇怪的结果。

没有内置函数可以做到这一点，因为数组的值通常表示不同的数字，而不是数字中的数字。

编辑：

根据您的评论，请尝试使用此版本来处理长整型：

long arrayToLong(int[] arr)
{
    StringBuilder s = new StringBuilder(); 

    for (int i : arr)
    {
         s.append(i);
    }

    return Long.parseLong(s.toString());
}

编辑2：

回应你的第二条评论：

int[] longToIntArray(long l)
{
    String s = String.valueOf(l);   //expand number into a string

    String token;

    int[] result = new int[s.length() / 2]; 

    for (int n = 0; n < s.length()/2; n ++) //loop through and split the string
    {
        token = s.substring(n*2, (n+2)*2);
        result[n] = Integer.parseInt(token); //fill the array with the numbers we parse from the sections
    }

    return result;
}

- ApproachingDarknessFish

---

请注意，如果您的数组中有任何负值，则此操作将失败，就像其他人的答案一样... 如果出现这种情况，那么很可能是无效输入的情况。 - Java Devil

@gotgot1995 int 的最大值为 2^32-1 或 4294967295。你的数太大了，请使用 long 或 java.math.BigInteger 如果你需要这么大的数字。 - ApproachingDarknessFish

@ValekHalfHeart 我想你指的是2^31 -1 请参见文档 - Java Devil

@ValekHalfHeart 不是...你知道我在Java方面的水平不是很高，而且一小时前我还不知道这个函数，所以没有使用上述任何内容。 - gotgot1995

@gotgot1995 这就是当Java中的long类型变得足够大时的表达方式。 - ApproachingDarknessFish

Answer 4

是的，您可以自己编写该函数。

int toInt(int[] array) {
    int result = 0;
    int offset = 1;
    for(int i = array.length - 1; i >= 0; i--) {
        result += array[i]*offset;
        offset *= 10;
    }
    return result;
}

我认为其背后的逻辑相当直观。只需遍历数组（从最后一个元素开始），并将数字与对应的10的幂相乘“将数字放在正确的位置”。最后返回该数字即可。

- datosh

Answer 5

int nbr = 0;
for(int i = 0; i < ar.length;i++)
    nbr = nbr*10+ar[i];

最终，你会得到想要的数字。

对于你给我们的新数组，请尝试这个。我看不出有什么方法可以避免使用某种形式的字符串，并且你必须使用long而不是int。

int [] ar = {2, 15, 14, 10, 15, 21, 18};
long nbr = 0;
double multiplier = 1;
for(int i = ar.length-1; i >=0 ;i--) {
    nbr += ar[i] * multiplier;
    multiplier = Math.pow(10, String.valueOf(nbr).length());
}

如果您真的非常想避免使用String（不知道为什么），我猜您可以使用

multiplier = Math.pow(10,(int)(Math.log10(nbr)+1));

只要数组中的最后一个元素不为0，这个方法就会起作用。

- jhnewkirk

---

如果我的数组被初始化为：int[] arr = {2, 15, 14, 10, 15, 21, 18}; 您的算法会给出3651728，但我想要的是2151410152118。 - gotgot1995

Answer 6

简单点!!!

public static int convertToInteger(int... arr) {
    return Integer.parseInt(Arrays.stream(arr)
                                  .mapToObj(String::valueOf)
                                  .collect(Collectors.joining()));
}

- oleg.cherednik

Answer 7

如果您可以使用Java 1.8，流API使其非常简单：

@Test
public void arrayToNumber() {
    int[] array = new int[]{1,2,3,4,5,6};
    StringBuilder sb = new StringBuilder();

    Arrays.stream(array).forEach(element -> sb.append(element));

    assertThat(sb.toString()).isEqualTo("123456");
}

- jfcorugedo

Answer 8

使用这种方法，如果您的输入太大而无法使用int，则可以使用long。

long r = 0;
for(int i = 0; i < arr.length; i++)
{
    int offset = 10;
    if(arr[i] >= 10)
        offset = 100;
    r = r*offset;
    r += arr[i];
}

这个检查当前的整数是否大于10，以将偏移重置为100，以获取所需的额外位数。如果您包括值> 100，则还需要添加额外的偏移量。

---

由于所有的字符串都被投票否决了，我把这个放在我的帖子末尾...这是一个完全合法的答案...OP从未要求最有效的方法，只是想要一个答案。

循环遍历数组，在每个整数后附加一个字符串，然后将字符串解析回整数。

String s = "";
for(int i = 0; i < arr.length; i++)
       s += "" + arr[i];
int result = Integer.parseInt(s);

从您的评论中可以看出，您拥有的数字对于int来说太长了，您需要使用long。

String s = "";
for(int i = 0; i < arr.length; i++)
       s += "" + arr[i];
long result = Long.parseLong(s);

- Java Devil

---

抱歉，运行时出现错误：java.lang.NumberFormatException: For input string: "2151410152118"。 - gotgot1995

这是因为结果是一个太大以至于 int 无法容纳的数字，你需要使用 long。当使用其他加法方法时不会出现此异常的原因是您将获得一个溢出错误。 - Java Devil

1. 不要这样做。
2. 如果你这么做了，不要使用 +=，而是使用 StringBuilder。

- Darkhogg

“由于字符串的所有负评...这是一个完全合法的答案...”不，这根本不是一个合理的答案。你可以执行浮点乘法，将数字位存储为两个字符串并对它们进行操作...虽然可行，但...你在开玩笑吗？ - Manu343726

@Manu343726 我从未说过这是合理的，我说过这是合法的。谁说过任何关于浮点数乘法的事情。重点是对于问题中给出的示例，它是有效的。OP不关心效率。 - Java Devil

@Darkhogg 1. 你的第一点和第二点是相同的。2. 如果要处理更大的数组，肯定要使用 StringBuilder，但如果长度超过这个程度，那么 OP 要处理的问题就更大了。 - Java Devil

Answer 9

你可以用那种方式做

public static int[] plusOne(int[] digits) {
    StringBuilder num= new StringBuilder();
    PrimitiveIterator.OfInt primitiveIterator = Arrays.stream(digits)
            .iterator();
    while (primitiveIterator.hasNext()) {
        num.append(primitiveIterator.nextInt());
    }
    int plusOne=Integer.parseInt(String.valueOf(num))+1;
    return Integer.toString(plusOne).chars().map(c -> c-'0').toArray();
}

- Mohammed Ashraf

Answer 10

这也可以将整数数组转换为int数组

    int[] result = new int[arr.length];
    for (int i = 0; i < arr.length; i++) {
        result[i] = arr[i].intValue();
    }

- maruf ahmed