{"id":76118,"date":"2020-02-05T09:57:28","date_gmt":"2020-02-05T04:27:28","guid":{"rendered":"https:\/\/techvidvan.com\/tutorials\/?p=76118"},"modified":"2020-02-05T09:57:28","modified_gmt":"2020-02-05T04:27:28","slug":"data-types-in-java","status":"publish","type":"post","link":"https:\/\/techvidvan.com\/tutorials\/data-types-in-java\/","title":{"rendered":"Data Types in Java Programming with Implementation Examples"},"content":{"rendered":"

The data-types are the most important basis of any programming language. It is the most important concept for every beginner. The data type is essential to represent the type, nature and set of operations for the value which it stores.<\/p>\n

Java data types are the most basic and initial thing you should know before moving towards other concepts of Java. These are very useful in every aspect of Java, either to create a simple program or to develop any application or software.<\/p>\n

In this tutorial, we will discuss everything that is essential for learning data types in Java. And, I bet after completing this article, you will not face any difficulty in the topic.<\/p>\n

Before starting with Java data types, let’s first learn about data types in general.<\/p>\n

What is a Data Type in Java?<\/h3>\n

In computer science, a data type is an attribute of data that tells the compiler or interpreter how the programmer aims to use the data.<\/p>\n

A data type restricts the values that expression, such as a variable or a function, might take. It defines how the values of that data type are stored in memory and what operations can be performed on the data.<\/p>\n

Data types incorporate storage categories like integers, floating-point values, strings, characters, etc.<\/p>\n

For example, if a variable is of \u201cint\u201d data type, then it can hold only integer values.<\/em><\/p>\n

Before moving towards the Java Data types, you must know the types of languages.<\/p>\n

There are majorly two types of languages:<\/p>\n

The first is statically typed language<\/strong> in which the data type of each variable has to be defined during the compile time. That is, we have to declare the type of the variable before we can use it.<\/p>\n

Once we declare a variable of a specific data type, then we cannot change its data type again. However, they can be converted to other types by using explicit type casting in Java, except boolean. Some statically typed languages are C, C++, C#, Java, <\/strong>and Scala<\/strong>.<\/p>\n

For example, if we write int num = 5<\/strong>;<\/em><\/p>\n

Then it means the variable num is of integer type and holds a numerical value and its type will always be the same.<\/p>\n

The other is dynamically typed language<\/strong>. In this type of language, the data types can change with respect to time and the variables are checked during run-time.<\/p>\n

Some dynamically typed languages are Ruby, Python, Erlang, Perl, VB,<\/strong> and PHP<\/strong>.<\/p>\n

Java Data Types<\/h3>\n

Java is a statically typed language. The base of any programming language is its data types<\/strong> and operators. Java comes with a rich set of both data types and operators, which makes it suitable for any type of programming.<\/p>\n

There are two categories of data types in Java:<\/p>\n

    \n
  1. Primitive Data Types<\/li>\n
  2. Non-Primitive DataTypes<\/li>\n<\/ol>\n

    1. Primitive Data Types in Java<\/h4>\n

    As the name suggests, the programming language pre-defines the primitive data types. Primitive types are the most basic data types available in Java. There are 8 primitive data types in Java: byte, char, short, int, long, float, double<\/strong> and boolean<\/strong>.<\/p>\n

    These data types act as the basic building blocks of data manipulation in Java. Primitive data types have a constraint that they can hold data of the same type and have a fixed size. Primitive data types are also called intrinsic data types. We can also perform operations on primitive data types.<\/p>\n

    All other types of data are derived from primitive data types.<\/p>\n

    Below diagram shows the complete chart of primitive data types –<\/p>\n

    \"primitive<\/a><\/p>\n

    Here is the classification of primitive data types in Java:<\/p>\n

    1.1 Java Characters<\/h5>\n

    A character is used to store a \u2018single\u2019 character. A single quote must surround a character. The valid Character type is char<\/strong>. In Java, a character is not an 8-bit quantity but here character is represented by a 16-bit Unicode.<\/p>\n

    Syntax:<\/strong><\/p>\n

    char myChar = \u2019A\u2019 ;<\/p>\n

    Size:<\/strong><\/p>\n

    2 bytes(16 bits)<\/p>\n

    Values:<\/strong><\/p>\n

    A single character representing a digit, letter, or symbol.<\/p>\n

    Default Value:<\/strong><\/p>\n

    ‘\\u0000\u2019 (0)<\/p>\n

    Range:<\/strong><\/p>\n

    ‘\\u0000’ (0) to ‘\\uffff’ (65535)<\/p>\n

    Code:<\/strong><\/p>\n

    public class CharDataType\n{\n  public static void main(String args[])\n  {\n    char marks,grade;\n    marks = '8';\n    grade = 'B';\n    System.out.println(\"Marks: \"+marks);\n    System.out.println(\"Grade: \"+grade);\n  }\n}<\/pre>\n
    Output:<\/strong><\/p>\n
    \n
    Marks: 8
    \nGrade: B<\/p>\n<\/div>\n
    We can also perform arithmetic operations on it since it is an unsigned 16-bit type. For example<\/strong>, consider the following program:<\/p>\n
    \/\/ char can be handled like integers\npublic class CharClass\n{\n  public static void main(String args[])\n  {\n    char myChar1 = 'A';\n    char myChar2 = 'B';\n\n    System.out.println(\"myChar1: \" +myChar1);\n    System.out.println(\"myChar2: \" +myChar2);\n    myChar2++; \/\/ valid increment operation\n    System.out.println(\"The Incremented value of myChar2: \" +myChar2);\n  }\n}<\/pre>\n
    Output:<\/strong><\/p>\n
    \n
    myChar1: A
    \nmyChar2: B
    \nThe incremented value of myChar2: C<\/p>\n<\/div>\n
    1.2 Java Integers<\/h5>\n
    Integer type stores whole numbers that may be positive or negative and should not contain any decimal places. Valid Integer types are – byte, short, int, <\/strong>and long<\/strong>. What type will be taken depends on the value or range of the variable.<\/p>\n
    \"valid<\/a><\/p>\n
    1.2.1 byte\u00a0<\/strong><\/p>\n
    The byte data type is mostly used in the large arrays which need memory savings. It saves memory as it is 4 times smaller than an int (integer). Sometimes, it can also be used in place of the “int” data type, when the value is very small.<\/p>\n
    The byte data type is an 8-bit signed 2\u2019s complement integers.<\/p>\n
    Syntax:<\/strong><\/p>\n
    byte myByte1 = -100 ;
    \nbyte myByte2 = 25 ;<\/p>\n
    Size:<\/strong><\/p>\n
    1 byte(8 bits)<\/p>\n
    Values:<\/strong><\/p>\n
    Positive or negative whole numbers.<\/p>\n
    Default Value:<\/strong><\/p>\n
    0<\/p>\n
    Range:<\/strong><\/p>\n
    -128 to 127<\/p>\n
    Code:<\/strong><\/p>\n
    public class ByteDataType\n{\n  public static void main(String args[])\n  {\n    byte myByte1,myByte2;\n    myByte1 = 127;\n    myByte2 = -48;\n    System.out.println(\"Byte 1: \" +myByte1);\n    System.out.println(\"Byte 2: \" +myByte2);\n    myByte1++; \/\/ Looping back within the range\n    System.out.println(\"Incremented Value of myByte1: \" +myByte1);\n  }\n}<\/pre>\n
    Output:<\/strong><\/p>\n
    \n
    Byte 1: 127
    \nByte 2: -48
    \nIncremented Value of myByte1: -128<\/p>\n<\/div>\n
    1.2.2 short<\/strong><\/p>\n
    Similar to the byte data type, a short data type is also used to save memory in large arrays. The short data type is a 16-bit signed 2\u2019s complement integer. It is half of an int (integer).<\/p>\n
    Syntax:<\/strong><\/p>\n
    short myShort = 6000 ;<\/p>\n
    Size:<\/strong><\/p>\n
    2 bytes (16 bits)<\/p>\n
    Values:<\/strong><\/p>\n
    Positive or negative whole numbers.<\/p>\n
    Default Value:<\/strong><\/p>\n
    0<\/p>\n
    Range:<\/strong><\/p>\n
    -32768 to 32767<\/p>\n
    Code:<\/strong><\/p>\n
    public class ShortDataType\n{\n  public static void main(String args[])\n  {\n    short myShort = 6000;\n    System.out.println(\"myShort: \" + myShort);\n  }\n}<\/pre>\n
    Output:<\/strong><\/p>\n
    \n
    myShort: 6000<\/p>\n<\/div>\n
    1.2.3. int<\/strong><\/p>\n
    Generally, we prefer to use int data type for integral values unless if there is no issue with memory. The int data type is a 32-bit signed 2’s complement integer.<\/p>\n
    Syntax:<\/strong><\/p>\n
    int myNum = 700000 ;<\/p>\n
    Size:<\/strong><\/p>\n
    4 bytes (32 bits)<\/p>\n
    Values:<\/strong><\/p>\n
    Positive or negative whole numbers.<\/p>\n
    Default Value:<\/strong><\/p>\n
    0<\/p>\n
    Range:<\/strong><\/p>\n
    – 2,147,483,648 (-231) to 2,147,483,647 (231 -1)<\/p>\n
    Note:<\/strong> In Java Standard Edition (SE) 8 version and later, we can use the int data type to represent an unsigned 32-bit integer<\/em>, which has value in the range [0, 232-1]. We Use the Integer<\/em> class to use the unsigned int data type of integer.<\/p>\n
    Code:<\/strong><\/p>\n
    public class IntDataType\n{\n  public static void main(String args[])\n  {\n    int myNum1, myNum2, result;\n    myNum1 = -7000;\n    myNum2 = 90000;\n    result = myNum1 + myNum2;\n    System.out.println(\"Number 1: \" +myNum1);\n    System.out.println(\"Number 2: \" +myNum2);\n    System.out.println(\"Number 1 + Number 2: \" +result);\n  }\n}<\/pre>\n
    Output:<\/strong><\/p>\n
    \n
    Number 1: -7000
    \nNumber 2: 90000
    \nNumber 1 + Number 2: 83000<\/p>\n<\/div>\n
    1.2.4. long\u00a0<\/strong><\/p>\n
    The long data type is a 64-bit signed 2’s complement integers. It is used when int data type cannot hold a value. It is 2 times larger than int(integer). We must use L<\/strong> at the end of the value.<\/p>\n
    Syntax:<\/strong><\/p>\n
    long myLong = 11000000000L ;<\/p>\n
    Size:<\/strong><\/p>\n
    8 bytes (64 bits)<\/p>\n
    Values:<\/strong><\/p>\n
    Positive or negative whole numbers.<\/p>\n
    Default Value:<\/strong><\/p>\n
    0<\/p>\n
    Range:<\/strong><\/p>\n
    -9,223,372,036,854,775,808(-263) to 9,223,372,036,854,775,807(263 -1)<\/p>\n
    Note:<\/strong> In Java Standard Edition (SE) 8 version and later, we can use the long data type to represent an unsigned 64-bit long<\/em>, which has value in the range [0, 264-1]. We use the Long<\/em> class to use the unsigned long data type.<\/p>\n
    Code:<\/strong><\/p>\n
    public class LongDataType\n{\n  public static void main(String args[])\n  {\n    long myLong1, myLong2, result;\n    myLong1 = 100000000L;\n    myLong2 = 200L;\n    result = myLong1 * myLong2;\n    System.out.println(\"Number 1: \" +myLong1);\n    System.out.println(\"Number 2: \" +myLong2);\n    System.out.println(\"Number 1 * Number 2: \" +result);\n  }\n}<\/pre>\n
    Output:<\/strong><\/p>\n
    \n
    Number 1: 100000000
    \nNumber 2: 200
    \nNumber 1 * Number 2: 20000000000<\/p>\n<\/div>\n
    1.3 Java Floating-Point Types<\/h5>\n
    These are the types that store the floating-point values or real numbers, which have floating decimal places. For example,<\/strong> it can store fractional numbers like 5.5, 100.78, 2090.985, etc. Valid floating-point types are float<\/strong> and double<\/strong>.<\/p>\n
    We will discuss both of them in detail.<\/p>\n
    1.3.1. float<\/strong><\/p>\n
    The float data type is a single-precision 32-bit floating-point, based on the IEEE 754 format (single-precision floating-point numbers). We use a float instead of double to store values in a large array of floating-point numbers so as to save memory.<\/p>\n
    Remember, we should always end the float type value with f or F<\/strong>, otherwise, the compiler considers it as a double value.<\/p>\n
    Syntax:<\/strong><\/p>\n
    float myFloat = 256.8f ;<\/p>\n
    Size:<\/strong><\/p>\n
    4 bytes (32 bits)<\/p>\n
    Values:<\/strong><\/p>\n
    Real numbers up to 7 decimal digits.<\/p>\n
    Default Value:<\/strong><\/p>\n
    0.0f<\/p>\n
    Range:<\/strong><\/p>\n
    1.40239846 x 10-45 to 3.40282347 x 1038<\/p>\n
    Code:<\/strong><\/p>\n
    public class FloatDataType\n{\n \t\tpublic static void main(String args[])\n \t\t{\n \t\t \t\tfloat myFloat1,myFloat2,result;\n \t\t \t\tmyFloat1=1000.666f;\n \t\t \t\tmyFloat2=110.77f;\n \t\t \t\tresult=myFloat1-myFloat2;\n \t\t \t\tSystem.out.println(\"Number1: \"+myFloat1);\n \t\t \t\tSystem.out.println(\"Number2: \"+myFloat2);\n \t\t \t\tSystem.out.println(\"Number1-Number2: \"+result);\n \t\t}\n}<\/pre>\n
    Output:<\/strong><\/p>\n
    \n
    Number1: 1000.666
    \nNumber2: 110.77
    \nNumber1-Number2: 889.896<\/p>\n<\/div>\n
    1.3.2. double<\/strong><\/p>\n
    Generally, we prefer to use the float data type for decimal values unless if there is no issue with memory. As it has a precision up to 15 decimals, it is safe to use double for large calculations. We can optionally<\/em> use the suffix d<\/strong> or D<\/strong> to end the floating type value.<\/p>\n
    That is, both 19.67 and 19.67d are the same. The double data type is a double-precision 64-bit floating-point, based on the IEEE 754 format (double-precision floating-point numbers).<\/p>\n
    Syntax:<\/strong><\/p>\n
    double myDouble = 256.7879837 ;<\/p>\n
    Size:<\/strong><\/p>\n
    8 bytes (64 bits)<\/p>\n
    Values:<\/strong><\/p>\n
    Real numbers up to 15 decimal digits.<\/p>\n
    Default Value:<\/strong><\/p>\n
    0.0<\/p>\n
    Range:<\/strong><\/p>\n
    4.9406564584124654 x 10-324 to 1.7976931348623157 x 10308<\/p>\n
    Code:<\/strong><\/p>\n
    public class DoubleDataType\n{\n    public static void main(String args[])\n    {\n        double myDouble1, myDouble2, result;\n        myDouble1 = 48976.8987;\n        myDouble2 = 29513.7812d;\n        result = myDouble1 + myDouble2;\n        System.out.println(\"Number 1: \" +myDouble1);\n        System.out.println(\"Number 2: \" +myDouble2);\n        System.out.println(\"Number 1 + Number 2: \" +result);\n    }\n}<\/pre>\n
    Output:<\/strong><\/p>\n
    \n
    Number 1: 48976.8987
    \nNumber 2: 29513.7812
    \nNumber 1 + Number 2: 78490.6799<\/p>\n<\/div>\n
    1.4 Boolean Types<\/h5>\n
    A boolean data type is a 2-valued data type that is declared with the boolean<\/strong> keyword. It is capable of storing only two possible values i.e., true<\/strong> and false<\/strong>.<\/p>\n
    This data type is used for flag generations, to check the true or false conditions. Boolean data type stores only 1-bit information and size is not precisely defined.<\/p>\n
    Syntax:<\/strong><\/p>\n
    boolean myBool = false ;<\/p>\n
    Size:<\/strong><\/p>\n
    Machine-dependent<\/p>\n
    Values:<\/strong><\/p>\n
    true, false<\/p>\n
    Default Value:<\/strong><\/p>\n
    false<\/p>\n
    Range:<\/strong><\/p>\n
    true or false<\/p>\n
    Code:<\/strong><\/p>\n
    public class BooleanDataType\n{\n  public static void main(String args[])\n  {\n    boolean myBool = true;\n    if(myBool == true)\n      System.out.println(\"I am using a Boolean data type\");\n      System.out.println(myBool);\n  }\n}<\/pre>\n
    Output:<\/strong><\/p>\n
    \n
    I am using a Boolean data type
    \ntrue<\/p>\n<\/div>\n
    2. Non-Primitive Data Types in Java<\/h4>\n
    The term non-primitive data type means that these types contain \u201ca memory address of the variable\u201d.<\/p>\n
    In contrast to primitive data types, which are defined by Java, non-primitive data types are not defined or created by Java but they are created by the programmers.<\/p>\n
    They are also called Reference data types<\/strong> because they cannot store the value of a variable directly in memory.Non-primitive data types do not store the value itself but they store a reference or address (memory location) of that value.<\/p>\n
    They can call methods to perform a particular function. They can also be null.<\/p>\n
    For example:<\/strong><\/p>\n
    long modelNumber = 62548723468;<\/pre>\n
    Instead of storing the value of modelNumber directly, reference data types in Java will store the address of this variable. So reference data type will store 1003 rather than the actual value. The below diagram explains how the value is stored in a memory area.<\/p>\n
    \"storage<\/a><\/p>\n
    There are many non-primitive data types in Java.<\/p>\n
    \"non-primitive<\/a><\/p>\n
    Let us now understand these.<\/p>\n
    2.1. Java Strings<\/h5>\n
    The String data type is used to store a sequence or array of characters (text). But in Java, a string is an object<\/strong> that represents an array or sequence of characters. The java.lang.String<\/em> is the class is used for creating a string object.<\/p>\n
    String literals should be enclosed within double-quotes. The difference between a character array and a string is that in the string a special character \u2018\\0\u2019 is present.<\/p>\n
    Basic Syntax for declaring a string in Java:<\/strong><\/p>\n
    String <String_variable_name> = \u201c<sequence_Of_Strings>\u201d ;<\/pre>\n
    Example:<\/strong><\/p>\n
    String myString = \u201cHello World\u201d ;<\/pre>\n
    Ways to create a string object:<\/strong><\/p>\n
    There are 2 ways of creating a String object:<\/p>\n