Respostas:
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 Paulo observou, isso fornecerá os números na ordem inversa. Você precisará empurrá-los para uma pilha e retirá-los na ordem inversa.
Código para imprimir os números na ordem correta:
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());
}
Converta-o em 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 realizar algumas operações agregadas posteriormente, considere usar String#chars()
para obter um IntStream
resultado.
IntStream chars = number.chars();
split("")
, o primeiro item da matriz é ""
. Use outro regex, como split("(?<=.)")
.
number.chars()
retornará o resultado em valores Ascii não numéricos. Para que o número "1234" seja dividido em "49", "50", "51", "52" em vez de "1", "2", "3", "4". Para fazer isso da maneira correta, deve ser parecido com: #IntStream chars = number.chars().map(Character::getNumericValue);
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 a 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);
}
Se você deseja manter a ordem dos dígitos de menos significativo (índice [0]) para mais significativo (índice [n]), o seguinte getDigits () atualizado é o que você precisa:
/**
* 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[]{});
}
+1
+1
if (number < 0) { return new Integer[0]; }
Testado com as seguintes entradas:Integer[] samples = {11111, 123457, 0, -13334, 93846, 87892, 9876543, -1234, 012455};
Não vi ninguém usar esse método, mas funcionou para mim e é curto e gentil:
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);
}
Isso produzirá:
digit: 5
digit: 5
digit: 4
digit: 2
0142323
é uma constante octal igual a 50387
, devido ao zero inicial, assim como 0x100
é uma constante hexadecimal igual a 256
, devido à liderança 0x
, e 0b1011
é uma constante binária igual a 11
devido à liderança 0b
. Desconfie de zeros à esquerda em constantes inteiras!
Notei que existem poucos exemplos de uso do fluxo Java 8 para resolver seu problema, mas acho que este é o mais simples:
int[] intTab = String.valueOf(number).chars().map(Character::getNumericValue).toArray();
Para ficar claro: você usa String.valueOf(number)
para converter int em String e, em seguida, chars()
método para obter um IntStream (cada caractere de sua string agora é um número Ascii), depois é necessário executar o map()
método para obter valores numéricos do número Ascii. No final, você usa o toArray()
método para alterar seu fluxo em uma matriz int [].
Vejo que todas as respostas são feias e não muito limpas.
Sugiro que você use um pouco de recursão para resolver seu problema. Esta publicação é muito antiga, mas pode ser útil para futuros codificadores.
public static void recursion(int number) {
if(number > 0) {
recursion(number/10);
System.out.printf("%d ", (number%10));
}
}
Resultado:
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);
A maneira mais fácil que eu acho é converter o número em string e usar substring
para extrair e depois converter para número inteiro.
Algo assim:
int digits1 =Integer.parseInt( String.valueOf(201432014).substring(0,4));
System.out.println("digits are: "+digits1);
ouput é 2014
Eu escrevi um programa que demonstra como separar os dígitos de um número inteiro usando uma abordagem mais simples e compreensível que não envolva matrizes, recursões e toda a schmancy sofisticada. 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 entrada seja o número 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 apenas pego as unidades, imprimo-as, subtraí-as do número e, em seguida, divido esse número por 10 - o que é sempre sem nenhum material flutuante, já que as unidades se foram, repita.
solução simples
public static void main(String[] args) {
int v = 12345;
while (v > 0){
System.out.println(v % 10);
v /= 10;
}
}
Tente o seguinte:
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ê receberá primeiro = 1, segundo = 2, terceiro = 3 e quarto = 4 ....
%
. Agrega pouco valor.
Solução Java 8 para obter dígitos como int [] de um número inteiro que você possui como uma String:
int[] digits = intAsString.chars().map(i -> i - '0').toArray();
i -> i - '0'
mapeamento para que o resultado seja exatamente o que o OP solicitou.
i - '0'
, também existem métodos como Character.toDigit
o IMO que são melhores para usar.
"0123456789".chars().map(i -> Character.digit(i, 10)).toArray()
Caractere # dígito (existe um para char e outro para int codePoints)
O Java 9 introduziu um novo Stream.iterate
método que pode ser usado para gerar um fluxo e parar em uma determinada condição. Isso pode ser usado para obter todos os dígitos do número, usando a abordagem de módulo.
int[] a = IntStream.iterate(123400, i -> i > 0, i -> i / 10).map(i -> i % 10).toArray();
Observe que isso obterá os dígitos na ordem inversa, mas isso pode ser resolvido fazendo um loop pela matriz para trás (inverter tristemente uma matriz é não tão simples ) ou criar outro fluxo:
int[] b = IntStream.iterate(a.length - 1, i -> i >= 0, i -> i - 1).map(i -> a[i]).toArray();
ou
int[] b = IntStream.rangeClosed(1, a.length).map(i -> a[a.length - i]).toArray();
Como exemplo, 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));
Irá imprimir:
[0, 0, 4, 3, 2, 1]
[1, 2, 3, 4, 0, 0]
Integer.toString (1100) fornece o número inteiro como uma sequência. 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<string.length(); ++i){
digits[i] = Integer.parseInt(string.substring(i, i+1));
}
System.out.println("digits:" + Arrays.toString(digits));
'1'
ou '0'
. Os valores de bytes não serão 1
, ou 0
.
Isso usa o método do módulo 10 para descobrir cada dígito em um número maior que 0, e isso reverterá a ordem da matriz. Isso pressupõe que você não esteja usando "0" como dígito inicial.
Isso é modificado para receber a entrada do usuário. Essa matriz é originalmente inserida ao contrário, então tive que usar a Collections.reverse()
chamada para colocá-la novamente 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<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);
Apenas para desenvolver o assunto, veja como confirmar que o número é um número inteiro palíndrico em 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;
}
Tenho certeza de que posso simplificar ainda mais esse algo. No entanto, é aqui que estou. E 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;
}
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;
}
veja abaixo minha proposta com comentários
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 assim retornará 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 noob, minha resposta seria:
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))
Agora todos os dígitos estão contidos na matriz "dígitos".
Por que você não faz:
String number = String.valueOf(input);
char[] digits = number.toCharArray();
Como não vejo um método nesta questão que usa o Java 8, abordarei isso. Supondo que você esteja começando com a String
e queira obter a List<Integer>
, poderá transmitir os elementos dessa maneira.
List<Integer> digits = digitsInString.chars()
.map(Character::getNumericValue)
.boxed()
.collect(Collectors.toList());
Este recebe os caracteres no String
como um IntStream
, mapeia essas representações inteiros de caracteres para um valor numérico, caixas-los, e depois recolhe-los em uma lista.
Collectors.toList()
→ " Incompatibilidade de tipo: não é possível converter do coletor <Objeto, captura # 3-de?, Lista <Objeto>> para fornecedor <R> ", collect
→ " O método collect (Fornecedor <R>, ObjIntConsumer <R >, BiConsumer <R, R>) no tipo IntStream não é aplicável aos argumentos (Coletor <Objeto,?, Lista <Objeto>>) "
Eu 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 tempo o método getDigitsOf. Então será mais lento. Você deve criar uma matriz int e chamar o método getDigitsOf uma vez, assim como no segundo bloco de código.
No código a seguir, você pode reverter para o processo. Este código reúne todos os dígitos para formar 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 métodos 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;
}
Resultado:
Digits Array:: [1, 1, 0, 0]
se o dígito for um Character
String numstr = Integer.toString( 123 );
Pattern.compile( "" ).splitAsStream( numstr ).map(
s -> s.charAt( 0 ) ).toArray( Character[]::new ); // [1, 2, 3]
Pattern.compile
? Isso é muito exagero.
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 Strings. (dígitos 1-99999)
resultado :
Digite o dígito para imprimir separadamente: - 12345
1 2 3 4 5
divider
.