Data Type

Variable
In java variable store specific type data in memory;
e.g int age = 23;

here age is a variable of type int which has a value 23. The variable is stored in RAM. How much memory is required and the format of data can be found by Data Type in this case int which requires 32bit of memory.

so int is a data type
age is variable
23 is a value ?? How 23 is understood by java
23 is Integer Literal

Primitive Data types

  • byte:
    • The byte data type is an 8-bit 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.
  • short:
    • The short data type is a 16-bit integer.
    • It has a minimum value of -32,768 and a maximum value of 32,767 (inclusive).
  • int:
    • The int data type is a 32-bit integer,
    • which has a minimum value of -231and a maximum value of 231-1.
  • long:
    • The long data type is a 64-bit integer.
    • The signed long has a minimum value of -263 and a maximum value of 263-1.
  • float:
    • 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.
  • double:
    • 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.
  • boolean:
    • 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.
  • char:
    • 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).

Literals

Primitive types are special data types built into the language;
A literal is the source code representation of a fixed value i.e programmer as well as compiler have same knowledge about the symbol.
literals are represented directly in your code without requiring computation.
As shown below, it’s possible to assign a literal to a variable of a primitive type:


boolean result = true;
char capitalC = 'C';
byte b = 100;
short s = 10000;
int i = 100000;

Here, true, ‘C’, 1000, 10000, 100000 are literal.

Integer Literals

An integer literal is of type long if it ends with the letter L or l; otherwise it is of type int.
Values of the integral types byte, short, int, and long can be created from int literals.
Values of type long that exceed the range of int can be created from long literals.

Integer literals can be expressed by these number systems:

  • Decimal: Base 10, whose digits consists of the numbers 0 through 9; this is the number system you use every day
  • Hexadecimal: Base 16, whose digits consist of the numbers 0 through 9 and the letters A through F
  • Binary: Base 2, whose digits consists of the numbers 0 and 1
  • Octal: Base 8, whose digit consists of the numbers 0 through 7

// The number 26, in decimal
int decVal = 26;
// The number 26, in hexadecimal
int hexVal = 0x1a;
// The number 26, in binary
int binVal = 0b11010;
// The number 10 in Octal
int octVal = 012;

Binary Literal starts with 0b
Hexadecimal start with 0x
Octal star with 0
Decimal base start with other than 0

Floating-Point Literals

A floating-point literal is of type float if it ends with the letter F or f; otherwise its type is double and it can optionally end with the letter D or d.
The floating point types (float and double) can also be expressed using E or e (for scientific notation)


double d1 = 123.4;
// same value as d1, but in scientific notation
double d2 = 1.234e2;
float f1 = 123.4f;

Character and String Literals

Literals of types char and String may contain any Unicode (UTF-16) characters. If your editor and file system allow it, you can use such characters directly in your code. If not, you can use a “Unicode escape” such as '\u0108' (capital C with circumflex), or "S\u00ED Se\u00F1or" (Sí Señor in Spanish).
Always use ‘single quotes’ for char literals and “double quotes” for String literals.

Unicode escape sequences
The Java programming language also supports a few special escape sequences for char and String literals: \b(backspace),
\t (tab),
\n (line feed),
\f (form feed),
\r (carriage return),
\" (double quote),
\' (single quote), and
\\(backslash).
There’s also a special null literal that can be used as a value for any reference type. null may be assigned to any variable, except variables of primitive types.
null is often used in programs as a marker to indicate that some object is unavailable.

Using Underscore Characters in Numeric Literals

In Java SE 7 and later, any number of underscore characters (_) can appear anywhere between digits in a numerical literal. This feature enables you, for example. to separate groups of digits in numeric literals, which can improve the readability of your code.
The following example shows other ways you can use the underscore in numeric literals:


long creditCardNumber = 1234_5678_9012_3456L;
long socialSecurityNumber = 999_99_9999L;
float pi = 3.14_15F;
long hexBytes = 0xFF_EC_DE_5E;
long hexWords = 0xCAFE_BABE;
long maxLong = 0x7fff_ffff_ffff_ffffL;
byte nybbles = 0b0010_0101;
long bytes = 0b11010010_01101001_10010100_10010010;

You can place underscores only between digits; you cannot place underscores in the following places:

  • At the beginning or end of a number
  • Adjacent to a decimal point in a floating point literal
  • Prior to an F or L suffix
  • In positions where a string of digits is expected

The following examples demonstrate valid and invalid underscore placements (which are highlighted) in numeric literals:


// Invalid: cannot put underscores
// adjacent to a decimal point
float pi1 = 3_.1415F;
// Invalid: cannot put underscores
// adjacent to a decimal point
float pi2 = 3._1415F;
// Invalid: cannot put underscores
// prior to an L suffix
long socialSecurityNumber1 = 999_99_9999_L;

// OK (decimal literal)
int x1 = 5_2;
// Invalid: cannot put underscores
// At the end of a literal
int x2 = 52_;
// OK (decimal literal)
int x3 = 5_______2;

// Invalid: cannot put underscores
// in the 0x radix prefix
int x4 = 0_x52;
// Invalid: cannot put underscores
// at the beginning of a number
int x5 = 0x_52;
// OK (hexadecimal literal)
int x6 = 0x5_2;
// Invalid: cannot put underscores
// at the end of a number
int x7 = 0x52_;
Scroll to top