Storing Characters

Variables of the type char store a single character. They each occupy 16 bits,

two bytes, in memory because all characters in Java are stored as Unicode.

To declare and initialize a character variable myCharacter you would use the

statement:

char myCharacter = 'X';

This initializes the variable with the Unicode character representation of the

letter 'X'. You must put single quotes around a character in a statement – 'X'.

This is necessary to enable the compiler to distinguish between the character

'X' and a variable with the name X. Note that you can't use double quotes

here as they are used to delimit a character string. A character string such as

"X" is quite different from the literal of type char, 'X'.

char myCharacter = '\u0058';

"It's freezing in here", he said coldly.

System.out.println("\"It\'s freezing in here\", he said coldly.");

myCharacter += 1;    // Increment to next character

++myCharacter;       // Increment to next character

char aChar = 0;
char bChar = '\u0025';
aChar = (char)(2*bChar + 8);

Logical Operators

The tests we have put in the if expressions have been relatively simple

so far, except perhaps for the last one. The real world is typically more

complicated. You will often want to combine a number of conditions so

that you execute a particular course, for example, if they are all true

simultaneously. You can ride the roller coaster if you are over 12 years

old, over four feet tall, and less than six feet six. Failure on any count

and it's no go. Sometimes, though, you may need to test for any one of

a number of conditions being true, for example, you get a lower price

entry ticket if you are under 16, or over 65.

You can deal with both of these cases, and more, using logical operators

to combine several expressions that have a value true or false. Because

they operate on boolean values they are also referred to as boolean

operators. There are five logical operators that operate on boolean values:

These are very simple, the only point of potential confusion being the fact

that we have the choice of two operators for each of AND and OR. The extra

operators are the bitwise & and | that you can also apply to boolean values

where they have an effect that is subtly different from && and ||. We'll first

consider what each of these are used for in general terms, then we'll look at

how we can use them in an example.

Boolean AND Operations

You can use either AND operator, && or &, where you have two logical

expressions that must both be true for the result to be true – that is, you

want to be rich and healthy. Either operator will produce the same result

from the logical expression. We will come back to how they are different in a

moment. First, let's explore how they are used. All of the following discussion

applies equally well to & as well as &&.

Let's see how logical operators can simplify the last example. You could use

the && operator if you were testing a variable of type char to determine

whether it contained an uppercase letter or not. The value being tested must

be both greater than or equal to 'A' AND less than or equal to 'Z'. Both

conditions must be true for the value to be a capital letter. Taking the

example from our previous program, with a value stored in a char variable

symbol, we could implement the test for an uppercase letter in a single if

by using the && operator:

if(symbol >= 'A' && symbol <= 'Z')
   System.out.println("You have the capital letter " + symbol);

We already know that the relational operators will be executed before the

&& operator, so no parentheses are necessary. Here, the output statement

will be executed only if both of the conditions combined by the operator &&

are true. However, as we have said before, it is a good idea to add

parentheses if they make the code easier to read. It also helps to avoid

mistakes.

In fact, the result of an && operation is very simple. It is true only if both

operands are true, otherwise the result is false.

We can now rewrite the set of ifs from the last example.

Try It Out – Deciphering Characters the Easy Way

Replace the outer if-else loop and its contents in LetterCheck.java with

the following:

if(symbol >= 'A' && symbol <= 'Z') {       // Is it a capital letter
  System.out.println("You have the capital letter " + symbol);

} else {
  if(symbol >= 'a' && symbol <= 'z') {    // or is it a small letter?
    System.out.println("You have the small letter " + symbol);

  } else {                                  // It is not less than z
    System.out.println("The code is not a letter");
  }
}

How It Works

Using the && operator has condensed the example down quite a bit.

We now can do the job with two ifs, and it's certainly easier to follow

what's happening.

You might want to note that when the statement in an else clause is

another if, the if is sometimes written on the same line as the else,

as in:

if(symbol >= 'A' && symbol <= 'Z') {          // Is it a capital letter
  System.out.println("You have the capital letter " + symbol);

} else if(symbol >= 'a' && symbol <= 'z') {   // or is it a small letter?
  System.out.println("You have the small letter " + symbol);

} else {                                      // It is not less than z
  System.out.println("The code is not a letter");
}

I think the original is clearer, so I prefer not to do this.

&& versus &

So what distinguishes && from & ? The difference between them is that

the conditional && will not bother to evaluate the right-hand operand if

the left-hand operand is false, since the result is already determined in

this case to be false. This can make the code a bit faster when the left-

hand operand is false.

For example, consider the following statements:

int number = 50;
if(number<40 && (3*number - 27)>100) {
  System.out.println("number = " + number);
}

Here the expression (3*number - 27)>100 will never be executed since

the expression number<40 is always false. On the other hand, if you

write the statements as:

int number = 50;
if(number<40 & (3*number - 27)>100) {
  System.out.println("number = " + number);
}

the effect is different. The whole logical expression is always evaluated,

