Come ottenere le cifre separate di un numero int?

Ho numeri come 1100, 1002, 1022 ecc. Vorrei avere le singole cifre, ad esempio per il primo numero 1100 voglio avere 1, 1, 0, 0.

Come posso ottenerlo in Java?

Per fare ciò, utilizzerai l' %operatore (mod).

int number; // = some int

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

L'operatore mod ti darà il resto di fare la divisione int su un numero.

Così,

10012 % 10 = 2

Perché:

10012 / 10 = 1001, remainder 2

Nota: come notato da Paul, questo ti darà i numeri in ordine inverso. Dovrai spingerli su una pila e saltarli in ordine inverso.

Codice per stampare i numeri nell'ordine corretto:

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

Convertilo in Stringe usa String#toCharArray()o String#split().

String number = String.valueOf(someInt);

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

Nel caso in cui tu sia già su Java 8 e ti capiti di voler fare alcune operazioni aggregate su di esso in seguito, String#chars()prendi in considerazione l'utilizzo per ottenerlo IntStream.

IntStream chars = number.chars();

Cosa ne pensi di questo?

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

o invece di stampare sulla console, possiamo raccoglierlo in una matrice di numeri interi e quindi stampare la matrice:

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 si desidera mantenere l'ordine delle cifre dal meno significativo (indice [0]) al più significativo (indice [n]), è necessario il seguente getDigits () aggiornato:

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

Non ho visto nessuno usare questo metodo, ma ha funzionato per me ed è breve e dolce:

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

Questo produrrà:

digit: 5
digit: 5
digit: 4
digit: 2

Ho notato che ci sono alcuni esempi di utilizzo del flusso Java 8 per risolvere il tuo problema, ma penso che questo sia il più semplice:

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

Per essere chiari: si utilizza String.valueOf(number)per convertire int in String, quindi il chars()metodo per ottenere un IntStream (ogni carattere della stringa è ora un numero Ascii), quindi è necessario eseguire il map()metodo per ottenere un valore numerico del numero Ascii. Alla fine usi il toArray()metodo per cambiare il tuo stream in un array int [].

Vedo che tutte le risposte sono brutte e non molto pulite.

Ti suggerisco di usare un po 'di ricorsione per risolvere il tuo problema. Questo post è molto vecchio, ma potrebbe essere utile per i programmatori futuri.

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

Produzione:

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

Il modo più semplice secondo me è convertire il numero in stringa e usarlo substringper estrarre e poi convertire in numero intero.

Qualcosa come questo:

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

L'uscita è il 2014

soluzione semplice

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

Ho scritto un programma che dimostra come separare le cifre di un numero intero usando un approccio più semplice e comprensibile che non coinvolge array, ricorsioni e tutta quella fantasiosa schmancy. Ecco il mio codice:

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

Supponiamo che l'input sia il numero intero 123, l'output risultante sarà il seguente:

1
2
3

Ecco la mia risposta, l'ho fatto per me stesso e spero sia abbastanza semplice per coloro che non vogliono usare l'approccio String o hanno bisogno di una soluzione matematica più:

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

Quindi ottengo solo le unità, le stampo, le sottraggo dal numero, quindi divido quel numero per 10 - che è sempre senza roba mobile, poiché le unità sono sparite, ripeti.

Prova questo:

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;

Otterrai primo = 1, secondo = 2, terzo = 3 e quarto = 4 ....

Soluzione Java 8 per ottenere cifre come int [] da un numero intero che hai come stringa:

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

né chars() né codePoints() - l'altro lambda

String number = Integer.toString( 1100 );

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

Java 9 ha introdotto un nuovo Stream.iteratemetodo che può essere utilizzato per generare un flusso e arrestarsi a una determinata condizione. Questo può essere usato per ottenere tutte le cifre del numero, usando l'approccio modulo.

int[] a = IntStream.iterate(123400, i -> i > 0, i -> i / 10).map(i -> i % 10).toArray();

Si noti che questo porterà le cifre in ordine inverso, ma che può essere risolto eseguendo il ciclo indietro dell'array (purtroppo invertire un array non è così semplice ) o creando un altro flusso:

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

Ad esempio, questo codice:

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

Stampa:

[0, 0, 4, 3, 2, 1]
[1, 2, 3, 4, 0, 0]

Integer.toString (1100) ti dà l'intero come stringa. Integer.toString (1100) .getBytes () per ottenere una matrice di byte delle singole cifre.

Modificare:

È possibile convertire le cifre dei caratteri in cifre numeriche, quindi:

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

Questo utilizza il metodo modulo 10 per capire ogni cifra in un numero maggiore di 0, quindi questo invertirà l'ordine dell'array. Ciò presuppone che non si stia utilizzando "0" come cifra iniziale.

Questo è stato modificato per accogliere l'input dell'utente. Questo array è stato originariamente inserito Collections.reverse()al contrario , quindi ho dovuto usare la chiamata per rimetterlo nell'ordine dell'utente.

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

Giusto per basarsi sull'argomento, ecco come confermare che il numero è un intero palindromico in 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;
}

Sono sicuro di poter semplificare ulteriormente questo algo. Eppure, questo è dove sono. E ha funzionato in tutti i miei casi di test.

Spero che questo aiuti qualcuno.

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

vedi sotto la mia proposta con commenti

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

Qualcosa del genere restituirà il 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();
}

Come un noob, la mia risposta sarebbe:

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

Ora tutte le cifre sono contenute nell'array "cifre".

Perché non lo fai:

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

Dal momento che non vedo un metodo su questa domanda che utilizza Java 8, lo Stringintrodurrò . Supponendo che stai iniziando con un e vuoi ottenere un List<Integer>, quindi puoi eseguire lo streaming degli elementi in questo modo.

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

In questo modo i caratteri vengono visualizzati Stringcome a IntStream, vengono mappati le rappresentazioni intere di caratteri su un valore numerico, li si inscatola e quindi si raccolgono in un elenco.

Penso che questo sarà il modo più utile per ottenere cifre:

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

Quindi puoi ottenere cifre in modo semplice:

int number = 12345;
int[] digits = getDigitsOf(number);

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

o più semplicemente:

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

Si noti che l'ultimo metodo chiama il metodo getDigitsOf troppo tempo. Quindi sarà più lento. È necessario creare un array int e quindi chiamare il metodo getDigitsOf una volta, proprio come nel secondo blocco di codice.

Nel codice seguente, è possibile invertire il processo. Questo codice riunisce tutte le cifre per creare il numero:

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

Entrambi i metodi che ho fornito funzionano anche per numeri negativi.

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

in Java, ecco come separare le cifre dai numeri e memorizzarle in un array.

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

Produzione:

Digits Array:: [1, 1, 0, 0]

se digit deve essere a Character

String numstr = Integer.toString( 123 );
Pattern.compile( "" ).splitAsStream( numstr ).map(
  s -> s.charAt( 0 ) ).toArray( Character[]::new );  // [1, 2, 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;

         }
     }
    }

Senza usare matrici e stringhe. (cifre 1-99999)

produzione :

Immettere la cifra da stampare separatamente: - 12345

1 2 3 4 5