Làm thế nào để có được các chữ số riêng biệt của một số int?

Tôi có các số như 1100, 1002, 1022, v.v. Tôi muốn có các chữ số riêng lẻ, ví dụ cho số đầu tiên 1100 tôi muốn có 1, 1, 0, 0.

Làm thế nào tôi có thể lấy nó trong Java?

Để làm điều này, bạn sẽ sử dụng %toán tử (mod).

int number; // = some int

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

Toán tử mod sẽ cung cấp cho bạn phần còn lại của phép chia int trên một số.

Vì thế,

10012 % 10 = 2

Bởi vì:

10012 / 10 = 1001, remainder 2

Lưu ý: Như Paul đã lưu ý, điều này sẽ cung cấp cho bạn các số theo thứ tự ngược lại. Bạn sẽ cần đẩy chúng lên một chồng và bật chúng theo thứ tự ngược lại.

Mã để in các số theo đúng thứ tự:

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

Chuyển đổi nó Stringvà sử dụng String#toCharArray()hoặc String#split().

String number = String.valueOf(someInt);

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

Trong trường hợp bạn đã có trên Java 8 và bạn tình cờ muốn thực hiện một số thao tác tổng hợp trên đó sau đó, hãy cân nhắc sử dụng String#chars()để thoát IntStreamkhỏi nó.

IntStream chars = number.chars();

Còn cái này thì sao?

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

hoặc thay vì in ra bàn điều khiển, chúng ta có thể thu thập nó trong một mảng các số nguyên và sau đó in mảng:

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

Nếu bạn muốn duy trì thứ tự các chữ số từ ít nhất có ý nghĩa (chỉ số [0]) đến đáng kể nhất (chỉ mục [n]), thì getDigits () được cập nhật sau đây là những gì bạn cần:

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

Tôi chưa thấy ai sử dụng phương pháp này, nhưng nó hiệu quả với tôi và ngắn gọn và ngọt ngào:

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

Điều này sẽ xuất ra:

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

Tôi nhận thấy rằng có một vài ví dụ về việc sử dụng luồng Java 8 để giải quyết vấn đề của bạn nhưng tôi nghĩ rằng đây là cách đơn giản nhất:

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

Để rõ ràng: Bạn sử dụng String.valueOf(number)để chuyển đổi int thành String, sau đó chars()phương thức để lấy IntStream (mỗi char từ chuỗi của bạn bây giờ là số Ascii), sau đó bạn cần chạy map()phương thức để lấy giá trị số của số Ascii. Cuối cùng, bạn sử dụng toArray()phương thức để thay đổi luồng của bạn thành một mảng int [].

Tôi thấy tất cả các câu trả lời là xấu xí và không sạch sẽ.

Tôi đề nghị bạn sử dụng một chút đệ quy để giải quyết vấn đề của bạn. Bài đăng này rất cũ, nhưng nó có thể hữu ích cho các lập trình viên tương lai.

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

Đầu ra:

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

Cách dễ dàng hơn tôi nghĩ là chuyển đổi số thành chuỗi và sử dụng substringđể trích xuất và sau đó chuyển đổi thành số nguyên.

Một cái gì đó như thế này:

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

dự kiến ​​là 2014

Tôi đã viết một chương trình trình bày cách phân tách các chữ số của một số nguyên bằng cách sử dụng một cách tiếp cận đơn giản và dễ hiểu hơn, không liên quan đến mảng, thu hồi và tất cả các sơ đồ lạ mắt đó. Đây là mã của tôi:

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

Giả sử đầu vào của bạn là số nguyên 123, đầu ra kết quả sẽ như sau:

1
2
3

Đây là câu trả lời của tôi, tôi đã tự làm điều đó và tôi hy vọng nó đủ đơn giản cho những ai không muốn sử dụng phương pháp Chuỗi hoặc cần một giải pháp toán học hơn:

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

Vì vậy, tôi chỉ cần lấy các đơn vị, in chúng ra, trừ chúng ra khỏi số, sau đó chia số đó cho 10 - luôn luôn không có bất kỳ nội dung nổi nào, vì các đơn vị đã biến mất, lặp lại.

giải pháp đơn giản

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

Thử cái này:

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;

