Data Types

1 Types of Data Types

Default values of data type

The byte data type is an 8-bit signed two's complement integer. It has a minimum value of
-128 and a maximum value of 127 (inclusive). The byte data type can be useful for saving
memory in large arrays, where the memory savings actually matters. They can also be used
in place of int where their limits help to clarify your code; the fact that a variable's range is
limited can serve as a form of documentation.

8 bit signed
-128 to 127 (Accepted range)

8 bit signed, -128 to 127, used in arrays where memory saving matters
1.2.2 Short

The short data type is a 16-bit signed two's complement integer. It has a minimum value of
-32,768 and a maximum value of 32,767 (inclusive). As with byte, the same guidelines
apply: you can use a short to save memory in large arrays, in situations where the memory
savings actually matters.

16 bit unsigned

-32768 to 32767

-2^15 to (2^15 -1)

16 bit signed, -32768 to 32767, used in large arrays where memory saving matters
1.2.3 Integer

By default, the int data type is a 32-bit signed two's complement integer, which has a
minimum value of -2^31 and a maximum value of 2^31-1. In Java SE 8 and later, you can
use the int data type to represent an unsigned 32-bit integer, which has a minimum value of
0 and a maximum value of 2^32-1. Use the Integer class to use int data type as an unsigned
integer. See the section The Number Classes for more information. Static methods like
compareUnsigned, divideUnsigned etc have been added to the Integer class to support the
arithmetic operations for unsigned integers.

Signed: -2^31 to 2^31-1

Unsigned: 2^32-1

32 bit signed two's complement, available as signed and unsigned, methods

The long data type is a 64-bit two's complement integer. The signed long has a minimum
value of -2^63 and a maximum value of 2^63-1. In Java SE 8 and later, you can use the long
data type to represent an unsigned 64-bit long, which has a minimum value of 0 and a
maximum value of 264-1. Use this data type when you need a range of values wider than
those provided by int. The Long class also contains methods like compareUnsigned,
divideUnsigned etc to support arithmetic operations for unsigned long.

64 bit two's complement integer

-2^63 to 2^63

64 bit two's complement, -2^63 to 2^63-1

The float data type is a single-precision 32-bit IEEE 754 floating point. Its range of values is
beyond the scope of this discussion, but is specified in the Floating-Point Types, Formats, and
Values section of the Java Language Specification. As with the recommendations for byte
and short, use a float (instead of double) if you need to save memory in large arrays of
floating point numbers. This data type should never be used for precise values, such as
currency. For that, you will need to use the java.math.BigDecimal class instead. Numbers
and Strings covers BigDecimal and other useful classes provided by the Java platform.

32 bit IEEE 754 floating bit, use of float instead of double where memory saving matters

32 bit IEEE 754 floating bit, use of float instead of double where memory saving
matters
1.2.6 Character

The char data type is a single 16-bit Unicode character. It has a minimum value of '\u0000'
(or 0) and a maximum value of '\uffff' (or 65,535 inclusive).

16 bit unicode character, '\u0000'(or 0) to '\uffff'(or 65,535 inclusive)

16 bit unicode character, '\u0000'(or 0) to '\uffff'(or 65,535 inclusive)

The boolean data type has only two possible values: true and false. Use this data type for
simple flags that track true/false conditions. This data type represents one bit of information,
but its "size" isn't something that's precisely defined.
one bit information, true/false

one bit information, true/false

The double data type is a double-precision 64-bit IEEE 754 floating point. Its range of values
is beyond the scope of this discussion, but is specified in the Floating-Point Types, Formats,
and Values section of the Java Language Specification. For decimal values, this data type is
generally the default choice. As mentioned above, this data type should never be used for
precise values, such as currency.

double-precision 64-bit IEEE 754

double-precision 64-bit IEEE 754

In addition to the eight primitive data types listed above, the Java programming language
also provides special support for character strings via the java.lang.String class. Enclosing
your character string within double quotes will automatically create a new String object; for
example, String s = "this is a string";. String objects are immutable, which means that once
created, their values cannot be changed. The String class is not technically a primitive data
type, but considering the special support given to it by the language, you'll probably tend to
think of it as such.

Double Quotes, immutable: once declared; values can't be changed

2 Variables
2.1 Declaring Variables-- "Declaring the data type"

Ask compiler to allocate some amount of memory to the variable for storing some value. As
compiler would like to know the data type of the variable, so that it can allocate only
required memory to the variable. That can be done by declaring the data type of the
variable.

"Declaring the data type" so the compiler would allocate some memory to the variable
2.2 Naming Variables-- "Variable Declaration", "Identifier"

After variable declaration, when the program needs the stored value, compiler will go to the
memory location to fetch the value and pass it back to the program. To effectively handle
this transaction, the compiler would need two pieces of information from the program: name
and data type of the variable. Give the name of your choice to the variable and let the
compiler know about it. So that next time when you refer that name, compiler would know
what piece of memory you are refereeing to. That name of the variable is called the
Identifier.

Simply put, naming the variable so the compiler knows exactly which location to target to
fetch the value of the variable

DataTypeOfVariable VariableName;

2.3 Initialization of Variable- Assign the value to Variable

Once variable declaration is done, then a value can be stored in the reserved memory
location. Before that you would not be able to use the variable. Initialization of a variable is
very important before using the variable for any sort of operations. Putting an initial value is
referred to as Initializing the Variable.

VariableName = Value;