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


143

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?

Respuestas:


204

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

44
Sin embargo, esto le dará los números en el orden incorrecto, por lo que deberá asegurarse y colocarlos en una pila o simplemente colocarlos en una matriz en orden inverso.
Paul Tomblin el

44
Tenga en cuenta que esto les da de derecha a izquierda. (El ejemplo del OP los muestra de izquierda a derecha). Suficientemente simple de manejar, pero debe tenerse en cuenta.
James Curran

1
@Don, en la práctica, no. No favorecería esto. Sin embargo, es mucho más rápido que la versión basada en cadenas. Sin embargo, miraría la respuesta de Marimuthu para obtener un código rápido y breve.
jjnguy

2
Gran solución, pero parece que no maneja el escenario cuando el número comienza con ceros a la izquierda. por ejemplo, 001122. Si uso la lógica anterior, obtendré solo 1,1,2,2. Los ceros a la izquierda se eliminan por% y / operaciones. Por favor, corríjame si estoy equivocado.
goyalshub1509 18/07/2016

2
¿Qué pasa con los enteros negativos aquí? si paso -3432, la salida será -2-3-4-3 que es incorrecta.
Nodir Nasirov

75

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

77
Este es el camino rápido y sucio.
jjnguy

8
Con split(""), el primer elemento de la matriz es "". Use otra expresión regular, como split("(?<=.)").
True Soft el

3
toCharArray es MUCHO más rápido que dividir. Acabo de poner ambos en un bucle 1000 veces y toCharArray tardó 20 ms y la división tardó 1021 ms. También lo hice matemáticamente usando dividir entre diez con mod (%) y tardé 50 ms en hacerlo de esa manera, por lo que toCharArray parece ser más rápido que los otros dos.
Jerry Destremps

2
Editar: lo hice nuevamente, esta vez con bucles más largos para estar seguro (10,000 iteraciones). toCharArray es aproximadamente 100 veces más rápido que dividir, y toCharArray es aproximadamente 5 veces más rápido que el método matemático de módulo.
Jerry Destremps

9
@BalusC number.chars()devolverá el resultado en valores Ascii no numéricos. Para que el número "1234" se divida en "49", "50", "51", "52" en lugar de "1", "2", "3", "4". Para hacerlo bien debería verse así:IntStream chars = number.chars().map(Character::getNumericValue);
Koin Arab

29

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

1
Esa es una buena manera de imprimir cosas en el orden correcto usando mod. +1
jjnguy

1
Esto es hermoso. Estaba pensando: "Tiene que haber una manera de revertir el orden sin usar una Colección ..." +1
bobndrew

Impecable. Es posible que desee agregar el siguiente código a getDigits (int num) para hacerlo inmune a las entradas incorrectas: if (number < 0) { return new Integer[0]; } Probado con las siguientes entradas:Integer[] samples = {11111, 123457, 0, -13334, 93846, 87892, 9876543, -1234, 012455};
realPK

24

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

Es asombroso. Gracias
Marwa Eltayeb

Por alguna razón, esta lógica da resultados incorrectos para números diferentes a 5542. Pruebe, por ejemplo: 0142323
tavalendo

@tavalendo 0142323es una constante octal igual a 50387, debido al cero inicial , al igual que 0x100es una constante hexadecimal igual a 256, debido al inicio 0x, y 0b1011es una constante binaria igual a 11debido al inicio 0b. ¡Tenga cuidado con los 0 iniciales en constantes enteras!
AJNeufeld

12

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


11

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 

Maldita sea, te refieres a que las respuestas son feas. Gracias.
analista el

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

El tipo int de Java tiene un valor mínimo de -2 ^ 31 y un valor máximo de 2 ^ 31-1. ¿Cómo puede funcionar la solución anterior para todos los valores + ve que encajan en un tipo int?
realPK

3

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


¿La conversión de tipos aquí costará más o las operaciones de división?
Rahul

2

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

2

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.


2

Solución simple

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

1

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


Esto es menos utilitario y elegante que los métodos generales enumerados anteriormente, ni es en principio diferente al uso de otras respuestas %. Agrega poco valor.
Shawn Mehan

