Як отримати окремі цифри int числа?


143

У мене є числа, наприклад 1100, 1002, 1022 і т. Д. Я хотів би мати окремі цифри, наприклад для першого числа 1100, я хочу мати 1, 1, 0, 0.

Як я можу отримати його на Java?

Відповіді:


204

Для цього ви скористаєтесь %оператором (mod).

int number; // = some int

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

Оператор мод надасть вам решту виконання int поділу на число.

Так,

10012 % 10 = 2

Тому що:

10012 / 10 = 1001, remainder 2

Примітка. Як зазначив Павло, це дасть вам цифри у зворотному порядку. Вам потрібно буде натиснути їх на стек і викласти їх у зворотному порядку.

Код для друку номерів у правильному порядку:

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

4
Однак ви отримаєте номери в неправильному порядку, тому вам доведеться бути впевненим і натиснути на стек або просто поставити їх у масив у зворотному порядку.
Пол Томблін

4
Зауважте, що це дає їм справа наліво. (Приклад ОП показує їх зліва направо). Простий хотів би впоратися, але це слід зазначити.
Джеймс Курран

1
@Don, на практиці, ні. Я б це не віддав перевазі. Це набагато швидше, ніж версія на основі рядків. Я хотів би поглянути на відповідь Марімутху, хоча для швидкого та короткого коду.
jjnguy

2
Чудове рішення, але схоже, що воно не справляється зі сценарієм, коли число починається з провідних нулів. наприклад - 001122. Якщо я використовую вище логіку - я отримаю лише 1,1,2,2. Провідні 0 знижуються на% та / операції. Будь ласка, виправте мене, якщо я помиляюся.
goyalshub1509

2
як щодо негативних цілих чисел тут? якщо я пройду -3432, вихід буде -2-3-4-3, що неправильно.
Нодір Насіров

75

Перетворити його на Stringта використовувати String#toCharArray()або String#split().

String number = String.valueOf(someInt);

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

У випадку, якщо ви вже користуєтесь Java 8 і після цього хочете зробити кілька сукупних операцій, подумайте String#chars()про те, щоб IntStreamвийти з неї.

IntStream chars = number.chars();

7
Це швидкий і брудний спосіб.
jjnguy

8
З split(""), перший елемент у масиві - це "". Використовуйте інший регулярний вираз, наприклад split("(?<=.)").
Справжнє м'яке

3
toCharArray набагато швидше, ніж спліт. Я просто поставив обидва в цикл 1000 разів, а toCharArray взяв 20 мс, а спліт - 1021 мс. Я також це зробив математично, використовуючи ділити на десять з модом (%), і це зайняло 50 мс, зробивши це таким чином, тож toCharArray виявляється швидше, ніж інші два.
Джеррі Дестремпс

2
Редагувати: я просто зробив це знову, на цей раз, з довшими петлями, щоб бути впевненим (10 000 ітерацій). toCharArray приблизно в 100 разів швидше, ніж спліт, а toCharArray - приблизно в 5 разів швидше, ніж метод математичної модуляції.
Джеррі Дестремпс

9
@BalusC number.chars()поверне результат у значеннях Ascii, а не числових. Так що число "1234" буде розбито на "49", "50", "51", "52" замість "1", "2", "3", "4". Щоб правильно це зробити, це має виглядати так:IntStream chars = number.chars().map(Character::getNumericValue);
Коін Араб

29

Як щодо цього?

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

Якщо ви хочете підтримувати порядок цифр від найменш значущого (індекс [0]) до найбільш значущого (індекс [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[]{});
}

1
Це хороший спосіб друкувати речі в правильному порядку, використовуючи мод. +1
jjnguy

1
Це прекрасно. Я думав: "Має бути спосіб змінити замовлення без використання колекції ...." +1
bobndrew

Бездоганний. Ви можете додати наступний код до getDigits (int num), щоб захистити його від поганих входів: if (number < 0) { return new Integer[0]; } Тестовано з наступними входами:Integer[] samples = {11111, 123457, 0, -13334, 93846, 87892, 9876543, -1234, 012455};
realPK

