web-dev-qa-db-fra.com

Comment puis-je vérifier si une valeur est de type Integer?

Je dois vérifier si une valeur est un entier. J'ai trouvé ceci: Comment vérifier si la valeur d'entrée est un entier ou un flottant? , mais si je ne me trompe pas, la variable y est toujours du type double même si la valeur elle-même est bien une integer.

javainteger
42
Voldemort

Si la valeur d'entrée peut être sous forme numérique autre qu'entier, vérifiez par

if (x == (int)x)
{
   // Number is integer
}

Si la valeur de chaîne est transmise, utilisez Integer.parseInt(string_var). Assurez-vous que la gestion des erreurs à l'aide de try catch en cas d'échec de la conversion.

73
Mudassir Hasan

Si vous avez un nombre double/flottant/à virgule flottante et que vous voulez voir s’il s’agit d’un nombre entier.

public boolean isDoubleInt(double d)
{
    //select a "tolerance range" for being an integer
    double TOLERANCE = 1E-5;
    //do not use (int)d, due to weird floating point conversions!
    return Math.abs(Math.floor(d) - d) < TOLERANCE;
}

Si vous avez une chaîne et que vous voulez voir si c'est un entier. De préférence, ne jetez pas le résultat Integer.valueOf():

public boolean isStringInt(String s)
{
    try
    {
        Integer.parseInt(s);
        return true;
    } catch (NumberFormatException ex)
    {
        return false;
    }
}

Si vous voulez voir si quelque chose est un objet Integer (et donc enveloppe une int):

public boolean isObjectInteger(Object o)
{
    return o instanceof Integer;
}
13
Ryan Amos

Essayez peut-être de cette façon

try{
    double d= Double.valueOf(someString);
    if (d==(int)d){
        System.out.println("integer"+(int)d);
    }else{
        System.out.println("double"+d);
    }
}catch(Exception e){
    System.out.println("not number");
}

Mais tous les nombres en dehors de la plage de nombres entiers (comme "-1231231231231231238") seront traités comme des doubles. Si vous voulez vous débarrasser de ce problème, essayez-le de cette façon

try {
    double d = Double.valueOf(someString);
    if (someString.matches("\\-?\\d+")){//optional minus and at least one digit
        System.out.println("integer" + d);
    } else {
        System.out.println("double" + d);
    }
} catch (Exception e) {
    System.out.println("not number");
}
8
Pshemo

Vous devez utiliser l'opérateur instanceof pour déterminer si votre valeur est Integer ou non.

Objet objet = votre_valeur;

if(object instanceof Integer) {

Integer integer = (Integer) object ;

} else {
 //your value isn't integer
}
7
Andrei Amarfii

Voici la fonction pour vérifier si String est Integer ou non?

public static boolean isStringInteger(String number ){
    try{
        Integer.parseInt(number);
    }catch(Exception e ){
        return false;
    }
    return true;
}
2
Yasir Shabbir Choudhary

Pour vérifier si une chaîne contient des caractères numériques représentant un entier, vous pouvez utiliser Integer.parseInt().

Pour vérifier si un double contient une valeur qui peut être un entier, vous pouvez utiliser Math.floor() ou Math.ceil().

1
Code-Apprentice

Peut-être que cette petite classe aide. J'ai d'abord voulu passer à la ligne suivante toutes les secondes, en essayant de vérifier si le float utilisé pour boucler avec était un entier si divisé par 2. Finalement, il m'a donné le code suivant:

public class Test {

    private static int sequencesPerLine = 20;
    private static int loops = 6400;

    private static long number = 999999999999999999L;


    public static void main(String[] args) {

        for (float i=0; i<loops; i++) {
        int integer = (int) i / sequencesPerLine;

        if (i / sequencesPerLine == integer) {
            System.out.print("\n");
        }
        System.out.print(number);
        }
    }
}

sequencesPerLine est le nombre de fois à imprimer number avant de passer à la ligne suivante . Changer sequencesPerLine en 2 donnera le résultat que je recherchais à l'origine.

1
Andreas

c'est le moyen le plus court que je connaisse avec les entiers négatifs activés:

Object myObject = "-1";

if(Pattern.matches("\\-?\\d+", (CharSequence) myObject);)==true)
{
    System.out.println("It's an integer!");
}

Et c'est comme ça avec les entiers négatifs désactivés:

Object myObject = "1";

if(Pattern.matches("\\d+", (CharSequence) myObject);)==true)
{
    System.out.println("It's an integer!");
}
1
august0490

Vous devez d'abord vérifier si c'est un numéro. Si c'est le cas, vous pouvez utiliser la méthode Math.Round. Si le résultat et la valeur d'origine sont égaux, il s'agit d'un entier.

1
Amjad Abdelrahman

Cela peut fonctionner:

int no=0;
try
{
    no=Integer.parseInt(string);
    if(string.contains("."))
    {
        if(string.contains("f"))
        {
            System.out.println("float");
        }
        else
            System.out.println("double");
    }
}

catch(Exception ex)
{
    Console.WriteLine("not numeric or string");
}
1
Ravindra Bagale
if (x % 1 == 0)
    // x is an integer

Ici x est une primitive numérique: short, int, long, float ou double

1
Gayan Weerakutti

Vous pouvez utiliser le module%, la solution est si simple:

import Java.text.DecimalFormat;
import Java.util.Scanner;
public class Main {
    public static void main(String[] args) {

    Scanner scan = new Scanner(System.in);
    System.out.println("Enter first number");
    Double m = scan.nextDouble();
    System.out.println("Enter second number");
    Double n= scan.nextDouble();

    if(m%n==0) 
    {
        System.out.println("Integer");
    }
    else
    {
        System.out.println("Double");
    }


}
}
0
Ali.Ghodrat

Essayez cet extrait de code

private static boolean isStringInt(String s){
    Scanner in=new Scanner(s);
    return in.hasNextInt();
}
0
Daniel Chang