Les opérateurs arithmétiques permettent d'effectuer des calculs mathmétiques.

x = 100;
y = 1024;
z = y - x - 16;

Un opérateur arithmétique possède deux opérandes (des littéraux ou des variables), dont les valeurs sont numériques (entier ou à virgule flottante)et renvoient une valeur numérique.

Les opérateurs arithmétiques standards sont l'addition (+), la soustraction (-), la multiplication (*), et la division (/).

Opérateur	Description	Exemple
x + y	L'opérateur permet d'additionner la valeur x à la valeur y.	5 + 6'retourne 11
x - y	L'opérateur permet de soustraire la valeur y de la valeur x.	8 - 10'retourne -2
x * y	L'opérateur permet de multiplier la valeur x par la valeur y.	4 * 9 'retourne 36
x / y	L'opérateur permet de diviser la valeur x par la valeur y en retournant un nombre à virgule flottante.	4 / 16 'retourne 0.25
x % y	L'opérateur modulo retourne le reste de la division x/y.	20 % 3 'retourne 2

Les opérateurs arithmétiques peuvent être utilisés avec n'importe quelle combinaison de type de données numériques.

L'exception ArithmeticException est lancée dans le cas d'une division dont le diviseur est un nombre entier nul et le dividende un entier (byte, short, int ou long) ou d'un entier (idem) modulo par un nombre entier nul.

class Division {
  public static void main(String[] args){
  int x = 10;
  int y = 0;
  float z = 0.0f;

  System.out.println(x / y); // provoque une exception
  System.out.println(x % y); // provoque une exception

  System.out.println(x / z);// affiche Infinity
  System.out.println(x % z);// affiche NaN
  }
}

Le type de résultats peuvent varier en fonction du type de chacune des opérandes d'une opération arithmétiques.

type opérande_gauche;
type opérande_droite;
type resultat = opérande_gauche opérateur opérande_droite;

	char	byte	short	int	long	float	double
char	int	int	int	int	long	float	double
byte	int	int	int	int	long	float	double
short	int	int	int	int	long	float	double
int	int	int	int	int	long	float	double
long	long	long	long	long	long	float	double
float	float	float	float	float	float	float	double
double	double	double	double	double	double	double	double

Les opérations arithmétiques sur les nombres entiers restent fiables. Par contre, des calculs simples ,dont les opérandes sont des nombres à virgule flottante, se révèlent parfois très approximatifs.

System.out.println(1.1f - 1.0f);
System.out.println(1.1d - 1.0d);
System.out.println(1.1 + 1.0);
System.out.println(1.1 * 0.5);
System.out.println(1.1 / 2.0);
/* Affichent
0.10000000000000009
0.10000000000000009
2.1
0.55
0.55
*/

Face à ces carences possibles dans les opérations arithmétiques et plus particulièrement la soustraction avec des valeurs float ou double, il faut préférer effectuer ces calculs avec la classe BigDecimal qui propose les méthodes add(), substract(), multiply() et divide().

BigDecimal decimal = new BigDecimal("1.1");
System.out.println(
          decimal.subtract(new BigDecimal("1.0")).doubleValue()); 

BigDecimal decimal = new BigDecimal(1.1);
System.out.println(
          decimal.subtract(new BigDecimal(1.0)).doubleValue());

/* Affichent
0.1
0.10000000000000009
*/

Afin de s'assurer de la précision des résultats, il faut créer des objets BigDecimal avec des chaines de caractères plutôt que des nombres décimaux.