Java包含一组内置的数学运算符，用于对Java变量执行简单的数学运算。 Java数学运算符相当简单。因此，Java也包含Java Math类，该类包含用于在Java中执行更高级的数学计算的方法。该Java数学教程将更详细地介绍Java的数学运算符以及Java Math类。

Java数学运算符

首先让我向我们介绍Java中的四个基本数学运算符。 Java数学运算符为：

在以下各节中，将对这些数学运算符中的每一个进行更详细的说明。

加法

" +"运算符执行两个值的加法运算。这可以是两个常数的加法，一个常数和一个变量，或者一个变量和一个变量。以下是一些Java添加示例：

int sum1 = 10 + 20;      // adding two constant values
int sum2 = sum1 + 33;    // adding a variable and a constant
int sum3 = sum2 + sum2;  // adding two variables

" +"运算符将在运行时将两个值替换为两个值的总和。因此，在写入表达式" sum1 + 33"的地方，在运行时将其替换为" sum1"的值与常数" 33"的和。

当然，我们可以创建更长的加法链，从而添加两个以上的数字。这是一个将3个或者更多值加在一起的示例：

int sum1 = 10 + 20 + 30;
int sum3 = sum2 + 99 + 123 + 1191;

对变量的常用数学运算是将变量设置为等于其自己的值加上另一个值。看起来是这样的：

int result = 10;
result = result + 20;

此示例的第二行将sum变量设置为等于其自己的值(在分配新值之前)+20。这意味着10 + 20。

由于将值添加到变量是非常常见的操作，因此Java包含用于该特定目的的内置运算符。它是+ =运算符。这是上面的示例，改写为使用+ =运算符：

int result = 10;
result += 20;

本例中的第二行将20加到变量result中。这相当于代码"结果=结果+ 20;"。

减法

操作员从另一个值中减去一个值。这可以是从另一个常量值中减去一个常量值，从一个变量中减去一个常量值，或者从一个变量中减去一个变量。以下是一些Java减法示例：

int diff1 = 200 - 10;
int diff2 = diff1 - 5;
int diff3 = diff1 - diff2;

就像+运算符一样，-运算符将用两个值之间的差替换这两个值。

我们可以创建更长的减法链，从而彼此减去更多的值。这是在单个Java语句中从另一个值中减去两个值的示例：

int diff = 200 - 10 - 20;

这也适用于变量。

请记住，正负号等于加号，就像正常的数学运算一样。这是一个例子：

int diff = 200 - (-10);

执行此数学表达式后，diff变量将包含值210，因为根据标准数学规则，(-10)等于+10.

就像加法一样，Java包含一个运算符，专门用于从变量中减去一个值，并将结果分配给该变量。首先是没有此运算符的情况在Java中的外观：

int result = 200;
result = result - 10;

这是使用-=运算符的相同数学运算的样子：

int result = 200;
result -= 10;

乘法

" *"运算符执行两个值的乘法运算。这些值可以是两个常数值，一个变量和一个常数值，也可以是两个变量。以下是一些Java乘法示例：

int prod1 = 10 * 20;
int prod2 = prod1 * 5;
int prod3 = prod1 * prod2;

" *"运算符将在运行时用两个值的乘积替换乘法数学表达式。

我们可以使用\*运算符来创建更长的乘法链。这是一个将3个值彼此相乘的示例：

int prod = 10 * 20 * 30;

将变量与值相乘并将值分配回该变量是Java应用程序中的常见数学运算。因此，Java包含此操作的显式运算符。 \* =运算符。首先是没有\* =运算符时的计算结果：

int result = 10;
result = result * 20;

此示例的第二行将result变量的值(在被分配此计算的结果之前)乘以20，然后将该值分配回result变量。

这是使用++运算符时相同的数学运算的外观：

int result = 10;
result *= 20;

除法

" /"运算符将一个值除以另一个。这可以是用一个常数除以另一个常数，用一个常数除以一个变量，或者用一个变量除以另一个变量。以下是一些Java部门示例：

