我有像1100,1002,1022等数字。我想有个别数字，例如第一个数字1100我想要1,1,0,0。
我怎样才能用Java获取它？
答案 0 :(得分：171)
为此，您将使用%（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());
}
答案 1 :(得分：68)
将其转换为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();
答案 2 :(得分：25)
这个怎么样？
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[]{});
}
答案 3 :(得分：19)
我还没有看到有人使用这种方法，但它对我有用而又简短又甜蜜：
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
答案 4 :(得分：7)
我注意到很少有使用Java 8流来解决问题的例子，但我认为这是最简单的一个：
double x=2.2, y=10.5要明确：
您使用int[] intTab = String.valueOf(number).chars().map(Character::getNumericValue).toArray();
将int转换为String，然后使用String.valueOf(number)方法获取IntStream（您的字符串中的每个字符串现在都是Ascii数字），然后您需要运行chars()方法来获取Ascii数字的数值。最后，使用map()方法将流更改为int []数组。
答案 5 :(得分：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);
答案 6 :(得分：4)
我看到所有答案都很丑陋而且不是很干净。
我建议您使用一些递归来解决您的问题。这篇文章很老，但是对以后的编码人员可能会有帮助。
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
答案 7 :(得分：4)
简单解决方案
public static void main(String[] args) {
int v = 12345;
while (v > 0){
System.out.println(v % 10);
v /= 10;
}
}
答案 8 :(得分：3)
Java 9引入了一种新的Stream.iterate方法，该方法可用于生成流并在特定条件下停止。可以使用取模方法来获取数字中的所有数字。
int[] a = IntStream.iterate(123400, i -> i > 0, i -> i / 10).map(i -> i % 10).toArray();
请注意，这将获得相反的数字，但是可以通过向后遍历数组（将数组not that simple反向翻转）或创建另一个流来解决：
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]
答案 9 :(得分：3)
我认为更简单的方法是将数字转换为字符串并使用substring提取然后转换为整数。
这样的事情：
int digits1 =Integer.parseInt( String.valueOf(201432014).substring(0,4));
System.out.println("digits are: "+digits1);
答案 10 :(得分：2)
我编写了一个程序，演示了如何使用更简单易懂的方法分离整数的数字，这种方法不涉及数组，递归和所有那些花哨的schmancy。这是我的代码：
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
答案 11 :(得分：2)
这是我的答案，我是为自己做的，我希望对于那些不想使用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 - 这总是没有浮动的东西，因为单位已经消失，重复。
答案 12 :(得分：1)
Java 8解决方案，从作为String的整数中获取数字int []：
int[] digits = intAsString.chars().map(i -> i - '0').toArray();
答案 13 :(得分：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))
现在所有数字都包含在“数字”数组中。
答案 14 :(得分：0)
都不是 chars() 也不是 codePoints() -另一个lambda
String number = Integer.toString( 1100 );
IntStream.range( 0, number.length() ).map( i -> Character.digit( number.codePointAt( i ), 10 ) ).toArray(); // [1, 1, 0, 0]
答案 15 :(得分：0)
使用 LINQ 的 .NET 解决方案。
List<int> numbers = number.ToString().Select(x => x - 48).ToList();
答案 16 :(得分：0)
为什么不这样做：
$ set -o noclobber
$ more test.txt
one
two
three
$ perl -e 'print "replaced"' > test.txt
-bash: test.txt: cannot overwrite existing file
答案 17 :(得分：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();
}
答案 18 :(得分：0)
试试这个。
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 ]
答案 19 :(得分：0)
由于我没有在这个使用Java 8的问题上看到一个方法，我会把它扔进去。假设你是从一个(z (z a))开始并希望获得一个String，那么你可以像这样流式化元素。
List<Integer>这会将List<Integer> digits = digitsInString.chars().map(Character::getNumericValue)
.collect(Collectors.toList());
中的字符作为String，将字符的整数表示形式映射为数字值，然后将它们收集到列表中。
答案 20 :(得分：0)
请参阅我的建议及评论
import { BrowserModule } from '@angular/platform-browser';
import { NgModule, ApplicationRef} from '@angular/core';
import { CommonModule } from '@angular/common';
import { HttpModule,RequestOptions } from '@angular/http';
import { FormsModule} from '@angular/forms';
import { routing,
appRoutingProviders } from './app.routing';
//Routes
import { ComboFinderComponent } from './combo-finder/combo-finder.component';
@NgModule({
declarations: [
AppComponent,
ComboFinderComponent
],
imports: [
BrowserModule,
CommonModule,
FormsModule,
HttpModule,
routing,
],
providers: [
{provide:RequestOptions, useClass: CustomRequestOptions }
],
entryComponents: [AppComponent],
bootstrap: [AppComponent]
})
export class AppModule {
}
答案 21 :(得分：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;
}
答案 22 :(得分：0)
试试这个：
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 ....
答案 23 :(得分：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;
}
我确信我可以进一步简化这个算法。然而，这就是我。它在我的所有测试用例中都有效。
我希望这有助于某人。
答案 24 :(得分：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;
}
答案 25 :(得分：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);
答案 26 :(得分：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));
答案 27 :(得分：-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;
}
}
}
}
答案 28 :(得分：-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]
答案 29 :(得分：-1)
如果数字是指 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]
答案 30 :(得分：-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;
}
我提供的两种方法也适用于负数。
答案 31 :(得分：-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