Home

Learning Hub

Articles

Data Types in Java – A Comprehensive Guide for Beginners

Within the programming domain, Java shines as a flexible and commonly used language appreciated for its portability (the ability to run on any machine) alongside performance. To develop a Java program that is both efficient and effective, it is necessary to have an understanding of data types. When we mention data types, we are referring to different kinds of information that a variable can hold during program execution. These have an impact on how memory is allocated and the kinds of operations that can be carried out on the data.

In this article, we will cover what data types are in Java, and various Java data types, explore their characteristics with their syntaxes, and even provide examples that would paint a picture of how they are used in practice.

What is a Data Type?

Data types as the name implies define the kind of data a variable can store. Java allows for storing data types with various sizes and values in variables that are created based on the needs and conditions to support every test case. They are essential for assigning variables memory addresses and defining the kinds of operations that can be carried out on them. Java allows two kinds of data types:

• Primitive data type
• Non-primitive or reference data type

Data Types in Java

In Java, two data types are supported to create, manipulate, and store the data. These two data types include: primitive and non-primitive. Let’s understand both the types in more detail:

Primitive Data Types

Primitive data types are the predefined data types by Oracle for the Java programming languages. The primitive data types have fixed sizes and memory representations and are supported directly by the hardware. Since primitive data are simple, it is not possible to break them up into smaller parts.

They are the fundamental units that Java applications use to manipulate data. The language predefines primitive type, which is identified by a reserved keyword. Primitive values are independent of one another in terms of state. Simple values are all that primitive data have, and they lack any unique features.

In Java, 8 types of primitive data types are used to create, store, and manipulate the data.

1. boolean

The boolean data type represents a single bit of information and has just two potential values: true or false. However, its “size” isn’t precisely defined; rather, it depends on the virtual machines. Boolean data types are meant to reflect the two truth values of logic and Boolean algebra by representing a single bit of information that might be true or false.

Boolean data types are more commonly used in the control flow statements, or boolean expressions when there is a need for any logical comparison. For straightforward flags that track true or false circumstances, use this data type. There is no implicit or explicit conversion (using casts) of values of type boolean to any other type in boolean. The size of the boolean is dependent on a virtual machine (VM).

Syntax:

Example: The below example demonstrates the usage of the boolean primitive data type in Java.

Output:

2. char

A char data type is a single character data type which can be an alphabetic letter, a number, a symbol, or a blank space. In Java, a char represents a single 16-bit Unicode character with values ranging from ‘u0000’ (or 0) to ‘uffff’ (or 65,535) inclusive.

Syntax:

Example: The below example demonstrates the usage of the chat primitive data type in Java.

Output:

3. short

A short data type is a signed 16-bit integer with two’s (2’s) complement integers in Java. Its range is as follows: -32,768 is its least value, while 32,767 is its maximum (inclusive). The same rules that apply to byte also apply to short data types. A short data type is very useful in scenarios where memory savings are truly important, you can use a short to conserve memory in huge arrays. The size of short = 2 bytes = 16 bits.

Syntax:

Example: The below example demonstrates the usage of the short primitive data type in Java.

Output:

4. byte

An 8-bit signed two’s (2’s) complement integer is what a byte data type is— it has an inclusive range, starting from -128 up to 127. In situations where large arrays are involved and there is a need for memory conservation due to the importance of keeping it low, using the byte data type can come in handy.

The byte data type is also used in place of int when their bounds make your code more understandable. The size of 1 byte = 8 bits.

Syntax:

Example: The below example demonstrates the usage of the byte primitive data type in Java.

Output:

5. int

The int data type is a 32-bit signed two’s complement integer with a minimum value of -2^31 and a maximum value of 2^31-1 (values are default). The int data type can be used in Java SE 8 and later to represent an unsigned 32-bit integer with a maximum value of 2^32-1 and a minimum value of 0. To use the int data type as an unsigned integer, use the Integer class using wrapper classes.