int division1 = 100 / 10;
int division2 = division1 / 2;
int division3 = division1 / division2;

我们可以链接多个值进行除法，但是由于Java数学运算符的优先级(稍后说明)，我们必须注意如何链接值。看一下这个划分示例：

int division = 100 / 10 / 2;

执行完该数学表达式后，"除法"变量将包含值5. 这是因为数学表达式是通过先将100除以10(= 10)然后再除以10除以2(= 5)而得出的。但是，如果我们想先将10除以2(= 5)，然后再将100除以5(= 20)，该怎么办？我们将不得不使用括号来实现这一点，如下所示：

int division = 100 / (10 / 2)

稍后，我们将在此Java数学教程中了解有关运算符优先级和括号的更多信息。

Java还包含一个快捷方式运算符，用于将变量的值除以另一个值，然后将该值分配回该变量。 / =运算符。首先是没有/ =运算符的数学运算在Java中的外观：

int result = 100;
result = result / 5;

此示例的第二行将result变量的值(在分配此计算结果之前的值)除以5，然后将结果分配回result变量。

这是使用/ =运算符的相同数学运算的样子：

int result = 100;
result /= 5;

余数/模数

余数运算将一个值除以另一个后的整数，然后返回该除法的余数。余数运算也称为模运算。余数/模运算的运算符是"％"(百分比)字符。这是一个模块操作示例：

int value    = 100;
int remainder = value % 9;

100除以9就是11，其余为1(11乘以9就是99)。因此，" remainder"变量被赋值为1.

Java还包含一个快捷方式运算符，用于将变量除以另一个值并将该除法的其余部分分配给该变量。 ％=运算符。这是一个例子：

int result = 100;
result %= 9;

此示例的第二行将为结果变量赋值1. 1是100％9的结果。

Java数学运算符优先级

一旦开始将Java数学运算符组合到数学表达式中，为了获得所需的结果，控制何时执行什么计算就变得很重要。 Java数学运算符的自然运算符优先级与标准数学运算符的优先级相似。

用于乘法和除法的数学运算符\*和/优先于+和-运算符。这意味着，在数学表达式中进行加法和减法之前，先对乘法和除法求值。如果有多个\*和/运算符，它们将从左到右计算。看一下这个Java数学表达式：

int result = 100 * 100 / 5 + 200 * 3 / 2;

首先执行乘法和除法。有两组，每组三个乘法和除法。每个组从左到右执行：

100 * 100 = 10000;
10000 / 5 = 2000;

200 * 3 = 600;
600 / 2 = 300;

计算完乘法和除法运算后，数学表达式如下所示：

int result = 2000 + 600;

现在执行加法和减法。因此，分配给result变量的值是2000 + 600 = 2600。

我们可以使用括号来控制Java中数学表达式中的运算符优先级和计算顺序。括号内的数学表达式的优先级高于任何其他运算符。因此，首先要计算括号内的表达式。在括号内使用普通运算符优先级。这是前面的数学表达式，但是插入了括号，这会改变计算：

int result = 100 * 100 / (5 + 200) * 3 / 2;

值100仍然乘以100(= 10,000)，但是现在将其除以5 + 200(= 205)而不是5. 除法之后，结果乘以3，然后除以2. Java中的数学表达式为72(计算的舍入会影响结果)。

Java整数数学

在Java整数类型(" byte"，" short"，" int"和" long")上执行的数学运算与普通数学运算的工作方式略有不同。由于Java整数类型不能包含分数，因此涉及一个或者多个整数类型的每次计算都将结果中的所有分数都截断。看一下这个数学表达式：

int result = 100 / 8;

该除法的结果将为12.5，但是由于两个数字均为整数，所以将截断.5分数。因此，结果仅为12.

四舍五入也发生在较大计算的子结果中，如我们将在下一节中了解Java浮点数学的内容。

Java浮点数学

Java包含两个浮点数据类型" float"和" double"。这些浮点类型能够包含数字中的分数。如果我们需要数学表达式中的分数，则应使用以下数据类型之一。这是一个Java浮点数学表达式示例：

