Java的逻辑运算符和数据类型在运算中的转换

Java的小知识

一、java中的逻辑运算符

​ Java 中的逻辑运算符主要有：

• 逻辑与：&&
• 逻辑或：||
• 逻辑非：!
• 按位与：&
• 按位或：|
• 按位异或：^

1. &（按位与和逻辑与）

• 按位与：如果用于整数类型（如 int），& 将对每个位进行相应的“与”操作。例如：

  int a = 5;  // 二进制: 0101
  int b = 3;  // 二进制: 0011
  int c = a & b;  // c 的值为 1（二进制: 0001）
  

• 逻辑与：如果用于布尔类型，& 也可以作为逻辑与运算符，但它会对两个操作数都进行求值。例如：

  boolean x = true;
  boolean y = false;
  boolean result = x & y;  // result 为 false
  

2. &&（逻辑与）

• &&是逻辑与运算符。它只用于布尔类型，并具有短路特性：

  • 如果第一个操作数为 false，则第二个操作数不会被求值，因为整个表达式的结果已经确定为 false。这在某些情况下可以提高效率并避免不必要的计算。

  例如：

  boolean x = false;
  boolean y = (x && (10 / 0 > 0));  // 第二个操作数不会被计算，避免了除以零的错误
  

总结

• &：
  • 可以用于整数（按位与）或布尔（逻辑与）。
  • 在布尔运算中，两个操作数都会被求值。
• &&：
  • 仅用于布尔运算。
  • 具有短路特性，避免不必要的计算。

3.| 和 ||

• |（按位或）:

  • 可以用于整数类型，执行按位或运算。

  • 当用于布尔类型时，它作为逻辑或运算符，但会对两个操作数都进行求值（不具有短路特性）。

  • 示例：

    boolean a = true;
    boolean b = false;
    boolean result = a | b;  // result 为 true
    

• ||（逻辑或）:

  • 仅用于布尔类型。

  • 具有短路特性：如果第一个操作数为 true，则第二个操作数不会被求值，因为整个表达式的结果已经确定为 true。

  • 示例：

    boolean a = true;
    boolean b = false;
    boolean result = a || b;  // result 为 true
    

4.逻辑非运算符（!）

• 描述：用于对布尔值取反。如果操作数为 true，结果为 false；如果操作数为 false，结果为 true。

• 示例：

  boolean a = true;
  boolean result = !a; // result 为 false
  

5.按位异或运算符（^）

• 描述：用于布尔值，只有当两个操作数不同（一个为 true，另一个为 false）时，结果为 true。不同时为真，相同时为假

• 示例：

  boolean a = true;
  boolean b = false;
  boolean result = a ^ b; // result 为 true
  

二、java中数据类型的转换

1.对于java中的整型类型

类型	大小	范围
byte	1字节	-128到127
short	2字节	-32768到32767
int	4字节	-2,147,483,648 到 2,147,483,647
long	8字节	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
char	2字节	0 到 65,535（Unicode字符）

在 Java 中，所有的整数类型（byte、short 和 char）在进行算术运算时会被自动提升为 int 类型，这是为了确保计算的安全性和一致性。

public class ArithmeticExample {
    public static void main(String[] args) {
        byte b = 10;
        short s = 20;
        char c = 'A'; // 字符 'A' 的 ASCII 值是 65

        // 自动提升为 int 类型
        int result1 = b + s; // byte 和 short 自动提升为 int
        int result2 = b * c; // byte 和 char 自动提升为 int

        System.out.println("Result of b + s: " + result1); // 输出：30
        System.out.println("Result of b * c: " + result2); // 输出：650
    }
}

在 Java 中，整型的算术运算（包括加法、减法、乘法、除法、取模、自增和自减）都会导致 byte、short 和 char 类型自动提升为 int 类型。这种自动提升确保了运算的准确性，并且避免了类型溢出的问题。

(1.自增和自减运算

在 Java 中，只有自增 (++) 和自减 (--) 操作会直接将 byte、short、char 类型的变量进行自动转换，而不需要强制类型转换。这是因为自增和自减操作在内部处理时会处理为它们的原始类型。

示例

public class Test {
    public static void main(String[] args) {
        char c = 'A'; // c 的初始值是 65
        c++; // c 的值增加 1，变为 66
        System.out.println(c); // 输出：B
    }
}

1. 字符的 ASCII 值：在 Java 中，字符类型 char 实际上是一个 16 位的无符号整数，代表 Unicode 字符。在 ASCII 中，字符 'A' 的值是 65。
2. 自增操作：当你执行 c++ 时：
   • c 会被提升为 int（其值为 65）。
   • 自增操作使其值变为 66。
   • 然后，结果（66）会被赋值回 c，仍然是 char 类型。

(2.其余的算术运算

整型在进行其他运算时，它们会被自动提升为 int 类型进行运算。因此，最终的结果也是 int 类型，在此情况下若要转换为其他类型则要使用强制转换。

示例

public class Test {
    public static void main(String[] args) {
        byte b = 3;
        short s = 4;
        char c = 5;

        // 将 byte、short、char 类型数值相加，再赋值给 byte 类型
        byte b2 = (byte)(b + s + c); // 需要强制转换为 byte

        System.out.println(b2); // 输出：12
    }
}

2.对于java中的浮点型

（1.整型与浮点型的运算

当整型（如 byte、short、int、long）与浮点型（如 float、double）进行运算时，整型会被自动转换为浮点型。

• 规则：整型在与浮点型运算时，会被提升为 double 类型（如果参与运算的是 double），或者提升为 float 类型（如果参与运算的是 float）。

• 示例：

  int intValue = 5;
  double doubleValue = 2.5;
  
  // int 被提升为 double
  double result = intValue + doubleValue; // result 为 7.5
  

(2.浮点型与浮点型的运算

在浮点型之间进行运算时，Java 会根据参与运算的类型进行自动提升。

• 规则：
  • 如果参与运算的任一浮点数是 double 类型，结果会是 double 类型。
  • 如果所有参与运算的浮点数都是 float 类型，结果会是 float 类型。
• 示例：

float floatValue = 1.5f;
double anotherDoubleValue = 2.5;

// float 被提升为 double
double result = floatValue + anotherDoubleValue; // result 为 4.0

// 两个 float 相加
float floatResult = floatValue + floatValue; // floatResult 为 3.0

(3.强制类型转换

在某些情况下，如果需要将结果转换回整型或浮点型，可以使用强制类型转换。

• 整型转换：

  double result = 7.5;
  int intResult = (int) result; // intResult 为 7
  

• 浮点型转换：

  double doubleValue = 3.14;
  float floatResult = (float) doubleValue; // floatResult 为 3.14f