24

ing point numbers, and truefalse values, along with sample programs that
illustrate their use.
Characters and Strings. A char is an alphanumeric character or symbol,
16
like the ones that you type. There are 2 different possible character values,
but we usually restrict attention to the ones that represent letters, numbers,
symbols, and white-space characters like tab and newline. To specify a character as a char literal, we enclose it in single quotes: 'a' represents the
letter a. For tab, newline, single quote and double quote, we use the special
escape sequences \t, \n, \', and \", respectively. The characters are encoded
as 16-bit integers using an encoding scheme known as Unicode, and there are
escape sequences for specifying any special character (see Appendix X). We
usually do not perform any operations on characters other than assigning
values to variables and using the comparison functions defined later in this
section, so we move immediately on to other data types.
A String is a sequence of characters. A literal String is a sequence
of characters within double quotes, like "Hello, World". The String data
type is not a primitive type, but Jave sometimes treats it like one. For example,
one of the most common operations that we perform on Strings is built in
to the Java language. That operation is known as concatenation: given two
strings, chain them together to make a new string. The symbol for concatenating strings in Java is + (the same symbol that we use for adding numbers).
For example, the following Java code fragment is like the one that we considered at the beginning of this section, but it uses Strings instead of ints:
String a, b, c;
a = "1234";
b = "99";
c = a + b;

As before, the first statement declares three variables to be of type String and
the next three assign values to them. In this case, the end result that c has the
value "123499".
We use the concatenation operation frequently to put together
results of computation in output. For example we could make Program 2.1.2
much simpler by replacing its three statements by this single statement:

AN INTRODUCTION TO COMPUTER SCIENCE

Primitive Types of Data

25

Program 2.1.1 String-concatenation example

public class Ruler
{
public static void main(String[] args)
{
String ruler1 = 1 ;
String ruler2 = ruler1 + 2 + ruler1;
String ruler3 = ruler2 + 3 + ruler2;
String ruler4 = ruler3 + 4 + ruler3;
System.out.println(ruler1);
System.out.println(ruler2);
System.out.println(ruler3);
System.out.println(ruler4);
}
}

This program prints the relative

lengths of the subdivisions on a ruler,
as shown, for example, by the lines at
right for the third line. The length of
the output of this program grows
exponentially: the nth line has 2 n 1
numbers on it.

%
%
1
1
1
1

javac Ruler
java Ruler
2 1
2 1 3 1 2 1
2 1 3 1 2 1 4 1 2 1 3 1 2 1

System.out.println("Hi, " + args[0] + ". How are you?");

The concatenation operation (along with the ability to declare String variables and to use them in expressions and assignment statements) is sufficiently powerful to allow us to attack some nontrivial computing tasks, as
illustrated in Program 2.1.1 and Exercise 2.1.18.
How do we print out the values of other types of data? To print out
anything, we need to convert it from its internal representation to a String.
Similarly, when we put a value on the command line, we type a string of characters: if we want to process the data that the string represents, we must convert the string to the appropriate internal reservation for that type of data.

26

Converting from one type of data to another is an important issue that we

often need to face when writing programs; we will discuss it at length at the
end of this section. We are discussing type conversion to and from String
briefly now so that we can write sample programs that take command-line
arguments and print out values for various types of data.
To convert from one type of data to another, we might explicitly call
a system method or we might expect the system to automatically do the conversion. In Java, we normally use the former approach for input from the
command line and the latter for output.
For input from the command line, we explicitly use system methods
to convert from String to the appropriate type. For example, the system
method Integer.parseInt takes a string parameter and converts the given
string of digits to an int. For output, we take advantage of the concatenation operator and Javas automatic type conversion facility to write statements
like this one:
System.out.println(a + " + " + b + " = " + (a+b));

If a and b are int variables with the values 1234 and 99, respectively, then this
statement prints out the string 1234 + 99 = 1243. This usage takes advantage of the Java convention that if one of the operands of + is a String, then
the other is automatically converted to a String so that the + is interpreted as
concatenation. We will discuss the specific rules for such conversions in more
detail at the end of this section, after we have discussed properties of each of
the types.
Integers. An int is an integer (whole number) between 2147483648 and
2147483647 . These bounds derive from the fact that integers are represented
32
in binary with with 32 binary digits: there are 2 possible values. (The term
binary digit is omnipresent in computer science, so the abbreviation bit is
always used: a bit is either 0 or 1.) The range of possible int values is asymmetric because 0 is included with the positive values. We will consider number representations in detail in Chapter 5 (see also Appendix X); in the
present context it suffices to know that an int is one of the finite set of values
in the range just given. We use ints frequently not just because they occur

