将整数转换为数字数组

小开

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

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

类似地，当你打印出 newGuess时，你应该循环到 newGuess.length，但不包括。所以你的情况应该是 i<newGuess.length。

小开

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

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

这样，数组列表中的数字就会以相反的顺序排列。如果需要，您可以轻松地将其恢复，并将其转换为 int []。

小开

使用字符串，分开方法要简单得多:

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

小开

最佳答案

当前的问题是由于您使用的是 <= 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循环在这种情况下使用 <，而不是 <=。

小开

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

顺便说一句，如果不使用字符串，而是使用整数的 /10和 %10，则可以更有效地完成这项工作。

小开

你不必使用 substring(...)。使用 temp.charAt(i)获得一个数字，并使用以下代码将 char转换为 int。

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

小开

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

小开

用途:

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

主要的想法是

将 int 转换为它的 String 值
```
Integer.toString(num);
```
获取一个 int 流，它表示构成整数的 String 版本的每个 char (~ digital)的 ASCII 值
```
Integer.toString(num).chars();
```
将每个字符的 ASCII 值转换为其值。为了得到字符的实际 int 值，我们必须从实际字符的 ASCII 代码中减去字符“0”的 ASCII 代码值。为了得到我们的数字的所有数字，这个操作必须应用于每个字符(对应的数字)组成的字符串等价于我们的数字，这是通过应用下面的映射函数到我们的 IntStream。
```
Integer.toString(num).chars().map(c -> c-'0');
```

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

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

小开

调用这个函数:

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

小开

我可以建议采用以下方法:

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

我的代码来了:

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

小开

在 Scala 中，你可以这样做:

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

排成一行，不要颠倒顺序。

小开

用途:

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;

您必须将其放入一个方法中。

小开

我不能给弗拉基米尔的解决方案添加注释，但是我认为当你的初始数字也可以小于10时，这样会更有效率。

这是我的提议:

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

记得反转数组。

小开

你可使用:

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

小开

你可以这样做:

char[] digits = string.toCharArray();

然后可以将字符计算为整数。

例如:

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

小开

下面的函数接受一个整数并返回一个数字数组。

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

小开

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

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

小开

你可以这样做:

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

这也将维持秩序。

小开

我不能向弗拉基米尔的决定添加注释，但是您可以立即在正确的方向部署数组。我的解决办法是:

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

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

小开

试试这个！


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

小开

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

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 的加方法，并将 temp的值加到它上面，因此 list 的值是:

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

小开

我修改了 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

小开

在 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”是一个可迭代的对象，因此它将从它创建一个 Array。

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

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

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

摘要

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

小开

不使用 String，Integer，ArrayList，Math:

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