Відповіді:
Для цього ви скористаєтесь %
оператором (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());
}
Перетворити його на 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();
split("")
, перший елемент у масиві - це ""
. Використовуйте інший регулярний вираз, наприклад split("(?<=.)")
.
number.chars()
поверне результат у значеннях Ascii, а не числових. Так що число "1234" буде розбито на "49", "50", "51", "52" замість "1", "2", "3", "4". Щоб правильно це зробити, це має виглядати так:IntStream chars = number.chars().map(Character::getNumericValue);
Як щодо цього?
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
if (number < 0) { return new Integer[0]; }
Тестовано з наступними входами:Integer[] samples = {11111, 123457, 0, -13334, 93846, 87892, 9876543, -1234, 012455};
Я не бачив, щоб хтось використовував цей метод, але він працював на мене, він короткий і милий:
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
0142323
- вісімкова константа, що дорівнює 50387
провідному нулю, так само, як 0x100
і шістнадцяткова константа, дорівнює 256
, за рахунок провідного 0x
, і 0b1011
є двійковою постійною, що дорівнює 11
провідному 0b
. Будьте обережні, що ведуть 0 на цілих константах!
Я помітив, що є мало прикладу використання потоку Java 8 для вирішення вашої проблеми, але я думаю, що це найпростіший:
int[] intTab = String.valueOf(number).chars().map(Character::getNumericValue).toArray();
Щоб було зрозуміло: ви використовуєте String.valueOf(number)
для перетворення int в String, потім chars()
метод для отримання 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
// 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);
Найпростішим способом, на мій погляд, є перетворення числа в рядок і використання substring
для вилучення, а потім перетворення в ціле число.
Щось на зразок цього:
int digits1 =Integer.parseInt( String.valueOf(201432014).substring(0,4));
System.out.println("digits are: "+digits1);
ouput - 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
Ось моя відповідь, я зробив це для себе, і я сподіваюся, що це досить просто для тих, хто не хоче використовувати струнний підхід або потребує більш математичного рішення:
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 - що завжди без плаваючих речей, оскільки одиниць немає, повторюємо.
Спробуйте це:
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 ....
%
. Це додає малої цінності.
Рішення Java 8, щоб отримати цифри як int [] з цілого числа, яке є у вас як String:
int[] digits = intAsString.chars().map(i -> i - '0').toArray();
i -> i - '0'
картографування, щоб результат був саме тим, про що вимагала ОП.
i - '0'
є також такі методи, як Character.toDigit
ІМО, краще використовувати.
"0123456789".chars().map(i -> Character.digit(i, 10)).toArray()
Символ # цифра (є одна для char та одна для int codePoints)
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]
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));
'1'
або '0'
. Значення байтів не будуть 1
, або 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);
Просто для розробки теми, ось як підтвердити, що число є паліндромним цілим числом на 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;
}
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;
}
див. нижче мою пропозицію з коментарями
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()+ " ");
}
Щось подібне поверне 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(input);
char[] digits = number.toCharArray();
Оскільки я не бачу в цьому питанні методу, який використовує Java 8, я вкину це. Припускаючи, що ви починаєте з a String
і хочете отримати List<Integer>
, ви можете передавати такі елементи, як так.
List<Integer> digits = digitsInString.chars()
.map(Character::getNumericValue)
.boxed()
.collect(Collectors.toList());
Це отримує символів у String
вигляді а IntStream
, відображає цілі уявлення символів на числове значення, позначає їх полями, а потім збирає їх у список.
Collectors.toList()
→ " Невідповідність типу: не може конвертувати з Collector <Object, capture # 3-of?, List <Object>> to постачальник <R> ", collect
→ " Метод збирання (постачальник <R>, ObjIntConsumer <R >, BiConsumer <R, R>) типу IntStream не застосовується для аргументів (Collector <Object,?, List <Object>>) "
Я думаю, що це буде найкорисніший спосіб отримати цифри:
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;
}
Обидва методи, які я запропонував, працюють і для від’ємних чисел.
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, ось як можна відокремити цифри від чисел і зберегти їх у масиві.
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]
якщо цифра означає а Character
String numstr = Integer.toString( 123 );
Pattern.compile( "" ).splitAsStream( numstr ).map(
s -> s.charAt( 0 ) ).toArray( Character[]::new ); // [1, 2, 3]
Pattern.compile
? Це багато надмірності.
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
.