double result = 100 / 8;

即使result变量现在是浮点类型(double)，最终结果仍然只是12而不是12.5. 这是因为数学表达式中的两个值(100和8)都是整数。因此，将一个除以另一个的结果首先转换为整数(12)，然后再分配给result变量。

为避免Java中的数学表达式中的计算四舍五入，必须确保数学表达式中涉及的所有数据类型均为浮点类型。例如，我们可以首先将值分配给浮点变量，如下所示：

double no1 = 100;
double no2 = 8;

double result = no1 / no2;

现在，result变量将以12.5结束。

Java有一种方法可以强制计算中的所有数字均为浮点变量。我们可以在数字后加上大写字母F或者D。这是一个示例：

double result = 100D / 8D;

注意每个数字后面的大写字母Ds。该大写字母D告诉Java，这些数字将被解释为浮点数，因此该除法应被认为是一个浮点除法，该分数保留分数而不是将其截断。

实际上，我们也可以通过在数字后加上大写字母L来强制数字为"长整数"，但是"长整数"仍然是整数类型，因此仍不会在计算中保留分数。

浮点精度

Java浮点数据类型不是100％精确的。我们可能会遇到这样的情况，其中包含很多小数的数字加起来不会等于我们期望的数字。如果浮点计算得出的数字的分数大于" float"或者" double"所能处理的分数，则分数可能会被切除。当然，对于许多类型的计算，给定的精度可能仍然绰绰有余，但是请记住，分数实际上可能会被截断。

查看以下Java浮点数学代码：

double resultDbl3 = 0D;
System.out.println("resultDbl3 = " + resultDbl3);

for(int i=0; i<100; i++){
    resultDbl3 += 0.01D;
}
System.out.println("resultDbl3 = " + resultDbl3);

使用Java 8执行此代码时输出的输出为：

resultDbl3 = 0.0
resultDbl3 = 1.0000000000000007

第一个System.out.println()语句正确输出值0.0，它是resultDbl3变量的起始值。

然而，第二个System.out.println()语句会打印出一些奇怪的结果。将0.01值与0相加共100次应得出1.0，对吗？但是不知何故，最终结果是1.0000000000000007。正如我们所看到的，某些方面在某些方面出了点问题。

通常，Java浮点数的不精确性微不足道，但要意识到这一点仍然很重要。

Java Math类

与基本Java数学运算符所提供的函数相比，Java Math类提供了更高级的数学计算。 " Math"类包含用于查找两个值的最大值或者最小值的方法，这些值包括舍入值，对数函数，平方根和三角函数(sin，cos，tan等)。

Math放在java.lang包中，而不在java.math包中。因此，Math类的完全限定类名是java.lang.Math。

由于Math类的许多函数是相互独立的，因此每种方法将在下面的单独部分中进行说明。

基本数学函数

" java.lang.Math"包含一组基本数学函数，用于获取绝对值，两个值的最高和最低值，取整值，随机值等。将覆盖JavaMath类的这些基本数学函数在以下各节中。

Math.abs()

Math.abs()函数返回传递给它的参数的绝对值。绝对值是参数的正值。如果参数值为负，则删除负号，并返回与没有符号的负值相对应的正值。这是两个Math.abs()方法示例：

int abs1 = Math.abs(10);  // abs1 = 10

int abs2 = Math.abs(-20); // abs2 = 20

10的绝对值为10. -20的绝对值为20。

Math.abs()方法在4个版本中已重载：

Math.abs(int)
Math.abs(long)
Math.abs(float)
Math.abs(double)

调用这些方法中的哪一个取决于传递给Math.abs()方法的参数的类型。

Math.ceil()

Math.ceil()函数将浮点值四舍五入到最接近的整数值。舍入后的值将以" double"形式返回。这是一个Math.ceil()Java示例：

double ceil = Math.ceil(7.343);  // ceil = 8.0

执行完此Java代码后，变量" ceil"将包含值" 8.0"。

Math.floor()

