Comment obtenir les chiffres séparés d'un numéro int?
J'ai des nombres comme 1100, 1002, 1022, etc. J'aimerais 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 mod vous donnera le reste de la division int sur un nombre.
Alors,
10012 % 10 = 2
Parce que:
10012 / 10 = 1001, remainder 2
Note: Comme Paul l'a noté, cela vous donnera les numéros dans l'ordre inverse. Vous devrez les empiler sur une pile et les extraire 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 String et utilisez 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 quelques opérations d’agrégation ultérieurement, envisagez d’utiliser String#chars() pour obtenir 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 devez disposer de la méthode getDigits () suivante:
/**
* 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 elle a fonctionné pour moi et est courte et douce:
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 de 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 int en String, puis la méthode chars() pour obtenir un IntStream (chaque caractère de votre chaîne est maintenant un numéro Ascii), puis vous devez exécuter la méthode map() pour obtenir une Numéro Ascii. À la fin, vous utilisez la méthode toArray() pour transformer votre flux en tableau int [].
// 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);
Je vois que toutes les réponses sont laides et pas très propres.
Je suggère que vous utilisiez 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));
}
}
Sortie:
Input: 12345
Output: 1 2 3 4 5
Je pense qu'il est plus simple de convertir le nombre en chaîne et d'utiliser substring pour 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
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 ne fait pas appel à des tableaux, à des récursions ni à tout ce qui est fantaisie. 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 est l'entier 123, le résultat obtenu sera le suivant:
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);
}
}
Je récupère donc les unités, les imprime, les soustrait du nombre, puis je divise ce nombre par 10 - ce qui est toujours sans aucun élément flottant, car les unités sont parties, répétez.
Solution Java 8 pour obtenir les chiffres en tant que int [] à partir d'un entier que vous avez sous forme de chaîne
int[] digits = intAsString.chars().map(i -> i - '0').toArray();
Quelque chose comme ceci retournera 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();
}
nichars()norcodePoints()- 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]
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;
}
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 en premier = 1, en second = 2, en troisième = 3 et en quatrième = 4 ....
Ceci utilise la méthode modulo 10 pour déterminer chaque chiffre en un nombre supérieur à 0, puis inverser 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 initialement inséré à l'envers, je devais donc utiliser l'appel Collections.reverse() 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);
Comme je ne vois pas de méthode à cette question qui utilise Java 8, je vais ajouter ceci. En supposant que vous démarrez avec un String et que vous voulez obtenir un List<Integer>, vous pouvez alors diffuser les éléments de cette manière.
List<Integer> digits = digitsInString.chars().map(Character::getNumericValue)
.collect(Collectors.toList());
Cela obtient les caractères de la String sous la forme d'une IntStream, mappe ces représentations entières de caractères sur une valeur numérique, puis les rassemble dans une liste.
voir ci-dessous ma proposition avec 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()+ " ");
}
Integer.toString (1100) vous donne le nombre entier sous forme de chaîne. Integer.toString (1100) .getBytes () pour obtenir un tableau d'octets des chiffres individuels.
Modifier:
Vous pouvez convertir les chiffres des caractères en chiffres, 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));
Pour construire sur le sujet, voici comment vérifier 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 cet algo davantage. Pourtant, c'est là où je suis. Et cela a fonctionné dans tous mes cas de test.
J'espère que ça aidera quelqu'un.