Primitive Data Types - Java Data Types Tutorial For Beginners 2020

The 8 primitive data types byte, short, int, long, char, boolean, float, and double are the types that store most raw numerical data in Java programs.

Table of Contents

The char primitive data types

A char can store a single 16-bit Unicode character. A character literal is enclosed in single quotes

char myChar = 'u';
char myChar2 = '5';
char myChar3 = 65; // myChar3 == 'A'

It has a minimum value of \u0000 (0 in the decimal representation, also called the null character) and a maximum value of \uffff (65,535).

The default value of a char is \u0000.

char defaultChar; // defaultChar == \u0000

In order to define a char of ‘ value an escape sequence (character preceded by a backslash) has to be used:

char singleQuote = '\'';

There are also other escape sequences:

char tab = '\t';
char backspace = '\b';
char newline = '\n';
char carriageReturn = '\r';
char formfeed = '\f';
char singleQuote = '\'';
char doubleQuote = '\"'; // escaping redundant here; '"' would be the same; however still allowed
char backslash = '\';
char unicodeChar = '\uXXXX' // XXXX represents the Unicode-value of the character you want to
display

You can declare a char of any Unicode character.

char heart = '\u2764';
System.out.println(Character.toString(heart));    // Prints a line containing "❤".

It is also possible to add to a char. e.g. to iterate through every lower-case letter, you could do to the following:

for (int i = 0; i <= 26; i++) {
char letter = (char) ('a' + i);
System.out.println(letter);
}

Primitive Types Cheatsheet

Table showing size and values range of all primitive types:

data type	numeric representation	range of values	default value
boolean	n/a	false and true	false
short	8-bit signed	-27 to 27 – 1, -128 to +127	0
short	16-bit signed	-215 to 215 – 1, -32,768 to +32,767	0
int	32-bit signed	-231 to 231 – 1, -2,147,483,648 to +2,147,483,647	0
float	64-bit signed	-263 to 263 – 1, -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807	0L
float	32-bit floating point	1.401298464e-45 to 3.402823466e+38 (positive or negative)	0.0F
double	64-bit floating point	4.94065645841246544e-324d to 1.79769313486231570e+308d (positive or negative)	0.0D
char	16-bit unsigned	0 to 216 – 1, 0 to 65,535	0

Notes:

The Java Language Specification mandates that signed integral types (byte through long) use binary twos-complement representation and the floating-point types use standard IEE 754 binary floating-point
representations.
Java 8 and later provide methods to perform unsigned arithmetic operations on int and long. While these methods allow a program to treat values of the respective types as unsigned, the types remain signed types.
The smallest floating-point shown above is subnormal; i.e. they have less precision than normal value. The smallest normal numbers are 1.175494351e−38 and 2.2250738585072014e−308
A char conventionally represents a Unicode / UTF-16 code unit.
Although a boolean contains just one bit of information, its size in memory varies depending on the Java Virtual Machine implementation (see boolean type).

The float primitive

A float is a single-precision 32-bit IEEE 754 floating point number. By default, decimals are interpreted as doubles.
To create a float, simply append an f to the decimal literal.

double doubleExample = 0.5;    // without 'f' after digits = double
float floatExample = 0.5f;    // with 'f' after digits = float
float myFloat = 92.7f;        // this is a float…
float positiveFloat = 89.3f;  // it can be positive,
float negativeFloat = -89.3f; // or negative
float integerFloat = 43.0f;   // it can be a whole number (not an int)
float underZeroFloat = 0.0549f; // it can be a fractional value less than 0

Floats handle the five common arithmetical operations: addition, subtraction, multiplication, division, and modulus.

Note: The following may vary slightly as a result of floating-point errors. Some results have been rounded for clarity and readability purposes (i.e. the printed result of the addition example was actually 34.600002).

// addition
float result = 37.2f + -2.6f; // result: 34.6
// subtraction
float result = 45.1f - 10.3f; // result: 34.8
GoalKicker.com – Java® Notes for Professionals 44
// multiplication
float result = 26.3f * 1.7f; // result: 44.71
// division
float result = 37.1f / 4.8f; // result: 7.729166
// modulus
float result = 37.1f % 4.8f; // result: 3.4999971

Because of the way floating point numbers are stored (i.e. in binary form), many numbers don’t have an exact representation.

float notExact = 3.1415926f;
System.out.println(notExact); // 3.1415925

While using float is fine for most applications, neither float nor double should be used to store exact representations of decimal numbers (like monetary amounts), or numbers where higher precision is required. Instead, the BigDecimal class should be used.

The default value of a float is 0.0f.

float defaultFloat; // defaultFloat == 0.0f
A float is precise to roughly an error of 1 in 10 million.

