Bagaimana cara mendapatkan angka terpisah dari nomor int?

Saya memiliki angka seperti 1100, 1002, 1022 dll. Saya ingin memiliki masing-masing digit, misalnya untuk angka pertama 1100 Saya ingin memiliki 1, 1, 0, 0.

Bagaimana saya bisa mendapatkannya di Jawa?

Untuk melakukan ini, Anda akan menggunakan %operator (mod).

int number; // = some int

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

Operator mod akan memberi Anda sisa melakukan pembagian int pada nomor.

Begitu,

10012 % 10 = 2

Karena:

10012 / 10 = 1001, remainder 2

Catatan: Seperti yang dicatat Paul, ini akan memberi Anda angka dalam urutan terbalik. Anda harus mendorongnya ke tumpukan dan melepaskannya dengan urutan terbalik.

Kode untuk mencetak angka dalam urutan yang benar:

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

Konversikan ke Stringdan gunakan String#toCharArray()atau String#split().

String number = String.valueOf(someInt);

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

Jika Anda sudah menggunakan Java 8 dan Anda ingin melakukan beberapa operasi agregat setelahnya, pertimbangkan String#chars()untuk menggunakannya IntStream.

IntStream chars = number.chars();

Bagaimana dengan ini?

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

atau alih-alih mencetak ke konsol, kami dapat mengumpulkannya dalam array bilangan bulat dan kemudian mencetak array:

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

Jika Anda ingin mempertahankan urutan digit dari paling tidak signifikan (indeks [0]) hingga paling signifikan (indeks [n]), getDigits yang diperbarui berikut ini adalah yang Anda butuhkan:

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

Saya belum pernah melihat orang menggunakan metode ini, tetapi itu berhasil untuk saya dan pendek dan manis:

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

Ini akan menampilkan:

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

Saya perhatikan bahwa ada beberapa contoh penggunaan Java 8 stream untuk menyelesaikan masalah Anda, tetapi saya pikir ini adalah yang paling sederhana:

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

Untuk menjadi jelas: Anda menggunakan String.valueOf(number)untuk mengkonversi int ke String, lalu chars()metode untuk mendapatkan IntStream (setiap karakter dari string Anda sekarang menjadi nomor Ascii), maka Anda perlu menjalankan map()metode untuk mendapatkan nilai numerik dari nomor Ascii. Pada akhirnya Anda menggunakan toArray()metode untuk mengubah aliran Anda ke array [].

Saya melihat semua jawabannya jelek dan tidak terlalu bersih.

Saya sarankan Anda menggunakan sedikit rekursi untuk menyelesaikan masalah Anda. Posting ini sudah sangat lama, tetapi mungkin bermanfaat untuk pembuat kode masa depan.

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

Keluaran:

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

Cara yang lebih mudah menurut saya adalah untuk mengubah angka menjadi string dan gunakan substringuntuk mengekstrak dan kemudian mengkonversi ke integer.

Sesuatu seperti ini:

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

ouput adalah 2014

Saya menulis sebuah program yang menunjukkan bagaimana memisahkan angka-angka dari bilangan bulat menggunakan pendekatan yang lebih sederhana dan mudah dipahami yang tidak melibatkan array, rekursi, dan semua schmancy mewah. Ini kode saya:

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

Misalkan input Anda adalah bilangan bulat 123, output yang dihasilkan adalah sebagai berikut:

1
2
3

Inilah jawaban saya, saya melakukannya untuk diri saya sendiri dan saya harap itu cukup sederhana bagi mereka yang tidak ingin menggunakan pendekatan String atau membutuhkan solusi matematika-y yang lebih:

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

Jadi saya hanya mendapatkan unit, mencetaknya, mengurangi dari jumlahnya, lalu membaginya dengan 10 - yang selalu tanpa benda mengambang, karena unit hilang, ulangi.

solusi sederhana

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

Coba ini:

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;

Anda akan mendapatkan yang pertama = 1, kedua = 2, ketiga = 3 dan keempat = 4 ....

Solusi Java 8 untuk mendapatkan digit sebagai int [] dari integer yang Anda miliki sebagai String:

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

tidak chars() juga codePoints() - lambda lainnya

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 memperkenalkan Stream.iteratemetode baru yang dapat digunakan untuk menghasilkan aliran dan berhenti pada kondisi tertentu. Ini dapat digunakan untuk mendapatkan semua angka dalam angka, menggunakan pendekatan modulo.

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

Perhatikan bahwa ini akan mendapatkan digit dalam urutan terbalik, tetapi itu dapat dipecahkan dengan mengulang melalui array ke belakang (sayangnya membalikkan array tidak sesederhana itu ), atau dengan membuat aliran lain:

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

atau

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

Sebagai contoh, kode ini:

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

Akan dicetak:

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

Integer.toString (1100) memberi Anda integer sebagai string. Integer.toString (1100) .getBytes () untuk mendapatkan array byte dari masing-masing digit.

Edit:

Anda dapat mengubah angka karakter menjadi angka angka, dengan demikian:

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

Ini menggunakan metode modulo 10 untuk mencari tahu setiap digit dalam angka lebih besar dari 0, maka ini akan membalik urutan array. Ini dengan asumsi Anda tidak menggunakan "0" sebagai angka awal.

Ini dimodifikasi untuk menerima input pengguna. Array ini awalnya disisipkan ke belakang, jadi saya harus menggunakan Collections.reverse()panggilan untuk memasukkannya kembali ke pesanan pengguna.

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

Hanya untuk membangun pada subjek, berikut ini cara mengonfirmasi bahwa angka tersebut adalah bilangan bulat palindrom di Jawa:

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

Saya yakin saya bisa menyederhanakan algo ini lebih jauh. Namun, di sinilah saya berada. Dan itu berhasil di bawah semua kasus pengujian saya.

Saya harap ini membantu seseorang.

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

lihat di bawah proposal saya dengan komentar

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

Sesuatu seperti ini akan mengembalikan 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();
}

Sebagai noob, jawaban saya adalah:

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

Sekarang semua digit terkandung dalam array "digit".

Kenapa tidak Anda lakukan:

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

Karena saya tidak melihat metode pada pertanyaan ini yang menggunakan Java 8, saya akan memasukkan ini. Dengan asumsi bahwa Anda mulai dengan Stringdan ingin mendapatkan List<Integer>, maka Anda dapat melakukan streaming elemen seperti itu.

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

Ini mendapatkan karakter di Stringsebagai IntStream, memetakan representasi bilangan bulat karakter ke nilai numerik, kotak mereka, dan kemudian mengumpulkan mereka ke dalam daftar.

Saya pikir ini akan menjadi cara yang paling berguna untuk mendapatkan angka:

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

Maka Anda bisa mendapatkan angka dengan cara sederhana:

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

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

atau lebih sederhana:

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

Perhatikan metode terakhir memanggil metode getDigitsOf terlalu banyak waktu. Jadi akan lebih lambat. Anda harus membuat array int dan kemudian memanggil metode getDigitsOf sekali, seperti di blok kode kedua.

Dalam kode berikut, Anda dapat membalikkan proses. Kode ini menyatukan semua digit untuk membuat nomor:

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

Kedua metode yang saya sediakan juga berfungsi untuk angka negatif.

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

di Jawa, ini adalah bagaimana Anda dapat memisahkan angka dari angka dan menyimpannya dalam Array.

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

Keluaran:

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

Jika digit dimaksudkan untuk a 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;

         }
     }
    }

Tanpa menggunakan array dan String. (digit 1-99999)

keluaran:

Masukkan digit untuk dicetak secara terpisah: - 12345

1 2 3 4 5