AN INTRODUCTION TO COMPUTER SCIENCE

Primitive Types of Data

27

Program 2.1.2 Integer multiplication and division

public class IntOps
{
public static void main(String[] args)
{
int a, b, p, q, r;
a = Integer.parseInt(args[0]);
b = Integer.parseInt(args[1]);
p = a * b;
q = a / b;
r = a % b;
System.out.println(a + * + b +
System.out.println(a + / + b +
System.out.println(a + % + b +
System.out.print(a + = );
System.out.println(q + * + b +
}
}

Arithmetic on integers is built in to

Java. Most of this code is devoted to
the tasks of getting the values in and
out; the actual arithmetic is in the
simple statements like p = a * b.

= + p);
= + q);
= + r);
+ + r);

% javac IntOps
% java IntOps 1234 99
1234 * 99 = 122166
1234 / 99 = 12
1234 % 99 = 46
1234 = 12*99 + 46

frequently in the real world, but also they naturally arise when expressing
algorithms.
Standard arithmetic operators for addition/subtraction ( + and -),
multiplication (*), division (/), and remainder (%) for the int data type are
built in to Java. These operators take two int arguments and produce an int
result, with one significant exception: division or reminder by 0 is not
allowed. These operations are defined just as in grade school: Given two ints
a and b, the value of a / b is the number of times b goes into a and the value
of a % b is the remainder that you get when you divide a by b. The int result
that we get from these operations is just what we expect from the gradeschool definition, with one significant exception: if the result is too large to fit
into the 32-bit representation described above, then it will be truncated to the

28

least significant 32 bits. We have to take care that such a result is not misinterpreted by our code.
Integer literals are just strings of decimal integers, as in the code fragment above. To use integer parameters on the command line, we need to use
the built-in Java method Integer.parseInt, which converts string values to
integer values. When we type a number as a command-line parameter, it is a
string of characters, so we have to include a statements that calls with Integer.parseInt to convert it to an integer at execution time; if we type the
same string of characters within the program, the compiler interprets it as a
literal integer and does the conversion at compile time. Program 2.1.2 illustrates these basic operations for manipulating integers.
Three other built-in types are different representations of integers.
The long, short, and byte types are the same as int except that they use 64,
16, and 8 bits respectively, so the range of allowed values is accordingly different. Programmers use long when working with huge integers and the others
to save space. Appendix X gives a table with the maximum and minimum values for each type.
Real numbers. The double type is for representing floating-point numbers, for use in scientific and commercial applications. The internal representation is like scientific notation, so that we can compute with numbers in a
huge range. Floating-point numbers are not the same as real numbers, primarily because there are an infinite number of real numbers, and we can only
represent finitely many numbers in any digital computer representation.
Floating-point numbers do approximate real numbers sufficiently well that
we can use them in all sorts of applications, but we often need to cope with
the fact that we cannot always do exact computations.
We can use a string of digits with a decimal point to type floatingpoint numbers. For example, 3.14159 represents a six-digit approximation
to ! . Alternatively, we can use a notation like scientific notation: the literal
23
6.022E23 represents the number 6.022 10 . As with integers, you can use
these conventions to write floating-point literals in your programs or to provide floating-point numbers as string parameters on the command line.
The arithmetic operators +, -, *, and / are defined for double. The
result of a calculation can be 0 (if the number is too small to be represented)

AN INTRODUCTION TO COMPUTER SCIENCE

Primitive Types of Data

29

Program 2.1.3 Quadratic formula

public class Quadratic
{
public static void main(String[] args)
{
double b = Double.parseDouble(args[0]);
double c = Double.parseDouble(args[1]);
double discriminant = Math.sqrt(b*b - 4.0*c);
System.out.println((-b + discriminant) / 2.0);
System.out.println((-b - discriminant) / 2.0);
}
}

This program prints the roots of the

polynomial x 2 + bx + c , using the
quadratic formula. For example, the
roots of x 2 3x + 2 are 1 and 2 since
we can factor it as ( x 1 ) ( x 2 ) ; the
roots of x 2 x 1 are " and 1 " ,
where " is the golden ratio; and the
roots of x 2 + x + 1 are not real numbers.

% javac Quadratic
% java Quadratic -3.0 2.0
2.0
1.0
% java Quadratic -1.0 -1.0
1.618033988749895
-0.6180339887498949
% java Quadratic 1.0 1.0
NaN
NaN

or one of the special values Infinity (if the number is too large to be represented) or NaN (if the result of the calculation is undefined). Beyond the builtin operators, the Java Math library defines the square root, trigonometric
functions, logarithm/exponential functions and other common functions for
floating-point numbers (see Appendix X).
There are myriad details to consider with regard to precision and
when calculations involve 0, infinity or NaN (see Appendix X and the Q&A
and exercises at the end of this section) but you can use these operations in a
natural way for all sorts of familiar calculations. With this library, you can
begin to write Java programs instead of using a calculator for all kinds of calculations. For example, Program 2.1.3 shows the use of doubles in computing roots of a quadratic equation using the quadratic formula. Several of the
exercises at the end of this section further illustrate this point.

30

As with short and byte for integers, there is another representation

for real numbers, called float, that programmers sometimes use to save
space when precision is a secondary consideration. The double type is useful
for about 15 significant digits; the float type is good for only about 7 digits.
We rarely use float in this book.
Booleans. The boolean type has just two values: true or false. These
are the two possible boolean literals, every boolean variable has one of these
two values, and every boolean operation has operands and a result that takes
on just one of these two values. This apparent simplicity is deceivingbooleans lie at the foundation of computer science, as we will see throughout this
book.
The most important operators defined for booleans are for the and
(&&), or (||), and not (!) functions, which are listed in the table below along
with two different descriptions of each of their meanings:
and

&&

a && b is true
a && b is false

if both a and b are true

if either a or b are false

or

||

a || b is true
a || b is false

if either a or b are true

if both a and b are false

not

!a
!a

is true if a is false
is false if a is true

Although these definitions are intuitive and easy to understand, it is worthwhile to fully specify each possibility for each operation, as in the following
tables. Such tables are known as truth tables.
a

!a

a && b

a || b

true
false

false

false

false

false

false

true

false

true

false

true

true

false

false

true

true

true

true

true

The not function (on the left) has only one operand: its value for each of the
two possible values of the operand is specified in the second column. The and

AN INTRODUCTION TO COMPUTER SCIENCE

Primitive Types of Data

31

Program 2.1.4 Computing with boolean values

public class LeapYear
{
public static void main(String[] args)
{
boolean isLeapYear;
int year = Integer.parseInt(args[0]);
isLeapYear = year % 4 == 0;
isLeapYear = isLeapYear && (year % 100 != 0);
isLeapYear = isLeapYear || (year % 400 == 0);
System.out.println(isLeapYear);
}
}

This program tests whether an integer

corresponds to a leap year in the Gregorian calendar. A year is a leap year
if it is divisible by 4 (2004) unless it is
divisible by 100 in which case it is not
(1900), unless it is divisible by 400 in
which case it is (2000).

% javac LeapYear
% java LeapYear 2004
true
% java LeapYear 1900
false
% java LeapYear 2000
true

and or functions each have two operands: there are four different possibilities
for operand input values, and the values of the functions for each possibility
are specified in the right two columns.
We can use these operators with parentheses to develop arbitrarily
complex expressions, each of which specifies a well-defined boolean function.
Often, the same function appears in different guises. For example, the
expressions (a && b) and !(!a || !b) are equivalent.
The study of manipulating expressions of this kind is known as Boolean logic and is the subject of Section 5.1. This field of mathematics is fundamental to computing. For example, Boolean logic plays an essential role in
the design and operation of computer hardware itself, as we will see in Chapter 5. It also helps us understand fundamental limitations on what we can
compute, as we will see in Chapter 8.

32

In the present context, we are interested in boolean expressions

because we use them to control the behavior of our programs. Typically, a
particular condition of interest is specified as a boolean variable and a piece
of program code is written to execute one set of statements if the variable is
true and a different set of statements if the variable is false. The mechanics
of doing so are the topic of Section X.
Comparisons. Some mixed-type operations take operands of one type and
produce a result of another type. The most important built-in operations of
this kind are the comparison operations ==, !=, <, <=, >, and >=, which all are
defined for each primitive numeric type and which all produce a boolean
result. As we will see in Section X, these operations play a critical role in the
process of developing programs more sophisticated than the sequence-ofstatements programs that we have been considering. The meanings of these
operations are summarized in the following table:
op