It is the most widely used data type, present in practically all programs with a significant mathematical or arithmetic operation component. The Integer class now supports arithmetic operations for unsigned integers through the addition of static methods like divideUnsigned, compareUnsigned, and so on. The size of int = 4 bytes = 32 bits.

Syntax:

Example: The below example demonstrates the usage of the int primitive data type in Java.

Output:

6. long

An unsigned 64-bit integer in Java SE 8+ can be represented by the long data type with a minimum value of zero and a maximum value of 2^64-1. The two’s complement integer for the same size is what -2^63 to 2^63-1 (values are default). To use the int data type as an unsigned integer, use the Integer class using wrapper classes.

When you require a range of values larger than those offered by int, use the long data type. When an int type cannot accommodate the required value, the long data type becomes the best type to handle the situation. The size of long = 8 bytes = 64 bits.

Syntax:

Example: The below example demonstrates the usage of the long primitive data type in Java.

Output:

7. float

The float data type is a 32-bit IEEE 754 floating point with single precision. The float data type range of values is described in the Java Language Specification’s Floating Point. If you need to save memory in large arrays of floating point integers, use a float (instead of a double), just like with the use for byte and short.

Never use this data type to calculate accurate values like currency as it may give you inaccurate values. Therefore, use the java.math for doing that task. The size float =

4 bytes = 32 bits.

Syntax:

Example: The below example demonstrates the usage of the float primitive data type in Java.

Output:

8. double

The double data type is an IEEE 754 double-precision 64-bit floating point data. Its range of values is described in the Java Language Specification’s Floating-Point Types. The double data type is typically the default selection for decimal numbers. As previously stated, the float is not recommended to calculate the precise values, rather the double data type is used to get the precise values like in the case of currency.

The size of the double = 8 bytes = 64 bits.

Syntax:

Example: The below example demonstrates the usage of the double primitive data type in Java.

Output:

Characteristics of Primitive Data Types

The primitive data types are the most commonly used in the Java language. They come predefined in Java, forming the basis for more complex data structures and objects. There are various characteristics of a primitive data type in Java:

• It is the Java language, not the programmer, that defines primitive data types.
• Real values, not pointers or addresses to memory locations, are stored by primitive data types.
• Primitive types are more memory efficient because the data is kept in memory directly.
• The size of each primitive data type is fixed as specified by the Java language specification but varies depending on the platform.
• Non-primitive types are inherently less efficient compared to primitive types in both memory consumption and speed of operation.
• There are no methods connected to primitive data types. They serve only as value storage devices.
• Once assigned, primitive data type’s values cannot be modified, making them immutable.
• When primitive types are not explicitly initialised, they have default values.

Non-Primitive or Reference Data Types

Reference data types are constructed using defined classes and include Classes, Interfaces, Arrays, and Enumerations. These data types store references to the data rather than the actual information stored in memory. When it comes to displaying complex structures and information, they are more advanced and adaptable than primitive data types. Since the reference types won’t store the variable value directly in memory, they will instead carry a memory address of the variable values.

In Java, there are various non-primitive or reference data types including strings, classes, arrays, interfaces, and enumerations.

1. Strings

A string is a collection of characters or an array of characters that are frequently used in Java programming. Strings are known as the objects in the Java programming language.

To create and work with strings, Java offers the String class. Java stores and processes text-based data using strings. Strings in Java are immutable therefore, the users cannot change the values of strings after they are formed since they cannot be muted.

Syntax:

Example: The below example demonstrates the usage of the string non-primitive data type in Java.

Output:

2. Classes

Classes are the blueprint of the objects in the object-oriented paradigm. Classes describe the structure, characteristics, and states of objects. A class acts as a template that users can utilise to create various objects like a real-world entity. It symbolises the collection of attributes or operations shared by every object of a certain type. Classes contain both data and methods to be performed on the data, and this concept is known as encapsulation.

