Como obter os dígitos separados de um número int?

Eu tenho números como 1100, 1002, 1022 etc. Eu gostaria de ter os dígitos individuais, por exemplo, para o primeiro número 1100 eu quero ter 1, 1, 0, 0.

Como posso obtê-lo em Java?

Para fazer isso, você usará o operador % (mod).

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

O operador mod lhe dará o restante da divisão int em um número.

Assim,

 10012 % 10 = 2 

Porque:

 10012 / 10 = 1001, remainder 2 

Nota: Como Paul observou, isso lhe dará os números na ordem inversa. Você precisará empurrá-los em uma pilha e retirá-los na ordem inversa.

Código para imprimir os números na ordem correta:

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

Converta-o para String e use String#toCharArray() ou String#split() .

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

Caso você já esteja no Java 8 e deseje fazer algumas operações agregadas depois, considere usar String#chars() para obter um IntStream .

 IntStream chars = number.chars(); 

Que tal agora?

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

ou em vez de imprimir no console, podemos coletá-lo em uma matriz de números inteiros e depois imprimir o array:

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

Eu não vi ninguém usar esse método, mas funcionou para mim e é curto e doce:

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

Isto irá produzir:

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

A maneira mais fácil é converter o número em string e usar substring para extrair e depois converter em integer.

Algo assim:

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

saída é 2014

Eu escrevi um programa que demonstra como separar os dígitos de um inteiro usando uma abordagem mais simples e compreensível que não envolve arrays, recursões e toda aquela schmancy extravagante. Aqui está o meu 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); } 

Suponha que sua input seja o inteiro 123 , a saída resultante será a seguinte:

 1 2 3 

Aqui está a minha resposta, eu fiz isso por mim mesmo e espero que seja simples o suficiente para aqueles que não querem usar a abordagem String ou precisam de uma solução mais 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); } } 

Então, eu só pego as unidades, imprimo-as, subtraio-as do número, então divido esse número por 10 – que é sempre sem material flutuante, já que as unidades se foram, repita.

veja abaixo minha proposta com comentários

  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 

Solução do Java 8 para obter dígitos como int [] de um inteiro que você tenha como String:

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

Percebi que há poucos exemplos de uso do stream do Java 8 para resolver seu problema, mas acho que é o mais simples:

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

Para ser claro: você usa String.valueOf(number) para converter int para String, então chars() para obter um IntStream (cada caractere de sua string é agora um número Ascii), então você precisa executar o método map() para obter valores numéricos do número Ascii. No final, você usa o método toArray() para alterar seu stream em um array int [].

Eu vejo que toda a resposta é feia e não muito limpa.

Eu sugiro que você use um pouco de recursion para resolver seu problema. Este post é muito antigo, mas pode ser útil para codificadores futuros.

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

Saída:

 Input: 12345 Output: 1 2 3 4 5 

Integer.toString (1100) fornece o inteiro como uma string. Integer.toString (1100) .getBytes () para obter uma matriz de bytes dos dígitos individuais.

Editar:

Você pode converter os dígitos dos caracteres em dígitos numéricos, assim:

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

Isso usa o método do módulo 10 para descobrir cada dígito em um número maior que 0, então isso inverterá a ordem da matriz. Isto está assumindo que você não está usando “0” como um dígito inicial.

Isso é modificado para aceitar a input do usuário. Esta matriz é originalmente inserida ao contrário, então eu tive que usar a chamada Collections.reverse() para colocá-la de volta na ordem do usuário.

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

Apenas para construir sobre o assunto, aqui está como confirmar que o número é um inteiro palíndromo em 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; } 

Tenho certeza de que posso simplificar ainda mais esse recurso. No entanto, este é o lugar onde eu estou. E isso funcionou em todos os meus casos de teste.

Espero que isso ajude alguém.

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

Tente isto:

 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; 

Você terá primeiro = 1, segundo = 2, terceiro = 3 e quarto = 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 não vejo um método nesta questão que usa o Java 8, vou usar isso. Supondo que você esteja iniciando com um String e queira obter um List , então você pode transmitir os elementos como .

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

Isso obtém os caracteres da String como um IntStream , mapeia essas representações inteiras de caracteres para um valor numérico e, em seguida, os coleta em uma lista.

Algo como isso retornará o 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(); } 

Acho que essa será a maneira mais útil de obter 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; } 

Então você pode obter dígitos de uma maneira simples:

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

ou mais simplesmente:

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

Observe que o último método chama muito o método getDigitsOf. Então será mais lento. Você deve criar uma matriz int e, em seguida, chamar o método getDigitsOf uma vez, assim como no segundo bloco de código.

No código a seguir, você pode reverter para processar. Este código coloca todos os dígitos juntos para fazer o 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 os methods que forneci também funcionam 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; } } } } 

em Java, é assim que você pode separar dígitos de números e armazená-los em uma 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; } 

Saída:

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

Sem usar matrizes e seqüências de caracteres. (dígitos 1-99999)

saída:

Digite o dígito para imprimir separadamente: - 12345

1 2 3 4 5