如何获取int数字的单独数字？

Question

我有像1100,1002,1022等数字.我想有个别数字,例如第一个数字1100我想要1,1,0,0.

我怎样才能用Java获取它？

Answer 1

为此,您将使用%(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());
}

Answer 2

将其转换为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();

Answer 3

这个怎么样？

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

Answer 4

我还没有看到有人使用这种方法,但它对我有用,并且简短而且甜美:

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

Answer 5

我注意到很少有使用Java 8流来解决问题的例子,但我认为这是最简单的一个:

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

要明确:您使用String.valueOf(number)将int转换为String,然后使用chars()方法获取IntStream(字符串中的每个字符串现在都是Ascii数字),然后您需要运行map()方法来获取Ascii数字的数值.最后,您使用toArray()方法将流更改为int []数组.

Answer 6

简单的解决方案

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

Answer 7

由于我在这个问题上没有看到使用 Java 8 的方法，我将把它扔进去。假设您从 a 开始String并想要获取 a List<Integer>，那么您可以像这样流式传输元素。

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

这将获取Stringas a 中的字符IntStream，将这些字符的整数表示映射到一个数值，将它们装箱，然后将它们收集到一个列表中。

Answer 8

我看到所有答案都很丑陋，也不是很干净。

我建议您使用一点递归来解决您的问题。这篇文章很老，但是可能对将来的编码人员有所帮助。

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 

Answer 9

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

Answer 10

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]