Classes in Java are created by including below components:

• Fields: The first item that a class includes are the variables that store an object’s state, also known as attributes or variables.
• Methods: Another item class stores are functions specified inside a class that explain how an object behaves. Operations and field manipulation are capabilities of methods.
• Constructors: They are a unique method for initialising an object but without a return type and with the same name as the class.
• Body: The class body is the part that is between the {} curly braces.
• Access Modifiers: Keywords (public, private, protected, etc.) that specify how the class, its fields, and its methods are visible.

Syntax:

Example: The below example demonstrates the usage of the class non-primitive data type in Java.

Output:

3. Interfaces

An interface in Java can have variables and methods much like a class, however by default, the methods described in an interface are abstract. They simply have a method signature without a body. The interfaces in Java allow collections to be manipulated independently of the details of their representation.

In Java, an interface is a set of linked method blueprints that a class needs to include. Java’s equivalent of a class, an interface is a reference type that can only have constants, method signatures, default methods, static methods, and nested types. Instance fields and constructors are not permitted in interfaces.

Syntax:

Example: The below example demonstrates the usage of the Interfaces non-primitive data type in Java.

Output:

4. Arrays

Arrays are the fixed-sequence contiguous elements of the same type of data structure in a programming language. Arrays are containers that hold multiple values of the same type. It may contain multiple elements, unlike a primitive data type variable. The array is referred to as empty if there are no variables in it. An array’s variables don’t have names. Instead, non-negative integer index values are used in array access expressions to refer to them. These variables are referred to as the array elements.

An array’s length (n), is determined by its number of components, which are identified by integer indices ranging from 0 to n – 1. For example, we can print the first, and last elements of the array along with its length using this example. Like, the length of the array (numbers.length), the first element (numbers[0]), and the last element (numbers[numbers.length – 1]) of the array are printed to the console, for instance, using System.out.println().

Syntax:

Example: The below example demonstrates the usage of the Arrays non-primitive data type in Java.

Output:

5. Enumerations

Enumerations in Java are used when a fixed collection of named values is required, type-safe enumerations can be defined using an enum keyword. Implicitly, every enum extends java.lang.List all. Enums are special Java types used to define collections of constants. One or more enum constants, which specify particular instances of the enum type, can be found in enums. An enum declaration declares an enum type, which is very similar to a class in that it can (and usually does) have constructors, methods, fields, and other members.

Syntax:

Example: The below example demonstrates the usage of the Enumeration non-primitive data type in Java.

Output:

Characteristics of Non-Primitive Data Types

The non-primitive data types are complex to create but are easy to use. They are manually created by the Java programmer. There are various characteristics of a non-primitive data type in Java:

• The non-primitive data types like classes, interfaces, and arrays are created manually by the programmers.
• These data types can include a null value assigned to them to indicate that they do not reference any objects.
• The non-primitive data types do not store the actual value, instead store the references to those values in the memory.
• It is possible to conduct operations on the data using the methods and characteristics of non-primitive types.
• A non-primitive data type’s size is variable and contingent upon the nature of the object and its contents.
• Non-primitive data types have dynamic memory allocation, usually on the heap.
• Any variable of non-primitive data type has null as its default value.

In Java, type conversion is the process of converting one data type into another for a variable. Implicit conversion (data widening) and explicit conversion (data narrowing) are the two types of conversion that are used for converting a data type into another.

Note that one data type may not be compatible with another when you assign a value from one type to another. Java’s Automatic Type Conversion feature will automatically convert data types if they are compatible; otherwise, the data types must be cast or converted explicitly.

Implicit Type Conversion

Implicit as the name implies internal, means here the type of data is converted internally or automatically by Java itself. This conversion happens on its own when the range of the source type is smaller than that of the destination type. There is no need for explicit casting with this kind of conversion, which is safe.

