Bir int numarasının ayrı rakamlarını nasıl alabilirim?

1100, 1002, 1022 vb. Sayılarım var. Bireysel rakamlara sahip olmak istiyorum, örneğin 1, 1, 0, 0 olmak istediğim ilk sayı 1100 için.

Java ile nasıl edinebilirim?

Bunu yapmak için, %(mod) operatörünü kullanacaksınız .

int number; // = some int

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

Mod operatörü size bir sayı üzerinde int bölünmesi yapmanın kalanını verecektir.

Yani,

10012 % 10 = 2

Çünkü:

10012 / 10 = 1001, remainder 2

Not: Paul'un belirttiği gibi, bu size sayıları ters sırada verecektir. Onları bir yığının üzerine itmeniz ve ters sırada patlatmanız gerekir.

Numaraları doğru sırada yazdırmak için kod:

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

Dönüştürün Stringve String#toCharArray()veya kullanın String#split().

String number = String.valueOf(someInt);

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

Zaten Java 8'deyseniz ve daha sonra üzerinde toplu işlemler yapmak istiyorsanız, bundan String#chars()kurtulmak için kullanmayı düşünün IntStream.

IntStream chars = number.chars();

Buna ne dersin?

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

veya konsola yazdırmak yerine, bir tamsayı dizisinde toplayabilir ve ardından diziyi yazdırabiliriz:

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

En az anlamlıdan (dizin [0]) en anlamlıya (dizin [n]) kadar basamakların sırasını korumak istiyorsanız, aşağıdaki güncellenmiş getDigits () ihtiyacınız olan şeydir:

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

Kimsenin bu yöntemi kullandığını görmedim, ama benim için çalıştı ve kısa ve tatlı:

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

Bu çıktı:

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

Sorununuzu çözmek için Java 8 akışı kullanmanın birkaç örneği olduğunu fark ettim ama bunun en basit olduğunu düşünüyorum:

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

Açık olmak için: int'i String'e String.valueOf(number)dönüştürmek için kullanın , ardından chars()bir IntStream (dizenizdeki her karakter artık bir Ascii numarasıdır) map()elde etmek için yöntem kullanın, sonra Ascii numarasının sayısal değerlerini almak için yöntemi çalıştırmanız gerekir . Sonunda toArray()akışınızı bir int [] dizisine dönüştürmek için yöntem kullanırsınız .

Tüm cevapların çirkin ve çok temiz olmadığını görüyorum.

Sorununuzu çözmek için biraz özyineleme kullanmanızı öneririz . Bu gönderi çok eskidir, ancak gelecekteki kodlayıcılara yardımcı olabilir.

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

Çıktı:

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

Bence daha kolay yolu dize numarasını dönüştürmek ve substringayıklamak ve sonra tamsayı dönüştürmek için kullanmaktır .

Bunun gibi bir şey:

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

çıkış 2014

basit çözüm

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

Dizileri, özyinelemeleri ve tüm bu fantezi şemaları içermeyen daha basit ve anlaşılır bir yaklaşım kullanarak bir tamsayının rakamlarını nasıl ayıracağını gösteren bir program yazdım. İşte benim 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);
}

Girişinizin tamsayı olduğunu varsayalım 123, sonuçta elde edilen çıktı aşağıdaki gibi olacaktır:

1
2
3

İşte cevabım, kendim için yaptım ve umarım String yaklaşımını kullanmak istemeyen veya daha fazla math-y çözümüne ihtiyaç duyanlar için yeterince basit:

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

Bu yüzden sadece birimleri alıyorum, yazdırıyorum, sayıdan soyutlaştırıyorum, sonra bu sayıyı 10'a bölüyorum.

Bunu dene:

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;

Önce = 1, ikinci = 2, üçüncü = 3 ve dördüncü = 4 alacaksınız.

String olarak sahip olduğunuz bir tam sayıdan basamakları int [] olarak almak için Java 8 çözümü:

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

ne chars() ne codePoints() - diğer 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, bir Stream.iterateakış oluşturmak ve belirli bir durumda durdurmak için kullanılabilecek yeni bir yöntem tanıttı . Bu, modulo yaklaşımını kullanarak sayıdaki tüm rakamları elde etmek için kullanılabilir.

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

Bunun rakamları ters sırada alacağını, ancak dizide geriye doğru döngü yaparak (ne yazık ki bir diziyi tersine çevirmek o kadar kolay değildir ) veya başka bir akış oluşturarak çözülebileceğini unutmayın :

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

veya

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

Örnek olarak, bu 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));

Yazdırılacak:

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

Integer.toString (1100) size tamsayı bir dize olarak verir. Bağımsız basamaklardan oluşan bir bayt dizisi elde etmek için Integer.toString (1100) .getBytes () .

Düzenle:

Karakter basamaklarını sayısal basamaklara dönüştürebilirsiniz, böylece:

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

Bu, 0'dan büyük bir sayıdaki her bir rakamı bulmak için modulo 10 yöntemini kullanır, daha sonra bu, dizinin sırasını tersine çevirir. Bu, başlangıç ​​basamağı olarak "0" kullanmadığınızı varsayar.

Bu, kullanıcı girişini alacak şekilde değiştirilir. Bu dizi başlangıçta geriye doğru eklenir, bu yüzden Collections.reverse()kullanıcının siparişine geri koymak için çağrıyı kullanmak zorunda kaldı .

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

Sadece konu üzerine inşa etmek için, sayının Java'da palindromik bir tam sayı olduğunu nasıl doğrulayacağınız aşağıda açıklanmıştır:

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

Eminim bu algoyu daha da basitleştirebilirim. Oysa ben buradayım. Ve tüm test vakalarım altında çalıştı.

Umarım bu birine yardımcı olur.

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

teklifimle yorumların altında görü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()+ " ");
                }

Bunun gibi bir şey 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();
}

Bir çaylak olarak cevabım şöyle olurdu:

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

Şimdi tüm rakamlar "rakamlar" dizisinde yer alıyor.

Neden yapmıyorsun:

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

Bu soruda Java 8 kullanan bir yöntem göremediğim için bunu atarım. İle başladığınızı Stringve a almak istediğinizi varsayarsak, bu List<Integer>şekilde öğeleri aktarabilirsiniz.

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

Bu, karakterleri Stringa olarak alır, karakterlerin IntStreamtamsayı temsillerini sayısal bir değerle eşleştirir, bunları kutulara yerleştirir ve sonra bunları bir liste halinde toplar.

Bu rakamları almanın en yararlı yolu olacağını düşünüyorum:

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

Sonra rakamları basit bir şekilde alabilirsiniz:

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

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

veya daha basit:

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

Son yöntemin getDigitsOf yöntemini çok fazla çağırdığına dikkat edin. Yani daha yavaş olacak. Bir int dizisi oluşturmalı ve sonra ikinci kod bloğunda olduğu gibi getDigitsOf yöntemini bir kez çağırmalısınız.

Aşağıdaki kodda, işlemi tersine çevirebilirsiniz. Bu kod, numarayı yapmak için tüm basamakları bir araya getirir:

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

Verdiğim her iki yöntem de negatif sayılar için çalışıyor.

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

Java'da rakamları sayılardan ayırabilir ve bir Array'de depolayabilirsiniz.

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

Çıktı:

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

eğer basamaklı bir olması gerekiyordu 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;

         }
     }
    }

Diziler ve Dizeler kullanmadan. (rakam 1-99999)

çıktı :

Ayrı olarak yazdırmak için rakamı girin: - 12345

1 2 3 4 5