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

Question

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

Comment puis-je l'obtenir en Java ?

Answer 1

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

int number; // = some int

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

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

Donc,

10012 % 10 = 2

Parce que :

10012 / 10 = 1001, remainder 2

Note : Comme Paul l'a noté, cela vous donnera les chiffres dans l'ordre inverse. Vous devrez les pousser sur une pile et les retirer dans l'ordre inverse.

Code pour imprimer les numéros dans l'ordre correct :

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

Answer 2

Convertissez-le en String et utiliser String#toCharArray() ou String#split() .

String number = String.valueOf(someInt);

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

Si vous utilisez déjà Java 8 et que vous souhaitez effectuer des opérations d'agrégation par la suite, vous pouvez utiliser la fonction String#chars() pour obtenir un IntStream pour en sortir.

IntStream chars = number.chars();

Answer 3

Que pensez-vous 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 dans la console, nous pouvons les rassembler dans un tableau d'entiers et ensuite imprimer ce 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 (indice[0]) au plus significatif (indice[n]), la mise à jour suivante getDigits() est ce qu'il vous faut :

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

Answer 4

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

Answer 5

Je ne connais pas bien les mécanismes internes de Java, mais ne pourriez-vous pas simplement moduler le nombre par 10 de façon répétée, et stocker le résultat dans une variable ?