У меня есть такие числа, как 1100, 1002, 1022 и т. Д. Я хотел бы иметь отдельные цифры, например, для первого числа 1100 я хочу иметь 1, 1, 0, 0.
Как я могу получить это на Java?
Для этого вы воспользуетесь %
оператором (mod).
int number; // = some int
while (number > 0) {
print( number % 10);
number = number / 10;
}
Оператор mod предоставит вам остаток от деления числа на 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
из этого.источник
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
. Остерегайтесь начинать нули в целочисленных константах!Я заметил, что есть несколько примеров использования потока Java 8 для решения вашей проблемы, но я думаю, что это самый простой:
int[] intTab = String.valueOf(number).chars().map(Character::getNumericValue).toArray();
Чтобы быть ясным: вы используете
String.valueOf(number)
для преобразования int в String, затемchars()
метод для получения IntStream (каждый char из вашей строки теперь является числом 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);
источник
простое решение
public static void main(String[] args) { int v = 12345; while (v > 0){ System.out.println(v % 10); v /= 10; } }
источник
Я думаю, что более простой способ - преобразовать число в строку и использовать
substring
для извлечения, а затем преобразовать в целое число.Что-то вроде этого:
int digits1 =Integer.parseInt( String.valueOf(201432014).substring(0,4)); System.out.println("digits are: "+digits1);
выпуск 2014
источник
В 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]
источник
000123
и-123
есть забавные результаты :-)%
имеет недостаток, заключающийся в том, что опускаются ведущие нули (например000123
). Только на бис мое решение тоже корректно работает и для знаков. Кстати: ваше решение подходит[8, 3]
для000123
.000123
делается83
потому, что 123 OCT = 83 DEC.000123
поступает[0, 0, 0, 1, 2, 3]
. Никто на странице не понял эту задачу неправильно.Я написал программу, которая демонстрирует, как разделять цифры целого числа, используя более простой и понятный подход, не связанный с массивами, рекурсиями и всем этим навороченным шармом. Вот мой код:
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 - что всегда без каких-либо плавающих вещей, поскольку единицы ушли, повторяю.
источник
Поскольку я не вижу в этом вопросе метода, который использует Java 8, я добавлю его. Предполагая, что вы начинаете с a
String
и хотите получить aList<Integer>
, вы можете передавать такие элементы в потоковом режиме.Это получает символы в
String
asIntStream
, сопоставляет эти целочисленные представления символов с числовым значением, помещает их в коробку, а затем собирает их в список.источник
Collectors.toList()
→ « Несоответствие типов: невозможно преобразовать из Collector <Object, capture # 3-of?, List <Object>> в Supplier <R> »,collect
→ « Method collect (Supplier <R>, ObjIntConsumer <R >, BiConsumer <R, R>) в типе IntStream неприменимо для аргументов (Collector <Object,?, List <Object>>) »Решение Java 8 для получения цифр как int [] из целого числа, которое у вас есть как String:
int[] digits = intAsString.chars().map(i -> i - '0').toArray();
источник
i - '0'
есть также такие методыCharacter.toDigit
, которые лучше использовать IMO."0123456789".chars().map(i -> Character.digit(i, 10)).toArray()
Character # digit (один для char и один для int codePoints)ни
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));
источник
'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; }
источник
Попробуй это:
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))
Теперь все цифры содержатся в массиве цифр.
источник
Почему бы вам не сделать:
String number = String.valueOf(input); char[] digits = number.toCharArray();
источник
Думаю, это будет самый полезный способ получить цифры:
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; } } } }
источник
в 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]
и следующие работы правильно
numstr = "000123"
получает[0, 0, 0, 1, 2, 3]
numstr = "-123"
получает[-, 1, 2, 3]
источник
Pattern.compile
? Это большой перебор.Character
-array. Я сомневаюсь, что один вызовPattern.compile
занимает больше времени, чем многократный вызов оператора по модулю,%
и он может обрабатывать все большие числа (безint
ограничений типа) одновременно.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
.