Math.floor()函数将浮点值四舍五入为最接近的整数值。舍入后的值将以" double"形式返回。这是一个Math.floor()Java示例：

double floor = Math.floor(7.343);  // floor = 7.0

执行完此Java代码后，变量" ceil"将包含值" 8.0"。

Math.floorDiv()

Math.floorDiv()方法将一个整数(" int"或者" long")除以另一个，然后将结果四舍五入为最接近的整数值。如果结果是肯定的，则效果与使用本文前面所述的Java/除法运算符相同。

但是，如果结果为负，则结果不相同。使用/除法运算符，分数被简单地截断。对于正数，这对应于四舍五入。对于负数，截短分数对应于四舍五入。 floorDiv()方法向下舍入为最接近的负整数，而不是小数截断时会发生的舍入。

这是一个Math.floorDiv()Java示例：

double result3 = Math.floorDiv(-100,9);
System.out.println("result3: " + result3);

double result4 = -100 / 9;
System.out.println("result4: " + result4);

此Java代码输出的输出是：

result3: -12.0
result4: -11.0

这表明/除法运算符和Math.floorDiv()之间的区别。

Math.min()

" Math.min()"方法返回作为参数传递给它的两个值中的最小值。这是一个Math.min()Java示例：

int min = Math.min(10, 20);

执行此代码后，" min"变量将包含值10.

Math.max()

" Math.max()"方法返回作为参数传递给它的两个值中的最大值。这是一个Math.max()Java示例：

int max = Math.max(10, 20);

执行此代码后，" max"变量将包含值20。

Math.round()

" Math.round()"方法使用正常的数学舍入规则(向上或者向下)将" float"或者" double"四舍五入到最接近的整数。这是一个JavaMath.round()示例：

double roundedDown = Math.round(23.445);
double roundedUp   = Math.round(23.545);

执行完这两个Java语句后，roundedDown变量将包含值23.0，而roundedUp变量将包含值24.0。

Math.random()

" Math.random()"方法返回一个介于0到1之间的随机浮点数。当然，该数字不是完全随机的，而是一些计算的结果，该计算被认为使其尽可能不可预测。这是一个JavaMath.random()示例：

double random = Math.random();

为了获得一个介于0到0之间的随机值，例如100，将Math.random()返回的值乘以最大值(例如100)。这是看起来的示例：

double random = Math.random() * 100D;

如果我们需要整数值，请使用round()，floor()或者ceil()方法。

指数和对数数学函数

JavaMath类还包含一组用于指数和对数计算的函数。我将在以下各节中介绍其中一些数学函数。

Math.exp()

" Math.exp()"函数返回e(欧拉数)，该数字升为作为参数提供的值的幂。这是一个Java Math.exp()示例：

double exp1 = Math.exp(1);
System.out.println("exp1 = " + exp1);

double exp2 = Math.exp(2);
System.out.println("exp2 = " + exp2);

执行此Java数学代码后，将输出以下输出：

exp1 = 2.718281828459045
exp2 = 7.38905609893065

Math.log()

Math.log()方法提供给定参数的对数。对数的底数是i(欧拉数)。因此，Math.log()提供了与Math.exp()相反的函数。这是一个JavaMath.log()示例：

double log1  = Math.log(1);
System.out.println("log1 = " + log1);

double log10 = Math.log(10);
System.out.println("log10 = " + log10);

这个Math.log()示例的输出是：

log1 = 0.0
log10 = 2.302585092994046

Math.log10()

" Math.log10"方法的工作方式与" Math.log()"方法类似，不同之处在于它使用10作为计算对数的基础，而不是e(欧拉数)。这是一个Math.log10()Java示例：

double log10_1   = Math.log10(1);
System.out.println("log10_1 = " + log10_1);

double log10_100 = Math.log10(100);
System.out.println("log10_100 = " + log10_100);

这个JavaMath.log10()示例输出的输出为：

log10_1 = 0.0
log10_100 = 2.0

Math.pow()

Math.pow()函数带有两个参数。该方法将第一个参数的值提高为第二个参数的幂。这是一个Math.pow()Java示例：