a op b

true

false

2 == 2

2 == 3

3 != 2

2 != 2

==

equal

a is equal to b

!=

not equal

!(a == b)

<

less than

a is less than b

2 < 13

2 < 2

<=

less than or equal

(a < b) || (a == b)

2 <= 2

3 <= 2

>

greater than

!(a <= b)

13 > 2

2 > 13

>=

greater than or equal

!(a < b)

3 >= 2

2 >= 3

Since operations are defined only with respect to data types, each of these
symbols stands for many operations, one for each data type. It is required
that both operands be of the same type, and the result is always boolean.
Even without going into the details of number representation that we consider in Section X, it is clear, on reflection, that the operations for the various
types are really quite different: for example, it is one thing to compare two
ints to check that 2 == 2 is true but quite another to compare two doubles
to check whether 2.1 == .0021E3 is true or false.

AN INTRODUCTION TO COMPUTER SCIENCE

Primitive Types of Data

Comparison operations, with boolean logic, provide the basis for

decision-making in Java programs. Program 2.1.4 is a simple example of
their use, and you can find other examples in the exercises at the end of this
section. In Section 2.2 we will see the critical role that such expressions play
in controlling the flow of execution of the statements in our programs.
Type conversion. One of the first rules of programming in Java is that you
should always be aware of the type of data that your program is processing.
Only by knowing the type can you know precisely what set of values each
variable can have, what literals you can use, and what operations you can perform. But typical programming tasks involve processing multiple types of
data, and we often need to be able to convert data from one type to another.
There are several ways to do so in Java.
Explicit type conversion. You can use a method that takes an argument of one
type (the value to be converted) and returns a result of another type. For
example, the library method Math.round takes a double argument and
returns an long result: the nearest integer to the argument. Thus, for example, Math.round(3.14159) and Math.round(2.71828) are both of type
long and have the same value ( 3). Our use of the library methods Integer.parseInt and Double.parseDouble in the programs in this section
are also examples of this kind of conversion. In Section 2.4, you will learn
how to implement such methods.
Automatic conversion for numbers. You can use data of any primitive numeric
type where a value whose type has a larger range of values is expected. Java
automatically converts to the type with the larger range. For example, we
used numbers all of type double in Program 2.1.3, so there is no conversion,
but we might instead have chosen to make b and c of type int (using Integer.parseInt to convert the command-line arguments). Then the expression b * b - 4 . 0 * c requires ty pe conversion, which Java would do
automatically: first, it would covert c to double and multiply by the double
literal 4.0 to get a double result. As for the other term, it would compute the
value b*b and then convert to double for the subtraction, leaving a double
result. Or, we might have written b*b - 4*c. In that case, the program would
evaluate the expression b*b - 4*c as an int and then automatically convert

33

34

Program 2.1.5 Casting to get a random integer

public class RandomInt
{
public static void main(String[] args)
{
int N = Integer.parseInt(args[0]);
double r = Math.random();
int n = (int) (r * N);
System.out.println(n);
}
}

This program uses the Java method

Math.random to get a random number between 0 and 1, then multiplies
it by the command-line argument N
to get a random number between 0
and N, then uses a cast to truncate the
result to be an integer between 0 and
N-1.

% javac RandomInt
% java RandomInt 1000
548
% java RandomInt 1000
141
% java RandomInt 1000000
135032

the result to double, because that is what Math.sqrt expects. Java does this
kind of type conversion automatically because your intent is clear and it can
do so with no loss of information. On the other hand, if the conversion might
involve loss of information, for example if you try to assign a double to an
int, you will get an error message from the compiler.
Explicit cast. Java has some built-in type conversion methods for primitive
types that you can use when you are aware that you might lose information,
but you have to make your intention to do so explicit using a device called a
cast. You cast a variable or an expression from one primitive type to another
simply by prepending the desired type name within parentheses: for example,
the expression (int) 3.14159 is a cast from double to int that is of type
int with value 3. Java has built-in conversion methods defined for casts
among primitive numeric types that implement reasonable and convenient
approaches to throwing away information (for a full list, see Appendix X).

AN INTRODUCTION TO COMPUTER SCIENCE