 # Java Operators: Performing Operations on Primitive Data Types

• Print
Steve Haines addresses all of the mathematical operations you can perform in Java on primitive data types. Learn about what Java operators are and how they are used, as well as what Java operators are evaluated first.
This chapter is from the book

### This chapter is from the book 

You will learn about the following in this chapter:

• All Java operators: what they are and how they are used.

• Java Operator Precedence: what operators are evaluated first?

In the previous chapter you learned that computers think in terms of 1s and 0s, and that you can use those 1s and 0s to represent numbers, characters, and booleans. Then you learned that through Java you could create meaningful names that refer to regions of memory using variables. The next step is to take those variables and do something meaningful with them. In this chapter, you will address all the mathematical operations you can perform in Java on primitive data types.

Operators work in conjunction with operands, or the literal values or variables involved in the operation. There are unary operators, which are operators that operate on a single operand, as well as operators that operate on two or more variables.

## Arithmetic Operators

Arithmetic operators refer to the standard mathematical operators you learned in elementary school: addition, subtraction, multiplication, and division.

Addition, as you would expect, is accomplished using the plus sign (+) operator. The form of an addition operation is

`operand + operand`

For example:

```// Add two literal values
int result = 5 + 5;

int a = 5;
int b = 6;
int result = a + b;

// Add two variables and a literal
int result = a + b + 15;```

An addition operation, can add two or more operands, whereas an operand can be a variable, a literal, or a constant.

### Subtraction

Subtraction, again as, you would expect, is accomplished using the minus sign (–) operator. The form of a subtraction operation is

`operand - operand`

For example:

```// Subtract a literal from a literal; the result is 5
int result = 10 - 5;

// Subtract a variable from another variable; the result is -1
int a = 5;
int b = 6;
int result = a - b;

// Subtract a variable and a literal from a variable
// The result is 5 – 6 – 15 = -1 – 15 = -16
int result = a - b - 15;```

A subtraction operation can compute the difference between two or more operands, where an operand can be a variable, a literal, or a constant.

### Multiplication

Multiplication is accomplished using the asterisk (*) operator. The form of a multiplication operation is

`operand * operand`

For example:

```// Multiply two literal values; result is 25
int result = 5 * 5;

// Multiply two variables; result is 30
int a = 5;
int b = 6;
int result = a * b;

// Multiply two variables and a literal
// The result is 5 * 6 * 15 = 30 * 15 = 450
int result = a * b * 15;```

A multiplication operation can multiply two or more operands, where an operand can be a variable, a literal, or a constant.

### Division

Division is accomplished using the forward slash (/) operator. The form of a division operation is

`operand / operand`

For example:

```// Divide a literal by a literal; result is 5
int result = 10 / 2;

// Divide a variable by another variable; result is 3
int a = 15;
int b = 5;
int result = a / b;```

When dividing integer types, the result is an integer type (see the previous chapter for the exact data type conversions for mathematical operations). This means that if you divide an integer unevenly by another integer, it returns the whole number part of the result; it does not perform any rounding. For example, consider the following two operations that both result to 1.

```int result1 = 10 / 6; // Float value would be 1.6666
int result2 = 10 / 9; // Float value would be 1.1111```

Both result1 and result2 resolve to be 1, even though result1 would typically resolve to 2 if you were rounding off the result. Therefore, be cognizant of the fact that integer division in Java results in only the whole number part of the result, any fractional part is dropped.

When dividing floating-point variables or values, this caution can be safely ignored. Floating-point division results in the correct result: The fractional part of the answer is represented in the floating-point variable.

```float f = 10.0f / 6.0f; // result is 1.6666
double d = 10.0 / 9.0; // result is 1.1111```

Note the appearance of the f following each literal value in the first line. When creating a floating-point literal value (a value that has a fractional element), the default assumption by the compiler is that the values are double. So, to explicitly tell the compiler that the value is a float and not a double, you can suffix the value with either a lowercase or uppercase F.

### Modulus

If integer division results in dropping the remainder of the operation, what happens to it? For example if you divide 10 by 6:

`int i = 10 / 6;`

The Java result is 1, but the true result is 1 Remainder 4. What happened to the remainder 4?

Java provides a mechanism to get the remainder of a division operation through the modulus operator, denoted by the percent character (%). Although the previous example had a result of 1, the modulus of the operation would give you that missing 4. The form of a modulus operation is

`operand % operand`

For example:

```int i = 10 / 6; // i = 1
int r = 10 % 6; // r = 4```

Similar to the other arithmetic operators in this chapter, the modulus of an operation can be performed between variables, literals, and constants.