Introducción a los operadores básicos de Java

En el nivel más bajo, los datos en Java se manipulan mediante operadores.

1.1 Declaraciones de impresión más simples

System.out.print("Hello World");
打印输出：Hello World

1.2 Uso de operadores de Java

    El operador acepta uno o más parámetros y genera un nuevo valor. Operadores comunes, signo más (+), signo menos (-), signo de multiplicación (*), signo de división (/) y signo de asignación (=).

1.3 Prioridad

    Cuando hay varios operadores en una expresión, multiplica y divide primero y luego suma y resta. Los que están entre paréntesis se cuentan primero. Sin embargo, en el programa, debe prestar atención al operador "+".

System.out.println(1 + "1");
System.out.println(1 + 1);
System.out.println("hello" + "world");
输出值:
11
2
helloworld

"+" significa "concatenación de cadenas" y, si es necesario, también realiza "conversión de cadenas". Cuando el compilador observa que un objeto String está conectado a este "+", y este "+" está conectado a un elemento de un objeto que no es String, intentará convertir el elemento de tipo que no es String en un String. Como se ve en la primera línea de código anterior, el tipo entero 1 se conecta a un "+" y luego se empalma un tipo de cadena "1", y el resultado es la cadena de salida "11".

1.4 Asignación

        El operador de cosa "=" se utiliza para la asignación. Al contrario de lo que entendemos habitualmente, solemos asignar el valor en el lado izquierdo del signo igual "=" a la derecha; pero el signo igual "=" en el programa significa "tomar el valor en el lado derecho del signo igual y asignarlo a la izquierda " . El valor de la derecha puede ser cualquier constante, variable o expresión (siempre que pueda generar un valor). Pero el de la izquierda debe ser una variable con un nombre claro. Por ejemplo: a = 1

       No puede asignar nada a una constante, y una constante no puede ser el valor en el lado izquierdo del signo igual (ejemplo de contador: 1 = a)

 

1.5 Operadores aritméticos

    Operadores aritméticos básicos de Java, más (+), menos (-), multiplicación (*), división (/) y módulo (%).

    Nota: La diferencia entre el signo de división en el programa Java y el método aritmético real es que cuando la división del programa usa división de enteros, no habrá resto si la división es inagotable, solo se tomarán enteros y no El resultado; si es un valor de tipo doble o flotante, la división se puede calcular al punto decimal.

         El módulo (%) es tomar el resto de la división de enteros

System.out.println(10/3);
System.out.println(10%3);
System.out.println(10.0/3.0);
System.out.println(10f/3);
输出结果：
3
1
3.3333333333333333
3.3333333

Operadores unarios : unario más (+), unario menos (-), multiplicación unaria (*), división unaria (/) y la suma, resta, multiplicación y división binarias correspondientes son todos el mismo número. Según la forma escrita de la expresión, el compilador determinará automáticamente cuál usar.

Por ejemplo: x - = a; se puede convertir en x = x-a; x + = b; se puede convertir en x = x + b;

             x * = c; se puede convertir en x = x * c; x / = d; se puede convertir en x = x / d;

1.6 Incremento y decremento automático

      Incrementar y decrementar son dos operaciones de atajo bastante buenas: el operador de decremento es "-" y el operador de incremento es "++". --ay a-- ambos expresan el mismo significado, es decir, a = a-1, lo mismo es cierto para aumentar. Pero hay algo a lo que prestar atención, la diferencia entre el operador en la parte delantera y trasera. Por lo general, se llama "prefijo" en la parte delantera y "sufijo" en la parte posterior. La diferencia es que el símbolo en el frente se calcula antes de que se genere el valor, y el símbolo en la parte posterior se asigna primero en el cálculo. ejemplo:

int a = 1;
int b = 1;
int c = 1;
int d = 1;
System.out.println("a   " + ++a);
System.out.println("b   " + b++);
System.out.println("c   " + --c);
System.out.println("d   " + d--);

输出：
a   2
b   1
c   0
d   1

