Primitive Types

There are eight primitive types in Java: each is a reserved keyword. They describe variables that contain single values of the appropriate format and size (see Table 3-1). Primitive types are always the specified precision, regardless of the underlying hardware precisions (e.g., 32- or 64-bit).

Literals for Primitive Types

All primitive types except boolean can accept character, decimal, hexadecimal, octal, and Unicode literal formats, as well as character escape sequences. Where appropriate, the literal value is automatically cast or converted. Remember that bits are lost during truncation. The following is a list of primitive assignment examples.

The boolean primitive’s only valid literal values are true and false:

boolean isEndogamous = true;

The char primitive represents a single Unicode character. Literal values of the char primitive that are greater than two bytes need to be explicitly cast.

// 'atDNA'
  char[] cArray = {
  ''', // '
  'u0061', // a
  't', // t
  0x0044, // D
  0116, // N
  (char) (65 + 131072) , // A
  0b00100111}; // '

The byte primitive has a four-byte signed integer as its valid literal. If an explicit cast is not performed, the integer is implicitly cast to one byte:

final byte CHROMOSOME_PAIRS = 12;
final byte CHROMOSOME_TOTAL = (byte) 48;

The short primitive has a four-byte signed integer as its valid literal. If an explicit cast is not performed, the integer is implicitly cast to two bytes:

short firstCousins = 6;
short secondCousins = (short) 18;

The int primitive has a four-byte signed integer as its valid literal. When char, byte, and short primitives are used as literals, they are automatically cast to four-byte integers, as in the case of the short value within vipSeats. Floating-point and long literals must be explicitly cast:

int thirdCousins = 104;
int forthCousins = (int) 648.0D;
int fifthCousins = (short) 3_888;

The long primitive has an eight-byte signed integer as its valid literal. It is designated by an L or l postfix. The value is cast from four bytes to eight bytes when no postfix or cast is applied:

long sixthCousins = 23_000;
long seventhCousins = (long) 138_000;
long eighthCousins = 828_000l;
long ninthCousins = 4_968_000L;

The float primitive has a four-byte signed floating point as its valid literal. An F or f postfix or an explicit cast designates it. Even though no explicit cast is necessary for an int literal, an int will not always fit into a float where the value exceeds about 2²³:

float totalSharedCentimorgansX = 0;
float totalSharedCentimorgansAutosomal = (float) 285.5;
float largestSharedCentimorgansX = 0.0f;
float largestSharedCentimorgansAutosomal = 71F;

The double primitive uses an eight-byte signed floating-point value as its valid literal. The literal can have a D, d, or explicit cast with no postfix. If the literal is an integer, it is implicitly cast:

double centimorgansSharedFloor = 0;
double centimorgansSharedCeiling = 6766.20;
double centimorgansShared = (double) 888;
double centimorgansUnShared = 5878.0d;
double centimorgansPercentShared = 13.12D;

See Chapter 2 for more details on literals.

Floating-Point Entities

Positive and negative floating-point infinities, negative zero, and not a number (NaN) are special entities defined to meet the IEEE 754-1985 standard (see Table 3-2).

The Infinity, –Infinity, and –0.0 entities are returned when an operation creates a floating-point value that is too large to be traditionally represented.

Positive infinity, negative infinity, and NaN entities are available as double and float constants:

Double.POSITIVE_INFINITY; // Infinity
Float.POSITIVE_INFINITY;  // Infinity
Double.NEGATIVE_INFINITY; // –Infinity
Float.NEGATIVE_INFINITY;  // –Infinity
Double.NaN; // Not-a-Number
Float.NaN;  // Not-a-Number

The Double and Float wrapper classes have methods to determine if a number is finite, infinite, or NaN:

Double.isFinite(Double.POSITIVE_INFINITY); // false
Double.isFinite(Double.NEGATIVE_INFINITY); // false
Double.isFinite(Double.NaN); // false
Double.isFinite(1); // true
// true
Double.isInfinite(Double.POSITIVE_INFINITY);
// true
Double.isInfinite(Double.NEGATIVE_INFINITY);
Double.isInfinite(Double.NaN); // false
Double.isInfinite(1); // false
Double.isNaN(Double.NaN); // true
Double.isNaN(1); // false

// 'NaN' will be printed
System.out.print((-0.0) * Double.NaN);

Numeric Promotion of Primitive Types

Numeric promotion consists of rules that are applied to the operands of an arithmetic operator under certain conditions. Numeric promotion rules consist of both unary and binary promotion rules.

Wrapper Classes

Each of the primitive types has a corresponding wrapper class/reference type, which is located in package java.lang. Each wrapper class has a variety of methods, including one to return the type’s value, as shown in Table 3-6. These integer and floating-point wrapper classes can return values of several primitive types.

Autoboxing and Unboxing

Autoboxing and unboxing are typically used for collections of primitives. Autoboxing involves the dynamic allocation of memory and the initialization of an object for each primitive. Note that the overhead can often exceed the execution time of the desired operation. Unboxing involves the production of a primitive for each object.

Computationally intensive tasks using primitives (e.g., iterating through primitives in a container) should be done using arrays of primitives instead of collections of wrapper objects.

// Create hash map of weight groups
HashMap<String, Integer> diploidChromosomeNumberMap
    = new HashMap<String, Integer> ();
diploidChromosomeNumberMap.put("Canis latrans", 78);
diploidChromosomeNumberMap.put("Bison bison", 60);
diploidChromosomeNumberMap.put("Homo sapiens", 46);
diploidChromosomeNumberMap.put("Sus scrofa", 38);
diploidChromosomeNumberMap.put("Myrmecia pilosula", 2);

// Set number of autosomal (atDNA) chromosomes
Integer atDnaChromosomeSet = 22; //improper

Integer atDnaChromosomeSet = Integer.valueOf(22);

// Get the DCN of a homo sapien, performing unboxing
int homoSapienDcn = diploidChromosomeNumberMap.get("Homo sapiens");

System.out.println(homoSapienDcn);
$ 46

// Establish the total number of chromosomes
Integer atDnaChromosomeSet = 22;
int multiplier = 2;
int xChromosomes = 2; // 1 or 2
int yChromosome = 0;  // 0 or 1
// Mixing int and Integer; not recommended
int dcn = xChromosomes + yChromosome
  + (multiplier * atDnaChromosomeSet);

int dcn = xChromosomes + yChromosome
  + (multiplier * atDnaChromosomeSet.intValue());