Was bedeutet % in Java?

In Java bedeutet „%“ Rest. Es handelt sich um einen binären arithmetischen Operator, der Divisionsoperationen durchführen und den Rest ermitteln kann. Der Operand des Restoperators „%“ ist normalerweise eine positive ganze Zahl oder eine negative Zahl oder sogar eine Gleitkommazahl. Wenn eine negative Zahl an dieser Operation beteiligt ist, hängt das Ergebnis davon ab, ob die vorherige Zahl positiv oder negativ ist.

Die Betriebsumgebung dieses Tutorials: Windows7-System, Java8-Version, DELL G3-Computer.

% bedeutet in Java Rest Es handelt sich um einen arithmetischen Operator, der Restoperationen implementieren, Divisionsoperationen durchführen und den Rest ermitteln kann.

Der Restoperator ist %, ein binärer Operator. Sein Operand ist normalerweise eine positive ganze Zahl oder eine negative Zahl oder sogar eine Gleitkommazahl. Wenn an dieser Operation eine negative Zahl beteiligt ist, hängt das Ergebnis davon ab, ob die vorherige Zahl vorhanden ist positive oder negative Zahl.

Für Ganzzahlen lauten die Restoperationsregeln von Java wie folgt:

a%b=a-(a/b)*b 
5%3=5-(5/3)*3=2 
5%-3=5-(5/-3)*-3=2 
-5%3=-5-(-5/3)*3=-2 
-5%-3=-5-(-5/-3)*-3=-2

Wenn der Operand Gleitkommazahlen enthält, gelten folgende Regeln:

a%b=a-(b*q)，这里q=int(a/b)

5.2%3.1=5.2-1*3.1=2.1 
5.2%-3.1=5.2-(-1)*(-3.1)=2.1 
-5.2%3.1=-5.1-(-1)*3.1=-2.1 
-5.2%-3.1=-5.1-(-1)*(-3.1)=-2.1

Erweiterte Kenntnisse:

Arithmetische Operatoren in Java werden hauptsächlich für verwendet Organisation Arithmetische Operationen an numerischen Daten können entsprechend den verschiedenen an der Operation beteiligten Operanden in unäre Operatoren und binäre Operatoren unterteilt werden.

Unäre Operatoren

Es gibt drei arithmetische unäre Operationen, nämlich -, ++ und --. Spezifische Anweisungen finden Sie in Tabelle 1.

Tabelle 1 Unäre arithmetische Operationen

Operator	Name	Beschreibung	Beispiel
-	Negationszeichen	Negationsoperation	b=-a
++	Selbst -Inkrementieren um eins	Nehmen Sie zuerst den Wert und addieren Sie dann eins, oder addieren Sie zuerst eins und nehmen Sie dann den Wert	a++ oder ++a
--	Selbstdekrementieren um eins	Nehmen Sie zuerst den Wert und dann eins subtrahieren oder zuerst subtrahieren Nehmen Sie wiederholt den Wert	a-- oder --a

In Tabelle 1 ist -a die Umkehroperation von a und a++ oder a-- dient zum Addieren oder Subtrahieren eins zu a, nachdem die Ausdrucksoperation abgeschlossen ist. Und ++a oder --a addiert oder subtrahiert zuerst eins zu a und führt dann die Ausdrucksoperation aus.

int a = 12;
System.out.println(-a);
int b = a++;
System.out.println(b);
b = ++a;
System.out.println(b);

Die zweite Zeile des obigen Codes ist -a, wodurch die a-Variable invertiert wird und die Ergebnisausgabe -12 ist. Die vierte Codezeile besteht darin, zuerst der Variablen b a zuzuweisen und dann eins hinzuzufügen, dh zuerst den Wert und dann ++ zuzuweisen, sodass das Ausgabeergebnis 12 ist. Die sechste Codezeile fügt eins zu a hinzu und weist dann a der b-Variablen zu, dh zuerst ++ und dann die Zuweisung, sodass das Ausgabeergebnis 14 ist.

Das Ausgabeergebnis ist in der folgenden Abbildung dargestellt:

Binärer Operator

Die Funktion arithmetischer Operatoren in der Java-Sprache besteht darin, zusätzlich zu den häufig verwendeten Additionen (+) und Subtraktionen arithmetische Operationen auszuführen ( -) und Multiplikation (*) und zusätzlich zu () gibt es auch die Modulo-Operation (%). Addition (+), Subtraktion (-), Multiplikation (*) und Division () haben dieselbe Bedeutung wie die mathematischen Operationen, mit denen wir normalerweise in Berührung kommen. Spezifische Anweisungen finden Sie in Tabelle 2.

Tabelle 2 Binäre arithmetische Operationen

