Comment les mathématiques.min fonctionnent réellement?

Je comprends que toutes les fonctions mathématiques de java sont intégrés. Mais je me demandais par curiosité comment Math.min() fonctionne réellement?

J'ai vérifié la documentation de java et ne pouvait pas trouver quelque chose pour m'aider. Je suis assez nouveau à java.

Utilisation de la source (Math.java): public static int min(int a, int b) { return (a <= b) ? a : b; }
Si vous n'avez pas un IDE à la main, grepcode peut aider beaucoup.
Lire la source, c'est juste une ligne dans de nombreux cas.
Comment cela fonctionne est indéfini. Il y a plusieurs façons possibles, il pourrait être écrit, mais ils ont tous à la suite de la même chose, comme spécifié dans la Javadoc. Pas clair ce que vous êtes vraiment se poser.

OriginalL'auteur Samuel L Jackson | 2013-09-25

int

public static int min(int a, int b) {
    return (a <= b) ? a : b;
}

public static long min(long a, long b) {
     return (a <= b) ? a : b;
}

float

public static float min(float a, float b) {
    if (a != a) return a;   //a is NaN
    if ((a == 0.0f) && (b == 0.0f) && (Float.floatToIntBits(b) == negativeZeroFloatBits)) {
         return b;
    }
    return (a <= b) ? a : b;
 }

double

public static double min(double a, double b) {
    if (a != a) return a;   //a is NaN
    if ((a == 0.0d) && (b == 0.0d) && (Double.doubleToLongBits(b) == negativeZeroDoubleBits)) {
        return b;
    }
    return (a <= b) ? a : b;
}

Plus d'infos: Ici

Merci!!!! Très très bien.

OriginalL'auteur Gray

Java 7 documentation:

Renvoie la plus petite des deux valeurs int. C'est, le résultat de l'argument de la plus proche à la valeur de l'Entier.MIN_VALUE. Si les arguments ont la même valeur, le résultat est que même valeur.

Comportement:

Math.min(1, 2) => 1
Math.min(1F, 2) => 1F
Math.min(3D, 2F) => 2D
Math.min(-0F, 0F) => -0F
Math.min(0D, -0D) => -0D
Math.min(Float.NaN, -2) => Float.NaN
Math.min(-2F, Double.NaN) => Double.NaN

java.lang.De mathématiques et de java.lang.StrictMath Source:

public static int min(int a, int b) {
    return (a <= b) ? a : b;
}

java.lang.Mathématiques Bytecode (javap -c Math.class de l'Oracle du JDK JRE rt.jar):

public static int min(int, int);
Code:
   0: iload_0           //loads a onto the stack
   1: iload_1           //loads b onto the stack
   2: if_icmpgt     9   //pops two ints (a, b) from the stack
                        //and compares them
                        //if b>a, the jvm continues at label 9
                        //else, at the next instruction, 5
                        //icmpgt is for integer-compare-greater-than
   5: iload_0           //loads a onto the stack
   6: goto          10  //jumps to label 10
   9: iload_1           //loads 
  10: ireturn           //returns the currently loaded integer

Si la comparaison à 5 est vrai, un sera chargé, la jvm va sauter à 10 et retour un,
si la comparaison des rendements faux, il saute à 9, ce qui vous permettra de charger et de retour b.

Intrinsèques:

C' .php fichier de Java 8 de la JVM Hotspot conseils qu'il optimise les Mathématiques.min encore plus loin avec l'optimisation de code machine:

do_intrinsic(_min, java_lang_Math, min_name, int2_int_signature, F_S)

Cela signifie que le ci-dessus bytecode ne sera pas exécutée par le Java 8 Hotspot de la JVM. Cependant, il diffère en cela de la JVM pour la JVM, c'est pourquoi j'ai aussi expliqué le bytecode!

Espérons que, maintenant, vous savez tout ce qu'il ya à savoir sur les Mathématiques.min! 🙂

OriginalL'auteur tilpner

Il suffit de cocher la Math.java fichier source :

public static int min(int a, int b) {
    return (a <= b) ? a : b;
}

OriginalL'auteur xlecoustillier

3

Référence

La java.lang.Les mathématiques.min(int a, int b) renvoie la plus petite des deux valeurs int. C'est, le résultat est la valeur la plus proche à l'infini négatif. Si les arguments ont la même valeur, le résultat est que même valeur. Si la valeur est NaN, alors le résultat est NaN. Contrairement au numérique, les opérateurs de comparaison, cette méthode considère négatif zéro pour être strictement inférieure à zéro positif. Si un argument est zéro positif et l'autre négatif zéro, le résultat est négatif zéro.

Par exemple
```
System.out.println(Math.min(1111, 1000));
```
Sortie
```
1000
```
Il affiche la valeur minimale de la Math.min()

Merci beaucoup pour localiser ce morceau de documentation. Ça m'aide vraiment à comprendre plus.

OriginalL'auteur Naveen Kumar Alonekar
2

Certaine forme efficace de
```
math.min(a,b) = public static int min (a, b) {
  if(a<=b) return a;
  else return b;
}
```
Merci, le X. L. Ant eu exactement la forme de celui-ci, mais le vôtre a aidé à me comprendre un peu plus en détail.
content d'avoir pu aider mon ami!

OriginalL'auteur Ruben Serrate

Vous devez vous connecter pour publier un commentaire.