Jak uzyskać oddzielne cyfry numeru int?

143

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?

Edy Moore
źródło

Odpowiedzi:

204

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());
}
jjnguy
źródło
4
Spowoduje to jednak, że liczby będą w złej kolejności, więc musisz być pewien i włożyć je na stos lub po prostu umieścić je w tablicy w odwrotnej kolejności.
Paul Tomblin
4
Zauważ, że to daje im prawa do lewej. (Przykład PO pokazuje je od lewej do prawej). Wystarczająco proste w obsłudze, ale należy to zauważyć.
James Curran
1
@Don, w praktyce nie. Nie sprzyjałbym temu. Jest jednak znacznie szybszy niż wersja oparta na ciągach. Spojrzałbym jednak na odpowiedź Marimuthu, szukając szybkiego i krótkiego kodu.
jjnguy
2
Świetne rozwiązanie, ale wygląda na to, że nie radzi sobie ze scenariuszem, w którym liczba zaczyna się od zer wiodących. na przykład - 001122. Jeśli użyję powyższej logiki - dostanę tylko 1,1,2,2. Wiodące zera są pomijane o% i / operacje. Proszę, popraw mnie jeśli się mylę.
goyalshub1509
2
a co z ujemnymi liczbami całkowitymi? jeśli przejdę -3432, na wyjściu będzie -2-3-4-3, co jest nieprawidłowe.
Nodir Nasirov
75

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();
BalusC
źródło
7
To jest szybki i brudny sposób.
jjnguy
8
W split("")przypadku pierwszym elementem tablicy jest "". Użyj innego wyrażenia regularnego, na przykład split("(?<=.)").
True Soft
3
toCharArray jest DUŻO szybszy niż split. Po prostu włączyłem obie pętle 1000 razy i toCharArray zajęło 20 ms, a split 1021 ms. Zrobiłem to również matematycznie, używając dzielenia przez dziesięć z mod (%) i zrobienie tego w ten sposób zajęło 50 ms, więc toCharArray wydaje się być szybsze niż pozostałe dwa.
Jerry Destremps
2
Edycja: po prostu zrobiłem to ponownie, tym razem z dłuższymi pętlami (10 000 iteracji). toCharArray jest około 100 razy szybsze niż split, a toCharArray jest około 5 razy szybsze niż metoda matematyczna modułu.
Jerry Destremps,
9
@BalusC number.chars()zwróci wynik w postaci wartości Ascii, a nie liczb. Dzięki temu liczba „1234” zostanie podzielona na „49”, „50”, „51”, „52” zamiast „1”, „2”, „3”, „4”. Aby zrobić to dobrze, powinno wyglądać następująco:IntStream chars = number.chars().map(Character::getNumericValue);
Koin Arab,
29

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[]{});
}
Marimuthu Madasamy
źródło
1
To dobry sposób na drukowanie rzeczy we właściwej kolejności za pomocą mod. +1
jjnguy
1
To jest piękne. Myślałem: „Musi istnieć sposób na odwrócenie kolejności bez użycia Kolekcji…” +1
bobndrew
Bez zarzutu. Może chcesz dodać następujący kod do getDigits (int num), aby to odporny na złe wejść: if (number < 0) { return new Integer[0]; } Testowane z następujących wejść:Integer[] samples = {11111, 123457, 0, -13334, 93846, 87892, 9876543, -1234, 012455};
realPK
24

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
espiering
źródło
To jest niesamowite. Dzięki
Marwa Eltayeb
Z jakiegoś powodu ta logika daje błędne wyjście dla liczb innych niż 5542. Spróbuj na przykład: 0142323
tavalendo
@tavalendo 0142323jest stałą ósemkową równą 50387ze względu na wiodące zero, podobnie jak 0x100stała szesnastkowa równa 256, ze względu na interlinię 0x, i 0b1011jest stałą binarną równą ze 11względu na interlinię 0b. Uważaj na początkowe zera w stałych całkowitych!
AJNeufeld
12

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 [].

Koin Arab
źródło
11

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 
Gwiezdny władca
źródło
Cholera racja, chodzi o brzydkie odpowiedzi. Dzięki.
parsecer
6
// 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);
Jonathan Norman
źródło
Typ int Java ma minimalną wartość -2 ^ 31 i maksymalną 2 ^ 31-1. Jak powyższe rozwiązanie może działać dla wszystkich wartości + ve, które pasują do typu int?
realPK
3

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

Siva
źródło
czy tutaj konwersja typów będzie kosztować więcej, czy operacje dzielenia?
Rahul
2

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
Na zawsze sam
źródło
2

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.

parsecer
źródło
2

proste rozwiązanie

public static void main(String[] args) {
    int v = 12345;
    while (v > 0){
        System.out.println(v % 10);
        v /= 10;
    }
}
slisnychyi
źródło
1

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

