Wie erhalte ich die separaten Ziffern einer int-Nummer?

Ich habe Nummern wie 1100, 1002, 1022 usw. Ich möchte die einzelnen Ziffern haben, zum Beispiel für die erste Nummer 1100, die ich 1, 1, 0, 0 haben möchte.

Wie kann ich es in Java bekommen?

Dazu verwenden Sie den %Operator (mod).

int number; // = some int

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

Der Mod-Operator gibt Ihnen den Rest der int-Division für eine Zahl.

So,

10012 % 10 = 2

Weil:

10012 / 10 = 1001, remainder 2

Hinweis: Wie Paul bemerkt hat, erhalten Sie die Zahlen in umgekehrter Reihenfolge. Sie müssen sie auf einen Stapel schieben und in umgekehrter Reihenfolge ablegen.

Code zum Drucken der Nummern in der richtigen Reihenfolge:

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

Konvertieren Sie es in Stringund verwenden Sie String#toCharArray()oder String#split().

String number = String.valueOf(someInt);

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

Falls Sie sich bereits auf Java 8 und Sie passieren wollen einige Aggregate Operationen auf , es zu tun danach prüfen , mit String#chars()einem um IntStreamaus ihn heraus.

IntStream chars = number.chars();

Wie wäre es damit?

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

oder anstatt auf der Konsole zu drucken, können wir es in einem Array von Ganzzahlen sammeln und dann das Array drucken:

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

Wenn Sie die Reihenfolge der Ziffern von niedrigstwertig (Index [0]) bis höchstwertig (Index [n]) beibehalten möchten, benötigen Sie die folgenden aktualisierten getDigits ():

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

Ich habe noch niemanden gesehen, der diese Methode angewendet hat, aber sie hat bei mir funktioniert und ist kurz und bündig:

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

Dies wird Folgendes ausgeben:

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

Ich habe festgestellt, dass es nur wenige Beispiele für die Verwendung von Java 8-Streams gibt, um Ihr Problem zu lösen, aber ich denke, dass dies das einfachste ist:

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

Um es klar zu sagen : Sie String.valueOf(number)konvertieren int in String, dann die chars()Methode, um einen IntStream zu erhalten (jedes Zeichen aus Ihrer Zeichenfolge ist jetzt eine Ascii-Nummer), und müssen dann die map()Methode ausführen , um numerische Werte der Ascii-Nummer zu erhalten. Am Ende verwenden Sie die toArray()Methode, um Ihren Stream in ein int [] -Array zu ändern.

Ich sehe alle Antworten sind hässlich und nicht sehr sauber.

Ich schlage vor, Sie verwenden ein wenig Rekursion , um Ihr Problem zu lösen. Dieser Beitrag ist sehr alt, könnte aber für zukünftige Programmierer hilfreich sein.

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

Ausgabe:

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

Ich denke, es ist einfacher, die Zahl in einen String zu konvertieren und sie substringzu extrahieren und dann in eine Ganzzahl zu konvertieren.

Etwas wie das:

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

Ausgabe ist 2014

Ich habe ein Programm geschrieben, das zeigt, wie man die Ziffern einer ganzen Zahl mit einem einfacheren und verständlicheren Ansatz trennt, der keine Arrays, Rekursionen und all diese ausgefallenen Schmancy beinhaltet. Hier ist mein 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);
}

Angenommen, Ihre Eingabe ist die Ganzzahl 123, die resultierende Ausgabe lautet wie folgt:

1
2
3

Hier ist meine Antwort, ich habe es für mich selbst getan und ich hoffe, es ist einfach genug für diejenigen, die den String-Ansatz nicht verwenden möchten oder eine mathematischere Lösung benötigen:

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

Also hole ich einfach die Einheiten, drucke sie aus, subtrahiere sie von der Zahl und dividiere diese Zahl durch 10 - was immer ohne schwebendes Zeug ist, da die Einheiten weg sind, wiederhole.

einfache Lösung

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

Versuche dies:

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;

Sie erhalten zuerst = 1, zweitens = 2, drittens = 3 und viertens = 4 ....

