[El JavaSE] operador

Los operadores aritméticos

Nos fijamos en un ejemplo

public class Solution {
    public static void main(String[] args) {
        double a = 13.5;
        int b = 2;
        System.out.println(a % b);
    }
}

La respuesta es 1.5, no sólo puede dar instrucciones% int mod, mod puede dar doble. número entero int promovido a duplicar.

operador de incremento decremento

Observamos un ejemplo:

public class Solution {
    public static void main(String[] args) {
        int a = 10;
        int b = ++a;
        System.out.println(b);
        int c = a++;
        System.out.println(c);
    }
}

Mira un ejemplo:

public class Solution {
    public static void main(String[] args) {
        int a = 0;
        int b = 0;
        b = a++;
        System.out.println(a); // 1
        System.out.println(b); // 0
    }
}

public class Solution {
    public static void main(String[] args) {
        int a = 0;
        int b = 0;
        b = ++a;
        System.out.println(a); // 1
        System.out.println(b); // 1
    }
}

Se llegó a la conclusión:

1. Si la expresión no es tomada por el valor de retorno de la operación, el incremento preincremento y post ninguna diferencia.
2. Si la expresión es tomar el valor de retorno, el valor de retorno es el valor preincremento después del incremento, el valor de retorno de ajuste es el valor antes del incremento del incremento.

Los operadores relacionales

Los operadores lógicos

Nota : operando operador lógico (operando a menudo el resultado de un operador relacional) y retorno de los valores son del tipo booleano.
Y lógico &&
reglas: dos operandos son verdaderas, el resultado es verdadero, de lo contrario el resultado es falso
lógica o | |
reglas: dos operandos son falsas, el resultado es falso, de lo contrario el resultado es verdadero

! No lógica
Reglas: los operandos es cierto, el resultado es falso; operando es falso, el resultado es verdadero (que es un operador unitario, sólo uno operando)

public class Solution {
    public static void main(String[] args) {
        System.out.println(10 > 15 && 10 / 0 == 0); 
        System.out.println(10 < 15 || 10 / 0 == 0); 
    }
}

Cálculo 10/0 hará que el programa para lanzar una excepción, pero el código de seguridad capaz de funcionar normalmente, indicando 10/0 y no realmente ha evaluado.
Conclusión :

1. Para &&, si el lado izquierdo de la expresión es falsa, todo el valor de la expresión debe ser falsa, sin calcular el lado derecho de la expresión.
2. Para ||, si el lado izquierdo de la expresión es verdadera, el valor global de la expresión debe ser cierto, sin calcular el lado derecho de la expresión.

Y Y | (no se recomienda)
y e |. Si los operandos a Boolean el tiempo, sino que también representa una operación lógica y && y || comparación, que no son compatibles con la evaluación de cortocircuito

Los operadores bit a bit

bits de operación de manipulación de bits representados por
bit y Y: Si los dos bits son 1, el resultado es 1, 0 en caso contrario

OR bit a bit |: si dos bits son 0, el resultado es cero, de lo contrario el resultado es 1

Nota: Cuando el yy | cuando el operando es un entero (int, corto, largo, de bytes ) , y representa una operación en modo bit, cuando el operando booleano cuando la operación lógica expresada

~ Bit a bit : Si este bit es un 0 a 1, si el bit es un 0 Interruptor

public class Solution {
    public static void main(String[] args) {
        int a = 0xf;
        System.out.printf("%x\n", ~a);
    }
}

Digit prefijo 0x hexadecimal número, 15 decimal 0xF, representado binario por 1111,% x representa una salida en hexadecimal, el resultado es:

bitwise exclusiva OR ^ : Si los mismos bits binarios de dos dígitos , el resultado es 0, el resultado es una diferente

operación de desplazamiento

>> A la derecha: el complemento positivo 0; 1 hasta negativo
conclusión:

1. A la izquierda, equivalente a la izquierda digital original de N bits * 2, equivalente a 2 * N-ésima potencia del número original.
2. Justo al lado de 1 bit, equivalente a la / digital original derecha 2. N bits correspondientes a N-ésima potencia del original digital / 2.
3. Debido a que el ordenador para calcular un cálculo de la transferencia eficiente que la multiplicación y la división, multiplicación y división cuando un código es exactamente N potencia de 2 se puede sustituir por una operación de desplazamiento

operador condicional

public class Solution {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int Max = a > b ? a : b;
        System.out.println(Max);
    }
}

En general, el operador de Java del lenguaje C y reglas básicas son básicamente los mismos.