min(float a, float b)
min(float a, float b) – Retorna o menor dos dois valores flutuantes.
public static float min(float a, float b) – Retorna o menor dos dois valores flutuantes. Ou seja, o resultado é o valor mais próximo do infinito negativo. Se os argumentos tiverem o mesmo valor, o resultado será esse mesmo valor. Se um dos valores for NaN, o resultado será NaN. Diferentemente dos operadores de comparação numérica, esse método considera que o zero negativo é estritamente menor que o zero positivo. Se um argumento é zero positivo e o outro é zero negativo, o resultado é zero negativo.
Parâmetros:
a – um argumento.
b – outro argumento.
Retornos:
o menor de a e b.
Fonte do código: https://javatutorialhq.com/java/lang/float-class-tutorial/min-method-example/
package com.javatutorialhq.java.examples;
import java.util.Scanner;
import static java.lang.System.*;
/*
* This example source code demonstrates the use of
* min(float a, float b) method of Float class.
*/
public class FloatMinExample {
public static void main(String[] args) {
// Ask user input for first number
System.out.print("Enter First Number:");
// declare the scanner object
Scanner scan = new Scanner(System.in);
// use scanner to get value from user console
Float f1 = scan.nextFloat();
// Ask user input for second number
System.out.print("Enter Second Number:");
Float f2 = scan.nextFloat();
// close the scanner object
scan.close();
// get the lowest number between the two input
Float result = Float.min(f1, f2);
System.out.println("The lowest number is: "+result);
}
}
min(int a, int b)
min(int a, int b) – Retorna o menor dos dois valores int.
public static int min(int a, int b) – Retorna o menor dos dois valores int. Ou seja, o resultado é o argumento mais próximo do valor de Integer.MIN_VALUE. Se os argumentos tiverem o mesmo valor, o resultado será esse mesmo valor.
Parâmetros:
a – um argumento.
b – outro argumento.
Retornos:
o menor de a e b.
Código fonte: https://www.tutorialspoint.com/java/lang/math_min_int.htm
package com.tutorialspoint;
import java.lang.*;
public class MathDemo {
public static void main(String[] args) {
// get two int numbers
int x = 9875;
int y = 154;
// print the smaller number between x and y
System.out.println("Math.min(" + x + "," + y + ")=" + Math.min(x, y));
}
}
min(long a, long b)
min(long a, long b) – Retorna o menor dos dois valores longos.
public static long min(long a, long b) – Retorna o menor dos dois valores longos. Ou seja, o resultado é o argumento mais próximo do valor de Long.MIN_VALUE. Se os argumentos tiverem o mesmo valor, o resultado será esse mesmo valor.
Parâmetros:
a – um argumento.
b – outro argumento.
Retornos:
o menor de a e b.
Código fonte: https://javatutorialhq.com/java/lang/long-class-tutorial/min-method-example/
package com.javatutorialhq.java.examples;
import java.util.Scanner;
/*
* This example source code demonstrates the use of
* min(long a, long b) method of Long class
*/
public class LongMinExample {
public static void main(String[] args) {
// Ask for user input
System.out.print("Enter a value:");
// declare a scanner object to read the user input
Scanner s = new Scanner(System.in);
// get the first value
long firstValue = s.nextLong();
// ask for another input
System.out.print("Enter another value:");
// get the second value
long secondValue = s.nextLong();
// get the smallest of two long values
Long result = Long.min(firstValue,secondValue);
// print the result
System.out.println("Result:" + result);
// close the scanner object
s.close();
}
}
multiplyExact(int x, int y)
public static int multiplyExact(int x, int y) – Retorna o produto dos argumentos, lançando uma exceção se o resultado exceder um valor int.
Parâmetros:
x – o primeiro valor
y – o segundo valor
Retornos:
o resultado
Lançamentos:
ArithmeticException – se o resultado exceder um valor int
Esse método existe desde a versão 1.8.
Fonte do código: https://www.geeksforgeeks.org/java-multiplyexact-math/
// Java program to demonstrate working
// of java.lang.Math.multiplyExact() method
import java.lang.Math;
class Gfg2 {
// driver code
public static void main(String args[])
{
int x = Integer.MAX_VALUE;
int y = 2;
System.out.println(Math.multiplyExact(x, y));
}
}
multiplyExact(long x, int y)
multiplyExact(long x, int y) – Retorna o produto dos argumentos, lançando uma exceção se o resultado exceder um tempo.
public static long multiplyExact(long x, int y) – Retorna o produto dos argumentos, lançando uma exceção se o resultado exceder um tempo.
Parâmetros:
x – o primeiro valor
y – o segundo valor
Retornos:
o resultado
Lançamentos:
ArithmeticException – se o resultado exceder um longo
Esse método existe desde a versão 9.
Fonte do código: https://www.tutorialandexample.com/java-math-multiplyexact-method/
public class JavaMathMultiplyExactExample2 {
public static void main(String[] args) {
long a = 0;
int b= 6;
//returns zero if either argument is zero
System.out.println("Product of "+a+" and "+ b+ " is :
"+Math.multiplyExact(a,b));
}
}
multiplyExact(long x, long y)
multiplyExact(long x, long y) – Retorna o produto dos argumentos, lançando uma exceção se o resultado exceder um tempo.
public static long multiplyExact(long x, long y) – Retorna o produto dos argumentos, lançando uma exceção se o resultado exceder um tempo.
Parâmetros:
x – o primeiro valor
y – o segundo valor
Retornos:
o resultado
Lançamentos:
ArithmeticException – se o resultado exceder um longo
Esse método existe desde a versão 1.8.
Fonte do código: https://www.tutorialandexample.com/java-math-multiplyexact-method/
public class JavaMathMultiplyExactExample4 {
public static void main(String[] args) {
long a = Long.MAX_VALUE;
long b= Long.MIN_VALUE;
// throws ArithmeticException, if the result overflows a long.
System.out.println("Product of "+a+" and "+ b+ " is :
"+Math.multiplyExact(a,b));
}
}
multiplyFull(int x, int y)
multiplyFull(int x, int y) – Retorna o produto matemático exato dos argumentos.
public static long multiplyFull(int x, int y) – Retorna o produto matemático exato dos argumentos.
Parâmetros:
x – o primeiro valor
y – o segundo valor
Retornos:
o resultado
Esse método existe desde a versão 9.
Fonte do código: https://www.geeksforgeeks.org/strictmath-multiplyfull-method-in-java-with-examples/
// Java program to demonstrate
// multiplyFull() method of StrictMath class
public class GFG {
// Main method
public static void main(String[] args)
{
// two Integer values
int a = Integer.MAX_VALUE;
int b = Integer.MAX_VALUE;
// apply multiplyFull method
long c = StrictMath.multiplyFull(a, b);
// print result
System.out.println(a + " * "
+ b + " = " + c);
}
}
multiplyHigh(long x, long y)
multiplyHigh(long x, long y) – Retorna os 64 bits mais significativos do produto de 128 bits, com dois fatores de 64 bits.
public static long multiplyHigh(long x, long y) – Retorna os 64 bits mais significativos do produto de 128 bits, com dois fatores de 64 bits.
Parâmetros:
x – o primeiro valor
y – o segundo valor
Retornos:
o resultado
Esse método existe desde a versão 9.
Esse método existe desde a versão: https://www.geeksforgeeks.org/strictmath-multiplyhigh-method-in-java-with-examples/
// Java program to demonstrate
// multiplyHigh() method of StrictMath class
public class GFG {
// Main method
public static void main(String[] args)
{
// two long values
long a = 45267356745l, b = 45676556735l;
// apply multiplyHigh method
long c = StrictMath.multiplyHigh(a, b);
// print result
System.out.println(a + " * "
+ b + " = "
+ c);
}
}
negateExact(int a)
negateExact(int a) – Retorna a negação do argumento, lançando uma exceção se o resultado exceder um valor int.
public static int negateExact(int a) – Retorna a negação do argumento, lançando uma exceção se o resultado exceder um valor int. O estouro ocorre apenas para o valor mínimo.
Parâmetros:
a – o valor a negar
Retornos:
o resultado
Lançamentos:
ArithmeticException – se o resultado exceder um valor int
Esse método existe desde a versão 1.8.
Fonte do código: https://www.geeksforgeeks.org/java-math-negateexact-method/
// Java program to demonstrate working
// of java.lang.Math.negateExact() method
import java.lang.Math;
class Gfg1 {
// driver code
public static void main(String args[])
{
int y = 10;
System.out.println(Math.negateExact(y));
int x = -12;
System.out.println(Math.negateExact(x));
}
}
Fonte: https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/Math.html
Deixe um comentário