Java 8-Lösung zum Abrufen von Ziffern als int [] aus einer Ganzzahl, die Sie als Zeichenfolge haben:

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

weder chars() noch codePoints() - das andere 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 führte eine neue Stream.iterateMethode ein, mit der ein Stream generiert und unter bestimmten Bedingungen gestoppt werden kann. Dies kann verwendet werden, um alle Ziffern in der Zahl unter Verwendung des Modulo-Ansatzes zu erhalten.

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

Beachten Sie, dass dadurch die Ziffern in umgekehrter Reihenfolge angezeigt werden. Dies kann jedoch entweder durch Rückwärtsschleifen des Arrays (leider ist das Umkehren eines Arrays nicht so einfach ) oder durch Erstellen eines anderen Streams gelöst werden :

int[] b = IntStream.iterate(a.length - 1, i -> i >= 0, i -> i - 1).map(i -> a[i]).toArray();

oder

int[] b = IntStream.rangeClosed(1, a.length).map(i -> a[a.length - i]).toArray();

Als Beispiel dieser 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));

Wird drucken:

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

Integer.toString (1100) gibt Ihnen die Ganzzahl als Zeichenfolge an. Integer.toString (1100) .getBytes () , um ein Array von Bytes der einzelnen Ziffern abzurufen .

Bearbeiten:

Sie können die Ziffern in numerische Ziffern umwandeln, also:

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

Dies verwendet die Modulo 10-Methode, um jede Ziffer in einer Zahl größer als 0 zu ermitteln. Dadurch wird die Reihenfolge des Arrays umgekehrt. Dies setzt voraus, dass Sie nicht "0" als Startziffer verwenden.

Dies wird geändert, um Benutzereingaben zu berücksichtigen. Dieses Array wurde ursprünglich rückwärts eingefügt, daher musste ich den Collections.reverse()Aufruf verwenden, um es wieder in die Reihenfolge des Benutzers zu bringen.

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

Um auf dem Thema aufzubauen, können Sie hier bestätigen, dass die Zahl in Java eine palindromische Ganzzahl ist:

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

Ich bin sicher, ich kann dieses Algo weiter vereinfachen. Doch hier bin ich. Und es hat unter all meinen Testfällen funktioniert.

Ich hoffe das hilft jemandem.

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

siehe unten meinen Vorschlag mit Kommentaren

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

So etwas wird Folgendes zurückgeben 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();
}

Als Noob wäre meine Antwort:

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

Jetzt sind alle Ziffern im Array "Ziffern" enthalten.

Warum tust du nicht:

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

Da ich in dieser Frage keine Methode sehe, die Java 8 verwendet, werde ich diese einwerfen. Angenommen, Sie beginnen mit a Stringund möchten eine erhalten List<Integer>, dann können Sie die Elemente wie folgt streamen.

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

Dadurch werden die Zeichen in Stringas as IntStreamabgerufen, diese ganzzahligen Darstellungen von Zeichen einem numerischen Wert zugeordnet, sie werden in Kästchen verpackt und anschließend in einer Liste zusammengefasst.

Ich denke, dies ist der nützlichste Weg, um Ziffern zu erhalten:

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

Dann können Sie auf einfache Weise Ziffern erhalten:

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

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

oder einfacher:

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

Beachten Sie, dass die letzte Methode die getDigitsOf-Methode zu lange aufruft. Es wird also langsamer sein. Sie sollten ein int-Array erstellen und dann die getDigitsOf-Methode einmal aufrufen, genau wie im zweiten Codeblock.

Im folgenden Code können Sie die Verarbeitung rückgängig machen. Dieser Code setzt alle Ziffern zusammen, um die Nummer zu bilden:

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

Beide Methoden, die ich bereitgestellt habe, funktionieren auch für negative Zahlen.

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 können Sie auf diese Weise Ziffern von Zahlen trennen und in einem Array speichern.

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

Ausgabe:

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

wenn die Ziffer a sein soll 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;

         }
     }
    }

Ohne Verwendung von Arrays und Strings. (Ziffern 1-99999)

Ausgabe :

Geben Sie die Ziffer ein, die separat gedruckt werden soll: - 12345

1 2 3 4 5