Example: The below example demonstrates the usage of implicit type conversion in Java.

Output:

Explicit Type Casting

Explicit as the name means clear, states that here the type of data is converted manually by assigning the type to be converted by the programmers. Since explicit conversion, often referred to as narrowing conversion, entails changing a bigger range type to a smaller range type, which may result in data loss, explicit casting is necessary.

Example: The below example demonstrates the usage of explicit type conversion in Java.

Output:

Wrapper Classes

A wrapper class is a class that works by wrapping the objects of the primitive data types. Because the generic classes essentially don’t support primitives and allow only functions with objects. Therefore, to operate with them, we must use wrapper objects from primitive values. The Java Collection Framework, for instance, only uses objects.

In the past, the primitive values had to be manually transformed into matching wrapper classes before being placed in collections. One technique to use primitive data types as objects is using wrapper classes. There is a corresponding wrapper class for every primitive type.

In Java, there 8 wrapper classes for all primitive data types and these are:

• Character for char
• Boolean for boolean
• String for string
• Integer for int
• Short for short
• Long for long
• Float for float
• Double for double

In the wrapper classes, we have to manually specify the wrapper class to convert a primitive data type to an object or a corresponding wrapper class. But this task of manual conversion can be hectic. Therefore, we will use a concept known as boxing.

Syntax:

Example: The below example demonstrates the usage of wrapper classes using the Integer class in Java.

Output:

Autoboxing and Unboxing

Before we move on to autoboxing and unboxing, let’s learn what is Boxing. The process of translating a raw value into an equivalent wrapper object is called “boxing.”

Autoboxing

Autoboxing is the automatic conversion of primitive types to their corresponding wrapper classes.

Example: The below example demonstrates the usage of autoboxing the data types in Java.

Output:

Unboxing

Unboxing is done when a wrapper object is unwrapped into a primitive value. It’s the reverse of the autoboxing method.

Example: The below example demonstrates the usage of unboxing the data types in Java.

Output:

Collections Framework

A collection of classes and interfaces that offer an already-built architecture is called a framework. A collection of classes and interfaces for managing and storing collections of data as a single entity are offered by the Java Collections Framework. With the Java Collection Framework, the user can store, search, sort, insert, remove, and update data on a set of elements, among other data manipulation functions. List, Set, and Map are a few important interfaces provided by the collections framework.

1. List

A list is an ordered collection that is also referred to as a sequence. Duplicate elements can be added to the list in Java. To use a List, we can create objects with various available classes including ArrayList, LinkedList, etc.

Example: The below example demonstrates the usage of the List (ArrayList) data type of collections framework in Java.

Output:

2. Map

A Map interface is a data structure that supports the key-value pair needed to map the data. A map is an object that associates or maps the values with keys. A key can map to a maximum of one value in a map; multiple keys are not allowed.

Example: The below example demonstrates the usage of the Map (HashMap) data type of collections framework in Java.

Output:

3. Set

An unordered group of items whose duplicate values cannot be kept is called a set. It is a collection in which duplicate components are not added.

Example: The below example demonstrates the usage of the Set (HashSet) data type of collections framework in Java.

Output:

Difference Between Primitive and Non-Primitive Data Types in Java

The primitive and non-primitive data types have a few differences that differ in various aspects including storage, size, memory allocation, etc. Here are the key differences between the primitive and non-primitive data types in Java:

Conclusion

In this article, we have covered the data types in Java in detail. Primitive and non-primitive are two types of data types in Java that are mainly used for defining the types of data in a variable. We learned detailed implementation for each type of data type whether it is char, string, int, boolean, Map, List, etc., with their syntaxes and examples. Wrapper classes with the autoboxing and unboxing methods were also covered in this article.

Beginners can develop a strong foundation in Java programming and be ready to take on more challenging subjects and projects by grasping these ideas. A solid grasp of Java data types can be helpful whether you’re working on a complex system or creating a simple application.