Que signifie % en Java

En Java, "%" signifie reste. C'est un opérateur arithmétique binaire qui peut effectuer des opérations de division et obtenir le reste. La syntaxe est "opérande 1 % opérande 2". L'opérande de l'opérateur reste "%" est généralement un entier positif ou un nombre négatif ou même un nombre à virgule flottante. Si un nombre négatif participe à cette opération, le résultat dépend si le nombre précédent est positif ou négatif.

L'environnement d'exploitation de ce tutoriel : système windows7, version java8, ordinateur DELL G3.

% en Java signifie reste C'est un opérateur arithmétique qui peut implémenter des opérations de reste, effectuer des opérations de division et obtenir le reste.

L'opérateur reste est %, qui est un opérateur binaire. Son opérande est généralement un entier positif ou un nombre négatif ou même un nombre à virgule flottante. Si un nombre négatif participe à cette opération, le résultat dépend si le nombre précédent est. nombre positif ou négatif.

Pour les entiers, les règles de fonctionnement du reste de Java sont les suivantes

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

S'il y a des nombres à virgule flottante dans l'opérande, les règles adoptées sont

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

Connaissances approfondies :

Les opérateurs arithmétiques en Java sont principalement utilisés pour organisation Les opérations arithmétiques sur des données numériques peuvent être divisées en opérateurs unaires et opérateurs binaires selon les différents opérandes impliqués dans l'opération.

Opérateurs unaires

Il existe 3 opérations arithmétiques unaires, à savoir -, ++ et --. Voir le tableau 1 pour des instructions spécifiques.

Tableau 1 Opérations arithmétiques unaires

Opérateur	Nom	Description	Exemple
-	Signe de négation	Opération de négation	b =-a
++	Soi -incrémenter de un	Prendre d'abord la valeur puis en ajouter une, ou en ajouter une d'abord puis prendre la valeur	a++ ou ++a
--	Auto-décrémentation de un	Prendre d'abord la valeur puis soustrayez-en un, ou soustrayez d'abord Prenez à plusieurs reprises la valeur	a-- ou --a

Dans le tableau 1, -a est l'opération d'inversion de a, et a++ ou a-- consiste à ajouter ou à soustraire un à a une fois l’opération d’expression terminée. Et ++a ou --a ajoute ou soustrait d'abord un à a, puis effectue l'opération d'expression.

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

La deuxième ligne du code ci-dessus est -a, qui inverse la variable a, et le résultat est -12. La quatrième ligne de code consiste à attribuer d'abord a à la variable b, puis à en ajouter une, c'est-à-dire à attribuer d'abord la valeur, puis ++, le résultat de sortie est donc 12. La 6ème ligne de code ajoute un à a, puis affecte a à la variable b, c'est-à-dire ++ d'abord, puis l'affectation, le résultat de sortie est donc 14.

Le résultat de sortie est présenté dans la figure ci-dessous :

Opérateurs binaires

La fonction des opérateurs arithmétiques en langage Java est d'effectuer des opérations arithmétiques, en plus de l'addition (+), de la soustraction ( -), et la multiplication (*) et en plus de (), il y a aussi l'opération modulo (%). L'addition (+), la soustraction (-), la multiplication (*), la division () ont la même signification que les opérations mathématiques avec lesquelles nous sommes habituellement en contact. Voir le tableau 2 pour des instructions spécifiques.

Tableau 2 Opérations arithmétiques binaires

Opérateur	Nom	Description	Exemple
+	Ajouter	Pour trouver la somme de a plus b, il peut également être utilisé pour String tapez pour effectuer des opérations sur les chaînes Opération de connexion	a + b
-	moins	Trouver la différence de a moins b	a - b
*	multiplier	Trouver le produit de a fois b	a * b
/	divide	Trouver le quotient de a divisé par b	a / b
%	Prendre le reste	Trouver le reste de un divisé par 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 的运算。

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!