如何得到一个整数的独立数字？

小开

转换为 String并使用 String#toCharArray()或 String#split()。

String number = String.valueOf(someInt);


char[] digits1 = number.toCharArray();
// or:
String[] digits2 = number.split("(?<=.)");

如果您已经使用了 Java8，并且之后碰巧想要对它执行一些聚合操作，那么可以考虑使用 String#chars()从中获取一个 IntStream。

IntStream chars = number.chars();

小开

为此，您将使用 %(mod)操作符。

int number; // = some int


while (number > 0) {
print( number % 10);
number = number / 10;
}

Mod 操作符将给出对数字进行整数除法的余数。

那么,

10012 % 10 = 2

因为:

10012 / 10 = 1001, remainder 2

注意: 正如 Paul 提到的，这将给出相反顺序的数字。您需要将它们推到一个堆栈上，然后按相反的顺序将它们弹出。

按正确顺序打印数字的代码:

int number; // = and int
LinkedList<Integer> stack = new LinkedList<Integer>();
while (number > 0) {
stack.push( number % 10 );
number = number / 10;
}


while (!stack.isEmpty()) {
print(stack.pop());
}

小开

ToString (1100) 将整数作为字符串显示。

编辑:

您可以将字符数字转换为数字数字，因此:

  String string = Integer.toString(1234);
int[] digits = new int[string.length()];


for(int i = 0; i<string.length(); ++i){
digits[i] = Integer.parseInt(string.substring(i, i+1));
}
System.out.println("digits:" + Arrays.toString(digits));

小开

这个怎么样？

public static void printDigits(int num) {
if(num / 10 > 0) {
printDigits(num / 10);
}
System.out.printf("%d ", num % 10);
}

或者不打印到控制台，我们可以在一个整数数组中收集它，然后打印数组:

public static void main(String[] args) {
Integer[] digits = getDigits(12345);
System.out.println(Arrays.toString(digits));
}


public static Integer[] getDigits(int num) {
List<Integer> digits = new ArrayList<Integer>();
collectDigits(num, digits);
return digits.toArray(new Integer[]{});
}


private static void collectDigits(int num, List<Integer> digits) {
if(num / 10 > 0) {
collectDigits(num / 10, digits);
}
digits.add(num % 10);
}

如果您希望保持从最小有效位(index [0])到最大有效位(index [ n ])的数字顺序，以下更新的 getDigits ()是您所需要的:

/**
* split an integer into its individual digits
* NOTE: digits order is maintained - i.e. Least significant digit is at index[0]
* @param num positive integer
* @return array of digits
*/
public static Integer[] getDigits(int num) {
if (num < 0) { return new Integer[0]; }
List<Integer> digits = new ArrayList<Integer>();
collectDigits(num, digits);
Collections.reverse(digits);
return digits.toArray(new Integer[]{});
}

小开

我认为这将是获得数字最有用的方法:

public int[] getDigitsOf(int num)
{
int digitCount = Integer.toString(num).length();


if (num < 0)
digitCount--;


int[] result = new int[digitCount];


while (digitCount-- >0) {
result[digitCount] = num % 10;
num /= 10;
}
return result;
}

然后你可以用一个简单的方法得到数字:

int number = 12345;
int[] digits = getDigitsOf(number);


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

或者更简单地说:

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

注意最后一个方法调用 getDigitsOf 方法的时间太长。所以会慢一点。您应该创建一个 int 数组，然后调用 getDigitsOf 方法一次，就像在第二个代码块中那样。

在下面的代码中，您可以反向进行处理。这个代码将所有数字放在一起形成数字:

public int digitsToInt(int[] digits)
{
int digitCount = digits.length;
int result = 0;


for (int i = 0; i < digitCount; i++) {
result = result * 10;
result += digits[i];
}


return result;
}

我提供的两种方法也适用于负数。

小开

// could be any num this is a randomly generated one
int num = (int) (Math.random() * 1000);