Note: Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, Float.NaN are float values. NaN stands for results of operations that cannot be determined, such as dividing 2 infinite values. Furthermore 0f and -0f are different, but == yields true:

float f1 = 0f;
float f2 = -0f;
System.out.println(f1 == f2); // true
System.out.println(1f / f1); // Infinity
System.out.println(1f / f2); // -Infinity
System.out.println(Float.POSITIVE_INFINITY / Float.POSITIVE_INFINITY); // NaN

The int primitive

A primitive data type such as int holds values directly into the variable that is using it, meanwhile, a variable that was declared using Integer holds a reference to the value.

According to java API: “The Integer class wraps a value of the primitive type int in an object. An object of type Integer contains a single field whose type is int.”

By default, int is a 32-bit signed integer. It can store a minimum value of -231, and a maximum value of 231 – 1.

int example = -42;
int myInt = 284;
int anotherInt = 73;
int addedInts = myInt + anotherInt; // 284 + 73 = 357
int subtractedInts = myInt - anotherInt; // 284 - 73 = 211

If you need to store a number outside of this range, long should be used instead. Exceeding the value range of int leads to an integer overflow, causing the value exceeding the range to be added to the opposite site of the range (positive becomes negative and vise versa). The value is ((value – MIN_VALUE) % RANGE) + MIN_VALUE, or ((value + 2147483648) % 4294967296) – 2147483648

int demo = 2147483647; //maximum positive integer
System.out.println(demo); //prints 2147483647
demo = demo + 1; //leads to an integer overflow
System.out.println(demo); // prints -2147483648

The maximum and minimum values of int can be found at:

int high = Integer.MAX_VALUE; // high == 2147483647
int low = Integer.MIN_VALUE; // low == -2147483648
The default value of an int is 0
int defaultInt; // defaultInt == 0

Converting Primitives

In Java, we can convert between integer values and floating-point values. Also, since every character corresponds to a number in the Unicode encoding, char types can be converted to and from the integer and floating-point types. boolean is the only primitive data type that cannot be converted to or from any other primitive datatype.

There are two types of conversions: widening conversion and narrowing conversion.

A widening conversion is when a value of one data type is converted to a value of another data type that occupies more bits than the former. There is no issue of data loss in this case.

Correspondingly, A narrowing conversion is when a value of one data type is converted to a value of another data type that occupies fewer bits than the former. Data loss can occur in this case.

Java performs widening conversions automatically. But if you want to perform a narrowing conversion (if you are sure that no data loss will occur), then you can force Java to perform the conversion using a language construct known as a cast.

Widening Conversion:

int a = 1;
double d = a; // valid conversion to double, no cast needed (widening)

Narrowing Conversion:

double d = 18.96
int b = d;               // invalid conversion to int, will throw a compile-time error
int b = (int) d;        // valid conversion to int, but result is truncated (gets rounded down)
                        // This is type-casting
                        // Now, b = 18

Memory consumption of primitives vs. boxed primitives

Primitive	Boxed Type	Memory Size of primitive / boxed
boolean	Boolean	1 byte / 16 bytes
byte	Byte	1 byte / 16 bytes
short	short	2 bytes / 16 bytes
char	Char	2 bytes / 16 bytes
int	Integer	4 bytes / 16 bytes
long	Long	8 bytes / 16 bytes
float	Float	4 bytes / 16 bytes
double	Double	8 bytes / 16 bytes

Boxed objects always require 8 bytes for type and memory management, and because the size of objects is always a multiple of 8, boxed types all require 16 bytes total. In addition, each usage of a boxed object entails storing a reference which accounts for another 4 or 8 bytes, depending on the JVM and JVM options.

In data-intensive operations, memory consumption can have a major impact on performance. Memory consumption grows even more when using arrays: a float[5] array will require only 32 bytes; whereas a Float[5] storing 5 distinct non-null values will require 112 bytes total (on 64 bit without compressed pointers, this increases to 152 bytes).

Boxed value caches

The space overheads of the boxed types can be mitigated to a degree by the boxed value caches. Some of the boxed types implement a cache of instances. For example, by default, the Integer class will cache instances to represent numbers in the range -128 to +127. This does not, however, reduce the additional cost arising from the additional memory indirection.

If you create an instance of a boxed type either by autoboxing or by calling the static valueOf(primitive) method, the runtime system will attempt to use a cached value. If your application uses a lot of values in the range that is
cached, then this can substantially reduce the memory penalty of using boxed types. Certainly, if you are creating boxed value instances “by hand”, it is better to use valueOf rather than new. (The new operation always creates a new instance.) If, however, the majority of your values are not in the cached range, it can be faster to call new and save the cache lookup.