A Classe Math Parte 7

Table of Contents

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);
		
	}

}

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));
   }
}

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();

	}
	
}

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)); 
    } 
}

// 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));
    }
}

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));
    }
}

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); 
    } 
}

// 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); 
    } 
}

// 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)); 
    } 
}

// 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

min(float a, float b)

min(int a, int b)

min(long a, long b)

multiplyExact(int x, int y)

multiplyExact(long x, int y)

multiplyExact(long x, long y)

multiplyFull(int x, int y)

multiplyHigh(long x, long y)

negateExact(int a)

Saídas Formatadas

Aprendendo Linguagem de Programação

Variáveis do Tipo Texto e Lógico

Para enviar seu comentário, preencha os campos abaixo:

Deixe um comentário Cancelar resposta

Seja o primeiro a comentar!

Damos valor à sua privacidade

Cookies estritamente necessários

Cookies de desempenho

Cookies de funcionalidade

Cookies de publicidade

min​(float a, float b)

min​(int a, int b)

min​(long a, long b)

multiplyExact​(int x, int y)

multiplyExact​(long x, int y)

multiplyExact​(long x, long y)

multiplyFull​(int x, int y)

multiplyHigh​(long x, long y)

negateExact​(int a)

Saídas Formatadas

Aprendendo Linguagem de Programação

Variáveis do Tipo Texto e Lógico

Para enviar seu comentário, preencha os campos abaixo:

Deixe um comentário Cancelar resposta

Seja o primeiro a comentar!

Damos valor à sua privacidade

Cookies estritamente necessários

Cookies de desempenho

Cookies de funcionalidade

Cookies de publicidade

min(float a, float b)

min(int a, int b)

min(long a, long b)

multiplyExact(int x, int y)

multiplyExact(long x, int y)

multiplyExact(long x, long y)

multiplyFull(int x, int y)

multiplyHigh(long x, long y)

negateExact(int a)