Things will begin to get **interesting**….

** **

So now you know how to install Java and Eclipse, how to create a simple project, a class and print the Hello World message, and also you know that Java has certain data types that can be used to create variables to store data.

** **

But… *what can be done with the data in the variables*?

** **

It is time to introduce to you the **operators**. With them you can do “operations” to your variables.

** **

There are quite a few operators in Java, and they are categorized into:

- Assignment
- Arithmetic
- Unary
- Equality
- Conditional
- Bitwise/bit shift

** **

I will explain all of these categories in this blog, but will get into more detail about Conditional and Equality operators in the Control Statements block posts.

** **

Every category will be explained using an example.

** **

**Assigment Operator**

Simple one. It is used to *assign a value* to a variable and it is represented by the equal symbol:

** **

// Assignment operator int firstValue = 8; int secondValue = 24;

** **

** **

**Arithmetic Operators**** **

In the next table you can see the arithmetic operators and their symbols:

** **

Symbol |
Operation |

+ | add/concatenate |

– | subtract |

* | multiply |

/ | divide |

% | remainder |

** **

Remember your elementary school classes. As you probably had already imagined, you can add, subtract, multiply and divide numbers in programming too.

** **

// Arithmetic operators int result = 0; result = firstValue + secondValue; System.out.println("Addition operator result: " + result); result = secondValue - firstValue; System.out.println("Subtraction operator result: " + result); result = firstValue * secondValue; System.out.println("Multiplication operator result: " + result); result = secondValue / firstValue; System.out.println("Division operator result: " + result);

You can try to do these operations using different data types, like float, double, long, etc and mixing them to see what happens. Be sure to have *consistent data types* of your operands and the result. (Later in another post I will explain what “* cast*” is about… remember this).

There is a new function for the** plus + sign** when you use it with strings. It won’t add the strings, but it will *concatenate* them, meaning that you can join two strings together with the plus sign.

** **

// Arithmetic operator - Strings String firstString = "This is "; String secondString = "a good day."; String stringResult = firstString + secondString; System.out.println("String concatenation: " + stringResult);

It is important to see that depending on the type of data that you have in your operations, *you will have a different result*.

These are the most used operators in programming. But there is another one that will join this family: the **remainder operator or modulus**. This operator returns the *remainder of the division* between two numbers.

** **

// Arithmetic operator - remainder/modulus result = secondValue % firstValue; System.out.println("Remainder: " + result); result = firstValue % secondValue; System.out.println("Remainder: " + result);

** **

**Unary Operators**

They are called unary because they only *require one operand*: they apply to only one variable.

** **

Symbol |
Operation |

+ | Indicates positive value (no need to use it) |

– | Negates the value |

++ | Increments the value in one. |

— | Decrements the value in one |

! | Inverts the boolean value (Logical complement) |

** **

/* Unary operators */ int unaryValue = 5; // - operator result = -unaryValue; // Result is -5, no big deal here. System.out.println("Result: " + result);

** **

For the ++ and — operators, *it matters where you use the operator*: after or before the variable. If you use it before, first it will make the increment/decrement and then it will perform the operation that you want, and if you use it after, you will use the original value first and then it will increment its value. This will be clearer in the example:

** **

System.out.println("========== Unary Operators: value++/value-- =========="); // ++ operator, unaryValue++ // unaryValue has a 5. System.out.println("Original value: " + unaryValue); // unaryValue prints a 5, after printing, it increments to 6 System.out.println("Result unaryValue++, value doesn't change: " + unaryValue++); // unaryValue incremented to 6 after printing in the previous line. System.out.println("Result unaryValue, value changed in previous line: " + unaryValue); System.out.println("========== Unary Operators: ++value/--value =========="); // ++ operator, ++unaryValue // unaryValue has a 6. System.out.println("Original value: " + unaryValue); // unaryValue prints a 7, because it increments BEFORE printing. System.out.println("Result ++unaryValue, value changes: " + ++unaryValue);

