将 integer 转换为数字数组

Question

我尝试将 integer 转换为数组。 例如 1234 到int[] arr = {1,2,3,4}; .

我写了一个 function：

public static void convertInt2Array(int guess)  {
    String temp = Integer.toString(guess);
    String temp2;
    int temp3;
    int [] newGuess = new int[temp.length()];
    for(int i=0; i<=temp.length(); i++) {
        if (i!=temp.length()) {
            temp2 = temp.substring(i, i+1);
        } else {
            temp2 = temp.substring(i);
            //System.out.println(i);
        }
        temp3 =  Integer.parseInt(temp2);
        newGuess[i] = temp3;
    }

    for(int i=0; i<=newGuess.length; i++) {
        System.out.println(newGuess[i]);
    }
}

但抛出异常：

线程“main”中的异常 java.lang.NumberFormatException：对于输入字符串：“”
在 java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)

在 java.lang.Integer.parseInt(Integer.java:504)
在 java.lang.Integer.parseInt(Integer.java:527)
在 q4.test.convertInt2Array(test.java:28)
在 q4.test.main(test.java:14)
Java 结果：1

我怎样才能解决这个问题？

Answer 1

直接的问题是由于您使用<= temp.length()而不是< temp.length() 。 但是，您可以更简单地实现这一点。 即使您使用字符串方法，您也可以使用：

String temp = Integer.toString(guess);
int[] newGuess = new int[temp.length()];
for (int i = 0; i < temp.length(); i++)
{
    newGuess[i] = temp.charAt(i) - '0';
}

在打印内容时，您也需要进行相同的更改以使用< newGuess.length() - 否则对于长度为 4（具有有效索引 0、1、2、3）的数组，您将尝试使用newGuess[4] 。 我编写的绝大多数for循环在条件中使用<而不是<= 。

Answer 2

您不需要将int转换为String 。 只需使用% 10获得最后一位数字，然后将您的 int 除以 10 即可获得下一位。

int temp = test;
ArrayList<Integer> array = new ArrayList<Integer>();
do{
    array.add(temp % 10);
    temp /= 10;
} while  (temp > 0);

这将为您留下以相反顺序包含您的数字的 ArrayList。 如果需要，您可以轻松还原它并将其转换为 int[]。

Answer 3

用：

public static void main(String[] args)
{
    int num = 1234567;
    int[] digits = Integer.toString(num).chars().map(c -> c-'0').toArray();
    for(int d : digits)
        System.out.print(d);
}

主要思想是

1. 将 int 转换为其 String 值

   Integer.toString(num);

2. 获取一个 int 流，它表示组成我们整数的 String 版本的每个 char(~digit) 的 ASCII 值

   Integer.toString(num).chars();

3. 将每个字符的 ASCII 值转换为其值。 要获得字符的实际 int 值，我们必须从实际字符的 ASCII 码中减去字符 '0' 的 ASCII 码值。 要获取我们数字的所有数字，必须对组成与我们数字等效的字符串的每个字符（对应于数字）应用此操作，这是通过将下面的 map 函数应用于我们的 IntStream 来完成的。

    Integer.toString(num).chars().map(c -> c-'0');

4. 使用 toArray() 将 int 流转换为 int 数组

    Integer.toString(num).chars().map(c -> c-'0').toArray();

Answer 4

您可以使用：

private int[] createArrayFromNumber(int number) {
    String str = (new Integer(number)).toString();
    char[] chArr = str.toCharArray();
    int[] arr = new int[chArr.length];
    for (int i = 0; i< chArr.length; i++) {
        arr[i] = Character.getNumericValue(chArr[i]);
    }
    return arr;
}

Answer 5

你可以这样做：

char[] digits = string.toCharArray();

然后您可以将字符评估为整数。

例如：

char[] digits = "12345".toCharArray();
int digit = Character.getNumericValue(digits[0]);
System.out.println(digit); // Prints 1

Answer 6

让我们使用递归来解决这个问题...

ArrayList<Integer> al = new ArrayList<>();

void intToArray(int num){
    if( num != 0){
        int temp = num %10;
        num /= 10;
        intToArray(num);
        al.add(temp);
    }
}

解释：

假设num值为 12345。

在第一次调用函数时， temp持有值 5 和num = 1234 的值。它再次传递给函数，现在temp持有值 4 和num的值是 123... 这个函数调用自己直到num的值不等于 0。

堆栈跟踪：

 temp - 5 | num - 1234
 temp - 4 | num - 123
 temp - 3 | num - 12
 temp - 2 | num - 1
 temp - 1 | num - 0

