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


143

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

Como posso obtê-lo em Java?

Respostas:


204

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

4
No entanto, você obterá os números na ordem errada, portanto, você deve ter certeza e empurrá-los para uma pilha ou simplesmente colocá-los em uma matriz na ordem inversa.
Paul Tomblin

4
Observe que isso os dá da direita para a esquerda. (O exemplo do OP mostra da esquerda para a direita). Simples o suficiente para lidar, mas deve-se notar.
James Curran

1
@ Don, na prática, não. Eu não seria a favor disso. É muito mais rápido que a versão baseada em strings. Gostaria de olhar para a resposta de Marimuthu embora para algum código rápido e curto.
Jjnguy

2
Ótima solução, mas parece que não lida com o cenário quando o número começa com zeros à esquerda. por exemplo - 001122. Se eu usar a lógica acima - receberei apenas 1,1,2,2. Os 0s iniciais são eliminados em% e / operações. Por favor corrija-me se eu estiver errado.
goyalshub1509

2
que tal números inteiros negativos aqui? se eu passar -3432, a saída será -2-3-4-3, o que está incorreto.
Nodir Nasirov

75

Converta-o em Stringe 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 IntStreamresultado.

IntStream chars = number.chars();

7
Esta é a maneira rápida e suja.
Jjnguy

8
Com split(""), o primeiro item da matriz é "". Use outro regex, como split("(?<=.)").
True Soft

3
toCharArray é MUITO mais rápido que dividir. Eu apenas coloquei ambos em um loop de 1000 vezes e toCharArray levou 20ms e split levou 1021ms. Eu também fiz isso matematicamente usando dividir por dez com mod (%) e levou 50ms dessa maneira, então o toCharArray parece ser mais rápido que os outros dois.
Jerry Destremps

2
Edit: Acabei de fazer novamente, desta vez com loops mais longos para ter certeza (10.000 iterações). O toCharArray é cerca de 100 vezes mais rápido que o split, e o toCharArray é cerca de 5 vezes mais rápido que o método matemático do módulo.
Jerry Destremps

9
O @BalusC 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);
Koin Arab

29

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
Essa é uma boa maneira de imprimir as coisas na ordem correta usando o mod. +1
jjnguy

1
Isso é lindo. Eu estava pensando: "Tem que haver uma maneira de inverter a ordem sem usar uma coleção ...." +1
bobndrew

Impecável. Pode querer adicionar código a seguir para getDigits (num int) para torná-lo imune a entradas ruins: if (number < 0) { return new Integer[0]; } Testado com as seguintes entradas:Integer[] samples = {11111, 123457, 0, -13334, 93846, 87892, 9876543, -1234, 012455};
realPK

24

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

É maravilhoso. Graças
Marwa Eltayeb

Por alguma razão, essa lógica fornece saída incorreta para números diferentes de 5542. Tente por exemplo: 0142323
tavalendo

@tavalendo 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 11devido à liderança 0b. Desconfie de zeros à esquerda em constantes inteiras!
AJNeufeld

12

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 [].


11

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 

Droga, você está certa de que as respostas estão mudando. Obrigado.
parsecer 6/03

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

O tipo Java int possui um valor mínimo de -2 ^ 31 e um valor máximo de 2 ^ 31-1. Como a solução acima pode funcionar para todos os valores + ve que se encaixam em um tipo int?
realPK 04/07

3

A maneira mais fácil que eu acho é converter o número em string e usar substringpara 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


a conversão de tipo aqui custa mais ou operações de divisão?
Rahul

2

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

2

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.


2

solução simples

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

1

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


Isso é menos utilitário e elegante do que os métodos gerais listados acima, nem é diferente em princípio do que outras respostas usando %. Agrega pouco valor.
quer

@ Shawn Mehan, eu discordo. Os métodos acima são principalmente sobre o uso de String ou sobre soluções longas com várias linhas, enquanto este é simples e simples.
parsecer 4/16

1

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

