Jak uzyskać oddzielne cyfry numeru int?

Mam liczby takie jak 1100, 1002, 1022 itd. Chciałbym mieć poszczególne cyfry, na przykład dla pierwszej liczby 1100 chcę mieć 1, 1, 0, 0.

Jak mogę to uzyskać w Javie?

Aby to zrobić, użyjesz %operatora (mod).

int number; // = some int

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

Operator mod da ci resztę z dzielenia int na liczbie.

Więc,

10012 % 10 = 2

Ponieważ:

10012 / 10 = 1001, remainder 2

Uwaga: jak zauważył Paul, da ci to liczby w odwrotnej kolejności. Będziesz musiał włożyć je na stos i zdjąć w odwrotnej kolejności.

Kod do wydrukowania liczb we właściwej kolejności:

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

Przekonwertuj go na Stringi użyj String#toCharArray()lub String#split().

String number = String.valueOf(someInt);

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

Jeśli jesteś już na Javie 8 i chcesz później wykonać na niej zagregowane operacje, rozważ użycie, String#chars()aby wyjść IntStreamz tego.

IntStream chars = number.chars();

Co powiesz na to?

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

lub zamiast drukować na konsolę, możemy zebrać ją w tablicy liczb całkowitych, a następnie wydrukować tablicę:

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

Jeśli chcesz zachować kolejność cyfr od najmniej znaczących (indeks [0]) do najbardziej znaczących (indeks [n]), potrzebujesz zaktualizowanej metody 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[]{});
}

Nie widziałem nikogo używającego tej metody, ale zadziałała i jest krótka i słodka:

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

Spowoduje to:

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

Zauważyłem, że jest kilka przykładów wykorzystania strumienia Java 8 do rozwiązania problemu, ale myślę, że ten jest najprostszy:

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

Dla jasności: używasz String.valueOf(number)do konwersji int na String, a następnie chars()metody, aby uzyskać IntStream (każdy znak z twojego ciągu jest teraz liczbą Ascii), a następnie musisz uruchomić map()metodę, aby uzyskać wartości liczbowe liczby Ascii. Na koniec używasz toArray()metody, aby zmienić swój strumień na tablicę int [].

Widzę, że wszystkie odpowiedzi są brzydkie i niezbyt czyste.

Proponuję użyć odrobiny rekursji, aby rozwiązać problem. Ten post jest bardzo stary, ale może być pomocny dla przyszłych programistów.

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

Wynik:

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

Myślę, że łatwiejszym sposobem jest przekonwertowanie liczby na ciąg i użycie substringdo wyodrębnienia, a następnie przekonwertowania na liczbę całkowitą.

Coś takiego:

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

ouput jest 2014

Napisałem program, który pokazuje, jak oddzielać cyfry w liczbie całkowitej, używając prostszego i bardziej zrozumiałego podejścia, które nie obejmuje tablic, rekurencji i całej tej fantazyjnej schmanii. Oto mój kod:

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

Załóżmy, że dane wejściowe to liczba całkowita 123, a wynikowe dane wyjściowe będą następujące:

1
2
3

Oto moja odpowiedź, zrobiłem to dla siebie i mam nadzieję, że jest to dość proste dla tych, którzy nie chcą używać metody String lub potrzebują bardziej matematycznego rozwiązania:

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

Więc po prostu pobieram jednostki, drukuję je, odejmuję od liczby, a następnie dzielę tę liczbę przez 10 - co jest zawsze bez żadnych elementów pływających, ponieważ jednostki zniknęły, powtórz.

proste rozwiązanie

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

Spróbuj tego:

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;

Otrzymasz pierwszy = 1, drugi = 2, trzeci = 3 i czwarty = 4 ....

Rozwiązanie Java 8 do pobierania cyfr jako int [] z liczby całkowitej, którą masz jako ciąg:

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

ani chars() ani codePoints() - druga 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 wprowadziła nową Stream.iteratemetodę, której można użyć do wygenerowania strumienia i zatrzymania się w określonym stanie. Można to wykorzystać do uzyskania wszystkich cyfr w numerze, stosując podejście modulo.

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

Zwróć uwagę, że spowoduje to wyświetlenie cyfr w odwrotnej kolejności, ale można to rozwiązać albo przez zapętlenie tablicy do tyłu (niestety odwrócenie tablicy nie jest takie proste ) lub przez utworzenie innego strumienia:

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

lub

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

Na przykład ten kod:

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

Wydrukuje:

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

Integer.toString (1100) podaje liczbę całkowitą jako ciąg. Integer.toString (1100) .getBytes (), aby uzyskać tablicę bajtów poszczególnych cyfr.

Edytować:

Możesz zamienić cyfry znaku na cyfry, w ten sposób:

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

Używa metody modulo 10, aby obliczyć każdą cyfrę w liczbie większej niż 0, a następnie odwróci kolejność tablicy. Zakłada się, że nie używasz „0” jako cyfry początkowej.

Jest to modyfikowane, aby uwzględnić dane wejściowe użytkownika. Ta tablica jest pierwotnie wstawiana od tyłu, więc musiałem użyć Collections.reverse()wywołania, aby przywrócić ją do kolejności użytkownika.

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

Aby rozwinąć ten temat, oto jak potwierdzić, że liczba jest palindromiczną liczbą całkowitą w Javie:

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

Jestem pewien, że mogę jeszcze bardziej uprościć ten algorytm. A jednak to jest miejsce, w którym jestem. I zadziałało we wszystkich moich przypadkach testowych.

Mam nadzieję, że to komuś pomoże.

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

zobacz poniżej moją propozycję z komentarzami

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

Coś takiego zwróci 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();
}

Jako noob, moja odpowiedź brzmiałaby:

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

Teraz wszystkie cyfry są zawarte w tablicy „digits”.

Dlaczego nie robisz:

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

Ponieważ nie widzę metody w tym pytaniu, która wykorzystuje Javę 8, dorzucę to. Zakładając, że zaczynasz od a Stringi chcesz otrzymać a List<Integer>, możesz strumieniować elementy w ten sposób.

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

Spowoduje to pobranie znaków w Stringas a IntStream, odwzorowanie tych reprezentacji całkowitych znaków na wartość liczbową, umieszczenie ich w ramce, a następnie zebranie ich na liście.

Myślę, że będzie to najbardziej przydatny sposób na zdobycie cyfr:

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

Następnie możesz uzyskać cyfry w prosty sposób:

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

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

lub prościej:

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

Zwróć uwagę, że ostatnia metoda wywołuje metodę getDigitsOf zbyt długo. Więc będzie wolniej. Powinieneś utworzyć tablicę int, a następnie raz wywołać metodę getDigitsOf, tak jak w drugim bloku kodu.

W poniższym kodzie możesz cofnąć proces. Ten kod łączy wszystkie cyfry, aby utworzyć numer:

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

Obie podane przeze mnie metody działają również dla liczb ujemnych.

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

w Javie w ten sposób można oddzielić cyfry od liczb i przechowywać je w tablicy.

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

Wynik:

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

jeśli cyfra ma być 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;

         }
     }
    }

Bez używania tablic i ciągów znaków. (cyfry 1-99999)

wynik :

Wprowadź cyfrę do wydrukowania oddzielnie: - 12345

1 2 3 4 5