Java Math Class: java.lang.Math

Use 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 Java we 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.

Tip: Using these included constants results in much clearer code—and no mistakes in the value of 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.

So: In a computation where overflow would be disastrous, these methods help check that the program is correct.

Part 1: Here we call the "exact" methods with 1 or 2 arguments. We store the results of the methods in locals.

Part 2: We display the results of all the method invocations. For the "addExact" method, 1 + 1 equals 2.

Part 3: We call multiplyExact with 2 arguments that will cause an overflow. An exception is thrown, and printed to the console.

Java program that uses addExact, exact methods import java.lang.Math; public class Program { public static void main(String[] args) { // Part 1: 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); // Part 2: display our results. System.out.println(result1 + " " + result2 + " " + result3 + " " + result4 + " " + result5 + " " + result6 + " " + result7); // Part 3: 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.

Example: The value 100 can be stored in an int, so the first toIntExact call succeeds. But Long.MAX_VALUE cannot be stored in an int.

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

Ceiling: The ceiling of 4.1 is 5. With Math.ceil in Java we compute the ceiling function for floating-point numbers.

Math.ceil

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.

The Dev Codes

.Net

.NET Array Dictionary List String 2D Async DataTable Dates DateTime Enum File For Foreach Format IEnumerable If IndexOf Lambda LINQ Parse Path Process Property Regex Replace Sort Split Static StringBuilder Substring Switch Tuple

Java

Core Array ArrayList HashMap String 2D Cast Character Console Deque Duplicates File For Format HashSet If IndexOf Lambda Math ParseInt Process Random Regex Replace Sort Split StringBuilder Substring Switch Vector While

TheDeveloperBlog.com

Java Math Class: java.lang.Math

Related Links:

.Net

Java

Related Links