然后调用ArrayList的add方法，把temp的值加temp ，所以list的值为：

 ArrayList - 1
 ArrayList - 1,2
 ArrayList - 1,2,3
 ArrayList - 1,2,3,4
 ArrayList - 1,2,3,4,5

Answer 7

使用String.split方法会简单得多：

public static void fn(int guess) {
    String[] sNums = Integer.toString(guess).split("");
    for (String s : nums) {
    ...

Answer 8

在 Scala 中，你可以这样做：

def convert(a: Int, acc: List[Int] = Nil): List[Int] =
  if (a > 0) convert(a / 10, a % 10 +: acc) else acc

在一行中并且不颠倒顺序。

Answer 9

你可以这样做：

public int[] convertDigitsToArray(int n) {

    int [] temp = new int[String.valueOf(n).length()]; // Calculate the length of digits
    int i = String.valueOf(n).length()-1 ;  // Initialize the value to the last index

    do {
        temp[i] = n % 10;
        n = n / 10;
        i--;
    } while(n>0);

    return temp;
}

这也将维持秩序。

Answer 10

在 Javascript 中，这一行就可以解决问题：

Array.from(String(12345), Number);

例子

 const numToSeparate = 12345; const arrayOfDigits = Array.from(String(numToSeparate), Number); console.log(arrayOfDigits); //[1,2,3,4,5]

解释

1- String(numToSeparate)将数字 12345 转换为字符串，返回 '12345'

2- Array.from()方法从类数组或可迭代对象创建一个新的 Array 实例，字符串 '12345' 是一个可迭代对象，因此它将从中创建一个数组。

3- 但是，在自动创建这个新数组的过程中， Array.from()方法将首先将任何可迭代元素（在这种情况下的每个字符，例如：'1'、'2'）传递给我们设置给他的函数作为第二个参数，在这种情况下是Number函数

4- Number函数将接受任何字符串字符并将其转换为数字，例如： Number('1') ; 将返回1 。

5- 这些数字将一个一个地添加到一个新数组中，最后返回这个数字数组。

概括

代码行Array.from(String(numToSeparate), Number); 将数字转换为字符串，获取该字符串的每个字符，将其转换为数字并放入一个新数组中。 最后，将返回这个新的数字数组。

Answer 11

调用这个函数：

  public int[] convertToArray(int number) {
    int i = 0;
    int length = (int) Math.log10(number);
    int divisor = (int) Math.pow(10, length);
    int temp[] = new int[length + 1];

    while (number != 0) {
        temp[i] = number / divisor;
        if (i < length) {
            ++i;
        }
        number = number % divisor;
        if (i != 0) {
            divisor = divisor / 10;
        }
    }
    return temp;
}

Answer 12

尝试这个！

int num = 1234; 

String s = Integer.toString(num); 

int[] intArray = new int[s.length()]; 


for(int i=0; i<s.length(); i++){
    intArray[i] = Character.getNumericValue(s.charAt(i));
}

Answer 13

您不必使用substring(...) 。 使用temp.charAt(i)获取数字并使用以下代码将char转换为int 。

char c = '7';
int i = c - '0';
System.out.println(i);

Answer 14

我可以建议以下方法：

将数字转换为字符串 → 将字符串转换为字符数组 → 将字符数组转换为整数数组

这是我的代码：

public class test {

    public static void main(String[] args) {

        int num1 = 123456; // Example 1
        int num2 = 89786775; // Example 2

        String str1 = Integer.toString(num1); // Converts num1 into String
        String str2 = Integer.toString(num2); // Converts num2 into String

        char[] ch1 = str1.toCharArray(); // Gets str1 into an array of char
        char[] ch2 = str2.toCharArray(); // Gets str2 into an array of char

        int[] t1 = new int[ch1.length]; // Defines t1 for bringing ch1 into it
        int[] t2 = new int[ch2.length]; // Defines t2 for bringing ch2 into it

        for(int i=0;i<ch1.length;i++) // Watch the ASCII table
            t1[i]= (int) ch1[i]-48; // ch1[i] is 48 units more than what we want

        for(int i=0;i<ch2.length;i++) // Watch the ASCII table
            t2[i]= (int) ch2[i]-48; // ch2[i] is 48 units more than what we want
        }
    }

Answer 15

用：

int count = 0;
String newString = n + "";
char [] stringArray = newString.toCharArray();
int [] intArray = new int[stringArray.length];
for (char i : stringArray) {
  int m = Character.getNumericValue(i);
  intArray[count] = m;
  count += 1;
}
return intArray;

你必须把它放到一个方法中。

Answer 16

我无法在Vladimir 的解决方案中添加评论，但我认为当您的初始数字也可能低于 10 时，这也会更有效。

这是我的提议：

int temp = test;
ArrayList<Integer> array = new ArrayList<Integer>();
do{
  array.add(temp % 10);
  temp /= 10;
} while  (temp > 1);

记得反转数组。

Answer 17

这是一个接受一个整数并返回一个数字数组的函数。

static int[] Int_to_array(int n)
{
    int j = 0;
    int len = Integer.toString(n).length();
    int[] arr = new int[len];
    while(n!=0)
    {
        arr[len-j-1] = n % 10;
        n = n / 10;
        j++;
    }
    return arr;
}

Answer 18

首先将用户输入为 int ，将其转换为String ，并制作一个str.length()大小的字符数组。 现在使用charAt()用for循环填充字符数组。

Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
String str = Integer.toString(num);
char [] ch = new char [str.length()];

for(int i=0; i<str.length(); i++)
{
    ch[i] = str.charAt(i);
}

for(char c: ch)
{
    System.out.print(c +" ");
}

Answer 19

不使用字符串、整数、数组列表、数学：

// Actual number
int n = 56715380;
            
            // Copy of the number
            int m = n;
            
            // Find no. of digits as length
            int ln = 0;
            while (m > 0) {
                m = m / 10;
                ln++;
            }
            
            // Copy of the length
            int len = ln;
    
            // Reverse the number
            int revNum = 0;
            ln--;
            int base;
            while (n > 0) {
                base = 1;
                for (int i = 0; i < ln; i++) {
                    base = base * 10;
                }
                revNum = revNum + base * (n % 10);
                n = n / 10;
                ln--;
            }
    
            // Store the reverse number in the array
            int arr[] = new int[len];
            for (int i = 0; revNum > 0; i++) {
                arr[i] = revNum % 10;
                revNum = revNum / 10;
            }
            
            // Print the array
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i]);
            }