double pow2 = Math.pow(2,2);
System.out.println("pow2 = " + pow2);

double pow8 = Math.pow(2,8);
System.out.println("pow8 = " + pow8);

这个Math.pow()示例的输出为：

pow2 = 4.0
pow8 = 256.0

换句话说，" Math.pow()"示例将计算22和2" 8"的值，即4和256.

Math.sqrt()

" Math.sqrt()"方法计算给定参数的平方根。这是一些JavaMath.sqrt()示例：

double sqrt4 = Math.sqrt(4);
System.out.println("sqrt4 = " + sqrt4);

double sqrt9 = Math.sqrt(9);
System.out.println("sqrt9 = " + sqrt9);

这些JavaMath.sqrt()示例输出的输出为：

sqrt4 = 2.0
sqrt9 = 3.0

三角数学函数

JavaMath类包含一组三角函数。这些函数可以计算三角函数中使用的值，例如正弦，余弦，正切等。在以下各节中，我将介绍最常用的三角函数。如果我们正在寻找三角函数，但在此处找不到它，请检查JavaDoc中的JavaMath类。即使我在这里没有描述，Math类也可能具有我们要查找的函数。

数学PI

" Math.PI"常量是一个" double"，其值非常接近PI的数学定义PI的值。进行三角计算时，通常需要使用" Math.PI"字段。

Math.sin()

Math.sin()方法以弧度计算某个角度值的正弦值。这是一个JavaMath.sin()示例：

double sin = Math.sin(Math.PI);
System.out.println("sin = " + sin);

Math.cos()

Math.cos()方法计算以弧度为单位的某个角度值的余弦值。这是一个JavaMath.cos()示例：

double cos = Math.cos(Math.PI);
System.out.println("cos = " + cos);

Math.tan()

" Math.tan()"方法计算以弧度为单位的某个角度值的正切值。这是一个JavaMath.tan()示例：

double tan = Math.tan(Math.PI);
System.out.println("tan = " + tan);

Math.asin()

" Math.asin()"方法计算介于1到-1之间的反正弦值。这是一个JavaMath.asin()示例：

double asin = Math.asin(1.0);
System.out.println("asin = " + asin);

Math.acos()

" Math.acos()"方法计算介于1到-1之间的反余弦值。这是一个JavaMath.acos()示例：

double acos = Math.acos(1.0);
System.out.println("acos = " + acos);

Math.atan()

" Math.atan()"方法计算介于1到-1之间的值的反正切值。这是一个JavaMath.atan()示例：

double atan = Math.atan(1.0);
System.out.println("atan = " + atan);

Math.atan2()

我不完全确定Math.atan2()方法在数学上的作用。这是JavaDoc所说的：

"从直角坐标(x，y)转换为极坐标(r，theta)返回角度theta"。

如果需要此方法，请阅读JavaDoc。但是现在我们至少知道它的存在。

Math.sinh()

Math.sinh()方法会计算介于1到-1之间的双曲正弦值。这是一个JavaMath.sinh()示例：

double sinh = Math.sinh(1.0);
System.out.println("sinh = " + sinh);

Math.cosh()

Math.cosh()方法计算介于1到-1之间的双曲余弦值。这是一个JavaMath.cosh()示例：

double cosh = Math.cosh(1.0);
System.out.println("cosh = " + cosh);

Math.tanh()

Math.tanh()方法计算介于1到-1之间的双曲正切值。这是一个JavaMath.tanh()示例：

double tanh = Math.tanh(1.0);
System.out.println("tanh = " + tanh);

Math.toDegrees()

Math.toDegrees()方法将以弧度为单位的角度转换为度。这是一个JavaMath.toDegrees()示例：

double degrees = Math.toDegrees(Math.PI);
System.out.println("degrees = " + degrees);

Math.toRadians()

Math.toRadians()方法将以度为单位的角度转换为弧度。这是一个JavaMath.toRadians()示例：

double radians = Math.toRadians(180);
System.out.println("radians = " + radians);