Home : Course Map : Chapter 2 : Java :
Primitive Data Types
JavaTech
Course Map
Chapter 2

Introduction
Essentials
Structure

Keywords
Primitive Types
Comments
Literals
Expressions
Operators
Statements
Casts & Mixing
Strings
Console Output 
   Demo
Exercises

    Supplements
Conditional: if-else
Repetitions
Flow Control

Java vs C/C++
JVM Instructions 1

     About JavaTech
     Codes List
     Exercises
     Feedback
     References
     Resources
     Tips
     Topic Index
     Course Guide
     What's New

How numbers and other data, such as characters, are represented in memory is of great practical importance. Ideally a single memory representation, or type, could represent all data including numbers, characters and boolean values.

Computer memory and transfer rates, however, are not infinite and designers must strike a compromise between the widest possible range of values and conserving memory and maximizing speed.

Also, the data representations must use base 2 as dictated by the underlying binary hardware. Thus floating point numbers cannot represent all decimal numbers exactly. For example, converting to base 2 from base 10 means 0.1 will not produce 1.0 if we sum it in a loop 10 times.

So it is clear that one universal numerical data type will not be efficient or sufficient for all situations.

8 Primitive Data Types

For any language there is the need to provide different storage representations for integers and floating point numbers.

In the case of integers, a variety of sizes allows for the most efficient use of memory for a given task. For example, the byte type (8-bit) is often useful for I/O tasks while long types (64-bit) are needed for representing very large values. In between are the 16-bit short and the 32-bit int types. The int type is the default for most integer operations in Java. The integer types use two's complement signed representations.

For floating point there are two widths available. The IEEE 754 floating point standard is used for the 32-bit float and 64-bit double types. See also Chapter 2: Tech : More about Floating Point.

Historically, characters were typically represented with 7-bit ASCII codes, which allowed for 128 characters. A large number of 8-bit encodings exist to provide both standard ASCII and characters needed for particular languages. However, full internationalization with a single code requires many more characters than is available with a single byte. So a two byte character type- char - is used to hold the Unicode representation. (An even larger 4-byte system is under development but not implemented in Java.) The char type can also represent 16-bit unsigned integers.

A boolean (true/false) type is needed for the many logic operations carried out in almost any program.

Java comes with 8 primitive data types in all. These include 4 types of integers, two floating points, a character type and a boolean. Below is a table of the Java primitive types with their specifications.

We will discuss classes and objects later, but note here that primitive types in Java are not instances of classes. The decision to use simple data types broke the symmetry and elegance of the language to some degree but vastly reduced overhead and execution times compared to the case where all data types are objects.

 Java Primitive Data Types
Type Values Default Size Range
byte signed integers 0 8 bits -128 to 127
short signed integers 0 16 bits -32768 to 32767
int signed integers 0 32 bits -2147483648 to 2147483647
long signed integers 0 64 bits -9223372036854775808 to 9223372036854775807
float IEEE 754 floating point 0.0 32 bits +/-1.4E-45 to +/-3.4028235E+38,
+/-infinity, +/-0, NAN
double IEEE 754 floating point 0.0 64 bits +/-4.9E-324 to
+/-1.7976931348623157E+308,
+/-infinity, +/-0, NaN
char Unicode character \u0000 16 bits \u0000 to \uFFFF
boolean true, false false 1 bit used in 32 bit integer NA

 

More comments about primitives:

  • Java is a strongly typed language. An explicit type must be assigned to every data value.

  • Converting from one type to another requires an explicit cast when going from a higher precision type to a lower precision type (see Casts and Mixing):

         float x = 3.1;

          int i = (int)x;

  • boolean type only holds true or false. In the JVM, the boolean values are represented as integers with 0 for false and 1 for true. (The JVM specification does not specify how boolean arrays are stored. So it will vary according to the particular JVM implementation; for example, as bit arrays, byte arrays, etc.)

    A boolean type cannot be cast to or from other types. In C/C++ it is common to convert back and forth between Booleans and integers. To obtain the same effect in Java, one can use this approach:

          b = (i != 0); /* integer to boolean
                          In C & C++
                            non-zero int => true
                            zero int => false
                       */
         i = (b)? 1 : 0;  // boolean to integer

  • char is not a single byte as in C/C++ but uses two bytes. It can also act as an unsigned integer. Casting to byte or short can result in an unexpected negative value.

  • The representations are the same on all machines to insure the portability of the code. However, during calculations involving floating point values, intermediate values can exceed the standard exponent ranges in the table if allowed by the particular processor. The strictfp modifier requires that the values remain within the given ranges throughout the calculation to insure same results on all platforms. Further details are given in Chapter 2: Tech :More about Floating Point.

  • Floating point operations that result in overflow or underflow, or zero-divided-by-zero do not give an error message. Instead they result in special floating point values: +/-infinity, +/-0, NaN. These are discussed in the Chapter 2: Tech : More about Floating Point.

  • For more about primitive types and numerical issues, continue to Chapter 2: Tech: Numerical Precision

More About the Primitive Types

See these other sections for additional information concernting the primitive data types:

 

References & Web Resources

Latest update: Jan.11, 2006

            Tech
Arithmetic Ops
Math Class
More on Integers
FP : Overview
FP : Java  
  
Demo 1
More Mix/Cast
  Demo 2
Exercises

           Physics
Differential Eq.
Euler Method
  
Demo 1
Predictor-Corrector
  
Demo 2
Exercises

  Part I Part II Part III
Java Core 1  2  3  4  5  6  7  8  9  10  11  12 13 14 15 16 17
18 19 20
21
22 23 24
Supplements

1  2  3  4  5  6  7  8  9  10  11  12

Tech 1  2  3  4  5  6  7  8  9  10  11  12
Physics 1  2  3  4  5  6  7  8  9  10  11  12

Java is a trademark of Sun Microsystems, Inc.