Operator	Name	Beschreibung	Beispiel
+	Hinzufügen	Um die Summe von a plus b zu ermitteln, kann es auch verwendet werden für String-Typ bis String-Operationen durchführen Verbindungsoperation	a + b
-	minus	Finden Sie die Differenz von a minus b	a - b
*	multiplizieren Sie	Finden Sie das Produkt von a mal b	a * b
/	dividieren	Finden Sie den Quotienten von a dividiert durch b	a / b
%	Nehmen Sie den Rest	Finden Sie Rest eines geteilt durch b	a % b

算术运算符都是双目运算符，即连接两个操作数的运算符。优先级上，*、/、％ 具有相同运算级别，并高于 +、-（+、- 具有相同级别）。例如：

int a = 4, b = 2, c = 3;
int d = a * (b + c) % c;

这种运算规则与数学运算中的规则是相同的。首先计算赋值符号（=）右边配对的括号内的值，其次按从左向右的结合方向计算乘法，最后做求余运算，表达式的结果为 2， 然后把 2 赋值给 d。

例如：

• ①int x=2,y=1;表达式 y/x 的结果是 0。

• ②float x=2.0f; int y=1; 表达式 y/x 的结果是 0.5。
  

在 ① 中整型变量 x 和 y 相除，其结果仍为整型数据 0；在 ② 中由于两个不同类型的数据进行运算，此时首先要进行类型转换，会把 int 型的 y 转换成与 x 一样的 float 型，然后相除，最终结果为 float 类型的数字 0.5。

【例1】编写一个程序，输出不同类型的两个数，执行相加、相减、相乘、相除和求余后输入结果。

public static void main(String[] args) {
    float f1 = 9 % 4;// 保存取余后浮点类型的结果
    double da = 9 + 4.5; // 双精度加法
    double db = 9 - 3.0; // 双精度减法
    double dc = 9 * 2.5; // 双精度乘法
    double dd = 9 / 3.0; // 双精度除法
    double de = 9 % 4; // 双精度取余
    System.out.println("整数的算术运算"); // 整数的加、减、乘、除和取余
    System.out.printf("9+4=%d \n", 9 + 4);
    System.out.printf("9-4=%d \n", 9 - 4);
    System.out.printf("9*4=%d \n", 9 * 4);
    System.out.printf("9/4=%d \n", 9 / 4);
    System.out.printf("9%%4=%d \n", 9 % 4);
    System.out.println("\n浮点数的算术运算"); // 浮点数的加、减、乘、除和取余
    System.out.printf("9+4.5f=%f \n", 9 + 4.5f);
    System.out.printf("9-3.0f=%f \n", 9 - 3.0f);
    System.out.printf("9*2.5f=%f \n", 9 * 2.5f);
    System.out.printf("9/3.0f=%f \n", 9 / 3.0f);
    System.out.printf("9%%4=%f \n", f1);
    System.out.println("\n双精度数的算术运算"); // 双精度数的加、减、乘、除和取余
    System.out.printf("9+4.5=%4.16f \n", da);
    System.out.printf("9-3.0=%4.16f \n", db);
    System.out.printf("9*2.5=%4.16f \n", dc);
    System.out.printf("9/3.0=%4.16f \n", dd);
    System.out.printf("9%%4=%4.16f \n", de);
    System.out.println("\n字符的算术运算"); // 对字符的加法和减法
    System.out.printf("'A'+32=%d \n", 'A' + 32);
    System.out.printf("'A'+32=%c \n", 'A' + 32);
    System.out.printf("'a'-'B'=%d \n", 'a' - 'B');
}

保存文件并运行，输出的结果如下所示。

本示例中使用了 4 种类型来执行算术运算。其中，整数类型的结果最容易理解，浮点型和双精度型返回的结果都带有小数，字符型将会把字符转换为 ASCII 码再运算。

从输出结果中可以看到，整数之间的运算结果只保留整数部分，浮点型运算时保留 6 位小数部分，双精度运算时则保留 16 位小数部分。

注意：Java 语言算术运算符的优先级是先乘除后加减。例如在表达式“a-b*c”中，b 的左侧为减号，右侧为乘号，而乘号优先级高于减号，因此该表达式可以转换为“a-(b*c)”。

如果在一个表达式中的多个算术运算符的优先级别相同，例如“a-b+c”，此时将按照运算符的结合方向决定顺序。算术运算符的结合方向都是“从左至右”，即先左后右。因此 b 先与减号结合，执行“a-b”的运算，再执行加 c 的运算。

更多编程相关知识，请访问：编程教学！！

Das obige ist der detaillierte Inhalt vonWas bedeutet % in Java?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!