Operator type

Predetermined ** Symbol for performing predetermined processing **
Variables processed by the operator ** Operand (operand) **
Arithmetic operators
Assignment operator
Relational operator
Logical operators
Bitwise operator

Arithmetic operator

+ Operator

- Behaves differently depending on the type of operant
If any of the operands is a string, ** + joins as a string **
If one is not an object, ** convert it to a string with the toString method and combine it **

import java.time.LocalDateTime;

public class Main {
    public static void main(String[] args) throws Exception {
    System.out.println("a"+LocalDateTime.now()); //a2020-10-29T…
    }
}

Numeric and non-object + operations are not possible
If you combine the characters with +
Since it generates three String strings, the original string, the concatenation string, and the result string, it is useful for increasing garbage collection. ..
→ ** Use the append method of the StringBuilder class ** to represent a variable length character string that secures a certain size, so you can freely change the character string in the reserved area.
→ ** There are few instances created / destroyed! ** **
If the amount of characters can be estimated in advance, streamline the process of clearly indicating the size at the time of instantiation, expanding the character string, and reallocating memory.
In the latest Java, the + operator is internally converted to StringBuilder, so in the case of single string concatenation, the + operator is OK.

import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
        var builder = new StringBuilder();
        for (var i=0;  i<100000; i++){
        	builder.append("mohu");
            //result += "mohu" ; 
        	}
        var result = builder.toString();
        System.out.println(result);
    }
}

Increment operator

++ i: ** Prefix addition (addition before substitution) **
- i = 3; j = ++i → i = 4 j = 4
i ++: ** Post-addition (addition after substitution) **
- i = 3; j = i++ → i = 4 j = 3

Pay attention to the type in division

/: Division
- 6 / 3 = 2 *%: Surplus (too much)
- 10 % 4 = 2

//NG **Since it is a calculation between integers, the result is also an integer**
System.out.println( 3 / 4 ); //0

//NG **It is the timing of the operation that is converted to an integer!**
double result = 3 / 4 ;
System.out.println(result); //0.0

//OK **Explicitly double one of the operants
System.out.println( 3d / 4 ); //0.75

Handling of zero

//NG **Acceleration of constant 0 is an error**
System.out.println( 5 / 0 ); //0

//OK **Operant is floating point**
System.out.println( 5d / 0 ); //Infinity(Infinity)

//OK 
System.out.println( 5d % 0 ); //NaN (Not a number:Non-number)

Precautions for floating point arithmetic

System.out.println(Math.floor(( 0.7 + 0.1 )*10 )); //7.0

Floating point type is operated by binary number
Decimal number 0.1 → Binary number becomes an infinite recurring decimal
→ ** Use BigDecimal class **
Internally, the decimal point is managed separately for integers and a small number of luck positions.
(Note) Use ** strings instead of floating point literals when instantiating! ** **
var bd1 = new BigDecimal (0.7); // NG example

import java.util.*;
import java.math.BigDecimal;

public class Main {
    public static void main(String[] args) throws Exception {
    var bd1 = new BigDecimal("0.7");
    var bd2 = new BigDecimal("0.1");
    var bd3 = new BigDecimal("10");
    System.out.println(bd1.add(bd2).multiply(bd3)); //8.0
    }
}

Assignment operator

Behavior differs between basic type and reference type
Since the value of the basic type is stored as it is in the variable, the copied variable (y) does not affect even if the original variable is changed.
In the reference type, the address in the memory that stores the value is stored in the variable, so the copied one also points to the object with the same address.

import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
    var x = 1;
    var y = x;
    x += 10;
    System.out.println(x); //11
    System.out.println(y); //1

    var builder1 = new StringBuilder("abc");
    var builder2 = builder1; //Copy address
    builder1.append("de");
    System.out.println(builder1.toString()); //abcde
    System.out.println(builder2.toString()); //abcde
    }
}

Assignment to a constant

Cannot be changed in the basic type
In the reference type, the constant itself cannot be rewritten, but only the content can be rewritten without changing the band eject.
String type is immutable, so its value cannot be changed

//NG example
final int VALUE = 10;
VALUE = 15;

final int[] VALUES = { 10, 20, 30 } ;
//NG **The constant itself cannot be reassigned
VALUES = new int[] { 10, 20, 30 } ; 

//OK
VALUES[0] = 100;
System.out.println(Arrays.toString(VALUES));  //[100, 20, 30]

Relational operator (comparison operator)

Compare both sides and return true / false
Identity
Equivalence

Difference between == and equals

== Operators compare ** operant identity (= references that store values) **, false for different objects
In the basic type that stores the value itself, there is no problem because the value is the target of comparison.
The equals method ** compares the values of objects **

var builder1 = new StringBuilder("neko");
var builder2 = new StringBuilder("neko");
System.out.println(builder1 == builder2); //false

var str1 = "neko";
var str2 = "neko";
System.out.println(str1 == str2); //true
System.out.println(str1 == "ne" + "ko"); //true string(String object)Are considered to be the same if they are

Floating point comparison

BigDeciamal
If the judgment result is 0, the numerical value of the object and the argument are equal, 1 is the larger argument, -1 is the smaller argument.
(Note) The equals method in BigDeciamal judges up to significant figures
- 1.0 ≠ 1.00
→ ** Use compareTo ** method
Use rounding units
EPSILON: Error tolerance
True if the difference is within the EPSILON range

System.out.println( 0.2*3 == 0.6 ); //false

