¿Cómo obtener los dígitos separados de un número int?

Tengo números como 1100, 1002, 1022, etc. Me gustaría tener los dígitos individuales, por ejemplo, para el primer número 1100, quiero tener 1, 1, 0, 0.

¿Cómo puedo obtenerlo en Java?

Para hacer esto, usará el %operador (mod).

int number; // = some int

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

El operador mod te dará el resto de hacer una división int en un número.

Entonces,

10012 % 10 = 2

Porque:

10012 / 10 = 1001, remainder 2

Nota: Como señaló Paul, esto le dará los números en orden inverso. Tendrá que empujarlos a una pila y sacarlos en orden inverso.

Código para imprimir los números en el orden correcto:

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

Conviértalo a Stringy use String#toCharArray()o String#split().

String number = String.valueOf(someInt);

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

En caso de que ya esté en Java 8 y desee realizar algunas operaciones agregadas en él después, considere usarlo String#chars()para IntStreamsalir de él.

IntStream chars = number.chars();

¿Qué tal esto?

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

o en lugar de imprimir en la consola, podemos recopilarlo en una matriz de enteros y luego imprimir la matriz:

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

Si desea mantener el orden de los dígitos desde el menos significativo (índice [0]) al más significativo (índice [n]), lo siguiente que necesita es getDigits () actualizado:

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

No he visto a nadie usar este método, pero funcionó para mí y es breve y dulce:

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

Esto generará:

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

Noté que hay pocos ejemplos de uso de Java 8 stream para resolver su problema, pero creo que este es el más simple:

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

Para ser claros: se usa String.valueOf(number)para convertir int a String, luego el chars()método para obtener un IntStream (cada carácter de su cadena ahora es un número Ascii), luego debe ejecutar el map()método para obtener valores numéricos del número Ascii. Al final, utiliza el toArray()método para cambiar su flujo a una matriz int [].

Veo que todas las respuestas son feas y no muy limpias.

Le sugiero que use un poco de recursividad para resolver su problema. Esta publicación es muy antigua, pero podría ser útil para futuros codificadores.

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

Salida:

Input: 12345

Output: 1   2   3   4   5 

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

La forma más fácil, creo, es convertir el número a cadena y usar substringpara extraer y luego convertir a entero.

Algo como esto:

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

la salida es 2014

Escribí un programa que demuestra cómo separar los dígitos de un número entero usando un enfoque más simple y comprensible que no involucra matrices, recursiones y toda esa fantasía sofisticada. Aquí está mi código:

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

Supongamos que su entrada es el entero 123, la salida resultante será la siguiente:

1
2
3

Aquí está mi respuesta, lo hice por mí mismo y espero que sea lo suficientemente simple para aquellos que no quieren usar el enfoque de String o necesitan una solución más matemática:

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

Así que solo obtengo las unidades, las imprimo, las resto del número, luego divido ese número entre 10, que siempre está sin ningún elemento flotante, ya que las unidades se han ido, repita.

Solución simple

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

Prueba esto:

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;

Obtendrá primero = 1, segundo = 2, tercero = 3 y cuarto = 4 ...

Solución Java 8 para obtener dígitos como int [] desde un entero que tiene como String:

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

ni chars() tampoco codePoints() - la otra lambda

String number = Integer.toString( 1100 );

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

Java 9 introdujo un nuevo Stream.iteratemétodo que puede usarse para generar una secuencia y detenerse en una determinada condición. Esto se puede usar para obtener todos los dígitos en el número, utilizando el enfoque de módulo.

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

Tenga en cuenta que esto obtendrá los dígitos en orden inverso, pero eso se puede resolver ya sea haciendo un bucle a través de la matriz hacia atrás (lamentablemente, invertir una matriz no es tan simple ) o creando otra secuencia:

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

o

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

Como ejemplo, este código:

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

Imprimirá:

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

Integer.toString (1100) le da el entero como una cadena. Integer.toString (1100) .getBytes () para obtener una matriz de bytes de los dígitos individuales.

Editar:

Puede convertir los dígitos de caracteres en dígitos numéricos, por lo tanto:

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

Esto utiliza el método del módulo 10 para calcular cada dígito en un número mayor que 0, luego esto invertirá el orden de la matriz. Esto supone que no está utilizando "0" como dígito inicial.

Esto se modifica para tomar la entrada del usuario. Esta matriz se insertó originalmente al revés, por lo que tuve que usar la Collections.reverse()llamada para volver a ponerla en el orden del usuario.

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

Solo para construir sobre el tema, he aquí cómo confirmar que el número es un entero palindrómico en 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;
}

Estoy seguro de que puedo simplificar aún más este algo. Sin embargo, aquí es donde estoy. Y ha funcionado en todos mis casos de prueba.

Espero que esto ayude a alguien.

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

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

vea abajo mi propuesta con comentarios

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

Algo como esto devolverá el 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();
}

Como novato, mi respuesta sería:

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

Ahora todos los dígitos están contenidos en la matriz de "dígitos".

¿Por qué no lo haces?

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

Como no veo un método en esta pregunta que use Java 8, lo incluiré. Suponiendo que está comenzando con un Stringy desea obtener un List<Integer>, entonces puede transmitir los elementos así.

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

Esto obtiene los caracteres en Stringforma de a IntStream, asigna esas representaciones enteras de caracteres a un valor numérico, los encuadra y luego los recopila en una lista.

Creo que esta será la forma más útil de obtener dígitos:

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

Entonces puede obtener dígitos de una manera simple:

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

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

o más simplemente:

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

Observe que el último método llama al método getDigitsOf demasiado tiempo. Entonces será más lento. Debería crear una matriz int y luego llamar al método getDigitsOf una vez, como en el segundo bloque de código.

En el siguiente código, puede revertir el proceso. Este código pone todos los dígitos juntos para hacer el número:

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

Ambos métodos que he proporcionado también funcionan para números negativos.

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

en Java, así es como puede separar los dígitos de los números y almacenarlos en una matriz.

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

Salida:

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

si el dígito está destinado a ser un Character

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

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;

         }
     }
    }

Sin usar matrices y cadenas. (dígitos 1-99999)

salida:

Ingrese el dígito para imprimir por separado: - 12345

1 2 3 4 5