// this will return each number to a int variable
int num1 = num % 10;
int num2 = num / 10 % 10;
int num3 = num /100 % 10;


// you could continue this pattern for 4,5,6 digit numbers
// dont need to print you could then use the new int values man other ways
System.out.print(num1);
System.out.print("\n" + num2);
System.out.print("\n" + num3);

小开

这将使用模10方法计算大于0的数字中的每个数字，然后这将颠倒数组的顺序。这是假设您不使用“0”作为起始数字。

这被修改为接受用户输入。这个数组最初是向后插入的，因此我必须使用 Collections.reverse()调用将其放回用户的顺序中。

    Scanner scanNumber = new Scanner(System.in);
int userNum = scanNumber.nextInt(); // user's number


// divides each digit into its own element within an array
List<Integer> checkUserNum = new ArrayList<Integer>();
while(userNum > 0) {
checkUserNum.add(userNum % 10);
userNum /= 10;
}


Collections.reverse(checkUserNum); // reverses the order of the array


System.out.print(checkUserNum);

小开

我还没有见过任何人使用这种方法，但它对我很有效，而且简短而贴心:

int num = 5542;
String number = String.valueOf(num);
for(int i = 0; i < number.length(); i++) {
int j = Character.digit(number.charAt(i), 10);
System.out.println("digit: " + j);
}

这将产生:

digit: 5
digit: 5
digit: 4
digit: 2

小开

int number = 12344444; // or it Could be any valid number


int temp = 0;
int divider = 1;


for(int i =1; i< String.valueOf(number).length();i++)
{


divider = divider * 10;


}


while (divider >0) {


temp = number / divider;
number = number % divider;
System.out.print(temp +" ");
divider = divider/10;
}

小开

我编写了一个程序，演示如何使用一种更简单易懂的方法来分离整数的数字，这种方法不涉及数组、递归和所有那些花哨的技巧。这是我的代码:

int year = sc.nextInt(), temp = year, count = 0;


while (temp>0)
{
count++;
temp = temp / 10;
}


double num = Math.pow(10, count-1);
int i = (int)num;


for (;i>0;i/=10)
{
System.out.println(year/i%10);
}

假设您的输入是整数 123，结果输出如下:

1
2
3

小开

在这个主题的基础上，我们来看看如何在 Java 中确认这个数字是一个回文整数:

public static boolean isPalindrome(int input) {
List<Integer> intArr = new ArrayList();
int procInt = input;


int i = 0;
while(procInt > 0) {
intArr.add(procInt%10);
procInt = procInt/10;
i++;
}


int y = 0;
int tmp = 0;
int count = 0;
for(int j:intArr) {
if(j == 0 && count == 0) {
break;
}


tmp = j + (tmp*10);
count++;
}


if(input != tmp)
return false;


return true;
}

我相信我可以进一步简化这个算法。然而，这就是我所在的地方。而且在我所有的测试案例中都有效。

我希望这能帮到别人。

小开

import java.util.Scanner;


public class SeparatingDigits {


public static void main( String[] args )
{


System.out.print( "Enter the digit to print separately :- ");
Scanner scan = new Scanner( System.in );


int element1 = scan.nextInt();
int divider;


if( ( element1 > 9999 ) && ( element1 <= 99999 ) )
{
divider = 10000;
}
else if( ( element1 > 999 ) && ( element1 <= 9999 ) )
{
divider = 1000;
}
else if ( ( element1 > 99) && ( element1 <= 999 ) )
{
divider = 100;
}
else if( ( element1 > 9 ) && ( element1 <= 99 ) )
{
divider = 10;
}
else
{
divider = 1;
}


quotientFinder( element1, divider );








}


public static void quotientFinder( int elementValue, int dividerValue )
{
for( int count = 1;  dividerValue != 0; count++)
{
int quotientValue = elementValue / dividerValue ;
elementValue = elementValue % dividerValue ;
System.out.printf( "%d  ", quotientValue );


dividerValue /= 10;


}
}
}

不使用数组和字符串(数字1-99999)

产出:

输入要分别打印的数字: -12345

12345

小开

我认为更简单的方法是将数字转换为字符串，然后使用 substring提取，然后转换为整数。

就像这样:

int digits1 =Integer.parseInt( String.valueOf(201432014).substring(0,4));
System.out.println("digits are: "+digits1);

输出是二零一四年

小开

试试这个:

int num= 4321
int first  =  num % 10;
int second =  ( num - first ) % 100 / 10;
int third  =  ( num - first - second ) % 1000 / 100;
int fourth =  ( num - first - second - third ) % 10000 / 1000;

你会得到第一个 = 1，第二个 = 2，第三个 = 3，第四个 = 4..。

小开

public int[] getDigitsOfANumber(int number) {
String numStr = String.valueOf(number);
int retArr[] = new int[numStr.length()];


for (int i = 0; i < numStr.length(); i++) {
char c = numStr.charAt(i);
int digit = c;
int zero = (char) '0';
retArr[i] = digit - zero;


}
return retArr;
}

小开

在我的建议下面附上评论

          int size=i.toString().length(); // the length of the integer (i) we need to split;
ArrayList<Integer> li = new ArrayList<Integer>(); // an ArrayList in whcih to store the resulting digits


Boolean b=true; // control variable for the loop in which we will reatrive step by step the digits
String number="1"; // here we will add the leading zero depending on the size of i
int temp;  // the resulting digit will be kept by this temp variable


for (int j=0; j<size; j++){
number=number.concat("0");
}


Integer multi = Integer.valueOf(number); // the variable used for dividing step by step the number we received
while(b){


multi=multi/10;
temp=i/(multi);
li.add(temp);
i=i%(multi);
if(i==0){
b=false;
}




}


for(Integer in: li){
System.out.print(in.intValue()+ " ");
}

小开

因为在这个问题上我没有看到一个使用 Java8的方法，所以我把它放进去。假设您从一个 String开始并希望得到一个 List<Integer>，那么您可以像这样对元素进行流处理。

List<Integer> digits = digitsInString.chars()
.map(Character::getNumericValue)
.boxed()
.collect(Collectors.toList());

这将 String中的字符作为 IntStream获取，将这些字符的整数表示映射到一个数值，对它们进行装箱，然后将它们收集到一个列表中。

小开

这是我的答案，我是为自己做的，我希望它对于那些不想使用 String 方法或者需要更多数学解决方案的人来说足够简单:

public static void reverseNumber2(int number) {


int residual=0;
residual=number%10;
System.out.println(residual);


while (residual!=number)  {
number=(number-residual)/10;
residual=number%10;
System.out.println(residual);
}
}

所以我只需要得到单位，打印出来，从数字中减去它们，然后除以10-这总是没有任何浮动的东西，因为单位已经没有了，重复。

小开

Java8解决方案从一个字符串形式的整数中获取 int []数字:

int[] digits = intAsString.chars().map(i -> i - '0').toArray();

小开

像这样的东西将返回 char[]:

public static char[] getTheDigits(int value){
String str = "";
int number = value;
int digit = 0;
while(number>0){
digit = number%10;
str = str + digit;
System.out.println("Digit:" + digit);
number = number/10;


}
return str.toCharArray();
}

小开

import java.util.Scanner;


class  Test
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);




int num=sc.nextInt();
System.out.println("Enter a number (-1 to end):"+num);
int result=0;
int i=0;
while(true)
{
int n=num%10;
if(n==-1){
break;
}
i++;
System.out.println("Digit"+i+" = "+n);
result=result*10+n;
num=num/10;




if(num==0)
{
break;
}
}
}
}

小开

在 Java 中，这就是将数字和数字分开并存储在 Array 中的方法。

public static void main(String[] args) {
System.out.println("Digits Array:: "+Arrays.toString(getNumberArr(1100)));
}


