{"id":87391,"date":"2020-04-22T15:00:00","date_gmt":"2020-04-22T12:00:00","guid":{"rendered":"http:\/\/examples.javacodegeeks.com\/?p=87391"},"modified":"2020-04-27T17:25:22","modified_gmt":"2020-04-27T14:25:22","slug":"java-data-types-example","status":"publish","type":"post","link":"https:\/\/examples.javacodegeeks.com\/java-data-types-example\/","title":{"rendered":"Java Data Types Example"},"content":{"rendered":"

In this article, we will learn about the Java data types. We will see examples with Java Primitive Data Types, like Number, Floating-point, Boolean, and Character, and examples with non-primitive Types, like String, Object, Interface, and Array.<\/p>\n

\n

Table Of Contents<\/h3>\n
\n
1. Introduction<\/a><\/dt>\n
2. Data Type<\/a><\/dt>\n
\n
\n
2.1 Primitive Data Type<\/a><\/dt>\n
\n
\n
2.1.1 Number<\/a><\/dt>\n
2.1.2 Floating-point<\/a><\/dt>\n
2.1.3 Boolean<\/a><\/dt>\n
2.1.4 Character<\/a><\/dt>\n<\/dl>\n<\/dd>\n
2.2 Non-Primitive Data Type<\/a><\/dt>\n
\n
\n
2.2.1 String<\/a><\/dt>\n
2.2.2 Object<\/a><\/dt>\n
2.2.3 Interface<\/a><\/dt>\n
2.2.4 Array<\/a><\/dt>\n<\/dl>\n<\/dd>\n<\/dl>\n<\/dd>\n
3. Java Data Types – Summary<\/a><\/dt>\n
4. Download the source code<\/a><\/dt>\n<\/dl>\n<\/div>\n

<\/a>1. Introduction<\/h2>\n

The Java programming language is statically-typed, which means that all variables must first be declared before they can be used. This involves stating the variable’s type and name.<\/p>\n

int age = 10;<\/pre>\n
Doing so tells your program that a field named age<\/em> exists, holds numerical data, and has an initial value of 10<\/em>. A variable’s data type determines the values it may contain, plus the operations that may be performed on it.<\/p>\n
<\/a>2. Data Type<\/h2>\n
In this section, we will look into the different types of data types<\/code> available in Java. In Java, Data Types<\/code> are divided into two broad categories: Primitive data types<\/code> and Non-primitive data types<\/code>.<\/p>\n
\"Java
Java Data Types<\/figcaption><\/figure>\n
<\/a>2.1 Primitive Data Type<\/h3>\n
A primitive type is predefined by the language and is named by a reserved keyword. It specifies the size and type of variable values, and it has no additional methods. Primitive values do not share state with other primitive values. There are eight primitive data types<\/code> in Java: byte<\/code>, short<\/code>, int<\/code>, long<\/code>, float<\/code>, double<\/code>, boolean<\/code> and char<\/code><\/p>\n
\n\n\n\n\n\n\n\n\n\n\n\n
Data Type<\/strong><\/td>\nSize<\/strong><\/td>\nDescription<\/strong><\/td>\nDefault Value<\/strong><\/td>\n<\/tr>\n
boolean<\/td>\n1 bit<\/td>\nHas values as true<\/code> or false<\/code><\/td>\nfalse<\/td>\n<\/tr>\n
byte<\/td>\n1 byte<\/td>\nStores whole numbers from -128 to 127<\/td>\n0<\/td>\n<\/tr>\n
char<\/td>\n2 bytes<\/td>\nStores a single character\/letter or ASCII values<\/td>\n‘\\u0000’<\/td>\n<\/tr>\n
short<\/td>\n2 bytes<\/td>\nStores whole numbers from -32,768 to 32,767<\/td>\n0<\/td>\n<\/tr>\n
int<\/td>\n4 bytes<\/td>\nStores whole numbers from -2,147,483,648 to 2,147,483,647<\/td>\n0<\/td>\n<\/tr>\n
long<\/td>\n8 bytes<\/td>\nStores whole numbers from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807<\/td>\noL<\/td>\n<\/tr>\n
float<\/td>\n4 bytes<\/td>\nStores fractional numbers. Sufficient for storing 6 to 7 decimal digits<\/td>\n0.0f<\/td>\n<\/tr>\n
double<\/td>\n8 bytes<\/td>\nStores fractional numbers. Sufficient for storing 15 decimal digits<\/td>\n0.0d<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n
<\/a>2.1.1 Numbers<\/h4>\n
Primitive number types are divided into two groups:<\/p>\n
Integer<\/strong> types stores whole numbers, positive or negative (such as 999 or -999), without decimals. Valid types are byte<\/code>, short<\/code>, int<\/code> and long<\/code>. Which type you should use, depends on the numeric value.<\/p>\n
Floating-point<\/b> types represent numbers with a fractional part, containing one or more decimals. There are two types: float<\/code> and double<\/code>.
 
<\/div> <\/div><\/p>\n
Byte<\/strong><\/p>\n
The byte<\/code> data type is an 8-bit signed two’s complement integer. The byte<\/code> data type can store whole numbers from -128<\/code> to 127<\/code>. This can be used instead of int<\/code> or other integer types to save memory when you are certain that the value will be within -128<\/code> and 127<\/code>. The byte<\/code> data type is used to save memory in large arrays where the memory saving is most required. It saves space because a byte is 4 times smaller than an integer<\/p>\n
byte myByte = 125;\nSystem.out.println(myByte);<\/pre>\n
Short<\/strong> <\/p>\n
The short<\/code> data type is a 16-bit signed two’s complement integer. Its value-range lies between -32,768<\/code> to 32,767<\/code> (inclusive). Its default value is 0. The short<\/code> data type can also be used to save memory just like byte<\/code> data type. A short data type is 2 times smaller than an integer.<\/p>\n
short myShort = -32765;\nSystem.out.println(myShort);<\/pre>\n
Int<\/strong><\/p>\n
The int<\/code> data type is a 32-bit signed two’s complement integer. Its value-range lies between - 2,147,483,648<\/code> (-2^31<\/code>) to 2,147,483,647<\/code> (2^31 -1<\/code>) (inclusive). Its default value is 0.The int<\/code> data type is generally used as a default data type for integral values unless if there is no problem about memory.<\/p>\n
int myInt = 2147483647;\nSystem.out.println(myInt);<\/pre>\n
Long<\/strong>
The long<\/code> data type can store whole numbers from -9223372036854775808<\/code> to 9223372036854775807<\/code>. This is used when int<\/code> is not large enough to store the value. Note that you should end the value with an L<\/code>.<\/p>\n
long myLong = -9223372036854775808L;\nSystem.out.println(myLong);<\/pre>\n
<\/a>2.1.2 Floating-point<\/h4>\n
Use floating-point type data-type when the number is in decimal.<\/p>\n
Float<\/strong>
The float<\/code> data type can store fractional numbers from 3.4e\u2212038<\/code> to 3.4e+038<\/code>. Note that you should end the value with an f<\/code>:<\/p>\n
float myFloat = 1234567.75f;\nSystem.out.println(myFloat);<\/pre>\n
Double<\/strong>
The double<\/code> data type can store fractional numbers from 1.7e\u2212308<\/code> to 1.7e+308<\/code>. Note that you should end the value with a d<\/code>:<\/p>\n
double myDouble = 123456789012.75234d;\nSystem.out.println(myDouble);<\/pre>\n
Running the above code will output 1.2345678901275233E11<\/code>. The precision of a floating point value indicates how many digits the value can have after the decimal point. The precision of float<\/code> is only six or seven decimal digits, while double<\/code> variables have a precision of about 15 digits. Therefore it is safer to use double for most calculations.<\/p>\n
<\/a>2.1.3 Boolean<\/h4>\n
A boolean data type is declared with the boolean keyword and can only take the values true or false. They are mostly used for conditional testing.<\/p>\n
boolean myBoolean = true;\nSystem.out.println(myBoolean);<\/pre>\n
<\/a>2.1.4 Character<\/h4>\n
The char<\/code> data type is used to store a single character. The character must be surrounded by single quotes, like ‘A’ or ‘a’.You can also use ASCII values to display certain characters:<\/p>\n
char myChar = 'a';\nSystem.out.println(myChar);\nchar A = 65;\nSystem.out.println(A);<\/pre>\n
<\/a>2.2 Non-Primitive Data Type<\/h3>\n
Non-primitive data types are called reference types because they refer to objects. The main difference between primitive and non-primitive data types are:<\/p>\n