如何获取整数的单独数字?


143

我有1100、1002、1022等数字。我想使用单个数字,例如,对于第一个数字1100,我希望具有1、1、0、0。

如何用Java获取它?

Answers:


204

为此,您将使用%(mod)运算符。

int number; // = some int

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

mod运算符将为您提供对int进行除法运算的其余部分。

所以,

10012 % 10 = 2

因为:

10012 / 10 = 1001, remainder 2

注意:如Paul所述,这将为您提供相反的数字。您将需要将它们压入堆栈并以相反的顺序弹出。

代码以正确的顺序打印数字:

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
但是,这将使您以错误的顺序获取数字,因此必须确保将其压入堆栈或以相反的顺序将其放入数组中。
Paul Tomblin

4
请注意,这使它们从右到左。(OP的示例从左到右显示它们)。简单到足以应付,但应注意。
詹姆斯·柯伦

1
@Don,实际上,不。我不会赞成这一点。这是方式比基于字符串的版本,虽然速度更快。我会看一下Marimuthu的答案,尽管有一些快速和简短的代码。
jjnguy 2010年

2
很好的解决方案,但是当数字以前导零开头时,它似乎无法解决这种情况。例如-001122。如果我使用上述逻辑-我只会得到1,1,2,2。前导0被%和/运算删除。如果我错了,请纠正我。
goyalshub1509 '16

2
负整数呢?如果我通过-3432,输出将是-2-3-4-3,这是不正确的。
Nodir Nasirov '18

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 2010年

8
使用split(""),数组中的第一项是""。使用其他正则表达式,例如split("(?<=.)")
True Soft

3
toCharArray比split快得多。我只是将它们放入一个循环中了1000次,toCharArray用了20毫秒,拆分用了1021毫秒。我也用mod(%)除以10进行了数学运算,这样做花了50毫秒,因此toCharArray似乎比其他两个要快。
Jerry Destremps

2
编辑:我只是再做一次,这次要确保更长的循环(10,000次迭代)。toCharArray的速度大约是split的100倍,toCharArray的速度是模数数学方法的大约5倍。
杰里·德斯特朗普斯

9
@BalusC number.chars()将以Ascii值(而非数字)返回结果。这样数字“ 1234”将被拆分为“ 49”,“ 50”,“ 51”,“ 52”,而不是“ 1”,“ 2”,“ 3”,“ 4”。要正确执行,它应该看起来像:IntStream chars = number.chars().map(Character::getNumericValue);
Koin Arab,

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

如果您希望保持数字从最低有效位(index [0])到最高有效位(index [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
这是使用mod按正确顺序打印内容的好方法。 +1
jjnguy 2010年

1
这很漂亮。我当时在想:“必须有一种无需使用Collection ...即可撤销订单的方法。” +1
bobndrew 2010年

无可挑剔。可能想向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 '19

出于某种原因,此逻辑会给错误的输出提供不同于5542的数字。请尝试:0142323
tavalendo

@tavalendo 014232350387由于前导零而等于的八进制常量,就像0x100256由于前导而导致的等于十六进制常量一样0x,并且0b101111由于前导而导致的等于二进制常量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()method来获取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。上面的解决方案如何对适合int类型的所有+ ve值起作用?
realPK

3

我认为更简单的方法是将数字转换为字符串,然后使用substring提取然后转换为整数的方式。

像这样:

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

输出是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);
}

假设您的输入是integer 123,结果输出将如下所示:

1
2
3

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-总是没有任何浮动内容,因为单位已经消失,请重复。


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


与上面列出的一般方法相比,它的实用性和优雅性较低,在原理上也与使用的其他答案没有区别%。它几乎没有价值。
肖恩·梅恩

@肖恩·梅汉,我不同意。上面的方法主要是关于使用String或长的多行解决方案,而这是简单明了的。
parsecer

1

Java 8解决方案,它从您具有的字符串整数中将数字作为int []获得:

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

我已经尝试过了,但是没有用。您可以简单地尝试“ 12” .chars()。toArray(),您会发现与其返回[1,2],它返回[49,50],我猜实际上是'1'的ASCII码, “ 2”,这绝对不是OP想要的。
Fran Marzoa

@Fran,你是对的。我更新了答案以包括一个i -> i - '0'映射,以便结果恰好是OP所要求的。
qben

而不是使用的i - '0'也有类似的方法Character.toDigit,国际海事组织是更好地使用。
西蒙·福斯伯格

您可以在@SimonForsberg中引用文档中的方法,并提供一个代码片段如何工作?如果有更优雅的方式,我很乐意更新我的答案。
qben

@qben "0123456789".chars().map(i -> Character.digit(i, 10)).toArray() Character#digit(一个用于char和一个用于int codePoints)
Simon Forsberg

1

也不 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]

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'。的字节数组。字节值将不是10
jjnguy 2010年

误导?有点苛刻。这个问题是模棱两可的。这确实取决于他想对数字进行的处理。您假设他要执行计算。我的答案假定为文本处理。两种假设都部分正确,但这并不是我的误导意图。
唐·布兰森

我想我觉得这是一种误导,因为您得到的是字节数组,我认为数字数组不是字符。
jjnguy 2010年

@贾斯汀-好的。我不会自动将字节关联为非字符。在上班期间,我会递增“ 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相当大。
朱塞佩·加拉西诺

@Beppe 12344444不太大,不能成为整数。Java文档声明了以下有关int的信息,从-2147483648到2147483647(含)之间。尽管要确定在系统上确实可以使用System.out.println(Integer.MAX_VALUE);找出java.lang包中支持的
max_value

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
请更新您的答案,并说明它如何解决问题。仅代码响应通常被认为是质量较差的答案。
devlin carnate

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并想要获得a List<Integer>,则可以像这样流式传输元素。

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

这得到了人物的String作为IntStream,字符的那些整数表示映射到一个数值,箱子他们,然后将它们收集到一个列表。


有趣的是,足够的chars()返回一个IntStream,因此,如果您调用boxed()和collect(),则可以立即返回Integer列表。
杰森

1
您会得到ASCII值。因此,1名映射到49
ifly6

有趣!ty,不知道。
杰森

无法编译:Collectors.toList()→“ 类型不匹配:无法从Collector <Object,capture#3-of?,List <Object >>转换为Supplier <R> ”,collect→“ 方法collect(Supplier <R>,ObjIntConsumer <R >,类型为IntStream的BiConsumer <R,R>)不适用于参数(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; 
      } 
    }
    }
}



-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
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.