private static Integer[] getNumberArr(int number) {
//will get the total number of digits in the number
int temp = number;
int counter = 0;


while (temp > 0) {
temp /= 10;
counter++;
}
//reset the temp
temp = number;


// make an array
int modulo;     //modulo is equivalent to single digit of the number.
Integer[] numberArr = new Integer[counter];
for (int i = counter - 1; i >= 0; i--) {
modulo = temp % 10;
numberArr[i] = modulo;
temp /= 10;
}


return numberArr;
}

产出:

Digits Array:: [1, 1, 0, 0]

小开

我注意到使用 Java8流来解决问题的例子很少，但我认为这是最简单的一个:

int[] intTab = String.valueOf(number).chars().map(Character::getNumericValue).toArray();

澄清一下: 使用 String.valueOf(number)将 int 转换为 String，然后使用 chars()方法获得 IntStream (字符串中的每个字符现在都是一个 Ascii 数字) ，然后需要运行 map()方法来获得 Ascii 数字的数值。最后，使用 toArray()方法将流更改为 int []数组。

小开

我看到所有的答案都是丑陋和不干净的。

我建议你用一点递归来解决你的问题。这篇文章已经很老了，但是它可能对未来的程序员有所帮助。

public static void recursion(int number) {
if(number > 0) {
recursion(number/10);
System.out.printf("%d   ", (number%10));
}
}

产出:

Input: 12345


Output: 1   2   3   4   5

小开

chars() 也没有 codePoints() & gt

String number = Integer.toString( 1100 );

IntStream.range( 0, number.length() ).map( i -> Character.digit( number.codePointAt( i ), 10 ) ).toArray();  // [1, 1, 0, 0]

小开

作为一个菜鸟，我的回答是:

String number = String.valueOf(ScannerObjectName.nextInt());
int[] digits = new int[number.length()];
for (int i = 0 ; i < number.length() ; i++)
int[i] = Integer.parseInt(digits.substring(i,i+1))

现在所有的数字都包含在数字数组中。

小开

如果数字 是注定要成为一个Character

String numstr = Integer.toString( 123 );
Pattern.compile( "" ).splitAsStream( numstr ).map(
s -> s.charAt( 0 ) ).toArray( Character[]::new );  // [1, 2, 3]

下面的工作是正确的
numstr = "000123"得到 [0, 0, 0, 1, 2, 3]
numstr = "-123"得到 [-, 1, 2, 3]

小开

简单的解决办法

public static void main(String[] args) {
int v = 12345;
while (v > 0){
System.out.println(v % 10);
v /= 10;
}
}

小开

Java9引入了一个新的 Stream.iterate方法，它可以用来生成一个流并在一定条件下停止。这可以用来获得数字中的所有数字，使用模方法。

int[] a = IntStream.iterate(123400, i -> i > 0, i -> i / 10).map(i -> i % 10).toArray();

请注意，这将得到反向顺序的数字，但这可以通过向后循环通过数组来解决(遗憾的是，反向数组是没那么简单) ，或者通过创建另一个流:

int[] b = IntStream.iterate(a.length - 1, i -> i >= 0, i -> i - 1).map(i -> a[i]).toArray();

或者

int[] b = IntStream.rangeClosed(1, a.length).map(i -> a[a.length - i]).toArray();

例如，这段代码:

int[] a = IntStream.iterate(123400, i -> i > 0, i -> i / 10).map(i -> i % 10).toArray();
int[] b = IntStream.iterate(a.length - 1, i -> i >= 0, i -> i - 1).map(i -> a[i]).toArray();
System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(b));

将印刷:

[0, 0, 4, 3, 2, 1]
[1, 2, 3, 4, 0, 0]

小开

你为什么不这样做:

String number = String.valueOf(input);
char[] digits = number.toCharArray();

小开

试试这个。

const check = (num) => {
let temp = num
let result = []
while(temp > 0){
let a = temp%10;
result.push(a);
temp = (temp-a)/10;
}
return result;
}


check(98) //[ 8, 9 ]

小开

使用 LINQ 的.NET 解决方案。

List<int> numbers = number.ToString().Select(x => x - 48).ToList();