int 번호의 개별 숫자를 얻는 방법은 무엇입니까?

int 번호의 개별 숫자를 얻는 방법은 무엇입니까?

저는 1100, 1002, 1022 등의 번호를 가지고 있습니다.예를 들어 첫 번째 숫자 1100은 1, 1, 0, 0으로 하고 싶습니다.

자바에서 입수하려면 어떻게 해야 하나요?

위해서는, 「 」를 사용합니다.% )operator . ( mod ) "

int number; // = some int

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

mod 연산자는 번호에 대해 int 나눗셈을 수행하는 나머지를 제공합니다.

그렇게,

10012 % 10 = 2

이유:

10012 / 10 = 1001, remainder 2

주의: Paul이 지적한 바와 같이, 역순으로 번호가 표시됩니다.스택에 푸시하여 역순으로 팝오프해야 합니다.

올바른 순서로 번호를 인쇄하는 코드:

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

변환하여 또는 를 사용합니다.

String number = String.valueOf(someInt);

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

이미 Java 8을 사용하고 있고 나중에 Java 8에 대한 집약 작업을 수행할 경우 를 사용하여 Java 8을 활용하십시오.

IntStream chars = number.chars();

이건 어때?

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

또는 콘솔에 인쇄하는 대신 정수 배열로 수집하여 다음 배열을 인쇄할 수 있습니다.

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

최하위(index[0])부터 최상위(index[n])까지의 디짓의 순서를 유지하려면 , 다음의 갱신된 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[]{});
}

이 방법을 사용하는 사람은 본 적이 없지만, 나에게도 효과가 있고 짧고 달콤합니다.

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

다음과 같이 출력됩니다.

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

Java 8 스트림을 사용하여 문제를 해결하는 예는 거의 없지만 이것이 가장 간단한 방법이라고 생각합니다.

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

사용법: 사용하다String.valueOf(number)으로 int'String으로 변환합니다.chars()에서 각 가 ASCII 번호하여 IntStream(ASCII)을 실행해야 .map()ASCII를 사용하다마지막에 사용하다toArray()int[ ] [[ [[ [[[ 。

나는 모든 답이 못생기고 깨끗하지 않다는 것을 안다.

문제를 해결하기 위해 약간의 재귀적 방법을 사용하는 것이 좋습니다.이 게시물은 매우 오래되었지만, 미래의 코드 작성자에게 도움이 될 수 있습니다.

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

출력:

Input: 12345

Output: 1   2   3   4   5 

단순해법

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

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

이 질문에는 Java 8을 사용하는 방법이 없기 때문에, 이것을 넣겠습니다.에 R&합니다.String사고 싶다List<Integer>이치노

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

.String로 IntStream는 이러한 문자의 정수 표현을 수치로 매핑하고 상자에 넣은 후 목록으로 수집합니다.

는 새로운 9를 했습니다.Stream.iterate특정 조건에서 스트림을 생성하고 중지하는 데 사용할 수 있는 메서드입니다.이것은 모듈로 방식을 사용하여 번호의 모든 숫자를 가져올 수 있습니다.

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

또는

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

예를 들어, 다음 코드는 다음과 같습니다.

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

인쇄:

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

하기 쉬운 방법은 하시면 됩니다.substring이치노

다음과 같은 경우:

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

out은 2014년이다.

저는 어떻게 정수의 자릿수를 분리하는지를 보여주는 프로그램을 만들었습니다. 배열, 재귀, 그리고 그 모든 화려한 슈만시를 수반하지 않는 보다 간단하고 이해하기 쉬운 접근법으로요.코드는 다음과 같습니다.

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

합니다.123출력 결과는 다음과 같습니다.

1
2
3

String 어프로치를 사용하고 싶지 않거나 보다 산술적인 해법이 필요한 분들을 위해 간단한 답변을 드리겠습니다.

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

유닛을 입수하여 출력하고, 그 숫자를 10으로 나눕니다.유닛이 없어졌으니 반복해 주세요.

왜 안 해요?

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

이거 드셔보세요.

const check = (num) => {
  let temp = num
  let result = []
  while(temp > 0){
    let a = temp%10;
    result.push(a);
    temp = (temp-a)/10;
  }
  return result;
}

check(98) //[ 8, 9 ]

Java 8 솔루션은 문자열로 지정한 정수에서 int[]와 같은 숫자를 가져옵니다.

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

둘 다 아니다. chars() 도 아니다 codePoints() : 다른 쪽 람다

String number = Integer.toString( 1100 );

IntStream.range( 0, number.length() ).map( i -> Character.digit( number.codePointAt( i ), 10 ) ).toArray();  // [1, 1, 0, 0]

Integer.toString(1100)은 정수를 문자열로 제공합니다.Integer.toString(1100).getBytes(): 개개의 자릿수의 바이트 배열을 가져옵니다.

편집:

다음과 같이 문자 숫자를 숫자로 변환할 수 있습니다.

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

modulo 10 방식을 사용하여 0보다 큰 숫자의 각 숫자를 계산하고 배열 순서를 반대로 합니다.이것은, 「0」을 개시 자리수로 사용하지 않는 것을 전제로 하고 있습니다.

이것은 사용자 입력을 받아들이도록 수정되었습니다.되어 있기 에, 는 이 배열을 수 없었습니다.Collections.reverse()를 호출하여 사용자 순서로 되돌립니다.

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

이 주제에 대해 설명하자면, 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;
}

나는 내가 이 모든 것을 더 단순화할 수 있다고 확신한다.하지만, 나는 여기 있다.제 모든 테스트 케이스에서 효과가 있었습니다.

이게 도움이 됐으면 좋겠어요.

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

이것을 시험해 보세요.

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;

첫 번째 = 1, 두 번째 = 2, 세 번째 = 3 및 네 번째 = 4 ......

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

이와 같은 것이 다시 돌아올 거야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();
}

노브로서 내 대답은 다음과 같다.

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

이제 모든 자릿수가 "자리수" 배열에 포함됩니다.

디지트가 a인 경우 Character

String numstr = Integer.toString( 123 );
Pattern.compile( "" ).splitAsStream( numstr ).map(
  s -> s.charAt( 0 ) ).toArray( Character[]::new );  // [1, 2, 3]

다음 기능이 올바르게 동작합니다.
numstr = "000123"얻다[0, 0, 0, 1, 2, 3]
numstr = "-123"얻다[-, 1, 2, 3]

LINQ를 사용하는 .NET 솔루션.

List<int> numbers = number.ToString().Select(x => x - 48).ToList();

이 방법이 숫자를 얻는 가장 유용한 방법이라고 생각합니다.

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

그러면 간단한 방법으로 숫자를 얻을 수 있습니다.

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

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

또는 더 간단하게:

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

마지막 메서드가 getDigitsOf 메서드를 호출하는 시간이 너무 길다는 점에 유의하십시오.그래서 더 느릴 거예요.두 번째 코드 블록과 마찬가지로 int 배열을 만들고 getDigitsOf 메서드를 한 번 호출해야 합니다.

다음 코드에서는 프로세스로 되돌릴 수 있습니다.이 코드는 모든 숫자를 조합하여 다음 숫자를 만듭니다.

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

제가 제공한 두 방법 모두 음수에도 효과가 있습니다.

코멘트로 내 제안을 외치다

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

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

언급URL : https://stackoverflow.com/questions/3389264/how-to-get-the-separate-digits-of-an-int-number