yanisB
źródło
Jest to mniej użyteczne i eleganckie niż ogólne metody wymienione powyżej, ani zasadniczo nie różni się od innych stosowanych odpowiedzi %. Dodaje niewielkiej wartości.
Shawn Mehan
@Shawn Mehan, nie zgadzam się. Powyższe metody dotyczą głównie używania String lub długich, wieloliniowych rozwiązań, podczas gdy ta jest prosta i prosta.
parsecer
1

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();
qben
źródło
Próbowałem tego i to nie działa. Możesz po prostu wypróbować „12” .chars (). ToArray (), a dowiesz się, że zamiast zwracać [1,2] zwraca [49,50], które, jak sądzę, są w rzeczywistości kodami ASCII dla „1” i „2” i zdecydowanie nie tego chciał PO.
Fran Marzoa
@Fran masz rację. Zaktualizowałem swoją odpowiedź, i -> i - '0'dodając mapowanie, aby wynik był dokładnie taki, o jaki prosił OP.
qben
Zamiast używać, i - '0'istnieją również metody takie jak Character.toDigitta IMO, które są lepsze w użyciu.
Simon Forsberg
@SimonForsberg Czy możesz odwołać się do metody w dokumentacji i podać fragment kodu, jak to zadziała? Z przyjemnością zaktualizuję moją odpowiedź, jeśli istnieje bardziej elegancki sposób.
qben
@qben "0123456789".chars().map(i -> Character.digit(i, 10)).toArray() Znak # cyfra (jest jeden dla znaku i jeden dla punktów kodu int)
Simon Forsberg
1

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]
Kaplan
źródło
1

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]
Simon Forsberg
źródło
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));
Don Branson
źródło
To jest trochę mylące. To da ci tablicę bajtów reprezentujących znak '1'lub '0'. Wartości bajtów nie będą 1, lub 0.
jjnguy
Zwodniczy? To trochę trudne. Pytanie było niejednoznaczne. To naprawdę zależy, co chce zrobić z cyframi. Zakładasz, że chce wykonać obliczenia. Moja odpowiedź zakłada przetwarzanie tekstu. Każde założenie jest częściowo poprawne, ale nie zamierzałem wprowadzać w błąd.
Don Branson
Wydaje mi się, że jest to mylące, ponieważ otrzymujesz tablicę bajtów, którą myślę o liczbach, a nie znakach.
jjnguy
@Justin - Ach, dobrze. Nie kojarzę automatycznie bajtów jako znaków. W czasach, kiedy tworzyłem asembler, zwiększałem „a”, aby uzyskać „b”, iterując po alfabecie - więc czasami bajty były jednocześnie obydwoma. Oczywiście języki wysokiego poziomu i UTF sprawiają, że wszystko to jest dyskusyjne.
Don Branson
0

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);
Prosty Sandman
źródło
0

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.

jmarcosSF
źródło
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;
}
Dushyant
źródło
12344444 jest zbyt duży, aby być int.
Giuseppe Garassino,
@Beppe 12344444 nie jest zbyt duży, aby być int. Dokumentacja Java twierdzi, że dla int, od -2147483648 do 2147483647 włącznie. Chociaż aby mieć pewność, że w systemie można użyć System.out.println (Integer.MAX_VALUE); aby dowiedzieć się, jaka wartość maksymalna jest obsługiwana w pakiecie java.lang
OrwellHindenberg
0
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;
}
Shibashis
źródło
1
Zaktualizuj swoją odpowiedź i wyjaśnij, jak rozwiązuje problem. Odpowiedzi zawierające tylko kod są ogólnie uważane za odpowiedzi niskiej jakości.
devlin carnate
0

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()+ " ");
                }
SocketM
źródło
0

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();
}
Pritam Banerjee
źródło
0

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”.

Akenaten
źródło
0

Dlaczego nie robisz:

String number = String.valueOf(input);
char[] digits = number.toCharArray();
WesternGun
źródło
0

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.

ifly6
źródło
Co ciekawe, chars () zwraca IntStream, więc jeśli wywołasz funkcję boxed () i collect (), możesz natychmiast zwrócić Listę liczb całkowitych.
Jason
1
Otrzymujesz wartości ASCII z powrotem. Więc 1 odpowiada 49.
ifly6
Ciekawy! Nie wiedziałem tego, ty.
Jason
Nie kompiluje: Collectors.toList()→ " Niezgodność typu: nie można przekonwertować z Collector <Object, capture # 3-of?, List <Object>> do Supplier <R> ", collect→ " Metoda collect (Supplier <R>, ObjIntConsumer <R >, BiConsumer <R, R>) w typie IntStream nie ma zastosowania dla argumentów (Collector <Object,?, List <Object>>) "
Gerold Broser
Edytowano. Przed zebraniem należy je zapakować w pudełko. Zobacz np. Repl.it/@ifly6/HeftyAffectionateHertz#Main.java
ifly6
-1

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.

Ramazan Polat
źródło
-1
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; 
      } 
    }
    }
}
zawsze 007
źródło
Odpowiedź brzmi DLA → [link] stackoverflow.com/questions/47196499/…
zawsze007
-1

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]
Yash P Shah
źródło
-1

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]
Kaplan
źródło
Pattern.compile? To duża przesada.
Simon Forsberg
-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

raaz
źródło
Musi być sposób na skuteczniejsze i bardziej dynamiczne określanie divider.
ZX9