subtopic

Range: -128 to 127

Default value: 0

Construction method: Byte(byte value)

Static method: valueOf(byte b)

Byte[] var

Construction method:

1. Default construction method Short()

2. Constructor method Short(short value) with one parameter

3. Constructor method Short(String s) with a string parameter

4. The static method valueOf(short value) returns a Short object of this value

5. The static method valueOf(String s) returns a Short object of this string parameter, which consists of characters and will be converted to a signed short if necessary.

6. The static method parseShort(String s) returns a Short object of this string parameter, which consists of characters and will be converted to a signed short when necessary.

7. Constructor method Short(byte value) for converting from byte

Interger var

Interger[] var

Long num1 = 10L; // Use suffix 'L' to represent a literal value of long type

Long num2 = Long.valueOf(10); // Use the static method valueOf() to convert the basic type long to a Long object

1. longValue(): Convert the value of the Long object to the basic type long.

2. compareTo(): ​​Compare the values ​​of two Long objects.

3. parseLong(): Parses the string into a long integer.

1. Starting from Java 5, automatic conversion between basic data types and their corresponding wrapper classes (such as long and Long) can be automatically converted. This is called automatic boxing and unboxing.

1.Long.MAX_VALUE

2. Long.MIN_VALUE

Using Long instead of the basic type long is useful when you want to store numbers in a collection (such as ArrayList, HashSet) and need its object properties. For example, you can store unique Long values ​​in a HashSet to eliminate duplicates.

Like other integer types, you can perform bit operations on long, such as bitwise AND (&), bitwise OR (|), bitwise XOR (^), etc. But note that the result is still a long integer.

Be careful when using the == operator to compare two Long objects. Although for small integer values ​​(between -128 and 127), Java caches the corresponding Long object, for values ​​outside this range, a new Long object is created every time, even if they represent the same numerical value. , their addresses in memory may also be different. Therefore, it is safer to use the .equals() method to compare whether the values ​​of two Long objects are equal.

float num1 = 1.5f; // Use the suffix 'f' to represent a literal value of float type

1. floatValue(): Convert the value of the Float object to the basic type float.

2. parseFloat(): Parses the string into a floating point number.

3. isNaN(): Check whether the specified floating point number is NaN (not a number)

4. toString(): Returns a string representing the specified floating point number.

Float boxedNum = 1.5f; // Automatic boxing: from float to Float

float primitiveNum = boxedNum; // Automatic unboxing: from Float to float

1. Float.MAX_VALUE: Indicates the maximum positive limited value that the float type can store, that is, 3.4028235E38F

2. Float.MIN_VALUE: Indicates the smallest positive finite value that the float type can store, that is, 1.4E-45F.

3. There are also constants such as Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, and Float.NaN that represent special floating point values.

Due to the precision of floating point numbers, it is generally unsafe to directly use the equal sign (==) to compare whether two floating point numbers are equal. Instead, you should check whether the absolute value of the difference between the two numbers is less than a very small value (called epsilon)

Floating-point arithmetic can lead to unexpected results due to the way floating-point numbers are represented and the way the computer operates internally. For example, in some cases, the result of 0.1 0.2 may not be exactly equal to 0.3. Therefore, you often need to be extra careful when dealing with financial calculations or other important calculations that require high precision.

double num1 = 3.14; // direct assignment

double num2 = Double.valueOf(3.14); // Use the static method valueOf() of the Double class for conversion

Since double is double precision, it is more accurate than the float type when storing numerical values. It can store more decimal places and is more accurate in mathematical operations. However, it should be noted that even when using the double type, there may be a loss of precision in some cases.

1. doubleValue(): Convert the value of the Double object to the basic type double.

2. parseDouble(): Parses the string into a double-precision floating point number.

3. isNaN(): Checks whether the specified floating point number is NaN (not a number).

4. toString(): Returns a string representing the specified floating point number.

Double boxedNum = 3.14; // Automatic boxing: from double to Double

double primitiveNum = boxedNum; // Automatic unboxing: from Double to double

1. Double.MAX_VALUE: Indicates the maximum positive limited value that the double type can store, that is, 1.7976931348623157E308

2. Double.MIN_VALUE: Indicates the smallest positive finite value that the double type can store, that is, 4.9E-324

3. In addition, there are constants representing special floating-point values ​​such as Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, and Double.NaN.

Similar to floating point numbers, it is generally unsafe to use the equal sign (==) directly to compare two double precision floating point numbers for equality due to precision issues. Instead, you should check whether the absolute value of the difference between the two numbers is less than a very small value (called epsilon

Although the double type provides higher precision and greater range, you still need to be cautious when dealing with calculations that require high precision. For example, financial calculations may require the use of specialized high-precision libraries to avoid any potential loss of precision issues. In addition, problems related to floating point operations also apply to double types, for example, the result of 0.1 0.2 may not be exactly equal to 0.3 in some cases. Therefore, when dealing with important calculations, extreme care and appropriate testing are usually required.

boolean flag1 = true; // Direct assignment

boolean flag2 = Boolean.valueOf(true); // Use the static method valueOf() of the Boolean class for conversion

1. booleanValue(): Convert the value of the Boolean object to the basic type boolean

2. parseBoolean(): Parses the string into a Boolean value. Note that the strings "true" and "false" (case-insensitive) are parsed as booleans true and false respectively, while other strings are parsed as false

3. toString(): Returns a string representing the specified Boolean value, that is, "true" or "false".

Boolean boxedFlag = true; // Automatic boxing: from boolean to Boolean

boolean primitiveFlag = boxedFlag; // Automatic unboxing: from Boolean to boolean