** **

If you want to *invert* a boolean value, use the **!** operator:

** **

System.out.println("========== Unary Operators: ! =========="); boolean booleanValue = true; System.out.println("Boolean original value: " + booleanValue); System.out.println("Boolean inverted value: " + !booleanValue);

** **

**Equality Operators**

** **They are used in the control statements (next week’s post, wait for it) to

*evaluate*if a value is equal, greater than, less than, greater or equal than or less or equal than another number.

Symbol |
Operation |

== | Equal to (two equal symbols, one is for assignment!!) |

!= | Not equal to |

> | Greater than |

< | Less than |

>= | Greater or equal than |

<= | Less or equal than |

/* Conditional Operators */ System.out.println("========== Equality Operators =========="); System.out.println("1 == 2?: " + (1 == 2)); System.out.println("1 >= 2?: " + (1 >= 2)); System.out.println("1 < 2?: " + (1 < 2));

** **

It is important to note that the *result* of an operation using Equality operators will** always be true or false**.

**Conditional Operators**

They are *AND and OR*, meaning that they compare two boolean expressions or values and they follow the AND and OR logical table for the results:

** **

- AND: will only be true if all
**expressions are true**, false otherwise. - OR: will be true when
**one or all the expressions are true**, false otherwise.

Symbol |
Operation |

&& | AND |

|| | OR |

/* Conditional Operators */ System.out.println("========== Conditional Operators =========="); System.out.println("true AND false?: " + (true && false)); System.out.println("true AND true: " + (true && true)); System.out.println("true OR false?: " + (true || false)); System.out.println("false OR false?: " + (false || false));

**IMPORTANT NOTE:** Maybe these examples for Equality and Conditional operators are foolish examples, but what I want you to learn are the different operators and the results that they generate. Later on I will create a post with a more realistic example where you can see a real usage of this. Believe me, you will use them everyday and everytime.

**Bit wise/Bit shift operators**

These operators are *rarely used* but it is good for you to know that they exist. Maybe t*hey will save your life someday*!

Symbol |
Operation |

~ | Inverts a bit pattern: ~1111 = 0000 |

<< | Left shift operator |

>> | Signed Right shift operator |

>>> | Unsigned right shift operator |

& | Bit AND operator |

^ | Bit XOR operator |

| | Bit OR operator. |

** **

For the *AND, XOR, and OR*, the operation is applied bit by bit (for AND and OR you can see previous explanation, **XOR** will give true or 1 if one of the operands is 1, but if both are 1 or 0, the result is 0).

** **

/* Bitwise/Bitshift Operators */ System.out.println("========== Bitwise/Bitshift Operators =========="); int bitmask = 0x000F; // 0000 0000 0000 1111 int val = 0x2222; // 0010 0010 0010 0010 // & result: 0000 0000 0000 0010 = 2 System.out.println("Bitwise AND: " + (val & bitmask)); // | result: 0010 0010 0010 1111 = 8751 System.out.println("Bitwise OR: " + (val | bitmask)); // ^ result: 0010 0010 0010 1101 = 8749 System.out.println("Bitwise XOR: " + (val ^ bitmask)); bitmask = 0x0001; // this is 1 in binary: 0000 0000 0000 0001 System.out.println("Shift left 2 positions: " + (bitmask<<2)); //it moves the 1 two spaces to the left to get 0100, that is 4. bitmask = 0x0004; // this is 2 in binary: 0000 0000 0000 0100. System.out.println("Shift right 1 position: " + (bitmask>>1)); //it moves the 1 one space to the right to get 0010, that is 2.

** **

Just remember that these operators *exist and what they do*, and someday you may come to a situation where these operators will help you solve your problem, and then you can research some more about them.

——

That is all for Operators and for the first Block in our diagram: **Variables and Operators**. Next time I will talk about** Control Statements**, where you can use everything learned until today.

You can find the code for this post in Warrior Minds Github.

**Questions? Comment or email me.