24

Я не бачив, щоб хтось використовував цей метод, але він працював на мене, він короткий і милий:

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

Це дивовижно. Спасибі
Marwa Eltayeb

Чомусь ця логіка дає неправильний вихід для чисел, відмінних від 5542. Спробуйте, наприклад: 0142323
tavalendo

@tavalendo 0142323- вісімкова константа, що дорівнює 50387провідному нулю, так само, як 0x100і шістнадцяткова константа, дорівнює 256, за рахунок провідного 0x, і 0b1011є двійковою постійною, що дорівнює 11провідному 0b. Будьте обережні, що ведуть 0 на цілих константах!
AJNeufeld

12

Я помітив, що є мало прикладу використання потоку Java 8 для вирішення вашої проблеми, але я думаю, що це найпростіший:

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

Щоб було зрозуміло: ви використовуєте String.valueOf(number)для перетворення int в String, потім chars()метод для отримання IntStream (кожен знак у вашому рядку тепер є числом Ascii), тоді вам потрібно запустити map()метод, щоб отримати числові значення числа Ascii. Наприкінці ви використовуєте toArray()метод для зміни потоку в масив int [].


11

Я бачу, що вся відповідь некрасива і не дуже чиста.

Я пропоную вам використати трохи рекурсії для вирішення своєї проблеми. Цей пост дуже старий, але може бути корисним майбутнім кодерам.

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 

Чорт забирає, ви про те, що відповіді є угл. Дякую.
розбір

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

Тип Java int має мінімальне значення -2 ^ 31 та максимальне значення 2 ^ 31-1. Як вищевказане рішення може працювати для всіх значень + ve, що входять до типу int?
realPK

3

Найпростішим способом, на мій погляд, є перетворення числа в рядок і використання substringдля вилучення, а потім перетворення в ціле число.

Щось на зразок цього:

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

ouput - 2014 рік


чи перетворення типів тут обійдеться дорожче або операції поділу?
Рахул

2

Я написав програму, яка демонструє, як розділити цифри цілого числа, використовуючи більш простий і зрозумілий підхід, який не передбачає масивів, рекурсій та всього цього фантазійного обертання. Ось мій код:

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

2

Ось моя відповідь, я зробив це для себе, і я сподіваюся, що це досить просто для тих, хто не хоче використовувати струнний підхід або потребує більш математичного рішення:

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 - що завжди без плаваючих речей, оскільки одиниць немає, повторюємо.


2

просте рішення

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

1

Спробуйте це:

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


Це менш утилітарно та елегантно, ніж загальні методи, перелічені вище, і принципово не відрізняються від інших відповідей %. Це додає малої цінності.
Шон Механ

@Shawn Mehan, я б не погодився. Способи, описані вище, здебільшого стосуються використання String або довгих багатошарових рішень, тоді як цей звичайний і простий.
розбір

1

Рішення Java 8, щоб отримати цифри як int [] з цілого числа, яке є у вас як String:

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

Я спробував це, і це не працює. Ви можете просто спробувати "12" .chars (). ToArray (), і ви дізнаєтесь, що замість повернення [1,2] він повертає [49,50], що, напевно, насправді є кодами ASCII для '1' та "2", і це точно не те, чого хотіла ОП.
Fran Marzoa

@Fran ти маєш рацію. Я оновив свою відповідь, щоб включити i -> i - '0'картографування, щоб результат був саме тим, про що вимагала ОП.
qben

Замість використання i - '0'є також такі методи, як Character.toDigitІМО, краще використовувати.
Саймон Форсберг

@SimonForsberg чи можете ви посилатися на метод у документах та дати фрагмент коду, як це буде працювати? Я радий оновити свою відповідь, якщо є більш елегантний спосіб.
qben

@qben "0123456789".chars().map(i -> Character.digit(i, 10)).toArray() Символ # цифра (є одна для char та одна для int codePoints)
Саймон Форсберг

1

ні 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]

1

Java 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]

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

Це трохи вводить в оману. Це дасть вам масив байтів, що представляють знак char '1'або '0'. Значення байтів не будуть 1, або 0.
jjnguy

Зман? Це трохи суворо. Питання було неоднозначним. Це дійсно залежить від того, що він хоче робити з цифрами. Ви припускаєте, що він хоче виконати розрахунки. Моя відповідь передбачає обробку тексту. Будь-яке припущення частково правильне, але вводити мене в оману не було.
Дон Бренсон

Я думаю, я вважаю, що це вводить в оману, тому що ви отримуєте масив байтів, який я думаю про числа, а не символи.
jjnguy

@Justin - Ага, гаразд. Я автоматично не пов'язую байти як символи. У мої збори я збільшив "a", щоб отримати "b", повторюючи алфавіт, тому іноді байти були одночасно обома. Звичайно, мови на високому рівні та UTF видають це все спірно.
Дон Бренсон

0

При цьому використовується метод модуля 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);

0

Просто для розробки теми, ось як підтвердити, що число є паліндромним цілим числом на 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;
}

Я впевнений, що можу далі спростити цю альгу. І все-таки тут я є. І він працював у всіх моїх тестових випадках.

Я сподіваюся, що це комусь допоможе.


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

12344444 - великим, щоб бути int.
Джузеппе Гарассино

@Beppe 12344444 не надто великий, щоб бути цілим. Документи Java заявляють наступне для int, від -2147483648 до 2147483647, включно Хоча для впевненості у своїй системі можна використовувати System.out.println (Integer.MAX_VALUE); щоб дізнатись максимальне значення, яке підтримується у вашому пакеті 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;
}

1
Будь ласка, оновіть свою відповідь та поясніть, як вона вирішує проблему. Відповіді, що стосуються лише коду, як правило, вважаються відповідями низької якості.
девлін карнат

0

див. нижче мою пропозицію з коментарями

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

0

Щось подібне поверне 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();
}

0

Як ноуб, моя відповідь буде:

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

Тепер усі цифри містяться в масиві "цифр".


0

Чому б не зробити:

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

0

Оскільки я не бачу в цьому питанні методу, який використовує Java 8, я вкину це. Припускаючи, що ви починаєте з a Stringі хочете отримати List<Integer>, ви можете передавати такі елементи, як так.

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

Це отримує символів у Stringвигляді а IntStream, відображає цілі уявлення символів на числове значення, позначає їх полями, а потім збирає їх у список.


Цікаво, що символи chars () повертають IntStream, тож якщо ви зателефонуєте в boxed () та збираєте (), ви можете негайно повернути Список цілих чисел.
Джейсон

1
Ви повертаєте значення ASCII. Отже 1 карта на 49.
ifly6

Цікаво! Не знав цього, ти.
Джейсон

Не компілюється: Collectors.toList()→ " Невідповідність типу: не може конвертувати з Collector <Object, capture # 3-of?, List <Object>> to постачальник <R> ", collect→ " Метод збирання (постачальник <R>, ObjIntConsumer <R >, BiConsumer <R, R>) типу IntStream не застосовується для аргументів (Collector <Object,?, List <Object>>) "
Gerold Broser

Відредаговано. Перед тим, як збирати їх, потрібно їх упакувати. Дивіться, наприклад, repl.it/@ifly6/HeftyAffectionateHertz#Main.java
ifly6

-1

Я думаю, що це буде найкорисніший спосіб отримати цифри:

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

Обидва методи, які я запропонував, працюють і для від’ємних чисел.


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


Відповідь для → [посилання] stackoverflow.com/questions/47196499 / ...
always007

-1

в Java, ось як можна відокремити цифри від чисел і зберегти їх у масиві.

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

Вихід:

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

-1

якщо цифра означає а Character

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

Pattern.compile? Це багато надмірності.
Саймон Форсберг

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

         }
     }
    }

Без використання масивів та рядків. (цифри 1-99999)

вихід:

Введіть цифру для друку окремо: - 12345

1 2 3 4 5


Повинен бути спосіб більш ефективно та динамічно визначатись divider.
ZX9
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.