Matemática.Método Max em Java

O método java max () retorna o máximo de dois números. Os números comparados devem ser do mesmo tipo. Eles podem ser de int/int, longos/longos, flutuantes/flutuantes ou duplos/duplos. Para isso, o Java.Lang.A aula de matemática deve ser importada (mas não obrigatória).

Comparando int/int

A sintaxe é:

estático int max (int a, int b)

Exemplo de programa:

importar java.Lang.*;
classe TheClass
public static void main (string [] args)
int x = 2;
int y = 7;
int z = matemática.max (x, y);
Sistema.fora.println (z);

A saída é 7. A matemática da classe está no java.Lang.* pacote. No método máximo, x ou y pode ser digitado primeiro. O seguinte programa sai 7, entre -7 e +7:

importar java.Lang.*;
classe TheClass
public static void main (string [] args)
int x = -7;
int y = +7;
int z = matemática.max (y, x);
Sistema.fora.println (z);

A saída é 7. O programa seguinte sai -3, entre -7 e -3:

importar java.Lang.*;
classe TheClass
public static void main (string [] args)
int x = -7;
int y = -3;
int z = matemática.max (x, y);
Sistema.fora.println (z);

A saída é -3.

Se os dois números forem iguais, o resultado será o mesmo valor, como ilustrado no programa a seguir:

importar java.Lang.*;
classe TheClass
public static void main (string [] args)
int x = 5;
int y = 5;
int z = matemática.max (x, y);
Sistema.fora.println (z);

A saída é 5.

Comparando Long/Long

Um tipo de dados longo é do tipo inteiro. Deve ser usado quando as faixas de números inteiros desejados forem mais do que isso para o INT.

A sintaxe é:

estático longo max (longo a, longo b)

Exemplo de programa:

importar java.Lang.*;
classe TheClass
public static void main (string [] args)
longo x = 200000000;
longo y = 700000000;
Longo Z = Matemática.max (x, y);
Sistema.fora.println (z);

A saída é 700000000. A matemática da classe está no java.Lang.* pacote. No método max (), x ou y pode ser digitado primeiro. O programa a seguir sai 700000000, entre -700000000 e +700000000:

importar java.Lang.*;
classe TheClass
public static void main (string [] args)
longo x = -700000000;
longa y = +700000000;
Longo Z = Matemática.max (y, x);
Sistema.fora.println (z);

A saída é 700000000. O programa seguinte sai -300000000, entre -700000000 e -300000000:

importar java.Lang.*;
classe TheClass
public static void main (string [] args)
longo x = -700000000;
longo y = -300000000;
Longo Z = Matemática.max (x, y);
Sistema.fora.println (z);

A saída é -300000000.

Se os dois números forem iguais, o resultado será o mesmo valor, como ilustrado no programa a seguir:

importar java.Lang.*;
classe TheClass
public static void main (string [] args)
longo x = 500000000;
longo y = 500000000;
Longo Z = Matemática.max (x, y);
Sistema.fora.println (z);

A saída é 500000000.

Comparando flutuação/flutuação

Um número de flutuação é um número com uma parte decimal (fracionária).

A sintaxe é:

Float estático Max (flutuação a, flutuação B)

Exemplo de programa:

importar java.Lang.*;
classe TheClass
public static void main (string [] args)
flutuar x = 2.5f;
flutuar y = 7.5f;
flutuar z = matemática.max (x, y);
Sistema.fora.println (z);

A saída é 7.5. A matemática da classe está no java.Lang.* pacote. No método máximo, x ou y pode ser digitado primeiro. O seguinte programa produz 7.5, entre -7.5 e +7.5:

importar java.Lang.*;
classe TheClass
public static void main (string [] args)
flutuar x = -7.5f;
flutuar y = +7.5f;
flutuar z = matemática.max (x, y);
Sistema.fora.println (z);

A saída é 7.5. O seguinte programa sai -3.5, entre -7.5 e -3.5:

importar java.Lang.*;
classe TheClass
public static void main (string [] args)
flutuar x = -7.5f;
flutuar y = -3.5f;
flutuar z = matemática.max (x, y);
Sistema.fora.println (z);

A saída é -3.5 .

Se os dois números forem iguais, o resultado será o mesmo valor, como ilustrado no programa a seguir:

importar java.Lang.*;
classe TheClass
public static void main (string [] args)
flutuar x = -2.5f;
flutuar y = -2.5f;
flutuar z = matemática.max (x, y);
Sistema.fora.println (z);

A saída é -2.5.

Comparando duplo/duplo

Um número duplo é semelhante a um número de flutuação, mas é mais preciso e não precisa do sufixo f.

A sintaxe é:

estático duplo max (duplo a, duplo b)

Exemplo de programa:

importar java.Lang.*;
classe TheClass
public static void main (string [] args)
duplo x = 2.5;
duplo y = 7.5;
duplo z = matemática.max (x, y);
Sistema.fora.println (z);

A saída é 7.5. A matemática da classe está no java.Lang.* pacote. No método max (), x ou y pode ser digitado primeiro. O seguinte programa produz 7.5, entre -7.5 e +7.5:

importar java.Lang.*;
classe TheClass
public static void main (string [] args)
duplo x = -7.5;
duplo y = +7.5;
duplo z = matemática.max (x, y);
Sistema.fora.println (z);

A saída é 7.5 para +7.5. O seguinte programa sai -3.5, entre -7.5 e -3.5:

importar java.Lang.*;
classe TheClass
public static void main (string [] args)
duplo x = -7.5;
duplo y = -3.5;
duplo z = matemática.max (x, y);
Sistema.fora.println (z);

A saída é -3.5 .

Se os dois números forem iguais, o resultado será o mesmo valor, como ilustrado no programa a seguir:

importar java.Lang.*;
classe TheClass
public static void main (string [] args)
duplo x = 2.5;
duplo y = 2.5;
duplo z = matemática.max (x, y);
Sistema.fora.println (z);

A saída é 2.5.

Número de tipos diferentes

Longo e int podem ser comparados. No entanto, o resultado de qualquer outra combinação não é confiável, especialmente se os números estiverem próximos. A comparação a seguir entre INT e Long ocorre sem nenhum problema, e o resultado é válido:

importar java.Lang.*;
classe TheClass
public static void main (string [] args)
int x = 15;
longo y = 14;
Longo Z = Matemática.max (x, y);
Sistema.fora.println (z);

A saída é 15. Nesse tipo de comparação, o resultado (retorno) deve ser um tipo longo.

O programa a seguir compara um INT e um duplo sem sequer uma mensagem de aviso:

importar java.Lang.*;
classe TheClass
public static void main (string [] args)
int x = 8;
duplo y = 2.5;
duplo z = matemática.max (x, y);
Sistema.fora.println (z);

A saída é 8.0. O int 8 foi convertido para um flutuador 8.0. Embora nenhuma mensagem de aviso tenha sido dada, ainda não é aconselhável misturar tipos, exceto Int e Long. Os tipos não devem ser misturados, para comparação, porque um flutuador ou um duplo dificilmente é representado exatamente.

Conclusão

Java Math.O método estático max () compara números do mesmo tipo; e retorna o número maior. Se os números forem iguais, o mesmo número será retornado. Os tipos não devem ser misturados em comparação, exceto Int e Long.