@ Shawn Mehan, no estaría de acuerdo. Los métodos anteriores son principalmente sobre el uso de String o sobre soluciones largas de líneas múltiples, mientras que esta es simple y llanamente.
analizador el

1

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

He intentado esto y no funciona. Simplemente puede probar "12" .chars (). ToArray () y descubrirá que en lugar de devolver [1,2] devuelve [49,50] que supongo que en realidad son los códigos ASCII para '1' y '2', y eso definitivamente no es lo que el OP quería.
Fran Marzoa

@Fran tienes razón. Actualicé mi respuesta para incluir una i -> i - '0'asignación para que el resultado sea exactamente lo que solicitó el OP.
qben

En lugar de usar, i - '0'también hay métodos como Character.toDigitese IMO son mejores para usar.
Simon Forsberg

@SimonForsberg, ¿puede hacer referencia al método en los documentos y dar un fragmento de código sobre cómo funcionaría? Me complace actualizar mi respuesta si hay una forma más elegante.
qben

@qben "0123456789".chars().map(i -> Character.digit(i, 10)).toArray() Carácter # dígito (hay uno para char y otro para int codePoints)
Simon Forsberg

1

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]

1

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]

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 es un poco engañoso. Esto le dará una matriz de bytes que representan el carácter '1'o el carácter '0'. Los valores de byte no serán 1, o 0.
jjnguy

¿Engañoso? Eso es un poco duro. La pregunta era ambigua. Realmente depende de lo que quiera hacer con los dígitos. Estás asumiendo que él quiere realizar cálculos. Mi respuesta supone el procesamiento de texto. Cualquiera de estas suposiciones es parcialmente correcta, pero no fue mi intención engañar.
Don Branson el

Supongo que siento que es engañoso porque obtienes una matriz de bytes, que creo que son números, no caracteres.
jjnguy

@Justin - Ah, está bien. No asocio automáticamente bytes como no caracteres. En mis días de montaje, incrementaba 'a' para obtener 'b', iterando a través del alfabeto, por lo que a veces los bytes eran simultáneamente ambos. Por supuesto, los lenguajes de alto nivel y UTF hacen que todo sea discutible.
Don Branson el

0

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

0

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.


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 es demasiado grande para ser un int.
Giuseppe Garassino

@Beppe 12344444 no es demasiado grande para ser un int. Java docs afirma lo siguiente Para int, de -2147483648 a 2147483647, inclusive. Para saber con certeza en su sistema, puede usar System.out.println (Integer.MAX_VALUE); para averiguar el valor_máximo que se admite en su paquete 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
Actualice su respuesta y explique cómo resuelve el problema. Las respuestas de solo código generalmente se consideran respuestas de baja calidad.
Devlin Carnate

0

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

0

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

0

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


0

¿Por qué no lo haces?

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

0

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.


Curiosamente, chars () devuelve un IntStream, por lo que si llama a boxed () y collect () puede devolver la Lista de enteros de inmediato.
Jason

1
Obtiene valores ASCII de vuelta. Entonces 1 se asigna a 49.
ifly6

¡Interesante! No lo sabía, ty.
Jason

No se compila: Collectors.toList()→ " Discrepancia de tipos: no se puede convertir de Collector <Object, capture # 3-of?, List <Object>> a Supplier <R> ", collect→ " El método collect (Supplier <R>, ObjIntConsumer <R >, BiConsumer <R, R>) en el tipo IntStream no es aplicable para los argumentos (Collector <Object,?, List <Object>>) "
Gerold Broser

Editado Necesitan ser en caja antes de recoger. Véase, por ejemplo, repl.it/@ifly6/HeftyAffectionateHertz#Main.java
ifly6

-1

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.


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


La respuesta es FOR → [link] stackoverflow.com/questions/47196499/…
always007

-1

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]

-1

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]

Pattern.compile? Eso es mucha exageración.
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;

         }
     }
    }

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

salida:

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

1 2 3 4 5


Tiene que haber una manera de determinar de manera más eficiente y dinámica divider.
ZX9
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.