[英]How to get the separate digits of an int number?
我有 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
。
IntStream chars = number.chars();
這個怎么樣?
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[]{});
}
我還沒有看到有人使用這種方法,但它對我有用,而且簡短而甜蜜:
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
我注意到使用 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
簡單的解決方案
public static void main(String[] args) {
int v = 12345;
while (v > 0){
System.out.println(v % 10);
v /= 10;
}
}
// 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 8 的方法,我將把它扔進去。假設你從一個String
開始並且想要一個List<Integer>
,那么你可以像這樣流式傳輸元素.
List<Integer> digits = digitsInString.chars()
.map(Character::getNumericValue)
.boxed()
.collect(Collectors.toList());
這將獲取String
中的String
作為IntStream
,將這些字符的整數表示映射到一個數值,將它們裝箱,然后將它們收集到一個列表中。
我認為更簡單的方法是將數字轉換為字符串並使用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]
我編寫了一個程序,它演示了如何使用更簡單易懂的方法來分隔整數的數字,該方法不涉及數組、遞歸和所有那些花哨的技巧。 這是我的代碼:
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 - 這總是沒有任何浮動的東西,因為單位消失了,重復。
你為什么不這樣做:
String number = String.valueOf(input);
char[] digits = number.toCharArray();
Java 8 解決方案,用於從作為字符串的整數獲取數字為 int[]:
int[] digits = intAsString.chars().map(i -> i - '0').toArray();
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]
這使用模 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);
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;
}
只是為了建立這個主題,這里是如何確認該數字是 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 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 ....
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));
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))
現在所有的數字都包含在“digits”數組中。
如果數字是一個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]
試試這個。
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 ]
使用 LINQ 的 .NET 解決方案。
List<int> numbers = number.ToString().Select(x => x - 48).ToList();
我認為這將是獲得數字的最有用的方法:
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]
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
聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.