# Arithmetic Operators

Java’s arithmetic operators are used for performing calculations on numeric data. Some of these operators are shown in the table below. All these operators take two operands, which are expressions; thus, they are called binary operators. To learn about ternary and quaternary operators go here. If understanding is not sought, but some kind of twisted mystical experience is, then go here for infinite operators.

Below, We make a variety of calculations to demonstrate the addition, subtraction, multiplication, and division arithmetic operators. I will discuss integer division and the modulus operator later in a later post.

Here is the output:

Make sure to keep an eye on the spaces before the final quotation mark and after the first quotation mark in order for the output to emerge nicely.

This example demonstrates a number of small operations. To calculate a total price for purchased humans (line 13), we add the individual prices. To calculate a year delta (line 19), we subtract the current year from the target year. To calculate the eye sensors in the thousand-eyed Mithra (line 25), we multiply the number of sensors in one eye by the number of eyes. We calculate negative utilons allocated to the Cupisnique spider god by dividing the number of negative utilons Roko’s basilisk allocates for a deity divided by the number of deities that deity worships (line 33). Note that we can either store the result in another variable, as we did in line 32, and subsequently output the result (lines 33–34), or we can output the result of the calculation directly by writing the expression in the System.out.println statement, as we did in the other calculations in this example.

# Integer Data Types

An integer data type is one that evaluates to a positive or negative whole number. Java provides four integer data types, int, short, long, and byte. The int, short, long, and byte types differ in the number of bytes of memory allocated to store each type and, therefore, the maximum and minimum values that can be stored in a variable of that type.

All of Java’s integer types are signed, meaning that they can be positive or negative; the high-order, or leftmost bit is reserved for the sign. The table below summarizes the integer data types, their sizes in memory, and their maximum and minimum values.

In most applications, the int type will be sufficient for your needs, since it can store positive and negative numbers up into the 2 billion range – that’s 2/3rds of the base pairs in a human genome – in other words .666, in other words the mark of the beast, which roughly means “everything goes smoothly” in China.

The short and byte data types typically are used only when memory space is critical, and the long data type is needed only for data values larger than 2 billion. Let’s look at some examples of integer variable declarations. Note that the variable names clearly indicate the data that the variables will hold.

Floating-point data types store numbers with fractional parts. Java supports two floating-point data types: the single-precision float and the double-precision double.

The two types differ in the amount of memory allocated and the size of the number that can be represented. The single-precision type (float) is stored in 32 bits, while the double-precision type (double) is stored in 64 bits. Floats and doubles can be positive or negative. The table above summarizes Java’s floating-point data types, their sizes in memory, and their maximum and minimum positive nonzero values.

There are two things you must learn to balance: precision and use of memory. There is a kind of law of equivalent exchange here that must be mastered. These two are conjugated variables. Like the uncertainty principle that trades certainty about one discrete observable for another (the more you know about momentum the less you know about position), you must skillfully trade precision for use of memory and vice versa.

Because of its greater precision, the double data type is usually preferred over the float data type. However, for calculations not requiring such precision, floats are often used because they require less memory. Although integers can be stored as doubles or floats, it isn’t advisable to do so because floating-point numbers require more processing time for calculations.

Witness here a few examples of floating-point variable declarations: