¿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 de mod le dará el rest de la división int en un número.

Asi que,

 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 stack y abrirlos en orden inverso.

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

 int number; // = and int LinkedList stack = new LinkedList(); while (number > 0) { stack.push( number % 10 ); number = number / 10; } while (!stack.isEmpty()) { print(stack.pop()); } 

Convierta a String y 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 posteriormente, considere usar String#chars() para obtener un IntStream fuera 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 recostackrla 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 digits = new ArrayList(); collectDigits(num, digits); return digits.toArray(new Integer[]{}); } private static void collectDigits(int num, List digits) { if(num / 10 > 0) { collectDigits(num / 10, digits); } digits.add(num % 10); } 

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 dará como resultado:

 digit: 5 digit: 5 digit: 4 digit: 2 
 // 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 manera más fácil, creo, es convertir el número a cadena y usar la substring para 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 progtwig que demuestra cómo separar los dígitos de un entero usando un enfoque más simple y comprensible que no involucra arreglos, recurrencias y toda esa fantasia 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); } 

Suponga que su entrada es el número 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 quieran usar el enfoque String o necesiten una solución matemática más:

 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 acabo de obtener las unidades, imprimirlas, restarlas del número, luego dividir ese número por 10, que siempre es sin elementos flotantes, ya que las unidades se han ido, repita.

ver abajo mi propuesta con comentarios

  int size=i.toString().length(); // the length of the integer (i) we need to split; ArrayList li = new ArrayList(); // 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 

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

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

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

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

Para que quede claro: String.valueOf(number) para convertir int a String, luego el método chars() para obtener un IntStream (cada char de tu cadena es ahora un número Ascii), entonces necesitas ejecutar el método map() para obtener un valor numérico del número Ascii. Al final, utilizas el método toArray() para cambiar tu flujo en una matriz int [].

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

Te sugiero que uses un poco de recursividad para resolver tu problema. Esta publicación es muy antigua, pero podría ser útil para los 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 

Integer.toString (1100) le da el número 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 los 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 

Esto usa el método del módulo 10 para descubrir cada dígito en un número mayor que 0, luego esto invertirá el orden de la matriz. Esto supone que no estás usando “0” como dígito inicial.

Esto se modifica para recibir la entrada del usuario. Esta matriz está originalmente insertada hacia atrás, así que tuve que usar la llamada Collections.reverse() para volver a colocarla 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 checkUserNum = new ArrayList(); 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 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 este algo más. 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; } 

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ás primero = 1, segundo = 2, tercero = 3 y cuarto = 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; } 

Como no veo un método en esta pregunta que use Java 8, lo incluiré. Suponiendo que empiezas con un String y quieres obtener un List , entonces puedes transmitir los elementos como así .

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

Esto obtiene los caracteres en String como IntStream , asigna esas representaciones enteras de caracteres a un valor numérico y luego los recostack en una lista.

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

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 puedes obtener los 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] ); } 

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

En el siguiente código, puede invertir para procesar. Este código junta todos los dígitos 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] 
 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