Answer 20

    String N="1234006"
    
    int[] a= new int[N.length()];
    
    for (int i = 0; i < N.length(); i++){
        a[i] = N.charAt(i) - '0';
    }

Answer 21

temp2 = temp.substring(i); 将始终返回空字符串“”。

相反，您的循环应该具有条件i<temp.length() 。 而temp2应该总是temp.substring(i, i+1); .

同样，当您打印newGuess ，您应该循环到newGuess.length但不包括在内。 所以你的条件应该是i<newGuess.length 。

Answer 22

for 语句中的<=应该是< 。

顺便说一句，不使用字符串可以更有效地执行此操作，而是使用整数的/10和%10 。

Answer 23

我无法对 Vladimir 的决定添加评论，但您可以立即将阵列部署到正确的方向。 这是我的解决方案：

public static int[] splitAnIntegerIntoAnArrayOfNumbers (int a) {
    int temp = a;
    ArrayList<Integer> array = new ArrayList<Integer>();
    do{
        array.add(temp % 10);
        temp /= 10;
    } while  (temp > 0);

    int[] arrayOfNumbers = new int[array.size()];
    for(int i = 0, j = array.size()-1; i < array.size(); i++,j--) 
        arrayOfNumbers [j] = array.get(i);
    return arrayOfNumbers;
}

重要提示：此解决方案不适用于负整数。

Answer 24

我修改了Jon Skeet 接受的答案，因为它不接受负值。

这现在接受并适当地转换数字：

public static void main(String[] args) {
    int number = -1203;
    boolean isNegative = false;
    String temp = Integer.toString(number);

    if(temp.charAt(0)== '-') {
        isNegative = true;
    }
    int len = temp.length();
    if(isNegative) {
        len = len - 1;
    }
    int[] myArr = new int[len];

    for (int i = 0; i < len; i++) {
        if (isNegative) {
            myArr[i] = temp.charAt(i + 1) - '0';
        }
        if(!isNegative) {
            myArr[i] = temp.charAt(i) - '0';
        }
    }

    if (isNegative) {
        for (int i = 0; i < len; i++) {
            myArr[i] = myArr[i] * (-1);
        }
    }

    for (int k : myArr) {
        System.out.println(k);
    }
}

输出

-1
-2
0
-3

Answer 25

public static void main(String k[])
{  
    System.out.println ("NUMBER OF VALUES ="+k.length);
    int arrymy[]=new int[k.length];
    for (int i = 0; i < k.length; i++)
    {
        int newGues = Integer.parseInt(k[i]);
        arrymy[i] = newGues;
    }
}