Is there any method or quick way to check whether a number is an Integer (belongs to Z field) in Java?
I thought of maybe subtracting it from the rounded number, but I didn't find any method that will help me with this.
Where should I check? Integer Api?
Quick and dirty...
if (x == (int)x)
{
...
}
edit: This is assuming x is already in some other numeric form. If you're dealing with strings, look into Integer.parseInt.
One example more :)
double a = 1.00
if(floor(a) == a) {
// a is an integer
} else {
//a is not an integer.
}
In this example, ceil can be used and have the exact same effect.
/**
* Check if the passed argument is an integer value.
*
* @param number double
* @return true if the passed argument is an integer value.
*/
boolean isInteger(double number) {
return number % 1 == 0;// if the modulus(remainder of the division) of the argument(number) with 1 is 0 then return true otherwise false.
}
if you're talking floating point values, you have to be very careful due to the nature of the format.
the best way that i know of doing this is deciding on some epsilon value, say, 0.000001f, and then doing something like this:
boolean nearZero(float f)
{
return ((-episilon < f) && (f <epsilon));
}
then
if(nearZero(z-(int)z))
{
//do stuff
}
essentially you're checking to see if z and the integer case of z have the same magnitude within some tolerance. This is necessary because floating are inherently imprecise.
NOTE, HOWEVER: this will probably break if your floats have magnitude greater than Integer.MAX_VALUE (2147483647), and you should be aware that it is by necessity impossible to check for integral-ness on floats above that value.
float for integers greater than 2^24 (about 16 million) If you use double you get round errors for integers gretaer than 2^53 (8 million trillion)With Z I assume you mean Integers , i.e 3,-5,77 not 3.14, 4.02 etc.
A regular expression may help:
Pattern isInteger = Pattern.compile("\\d+");
double x == 2.15;
if(Math.floor(x) == x){
System.out.println("an integer");
} else{
System.out.println("not an integer");
}
I think you can similarly use the Math.ceil() method to verify whether x is an integer or not. This works because Math.ceil or Math.floor rounds up x to the nearest integer (say y) and if x==y then our original `x' was an integer.
if((number%1)!=0)
{
System.out.println("not a integer");
}
else
{
System.out.println("integer");
}
change x to 1 and output is integer, else its not an integer add to count example whole numbers, decimal numbers etc.
double x = 1.1;
int count = 0;
if (x == (int)x)
{
System.out.println("X is an integer: " + x);
count++;
System.out.println("This has been added to the count " + count);
}else
{
System.out.println("X is not an integer: " + x);
System.out.println("This has not been added to the count " + count);
}
All given solutions are good, however most of them can give issues with Static Code Analysis (e.g. SONAR): "Floating point numbers should not be tested for equality" (see https://jira.sonarsource.com/browse/RSPEC-1244).
I am assuming that input that should be tested is double, not string.
As a workaround, I test numbers for not being integers:
public boolean isNotInteger(double x) {
return x - Math.floor(x) > 0;
}
int x = 3;
if(ceil(x) == x) {
System.out.println("x is an integer");
} else {
System.out.println("x is not an integer");
}
ceil(int) function, this is unusable. Also, if x is already an int, what point does this check even have?Check if ceil function and floor function returns the same value
static boolean isInteger(int n)
{
return (int)(Math.ceil(n)) == (int)(Math.floor(n));
}
You can just use x % 1 == 0 because x % 1 gives the residual value of x / 1
// in C language.. but the algo is same
#include <stdio.h>
int main(){
float x = 77.6;
if(x-(int) x>0)
printf("True! it is float.");
else
printf("False! not float.");
return 0;
}