Bạn sẽ nhận được đầu tiên = 1, thứ hai = 2, thứ ba = 3 và thứ tư = 4 ....

Giải pháp Java 8 để lấy các chữ số là int [] từ một số nguyên mà bạn có dưới dạng Chuỗi:

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

cũng không chars() phải codePoints() - lambda khác

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 đã giới thiệu một Stream.iteratephương thức mới có thể được sử dụng để tạo luồng và dừng ở một điều kiện nhất định. Điều này có thể được sử dụng để có được tất cả các chữ số trong số, sử dụng phương pháp modulo.

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

Lưu ý rằng điều này sẽ có được các chữ số theo thứ tự ngược lại, nhưng điều đó có thể được giải quyết bằng cách lặp qua mảng ngược (đáng buồn là đảo ngược một mảng không đơn giản ) hoặc bằng cách tạo một luồng khác:

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

hoặc là

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

Ví dụ, mã này:

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

Sẽ in:

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

Integer.toString (1100) cung cấp cho bạn số nguyên dưới dạng chuỗi. Integer.toString (1100) .getBytes () để lấy một mảng byte của các chữ số riêng lẻ.

Biên tập:

Bạn có thể chuyển đổi các chữ số ký tự thành chữ số, do đó:

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

Điều này sử dụng phương thức modulo 10 để tìm ra mỗi chữ số trong một số lớn hơn 0, sau đó điều này sẽ đảo ngược thứ tự của mảng. Điều này giả sử bạn không sử dụng "0" làm chữ số bắt đầu.

Điều này được sửa đổi để đưa vào đầu vào của người dùng. Mảng này ban đầu được chèn ngược, vì vậy tôi phải sử dụng lệnh Collections.reverse()gọi để đưa nó trở lại trật tự của người dùng.

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

Chỉ để xây dựng chủ đề, đây là cách xác nhận số đó là số nguyên palindromic trong 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;
}

Tôi chắc chắn rằng tôi có thể đơn giản hóa thuật toán này hơn nữa. Tuy nhiên, đây là nơi tôi đang có. Và nó đã làm việc theo tất cả các trường hợp thử nghiệm của tôi.

Tôi hi vọng điêu nay se giup được ai đo.

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

xem dưới đề xuất của tôi với ý kiến

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

Một cái gì đó như thế này sẽ trả lại 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();
}

Là một người mới, câu trả lời của tôi sẽ là:

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

Bây giờ tất cả các chữ số được chứa trong mảng "chữ số".

Tại sao bạn không làm:

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

Vì tôi không thấy một phương thức cho câu hỏi này sử dụng Java 8, tôi sẽ đưa nó vào. Giả sử rằng bạn đang bắt đầu với một Stringvà muốn có một List<Integer>, thì bạn có thể truyền phát các phần tử như vậy.

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

Điều này nhận các ký tự Stringdưới dạng a IntStream, ánh xạ các biểu diễn số nguyên của các ký tự thành một giá trị số, đóng hộp chúng và sau đó thu thập chúng vào một danh sách.

Tôi nghĩ rằng đây sẽ là cách hữu ích nhất để có được chữ số:

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

Sau đó, bạn có thể nhận được các chữ số một cách đơn giản:

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

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

hoặc đơn giản hơn:

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

Lưu ý phương thức cuối cùng gọi phương thức getDigitsOf quá nhiều thời gian. Vì vậy, nó sẽ chậm hơn. Bạn nên tạo một mảng int và sau đó gọi phương thức getDigitsOf một lần, giống như trong khối mã thứ hai.

Trong đoạn mã sau, bạn có thể đảo ngược để xử lý. Mã này đặt tất cả các chữ số lại với nhau để tạo thành số:

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

Cả hai phương pháp tôi đã cung cấp hoạt động cho các số âm quá.

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

trong Java, đây là cách bạn có thể tách các chữ số khỏi các số và lưu trữ chúng trong một mảng.

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

Đầu ra:

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

nếu chữ số có nghĩa là một 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;

         }
     }
    }

Không sử dụng mảng và chuỗi. (chữ số 1-99999)

đầu ra:

Nhập chữ số để in riêng: - 12345

1 2 3 4 5