so even though the left-hand operand of the & operator is false and the

result is a forgone conclusion once that is known, the right hand operand

((3*number - 27)>100) will still be evaluated. So, we can just use && all

the time to make our programs a bit faster and forget about &, right?

Wrong – it all depends on what you are doing. Most of the time you can

use &&, but there are occasions when you will want to be sure that the

right-hand operand is evaluated – and equally, there are instances where

you want to be certain the right-hand operand won't be evaluated if the

left operand is false.

The first situation can arise for instance when the right hand expression

involves modifying a variable – and you want the variable to be modified

in any event. An example of a statement like this is:

if(++value%2 == 0 & ++count < limit) {
  // Do something
}

Here, the variable count will be incremented in any event. If you use &&

instead of &, count will only be incremented if the left operand of the AND

operator is true. You get a different result depending on which operator is

used. We can illustrate the second situation with the following statement:

if(count > 0 && total/count > 5) {
  // Do something...
}

In this case the right operand for the && operation will only be executed

if the left operand is True – that is, when count is positive. Clearly, if we

were to use & here, and count happened to be zero, we will be attempting

to divide the value of total by 0, which in the absence of code to prevent it,

will terminate the program.

Boolean OR Operations

The OR operators, | and ||, apply when you want a true result if either or

both of the operands are true. The conditional OR, ||, has a similar effect

to the conditional AND, in that it omits the evaluation of the right-hand

operand when the left-hand operand is true. Obviously if the left operand

is true, the result will be True regardless of whether the right operand is

true or false.

Let's take an example. A reduced entry ticket price is issued to under 16

year olds and to those aged 65 or over; this could be tested using the

following if:

if(age < 16 || age>= 65) {
  ticketPrice *= 0.9;         // Reduce ticket price by 10%
}

The effect here is to reduce ticketPrice by ten percent if either condition is

true. Clearly in this case both conditions cannot be true.

With an | or an || operation, you only get a false result if both operands

are false. If either or both operands are true, the result is true.

Boolean NOT Operations

The third type of logical operator, !, takes one boolean operand and inverts

its value. So if the value of a boolean variable, state, is true, then the

expression !state has the value false, and if it is false then !state becomes

true. To see how the operator is used with an expression, we could rewrite

the code fragment we used to provide discounted ticket price as:

if(!(age >= 16 && age < 65)) {
  ticketPrice *= 0.9;         // Reduce ticket price by 10%
}

The expression (age >= 16 && age < 65) is true if age is from 16 to 64.

People of this age do not qualify for the discount, so the discount should

only be applied when this expression is false. Applying the ! operator to

the result of the expression does what we want.

We could also apply the ! operator in an expression that was a favorite

of Charles Dickens:

!(Income>Expenditure)

If this expression is true, the result is misery, at least as soon as the

bank starts bouncing your checks.

Of course, you can use any of the logical operators in combination if

necessary. If the theme park decides to give a discount on the price of

entry to anyone who is under 12 years old and under 48 inches tall, or

someone who is over 65 and over 72 inches tall, you could apply the

discount with the test:

if((age < 12 && height < 48) || (age > 65 && height > 72)) {
   ticketPrice *= 0.8;             // 20% discount on the ticket price
}

The parentheses are not strictly necessary here, as && has a higher

precedence than ||, but adding the parentheses makes it clearer how the

comparisons combine and makes it a little more readable.

Don't confuse the bitwise operators &, |, and !, with the logical operators

that look the same. Which type of operator you are using in any particular

instance is determined by the type of operand with which you use it. The

bitwise operators apply to integer types and produce an integer result.

The logical operators apply to operands that have boolean values and

produce a result of type boolean – true or false. You can use both bitwise

and logical operators in an expression if it is convenient to do so.

Important

Character Testing Using Standard Library Methods

While testing characters using logical operators is a useful way of

demonstrating how these operators work, in practice there is an easier way.

The standard Java packages provide a range of standard methods to do the

sort of testing for particular sets of characters such as letters or digits that

we have been doing with if statements. They are all available within the

class Character, which is automatically available in your programs. For

example, we could have written the if statement in our LetterCheck program

as shown in the following example.

Try It Out – Deciphering Characters Trivially

Replace the code body of the LetterCheck class with the following code:

if(Character.isUpperCase(symbol)) {
  System.out.println("You have the capital letter " + symbol);

} else {
  if(Character.isLowerCase(symbol)) {
    System.out.println("You have the small letter " + symbol);

  } else {
    System.out.println("The code is not a letter");
  }
}

How It Works

The isUpperCase() method returns true if the char value passed to it is

uppercase, and false if it is not. Similarly, the isLowerCase() method

returns true if the char value passed to it is lowercase.

The following table shows some of the other methods included in the

class Character that you may find useful for testing characters. In each

case the argument to be tested is of type char, and is placed between

the parentheses following the method name:

   space (' '),
   tab ('\t'),
   newline ('\n'),
   carriage return ('\r'),
   form feed ('\f')