Comment obtenir les chiffres séparés d'un nombre entier?

J'ai des nombres comme 1100, 1002, 1022 etc. Je voudrais avoir les chiffres individuels, par exemple pour le premier numéro 1100 je veux avoir 1, 1, 0, 0.

Comment puis-je l'obtenir en Java?

Pour ce faire, vous utiliserez l' %opérateur (mod).

int number; // = some int

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

L'opérateur de mod vous donnera le reste de la division int sur un nombre.

Alors,

10012 % 10 = 2

Car:

10012 / 10 = 1001, remainder 2

Remarque: comme Paul l'a noté, cela vous donnera les nombres dans l'ordre inverse. Vous devrez les pousser sur une pile et les faire sortir dans l'ordre inverse.

Code pour imprimer les nombres dans le bon ordre:

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

Convertissez-le en Stringet utilisez String#toCharArray()ou String#split().

String number = String.valueOf(someInt);

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

Si vous êtes déjà sur Java 8 et que vous souhaitez effectuer des opérations d'agrégation sur celui-ci par la suite, envisagez d'utiliser String#chars()pour en extraire un IntStream.

IntStream chars = number.chars();

Que dis-tu de ça?

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

ou au lieu d'imprimer sur la console, nous pouvons le collecter dans un tableau d'entiers puis imprimer le tableau:

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 vous souhaitez conserver l'ordre des chiffres du moins significatif (index [0]) au plus significatif (index [n]), vous avez besoin de getDigits () mis à jour:

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

Je n'ai vu personne utiliser cette méthode, mais cela a fonctionné pour moi et est court et doux:

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

Cela produira:

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

J'ai remarqué qu'il existe peu d'exemples d'utilisation du flux Java 8 pour résoudre votre problème, mais je pense que c'est le plus simple:

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

Pour être clair: vous utilisez String.valueOf(number)pour convertir un int en chaîne, puis une chars()méthode pour obtenir un IntStream (chaque caractère de votre chaîne est maintenant un nombre Ascii), puis vous devez exécuter une map()méthode pour obtenir une valeur numérique du nombre Ascii. À la fin, vous utilisez la toArray()méthode pour changer votre flux en un tableau int [].

Je vois que toutes les réponses sont laides et pas très propres.

Je vous suggère d'utiliser un peu de récursivité pour résoudre votre problème. Cet article est très ancien, mais il pourrait être utile aux futurs codeurs.

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

Production:

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

Un moyen plus simple, je pense, est de convertir le nombre en chaîne et de l'utiliser substringpour extraire puis convertir en entier.

Quelque chose comme ça:

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

la sortie est 2014

solution simple

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

J'ai écrit un programme qui montre comment séparer les chiffres d'un entier en utilisant une approche plus simple et compréhensible qui n'implique pas de tableaux, de récursions, et tout ce schmancy sophistiqué. Voici mon code:

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

Supposons que votre entrée soit l'entier 123, la sortie résultante sera la suivante:

1
2
3

Voici ma réponse, je l'ai fait pour moi-même et j'espère que c'est assez simple pour ceux qui ne veulent pas utiliser l'approche String ou qui ont besoin d'une solution plus mathématique:

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

Donc, je viens de récupérer les unités, de les imprimer, de les soustraire du nombre, puis de diviser ce nombre par 10 - ce qui est toujours sans aucun élément flottant, puisque les unités ont disparu, répétez.

Essaye ça:

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;

Vous obtiendrez premier = 1, deuxième = 2, troisième = 3 et quatrième = 4 ....

Solution Java 8 pour obtenir des chiffres comme int [] à partir d'un entier que vous avez comme chaîne:

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

ni chars() ni codePoints() - l'autre 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 a introduit une nouvelle Stream.iterateméthode qui peut être utilisée pour générer un flux et s'arrêter à une certaine condition. Cela peut être utilisé pour obtenir tous les chiffres du nombre, en utilisant l'approche modulo.

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

Notez que cela obtiendra les chiffres dans l'ordre inverse, mais cela peut être résolu soit en bouclant le tableau à l'envers (malheureusement, inverser un tableau n'est pas si simple ), soit en créant un autre flux:

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

A titre d'exemple, ce code:

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

Imprime:

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

Integer.toString (1100) vous donne l'entier sous forme de chaîne. Integer.toString (1100) .getBytes () pour obtenir un tableau d'octets des chiffres individuels.

Éditer:

Vous pouvez convertir les chiffres des caractères en chiffres numériques, ainsi:

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

Cela utilise la méthode modulo 10 pour comprendre chaque chiffre dans un nombre supérieur à 0, cela inversera l'ordre du tableau. Cela suppose que vous n'utilisez pas "0" comme chiffre de départ.

Ceci est modifié pour prendre en compte l'entrée utilisateur. Ce tableau est à l'origine inséré à l'envers, j'ai donc dû utiliser l' Collections.reverse()appel pour le remettre dans l'ordre de l'utilisateur.

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

Juste pour construire sur le sujet, voici comment confirmer que le nombre est un entier palindromique 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;
}

Je suis sûr que je peux simplifier davantage cet algo. Pourtant, c'est là que je suis. Et cela a fonctionné dans tous mes cas de test.

J'espère que ça aidera quelqu'un.

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

voir ci-dessous ma proposition avec des commentaires

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

Quelque chose comme ceci renverra le 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();
}

En tant que noob, ma réponse serait:

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

Maintenant, tous les chiffres sont contenus dans le tableau "digits".

Pourquoi tu ne fais pas:

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

Comme je ne vois pas de méthode sur cette question qui utilise Java 8, je vais la jeter. En supposant que vous commencez par a Stringet que vous voulez obtenir a List<Integer>, alors vous pouvez diffuser les éléments comme ça.

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

Cela obtient les caractères dans le Stringsous forme de IntStream, mappe ces représentations entières de caractères à une valeur numérique, les encadre, puis les rassemble dans une liste.

Je pense que ce sera le moyen le plus utile d'obtenir des chiffres:

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

Ensuite, vous pouvez obtenir des chiffres de manière simple:

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

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

ou plus simplement:

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

Notez que la dernière méthode appelle la méthode getDigitsOf trop longtemps. Ce sera donc plus lent. Vous devez créer un tableau int, puis appeler la méthode getDigitsOf une fois, comme dans le deuxième bloc de code.

Dans le code suivant, vous pouvez inverser le processus. Ce code rassemble tous les chiffres pour former le numéro:

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

Les deux méthodes que j'ai fournies fonctionnent également pour les nombres négatifs.

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

en Java, voici comment séparer les chiffres des nombres et les stocker dans un tableau.

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

Production:

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

si le chiffre est censé être un 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;

         }
     }
    }

Sans utiliser de tableaux et de chaînes. (chiffres 1-99999)

production :

Entrez le chiffre à imprimer séparément: - 12345

1 2 3 4 5