//BigDecimal
import java.util.*;
import java.math.BigDecimal;

public class Main {
    public static void main(String[] args) throws Exception {
    var bd1 = new BigDecimal("0.2");
    var bd2 = new BigDecimal("4");
    var bd3 = new BigDecimal("0.8");
    System.out.println(bd1.multiply(bd2).compareTo(bd3)); //0
    }
}

//Use rounding units
public class Main {
    public static void main(String[] args) throws Exception {
    final double EPSILON = 0.00001;  //Guaranteed to 5 decimal places
    var x = 0.2 * 4;
    var y = 0.8;
    System.out.println(Math.abs(x - y) < EPSILON); //true
    }
}

Array comparison

Use the equals method of the Array class
Nested arrays are ** deepEquals ** methods
** Compare ** method (Java 9 or later) compares the inserts in order from the first element, and if there is a large / small element, the overall size is confirmed.

public class Main {
    public static void main(String[] args) throws Exception {
    var data1 = new String[] { "a", "b", "c" };
    var data2 = new String[] { "a", "b", "c" };
    
    var data3 = new int[][] {
      { 1, 2, 3 },
      { 4, 5, 6 },
      { 7, 8, 9 },
    };
    var data4 = new int[][] {
      { 1, 2, 3 },
      { 4, 5, 6 },
      { 7, 8, 9 },
    };
    
    System.out.println(Arrays.equals(data1, data2)); //true
    System.out.println(Arrays.deepEquals(data3, data4)); //true
    
    }
}

//Compare method
import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
    var data1 = new int[] {1, 3};
    var data2 = new int[] {1, 2, 3};
    var data3 = new int[] {1, 2, 3};
    var data4 = new int[] {1, 3, 1};
    var data5 = new int[] {0, 0, 6};
    var data6 = new int[] {6, 0, 0};
    System.out.println(Arrays.compare(data1, data2)); //1
    System.out.println(Arrays.compare(data3, data4)); //-1
    System.out.println(Arrays.compare(data2, data3)); //0
    System.out.println(Arrays.compare(data3, data5)); //1
    System.out.println(Arrays.compare(data3, data6)); //-1
    }
}

Conditional operator (ternary operator)

(Conditional expression)? Expression A: Expression B
When comparing A and B (Equation A: Expression B) Expressions A and B must return some value

public class Main {
    public static void main(String[] args) throws Exception {

    var age = 20;
    System.out.println(age >= 20 ? "grown up" : "children"); //grown up

    }
}

Logical operator

Multiple conditional expressions can be logically combined to express more complex conditional expressions
&&: ** Logical product ** (true when both are true)
- ||：Logical sum(True when one is true)
^: ** Exclusive OR ** (true when only one is true) *!: ** Negation ** (false when expression is true, true when expression is false)

Short-circuit operation (short-circuit operation)

** Calculations where only the left expression is evaluated ** and the right is not evaluated
In logical product, when the left side is false, it is false regardless of the right side.
In OR, when the left side is true, true regardless of the right side
** & and | operators do not shortcut **
Used for null check
If null, the startsWith method will not be called
Setting && to & results in NullPoiintException error

//null check
import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {

    String str = "http://hoge";
    if (str != null && str.startsWith("http://")) {
    // if(str.startsWith("http://")) {
      System.out.println("「http://It starts with "...".");  //「http://It starts with "...". 
    }
  }
}

//Null check is also possible with the following method
 if(!Objects.isNull(str)&&str.startsWith("http://"))
        {...}
 if(Objects.nonNull(str)&&str.startsWith("http://"))
        {...}

Bit operator

Bit logical operator

Convert integers to binary and perform logical operations on each digit
When both are 1 and the result is 1 (true)
Returns the result of the operation converted back to decimal.
Negation operation inverts bits
Negation of 0101 → (reversal) 1010 → (result) −6 // The result is not 10!
** Invert the sign indicating positive or negative! ** **
Negative numbers in bits are "absolute values obtained by adding 1 after bit inversion"
0101 plus 1 0110 (decimal number) → The result is -6 (decimal number) with the sign added.

Bit shift operator

Calculate decimal number as binary number and move ** digit to left or right by specified sentence **
1010 (decimal number) → left 2 shift → 101000 → result 40 (decimal number)
Arithmetic shift (>>): Shift that maintains the most significant bit (sign)
Logical shift (>>>): Fills with 0 regardless of the most significant bit

Operator precedence

Explicitly describe the priority in ()
Representative example

[Highest priority]
argument, [] , .
++(Postscript), --(Postscript)
++(Prefix), +(unary), ! , ~
* , / , %
+ , -
> , >=
== , !=
&
^
&&
?:
= , += , &=

Associative law

For the same priority, there are left join (left → right) and right join (right → left)
Right join is only ** assignment operator **
- j = i +=10
- j = ( i +=10 )
= And + = have the same priority and are right-joined, so evaluate from the right
The result of adding 10 is assigned to j

[Java] Summary of operators (operator)

Operator type

Arithmetic operator

+ Operator

Increment operator

Pay attention to the type in division

Handling of zero

Precautions for floating point arithmetic

Assignment operator

Assignment to a constant

Relational operator (comparison operator)

Difference between == and equals

Floating point comparison

Array comparison

Conditional operator (ternary operator)

Logical operator

Short-circuit operation (short-circuit operation)

Bit operator

Bit logical operator

Bit shift operator

Operator precedence

Associative law