Eu tentei isso e não funciona. Você pode simplesmente tentar "12" .chars (). ToArray () e descobrirá que, em vez de retornar [1,2], ele retorna [49,50], que eu acho que são os códigos ASCII para '1' e '2', e isso definitivamente não é o que o OP queria.
27517 Fran Franzozo Mar

@Fran, você está certo. Atualizei minha resposta para incluir um i -> i - '0'mapeamento para que o resultado seja exatamente o que o OP solicitou.
qben

Em vez de usar i - '0', também existem métodos como Character.toDigito IMO que são melhores para usar.
Simon Forsberg

@SimonForsberg, você pode fazer referência ao método nos documentos e fornecer um snippet de código como isso funcionaria? Fico feliz em atualizar minha resposta se houver uma maneira mais elegante.
qben 10/06

@qben "0123456789".chars().map(i -> Character.digit(i, 10)).toArray() Caractere # dígito (existe um para char e outro para int codePoints)
Simon Forsberg

1

nem chars() nem codePoints() - o outro lambda

String number = Integer.toString( 1100 );

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

1

O Java 9 introduziu um novo Stream.iteratemé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]

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

Isso é um pouco enganador. Isso fornecerá uma matriz de bytes representando o caractere '1'ou '0'. Os valores de bytes não serão 1, ou 0.
Jjnguy

Enganador? Isso é um pouco duro. A pergunta era ambígua. Realmente depende do que ele quer fazer com os dígitos. Você está assumindo que ele deseja realizar cálculos. Minha resposta assume o processamento de texto. Qualquer hipótese está parcialmente correta, mas não era minha intenção enganar.
Don Branson

Eu acho que acho que é enganoso, porque você recebe uma matriz de bytes, que eu penso em números, não em caracteres.
Jjnguy

@ Justin - Ah, tudo bem. Não associo bytes automaticamente como caracteres. Nos meus dias de montagem, eu incrementava 'a' para obter 'b', percorrendo o alfabeto - às vezes os bytes eram simultaneamente os dois. Obviamente, linguagens de alto nível e UTF tornam isso muito discutível.
Don Branson

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

0

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.


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

12344444 é grande demais para ser um int.
Giuseppe Garassino

@Beppe 12344444 não é muito grande para ser um int. A documentação do Java reivindica o seguinte For int, de -2147483648 a 2147483647, inclusive Embora tenha certeza de que no seu sistema você pode usar System.out.println (Integer.MAX_VALUE); para descobrir a MAX_VALUE que é suportado em seu pacote java.lang
OrwellHindenberg

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

1
Atualize sua resposta e explique como ele resolve o problema. As respostas somente de código são geralmente consideradas respostas de baixa qualidade.
Devlin carnate

0

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

0

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

0

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".


0

Por que você não faz:

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

0

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 Stringe 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 Stringcomo um IntStream, mapeia essas representações inteiros de caracteres para um valor numérico, caixas-los, e depois recolhe-los em uma lista.


Curiosamente, chars () retorna um IntStream, portanto, se você chamar boxed () e collect (), poderá retornar a Lista de Inteiros imediatamente.
Jason

1
Você recebe valores ASCII de volta. Então 1 mapas para 49.
ifly6

Interessante! Não sabia disso, ty.
Jason

Não compila: 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>>) "
Gerold Broser

Editado. Eles precisam ser encaixotados antes da coleta. Veja por exemplo repl.it/@ifly6/HeftyAffectionateHertz#Main.java
ifly6 19/07

-1

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.


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


A resposta é FOR → [link] stackoverflow.com/questions/47196499/…
always007

-1

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]

-1

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.
Simon Forsberg

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

         }
     }
    }

Sem usar matrizes e Strings. (dígitos 1-99999)

resultado :

Digite o dígito para imprimir separadamente: - 12345

1 2 3 4 5


Tem que haver uma maneira de determinar de maneira mais eficiente e dinâmica divider.
ZX9 16/09/2015
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.