HomeSearch | ## Java Math Class: java.lang.MathUse the Math class, part of java.lang.Math. Call Math.floor, ceil and other methods. | |

## Math.A drop of water falls to the ground. It lands near a carved stone—this tablet is covered with mathematical works. Our world conceals many things. | ||

## In Javawe need no stone tablets—we use the Math class. It has high-quality methods. It computes simple things like absolute values, to complex ones like cube roots. | ||

## Math.E, PI.Sometimes programs need to use the E and pi constants. With the Math class, we can access these as fields. We do not need to specify 3.14 for pi.
| Java program that gets Math.E, PI
public class Program {
public static void main(String[] args) {
// Get these known constants.
double value1 = Math.E;
double value2 = Math.PI;
System.out.println(value1);
System.out.println(value2);
}
}
Output
2.718281828459045
3.141592653589793 | |

## Exact methods.The Math class provides "exact" methods. These do what we expect (add, subtract, multiply) but throw an ArithmeticException when the result overflows.
| Java program that uses addExact, exact methods
import java.lang.Math;
public class Program {
public static void main(String[] args) {
// Use exact methods.
int result1 = Math.addExact(1, 1);
int result2 = Math.addExact(100, 1);
int result3 = Math.subtractExact(100, 1);
int result4 = Math.multiplyExact(5, 4);
int result5 = Math.incrementExact(2);
int result6 = Math.decrementExact(1000);
int result7 = Math.negateExact(100);
// Display our results.
System.out.println(result1 + " " + result2 + " " + result3 + " "
+ result4 + " " + result5 + " " + result6 + " " + result7);
// An ArithmeticException is thrown if a number overflows.
try {
int invalid = Math.multiplyExact(Integer.MAX_VALUE, 100);
} catch (Exception ex) {
System.out.println(ex);
}
}
}
Output
2 101 99 20 3 999 -100
java.lang.ArithmeticException: integer overflow | |

## Math.toIntExact.The Math class has some conversion methods. Here, we use toIntExact, which converts along value to an int. The int must be able to store the long's value.
| Java program that uses Math.toIntExact
import java.lang.Math;
public class Program {
public static void main(String[] args) {
// An int can store the value 100.
long test = 100;
int result = Math.toIntExact(test);
System.out.println("INT: " + result);
// This will cause an exception, as the int cannot store the value.
test = Long.MAX_VALUE;
result = Math.toIntExact(test);
}
}
Output
INT: 100
Exception in thread "main" java.lang.ArithmeticException: integer overflow
at java.base/java.lang.Math.toIntExact(Math.java:1071)
at Program.main(Program.java:13) | |

## Abs.A number is -1. With the Math.abs method, we take its absolute value. So negative one is transformed into one. Positive numbers are left unchanged.Math.abs | ||

## Floor.When we take the floor of a number we get the nearest, lower integral value. So the floor of 4.9 is 4. We can use Math.floor, floorDiv and floorMod.Math.floor
| ||

## Square root.Imagine a square. It has an area. With the square root function, we map its area (a number) to the length of one of its sides.Math.sqrt | ||

## Math.max, min.These methods receive two numeric arguments. Math.max returns the higher of the two arguments. And Math.min returns the lower one.Math.max | ||

## Math.pow.With this method we use exponents. We can square numbers by raising a number to the power of 2. The second argument to Math.pow is the exponent.Math.pow | ||

## Random.We use the Math.random method to get a pseudo-random number. Internally this method creates a Random class instance. It makes using random numbers easier.Random | ||

## Math.round.With doubles and floats we have numbers like 10.5 and 10.9. Theses are often "rounded up" to 10. With Math.round we have an efficient way to round numbers.Math.round | ||

## Truncate.There is no Math.truncate method in Java 8. But we can create a truncate method that combines Math.ceil and Math.floor with good results for both positive and negative numbers.Truncate Number | ||

## Compound interest.We use Math.pow() to compute compound interest, which is an exponential function. Investment interest compounds at different rates (schedules).Compound Interest | ||

## With abstraction,we conceal incredible levels of complexity. This is called information hiding. With the Math class, we use declarative method calls to compute values. | ||

## As developers,we can avoid implementing this code ourselves. Instead we use prebuilt, tested, optimized methods. In most cases (not all) this approach is best. | ||

Home Dot Net Perls | © 2007-2019 Sam Allen. All rights reserved. Written by Sam Allen, info@dotnetperls.com. |