1.7 Operadores relacionales

        Los operadores relacionales generan un resultado booleano y calculan la relación entre el valor del operando. Si la relación es verdadera, la expresión generará verdadero; si Guangxi no es verdadero, entonces falso. Los operadores relacionales incluyen .63. Mayor que (>), menor que (<), mayor o igual que (> =), menor o igual que (<=), igual a (==), no igual a (! =).

        Nota: La igualdad y la desigualdad se aplican a todos los tipos de datos básicos, mientras que otros operadores de comparación no se aplican a los tipos booleanos. Debe ser un valor booleano que solo puede ser verdadero y falso, mayor que, menor que, mayor o igual que, y menor o igual que el tipo booleano no tiene significado práctico.

    Equivalencia de objetos de prueba

Los operadores relacionales == y! = Se aplican a todos los objetos, pero debe prestar atención si desea comparar dos objetos o si los valores son iguales.

String str1 = "a";
String str2 = "a";
String str3 = new String("a");
String str4 = new String("a");

System.out.println("str1==str2    " + (str1==str2));
System.out.println("str1==str3    " + (str1==str3));
System.out.println("str3==str4    " + (str3==str4));
System.out.println("str1.equals(str3)    " + (str1.equals(str3)));

输出：
str1==str2    true
str1==str3    false
str3==str4    false
str1.equals(str3)    true

       En primer lugar, los valores de las cuatro variables son todos a. La razón por la que el resultado de salida es falso es que las variables str1 y str2 se almacenan en la aplicación del grupo de constantes en la memoria, y el valor a corresponde a las dos variables están en el grupo de constantes. En, se refiere a la dirección en el mismo grupo de constantes, por lo que cuando str1 == str2, da como resultado verdadero; el valor a en str3 y str4 se almacena en el montón y todavía está en dos Se guardan diferentes áreas, str3 y str4. Es una referencia a la dirección del montón, por lo que la salida es falsa cuando str3 == str4. Por lo tanto, al comparar el contenido real del objeto, se recomienda utilizar el método equals (); pero debe tenerse en cuenta que si se llama al método equals () en una clase personalizada, es necesario reescribir el método equals () , de lo contrario el uso de este método fallará. Para el efecto que queremos, habrá problemas.

1.8 Operadores lógicos

Los operadores lógicos "y (&&)", "o (||)" y "no (!)" Pueden generar un valor booleano (verdadero o falso) según la relación lógica de los parámetros.

System.out.println((1<2) && (1>3));
System.out.println((1<2) && (1<3));
System.out.println((1<2) || (1>3));
System.out.println((1<2) || (1<3));
System.out.println(1 != 2);

输出：
false
true
true
true
true

Nota: Si se usa un valor booleano donde se debe usar un valor de cadena, el valor booleano se reemplazará automáticamente con el formato de texto apropiado.

También es necesario prestar atención a la diferencia entre bit a bit y (&), bit a bit o (|) y y (&&), o (||)

        Y (&&) en el proceso de ejecución, si alguna de las condiciones múltiples es falsa, devuelve falso y la condición lógica de juicio no se ejecutará hacia atrás; o (||) en el proceso de ejecución, si alguna de las condiciones múltiples es verdadero, devuelve verdadero, y la condición lógica de juicio no se ejecutará hacia atrás. La diferencia entre AND bit a bit (&) y OR bit a bit (|) es que después de que se cumplan las condiciones, ejecutarán la condición lógica de juicio al revés y los pasos subsiguientes se ejecutarán después de que se ejecuten todas las condiciones lógicas. ejemplo:

List<String> lists = null;
if(lists == null || lists.size() == 0){
   System.out.println("集合为空");
}

输出：
集合为空

La misma lógica de juicio, pero uno usa OR (||) y el otro usa OR bit a bit (|), y hay resultados diferentes. Por lo tanto, necesita usar bit a bit o (|) y bit a bit y (&) con precaución en el proceso de desarrollo. Se recomienda usar y (&&) o (||) para ahorrar recursos.

Por favor corríjame si hay algún error, gracias.