如何获得整数的单独数字？

Java 9 引入了一种新的 Stream.iterate 方法，可用于生成流并在特定条件下停止。这可用于获取数字中的所有数字，使用模数方法。

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

请注意，这将以相反的顺序获得数字，但这可以通过向后循环数组来解决（遗憾的是，反转数组是 not that simple），或者通过创建另一个流：

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]

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

像这样的东西：

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

输出是 2014

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

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

这是我的答案，我是为自己做的，我希望对于那些不想使用 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 - 这总是没有任何浮动的东西，因为单位已经消失，重复。

Java 8 解决方案从作为字符串的整数获取数字作为 int[]：

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

你为什么不这样做：

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 ]

既不 chars() 也不 codePoints() ——另一个 lambda

String number = Integer.toString( 1100 );

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

Integer.toString(1100) 将整数作为字符串提供给您。 Integer.toString(1100).getBytes() 获取单个数字的字节数组。

编辑：

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

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

这使用模 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);

只是为了建立这个主题，这里是如何确认数字是 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;
}

我确信我可以进一步简化这个算法。然而，这就是我所在的地方。它在我所有的测试用例下都有效。

我希望这可以帮助别人。

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

类似这样的内容将返回 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();
}

作为菜鸟，我的回答是：

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

现在所有数字都包含在“digits”数组中。

if 数字 意味着是一个 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]

使用 LINQ 的 .NET 解决方案。

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

我认为这将是获取数字的最有用的方法：

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

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

请参阅下面我的建议和评论

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

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