In this article, we will discuss

**eight primitive types**of data:*byte*,*short*,*int*,*long*,*char*,*float*,*double*, and*boolean*.
The Java programming language is statically-typed, which means that all variables must first be declared before they can be used.

These eight primitive data types can be put into four groups:

**Integers**- This group includes byte, short, int, and long, which are for whole-valued signed numbers.**Floating-point numbers**- This group includes float and double, which represent numbers with fractional precision.**Characters**- This group includes char, which represents symbols in a character set, like letters and numbers.**Boolean**- This group includes boolean, which is a special type for representing true/false values.

Let's discuss each primitive datatype with examples.

## Integers

Java defines four integer types:

*byte*,*short*,*int*, and*long*. All of these are signed, positive and negative values. Java does not support unsigned, positive-only integers.
Let’s look at each type of integer.

### byte

The smallest integer type is a

*byte*. This is a signed*8-bit*type that has a range from*–128*to*127*. Variables of type byte are especially useful when you’re working with a stream of data from a network or file. They are also useful when you’re working with raw binary data that may not be directly compatible with Java’s other built-in types.
Byte variables are declared by use of the

*byte*keyword.
For example, the following declares two-byte variables called

**b**and**c**:`byte b, c;`

### short

*short*is a signed

*16-bit*type. It has a range from

*–32,768*to

*32,767*. It is probably the least-used Java type. Here are some examples of short variable declarations:

```
short s;
short t;
```

### int

The most commonly used integer type is

*int*. It is a signed*32-bit*type that has a range from*–2,147,483,648*to*2,147,483,647*. In addition to other uses, variables of type int are commonly employed to control loops and to index arrays. Although you might think that using a byte or short would be more efficient than using an int in situations in which the larger range of an int is not needed, this may not be the case.
In the following example, the

**sum**,**i**and**n**variables are of type*int*:```
package net.javaguides.corejava.variables;
public class LocalVariableExample {
public int sum(int n) {
int sum = 0;
for (int i = 0; i < n; i++) {
sum = sum + i;
}
return sum;
}
public static void main(String[] args) {
LocalVariableExample localVariableExample = new LocalVariableExample();
int sum = localVariableExample.sum(10);
System.out.println("Sum of first 10 numbers -> " + sum);
}
}
```

Output:

`Sum of first 10 numbers -> 45`

### long

*long*is a signed

*64-bit*type and is useful for those occasions where an int type is not large enough to hold the desired value. The range of a

*long*is quite large. This makes it useful when big, whole numbers are needed.

For example, here is a program that computes the number of miles that light will travel in a specified number of days:

```
// Compute distance light travels using long variables.
class Light {
public static void main(String args[]) {
int lightspeed;
long days;
long seconds;
long distance;
// approximate speed of light in miles per second
lightspeed = 186000;
days = 1000; // specify number of days here
seconds = days * 24 * 60 * 60; // convert to seconds
distance = lightspeed * seconds; // compute distance
System.out.print("In " + days);
System.out.print(" days light will travel about ");
System.out.println(distance + " miles.");
}
}
```

This program generates the following output:

```
In 1000 days light will travel about 16070400000000 miles.
```

Clearly, the result could not have been held in an int variable.

## Floating-Point Types

Floating-point numbers, also known as real numbers, are used when evaluating expressions that require fractional precision. For example, calculations such as square root, or transcendentals such as sine and cosine, result in a value whose precision requires a floating point type.

### float

The type

*float*specifies a single-precision value that uses*32 bits*of storage. Single precision is faster on some processors and takes half as much space as double precision, but will become imprecise when the values are either very large or very small. Variables of type float are useful when you need a fractional component, but don’t require a large degree of precision.
For example, a

*float*can be useful when representing dollars and cents. Here are some example float variable declarations:`float hightemp, lowtemp;`

### double

Double precision, as denoted by the double keyword, uses

*64 bits*to store a value. Double precision is actually faster than single precision on some modern processors that have been optimized for high-speed mathematical calculations. All transcendental math functions, such as sin( ), cos( ), and sqrt( ), return double values. When you need to maintain accuracy over many iterative calculations or are manipulating large-valued numbers, double is the best choice.
Here is a short program that uses double variables to compute the area of a circle:

```
// Compute the area of a circle.
class Area {
public static void main(String args[]) {
double pi, r, a;
r = 10.8; // radius of circle
pi = 3.1416; // pi, approximately
a = pi * r * r; // compute area
System.out.println("Area of circle is " + a);
}
}
```

## Characters

### char

In Java, the data type used to store characters is

*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).
Here is a program that demonstrates char variables:

```
// Demonstrate char data type.
class CharDemo {
public static void main(String args[]) {
char ch1, ch2;
ch1 = 88; // code for X
ch2 = 'Y';
System.out.print("ch1 and ch2: ");
System.out.println(ch1 + " " + ch2);
}
}
```

This program displays the following output:

```
ch1 and ch2: X Y
```

Although

*char*is designed to hold Unicode characters, it can also be used as an integer type on which you can perform arithmetic operations. For example, you can add two characters together, or increment the value of a character variable. Consider the following program:```
// char variables behave like integers.
class CharDemo {
public static void main(String args[]) {
char ch1;
ch1 = 'X';
System.out.println("ch1 contains " + ch1);
ch1++; // increment ch1
System.out.println("ch1 is now " + ch1);
}
}
```

The output generated by this program is shown here:

```
ch1 contains X
ch1 is now Y
```

In the program,

**ch1**is first given the value**X**. Next,**ch1**is incremented. This results in**ch1**containing**Y**, the next character in the ASCII (and Unicode) sequence.## Booleans

### boolean

Java has a primitive type, called

*boolean*, for logical values. It can have only one of two possible values,*true*or*false*. This is the type returned by all relational operators, as in the case of a < b.*boolean*is also the type required by the conditional expressions that govern the control statements such as if and for.

Here is a program that demonstrates the boolean type:

```
// Demonstrate boolean values.
class BoolTest {
public static void main(String args[]) {
boolean b;
b = false;
System.out.println("b is " + b);
b = true;
System.out.println("b is " + b);
// a boolean value can control the if statement
if (b) System.out.println("This is executed.");
b = false;
if (b) System.out.println("This is not executed.");
// outcome of a relational operator is a boolean value
System.out.println("10 > 9 is " + (10 > 9));
}
}
```

The output generated by this program is shown here:

```
b is false
b is true
This is executed.
10 > 9 is true
```

## Comments

## Post a Comment