JAVA ARRAY LOOPING AND ETC

Adding behavior to a Java class

Person is looking good so far, but it can use some additional behavior to make it more interesting. Creating behavior means adding methods. This section looks more closely at accessor methods— namely, the getters and setters you've already seen in action.

Accessor methods

To encapsulate a class's data from other objects, you declare its variables to be private and then provide accessor methods. As you have seen, a getter is an accessor method for retrieving the value of an attribute; a setter is an accessor method for modifying that value. The naming of accessors follows a strict convention known as the JavaBeans pattern, whereby any attribute Foo has a getter called getFoo() and a setter calledsetFoo().

The JavaBeans pattern is so common that support for it is built into the Eclipse IDE. You've even already seen it in action — when you generated getters and setters for Person in the preceding section.

Accessors follow these guidelines:

• The attribute itself is always declared with private access.
• The access specifier for getters and setters is public.
• Getters don't take any parameters and return a value whose type is the same as the attribute it accesses.
• Settings only take one parameter, of the type of the attribute, and do not return a value.

Declaring accessors

By far the easiest way to declare accessors is to let Eclipse do it for you, as shown in Figure 6. But you should also know how to hand-code a getter-and-setter pair. Suppose you have an attribute, Foo, whose type is java.lang.String. A complete declaration for it (following the accessor guidelines) would be:

private String foo;
public String getFoo() {
  return foo;
}
public void setFoo(String value) {
  foo = value;
}

You might notice right away that the parameter value passed to the setter is named differently than if it had been generated by Eclipse. The naming follows my own convention, which I recommend to other developers. On the rare occasion that I do hand-code a setter, I always use the namevalue as the parameter value to the setter. This eye-catcher reminds me that I've hand-coded the setter. Because I usually allow Eclipse to generate getters and setters for me, when I don't, there's a good reason. Using value as the setter's parameter value reminds me that this setter is special. (Code comments also do that.)

Calling methods

Invoking, or calling, methods is easy. You saw in Listing 6 how to invoke the various getters of Person to return their values. Now, I formalize the mechanics of making method calls.

Method invocation with and without parameters

To invoke a method on an object, you need a reference to that object. Method-invocation syntax comprises the object reference, a literal dot, the method name, and any parameters that need to be passed:

objectReference.someMethod();
objectReference.someOtherMethod(parameter);

Here is a method invocation without parameters:

Person p = /*obtain somehow */;
p.getName();

And here's a method invocation with parameters (accessing the Name attribute of Person):

Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");

Remember that constructors are methods, too. And you can separate the parameters with spaces and newlines. The Java compiler doesn't care. These next two method invocations are identical:

new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");

new Person("Joe Q Author",// Name
  42,     // Age
  173,    // Height in cm
  82,     // Weight in kg
  "Brown",// Eye Color
  "MALE");// Gender

Notice how the comments in the second constructor invocation leave behind readability for the next developer. At a glance that person can tell what each parameter is for.

Nested method invocation

Method invocations can also be nested:

Logger l = Logger.getLogger(Person.class.getName());
l.info("Name: " + p.getName());

Here you are passing the return value of Person.class.getName() to the getLogger() method. Remember that the getLogger()method call is a static method call, so its syntax differs slightly. (You don't need a Logger reference to make the invocation; instead, you use the name of the class as the left side of the invocation.)

That's really all there is to method invocation.

Strings and operators

The tutorial has so far introduced several variables of type String, but without much explanation. You learn more about strings in this section, and also find out when and how to use operators.

Strings

Handling strings in C is labor-intensive because they're null-terminated arrays of 8-bit characters that you must manipulate. In the Java language, strings are first-class objects of type String, with methods that help you manipulate them. (The closest Java code gets to the C world with regard to strings is the char primitive data type, which can hold a single Unicode character, such as a.)

You've already seen how to instantiate a String object and set its value (back in Listing 4), but you have several other ways to do that. Here are a couple of ways to create a String instance with a value of hello:

String greeting = "hello";

greeting = new String("hello");

Because Strings are first-class objects in the Java language, you can use new to instantiate them. Setting a variable of type String has the same result, because the Java language creates a String object to hold the literal, then assigns that object to the instance variable.

Concatenating strings

You can do many things with String, and the class has many helpful methods. Without even using a method, you've already done something interesting with two Strings by concatenating, or combining, them:

l.info("Name: " + p.getName());

The plus (+) sign is shorthand for concatenating Strings in the Java language. (You incur a performance penalty for doing this type of concatenation inside a loop, but for now, you don't need to worry about that.)

Concatenation example

Now, you can try concatenating Strings inside of the Person class. At this point, you have a name instance variable, but it would be nice to have a firstName and lastName. You can then concatenate them when another object requests Person's full name.

The first thing you need to do is add the new instance variables (at the same location in the source code where name is currently defined):

//private String name;
private String firstName;
private String lastName;

You don't need name anymore; you've replaced it with firstName and lastName.

Chaining method calls

Now you can generate getters and setters for firstName and lastName (as shown back in Figure 6), remove the setName() method, and change getName() to look like this:

public String getName() {
  return firstName.concat(" ").concat(lastName);
}

This code illustrates chaining of method calls. Chaining is a technique commonly used with immutable objects like String, where a modification to an immutable object always returns the modification (but doesn't change the original). You then operate on the returned, changed value.

Operators

As you might expect, the Java language can do arithmetic, and you've already seen how to assign variables. Now, I give you a brief look at some of the Java language operators you need as your skills improve. The Java language uses two types of operators:

• Unary: Only one operand is needed.
• Binary: Two operands are needed.

The Java language's arithmetic operators are summarized in Table 2.

Table 2. Java language's arithmetic operators

Operator	Usage	Description
+	a + b	Adds a and b
+	+a	Promotes a to int if it's a byte, short, or char
-	a - b	Subtracts b from a
-	-a	Arithmetically negates a
*	a * b	Multiplies a and b
/	a / b	Divides a by b
%	a % b	Returns the remainder of dividing a by b (the modulus operator)
++	a++	Increments a by 1; computes the value of a before incrementing
++	++a	Increments a by 1; computes the value of a after incrementing
--	a--	Decrements a by 1; computes the value of a before decrementing
--	--a	Decrements a by 1; computes the value of a after decrementing
+=	a += b	Shorthand for a = a + b
-=	a -= b	Shorthand for a = a - b
*=	a *= b	Shorthand for a = a * b
%=	a %= b	Shorthand for a = a % b

Additional operators

In addition to the operators in Table 2, you've seen several other symbols that are called operators in the Java language, including:

• Period (.), which qualifies names of packages and invokes methods
• Parentheses (()), which delimit a comma-separated list of parameters to a method
• new, which (when followed by a constructor name) instantiates an object

The Java language syntax also includes several operators that are used specifically for conditional programming — that is, programs that respond differently based on different input. You look at those in the next section.

Back to top

Conditional operators and control statements

In this section, you learn about the various statements and operators you can use to tell your Java programs how you want them to act based on different input.

Relational and conditional operators

The Java language gives you operators and control statements that you can use to make decisions in your code. Most often, a decision in code starts with a Boolean expression (that is, one that evaluates to either true or false). Such expressions use relational operators, which compare one operand or expression to another, and conditional operators.

Table 3 lists the relational and conditional operators of the Java language.

Table 3. Relational and conditional operators

Operator	Usage	Returns true if...
>	a > b	a is greater than b
>=	a >= b	a is greater than or equal to b
<	a < b	a is less than b
<=	a <= b	a is less than or equal to b
==	a == b	a is equal to b
!=	a != b	a is not equal to b
&&	a && b	a and b are both true, conditionally evaluates b (if a is false, b is not evaluated)
||	a || b	a or b is true, conditionally evaluates b (if a is true, b is not evaluated)
!	!a	a is false
&	a & b	a and b are both true, always evaluates b
|	a | b	a or b is true, always evaluates b
^	a ^ b	a and b are different

The if statement

Now that you have a bunch of operators, it's time to use them. This code shows what happens when you add some logic to the Person object'sgetHeight() accessor:

public int getHeight() {
  int ret = height;
  // If locale of the machine this code is running on is U.S.,
  if (Locale.getDefault().equals(Locale.US))
    ret /= 2.54;// convert from cm to inches
  return ret;
}

If the current locale is in the United States (where the metric system is not in use), it might make sense to convert the internal value of height (in centimeters) to inches. This (somewhat contrived) example illustrates the use of the if statement, which evaluates a Boolean expression inside parentheses. If that expression evaluates to true, it executes the next statement.

In this case, you only need to execute one statement if the Locale of the machine the code is running on is Locale.US. If you need to execute more than one statement, you can use curly braces to form a compound statement. A compound statement groups many statements into one — and compound statements can also contain other compound statements.

Variable scope

Every variable in a Java application has scope, or localized namespace, where you can access it by name within the code. Outside that space the variable is out of scope, and you get a compile error if you try to access it. Scope levels in the Java language are defined by where a variable is declared, as shown in Listing 7.

Listing 7. Variable scope

public class SomeClass {
  private String someClassVariable;
  public void someMethod(String someParameter) {
    String someLocalVariable = "Hello";

    if (true) {
      String someOtherLocalVariable = "Howdy";
    }
    someClassVariable = someParameter; // legal
    someLocalVariable = someClassVariable; // also legal
    someOtherLocalVariable = someLocalVariable;// Variable out of scope!
  }
  public void someOtherMethod() {
    someLocalVariable = "Hello there";// That variable is out of scope!
  }
}

Within SomeClass, someClassVariable is accessible by all instance (that is, nonstatic) methods. Within someMethod, someParameter is visible, but outside of that method it is not, and the same is true for someLocalVariable. Within the if block, someOtherLocalVariable is declared, and outside of that if block it is out of scope. For this reason, we say that Java has block scope, because blocks (delimited by { and }) define the scope boundaries.

Scope has many rules, but Listing 7 shows the most common ones. Take a few minutes to familiarize yourself with them.

The else statement

Sometimes in a program's control flow, you want to take action only if a particular expression fails to evaluate to true. That's when else comes in handy:

public int getHeight() {
  int ret;
  if (gender.equals("MALE"))
    ret = height + 2;
  else {
    ret = height;
  Logger.getLogger("Person").info("Being honest about height...");
  }
  return ret;
}

The else statement works the same way as if, in that it executes only the next statement it runs across. In this case, two statements are grouped into a compound statement (notice the curly braces), which the program then executes.

You can also use else to perform an additional if check:

if (conditional) {
  // Block 1
} else if (conditional2) {
  // Block 2
} else if (conditional3) {
  // Block 3
} else {
  // Block 4
} // End

If conditional evaluates to true, then Block 1 is executed and the program jumps to the next statement after the final curly brace (which is indicated by // End). If conditional does not evaluate to true, then conditional2 is evaluated. If conditional2 is true, then Block 2 is executed, and the program jumps to the next statement after the final curly brace. If conditional2 is not true, then the program moves on toconditional3, and so on. Only if all three conditionals fail is Block 4 executed.

The ternary operator

The Java language provides a handy operator for doing simple if / else statement checks. Its syntax is:

(conditional) ? statementIfTrue : statementIfFalse;

If conditional evaluates to true, then statementIfTrue is executed; otherwise, statementIfFalse is executed. Compound statements are not allowed for either statement.

The ternary operator comes in handy when you know that you need to execute one statement as the result of the conditional evaluating to true, and another if it does not. Ternary operators are most often used to initialize a variable (such as a return value), like so:

public int getHeight() {
  return (gender.equals("MALE")) ? (height + 2) : height;
}

The parentheses following the question mark aren't strictly required, but they do make the code more readable.

Loops

In addition to being able to apply conditions to your programs and see different outcomes based on various if/then scenarios, you sometimes want your code to do the same thing over and over again until the job is done. In this section, learn about two constructs used to iterate over code or execute it more than once: for loops and while loops.

What is a loop?

A loop is a programming construct that executes repeatedly while some condition (or set of conditions) is met. For instance, you might ask a program to read all records until the end of a file, or loop over all the elements of an array, processing each one. (You learn about arrays in this tutorial's "Java Collections" section.)

for loops

The basic loop construct in the Java language is the for statement, which you can use to iterate over a range of values to determine how many times to execute a loop. The abstract syntax for a for loop is:

for (initialization; loopWhileTrue; executeAtBottomOfEachLoop) {
  statementsToExecute
}

At the beginning of the loop, the initialization statement is executed (multiple initialization statements can be separated by commas). Provided thatloopWhileTrue (a Java conditional expression that must evaluate to either true or false) is true, the loop executes. At the bottom of the loop,executeAtBottomOfEachLoop executes.

Example of a for loop

If you wanted to change a main() method to execute three times, you can use a for loop, as shown in Listing 8.

Listing 8. A for loop

public static void main(String[] args) {
  Logger l = Logger.getLogger(Person.class.getName());
  for (int aa = 0; aa < 3; aa++) {
    Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");
    l.info("Loop executing iteration# " + aa);
    l.info("Name: " + p.getName());
    l.info("Age:" + p.getAge());
    l.info("Height (cm):" + p.getHeight());
    l.info("Weight (kg):" + p.getWeight());
    l.info("Eye Color:" + p.getEyeColor());
    l.info("Gender:" + p.getGender());
  }
}

The local variable aa is initialized to zero at the beginning of Listing 8. This statement executes only once, when the loop is initialized. The loop then continues three times, and each time aa is incremented by one.

As you'll see later, an alternate for loop syntax is available for looping over constructs that implement the Iterable interface (such as arrays and other Java utility classes). For now, just note the use of the for loop syntax in Listing 8.

while loops

The syntax for a while loop is:

while (condition) {
  statementsToExecute
}

As you might suspect, while condition evaluates to true, so the loop executes. At the top of each iteration (that is, before any statements execute), the condition is evaluated. If the condition evaluates to true, the loop executes. So it's possible that a while loop will never execute if its conditional expression is not true at least once.

Look again at the for loop in Listing 8. For comparison, Listing 9 uses a while loop to obtain the same result.

Listing 9. A while loop

public static void main(String[] args) {
  Logger l = Logger.getLogger(Person.class.getName());
  int aa = 0;
  while (aa < 3) {
    Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");
    l.info("Loop executing iteration# " + aa);
    l.info("Name: " + p.getName());
    l.info("Age:" + p.getAge());
    l.info("Height (cm):" + p.getHeight());
    l.info("Weight (kg):" + p.getWeight());
    l.info("Eye Color:" + p.getEyeColor());
    l.info("Gender:" + p.getGender());
    aa++;
  }
}

As you can see, a while loop requires a bit more housekeeping than a for loop. You must initialize the aa variable and also remember to increment it at the bottom of the loop.

do...while loops

If you want a loop that always executes once and then checks its conditional expression, try using a do...while loop, as shown in Listing 10.

Listing 10. A do...while loop

int aa = 0;
do {
  Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");
  l.info("Loop executing iteration# " + aa);
  l.info("Name: " + p.getName());
  l.info("Age:" + p.getAge());
  l.info("Height (cm):" + p.getHeight());
  l.info("Weight (kg):" + p.getWeight());
  l.info("Eye Color:" + p.getEyeColor());
  l.info("Gender:" + p.getGender());
  aa++;
} while (aa < 3);

The conditional expression (aa < 3) is not checked until the end of the loop.

Loop branching

At times, you need to bail out of a loop before the conditional expression evaluates to false. This situation can occur if you are searching an array ofStrings for a particular value, and once you find it, you don't care about the other elements of the array. For the times when you want to bail, the Java language provides the break statement, shown in Listing 11.

Listing 11. A break statement

public static void main(String[] args) {
  Logger l = Logger.getLogger(Person.class.getName());
  int aa = 0;
  while (aa < 3) {
    if (aa == 1)
      break;
    Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");
    l.info("Loop executing iteration# " + aa);
    l.info("Name: " + p.getName());
    l.info("Age:" + p.getAge());
    l.info("Height (cm):" + p.getHeight());
    l.info("Weight (kg):" + p.getWeight());
    l.info("Eye Color:" + p.getEyeColor());
    l.info("Gender:" + p.getGender());
    aa++;
  }
}

The break statement takes you to the next executable statement outside of the loop in which it's located.

Loop continuation

In the (simplistic) example in Listing 11, you only want to execute the loop once and bail. You can also skip a single iteration of a loop but continue executing the loop. For that purpose, you need the continue statement, shown in Listing 12.

Listing 12. A continue statement

public static void main(String[] args) {
  Logger l = Logger.getLogger(Person.class.getName());
  int aa = 0;
  while (aa < 3) {
    if (aa == 1)
      continue;
    else
    aa++;
    Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");
    l.info("Loop executing iteration# " + aa);
    l.info("Name: " + p.getName());
    l.info("Age:" + p.getAge());
    l.info("Height (cm):" + p.getHeight());
    l.info("Weight (kg):" + p.getWeight());
    l.info("Eye Color:" + p.getEyeColor());
    l.info("Gender:" +
    p.getGender());
  }
}

In Listing 12, you skip the second iteration of a loop but continue to the third. continue comes in handy when you are, say, processing records and come across a record you definitely don't want to process. You can skip that record and move on to the next one.

Back to top

Java Collections

Most real-world applications deal with collections of things like files, variables, records from files, or database result sets. The Java language has a sophisticated Collections Framework that enables you to create and manage collections of objects of various types. This section won't teach you everything about Java Collections, but it does introduce the most commonly used collection classes and get you started with using them.

Arrays

Most programming languages include the concept of an array to hold a collection of things, and the Java language is no exception. An array is nothing more than a collection of elements of the same type.

Note: The square brackets in this section's code examples are part of the required syntax for Java Collections, not indicators of optional elements.

You can declare an array in one of two ways:

• Create it with a certain size, which is fixed for the life of the array.
• Create it with a certain set of initial values. The size of this set determines the size of the array — it is exactly large enough to hold all of those values, and its size is fixed for the life of the array.

Declaring an array

In general, you declare an array like this:

new elementType [arraySize]

You can create an integer array of elements in two ways. This statement creates an array that has space for five elements but is empty:

// creates an empty array of 5 elements:
int[] integers = new int[5];

This statement creates the array and initializes it all at once:

// creates an array of 5 elements with values:
int[] integers = new int[] { 1, 2, 3, 4, 5 };

The initial values go between the curly braces and are separated by commas.

Another way to create an array is to create it and then code a loop to initialize it:

int[] integers = new int[5];
for (int aa = 0; aa < integers.length; aa++) {
  integers[aa] = aa+1;
}

The preceding code declares an integer array of five elements. If you try to put more than five elements in the array, the Java runtime will throw anexception. You'll learn about exceptions and how to handle them in Part 2.

Loading an array

To load the array, you loop through the integers from 1 through the length of the array (which you get by calling .length on the array — more about that in a minute). In this case, you stop when you hit 5.

Once the array is loaded, you can access it as before:

Logger l = Logger.getLogger("Test");
for (int aa = 0; aa < integers.length; aa++) {
  l.info("This little integer's value is: " + integers[aa]);
}

This newer (available since JDK 5) syntax also works:

Logger l = Logger.getLogger("Test");
for (int i : integers) {
  l.info("This little integer's value is: " + i);
}

I find the newer syntax simpler to work with, and I use it throughout this section.

The element index

Think of an array as a series of buckets, and into each bucket goes an element of a certain type. Access to each bucket is gained using an index:

element = arrayName [elementIndex];

To access an element, you need the reference to the array (its name) and the index where the element that you want resides.

The length method

A handy method, as you've already seen, is length. It's a built-in method, so its syntax doesn't include the usual parentheses. Just type the wordlength, and it will return — as you would expect — the size of the array.

Arrays in the Java language are zero-based. So, for some array named array, the first element in the array always resides at array[0], and the last resides at array[array.length - 1].

An array of objects

You've seen how arrays can hold primitive types, but it's worth mentioning that they can also hold objects. In that sense, the array is the Java language's most utilitarian collection.

Creating an array of java.lang.Integer objects isn't much different from creating an array of primitive types. Once again, you have two ways to do it:

// creates an empty array of 5 elements:
Integer[] integers = new Integer[5];

// creates an array of 5 elements with values:
Integer[] integers = new Integer[] { Integer.valueOf(1),
Integer.valueOf(2)
Integer.valueOf(3)
Integer.valueOf(4)
Integer.valueOf(5));

Boxing and unboxing

Every primitive type in the Java language has a JDK counterpart class, which you can see in Table 4.

Table 4. Primitives and JDK counterparts

Primitive	JDK counterpart
boolean	java.lang.Boolean
byte	java.lang.Byte
char	java.lang.Character
short	java.lang.Short
int	java.lang.Integer
long	java.lang.Long
float	java.lang.Float
double	java.lang.Double

Each JDK class provides methods to parse and convert from its internal representation to a corresponding primitive type. For example, this code converts the decimal value 238 to an Integer:

int value = 238;
Integer boxedValue = Integer.valueOf(value);

This technique is known as boxing, because you're putting the primitive into a wrapper, or box.

Similarly, to convert the Integer representation back to its int counterpart, you unbox it:

Integer boxedValue = Integer.valueOf(238);
int intValue = boxedValue.intValue();

Autoboxing and auto-unboxing

Strictly speaking, you don't need to box and unbox primitives explicitly. Instead, you can use the Java language's autoboxing and auto-unboxing features:

int intValue = 238;
Integer boxedValue = intValue;
//
intValue = boxedValue;

I recommend that you avoid autoboxing and auto-unboxing, however, because it can lead to code-readability issues. The code in the boxing and unboxing snippets is more obvious, and thus more readable, than the autoboxed code; I believe that's worth the extra effort.

Parsing and converting boxed types

You've seen how to obtain a boxed type, but what about parsing a String that you suspect has a boxed type into its correct box? The JDK wrapper classes have methods for that, too:

String characterNumeric = "238";
Integer convertedValue = Integer.parseInt(characterNumeric);

You can also convert the contents of a JDK wrapper type to a String:

Integer boxedValue = Integer.valueOf(238);
String characterNumeric = boxedValue.toString();

Note that when you use the concatenation operator in a String expression (you've already seen this in calls to Logger), the primitive type is autoboxed, and wrapper types automatically have toString() invoked on them. Pretty handy.

Lists

A List is a collection construct that is by definition an ordered collection, also known as a sequence. Because a List is ordered, you have complete control over where in the List items go. A Java List collection can only hold objects, and it defines a strict contract about how it behaves.

List is an interface, so you can't instantiate it directly. You'll work with its most commonly used implementation, ArrayList. There are two ways to make the declaration. First, using the explicit syntax:

List<String> listOfStrings = new ArrayList<String>();

Second, using the "diamond" operator, introduced in JDK 7:

List<String> listOfStrings = new ArrayList<>();

Notice the type of the object in the ArrayList instantiation is not specified. This is the case because the type of the class on the right side of the expression must match that of the left side. Throughout the remainder of this tutorial, I use both types, because you are likely to see both usages in practice.

Note that I have assigned the ArrayList object to a variable of type List. With Java programming, you can assign a variable of one type to another, provided the variable being assigned to is a superclass or interface implemented by the variable being assigned from. You can look more at how variable assignments are affected in Part 2 in the "Inheritance" section.

Formal type

The <Object> in the preceding code snippet is called the formal type. <Object> tells the compiler that this List contains a collection of typeObject, which means you can pretty much put whatever you like in the List.

If you want to tighten up the constraints on what can or cannot go into the List, you can define the formal type differently:

List<Person> listOfPersons = new ArrayList<Person>();

Now your List can only hold Person instances.

Using Lists

Using Lists is super easy, like Java collections in general. Here are some of the things you do with Lists:

• Put something in the List.
• Ask the List how big it currently is.
• Get something out of the List.

Now, you can try some of these things out. You've already seen how to create an instance of List by instantiating its ArrayList implementation type, so you can start from there.

To put something in a List, call the add() method:

List<Integer> listOfIntegers = new ArrayList<>();
listOfIntegers.add(Integer.valueOf(238));

The add() method adds the element to the end of the List.

To ask the List how big it is, call size():

List<Integer> listOfIntegers = new ArrayList<>();

listOfIntegers.add(Integer.valueOf(238));
Logger l = Logger.getLogger("Test");
l.info("Current List size: " + listOfIntegers.size());

To retrieve an item from the List, call get() and pass it the index of the item you want:

List<Integer> listOfIntegers = new ArrayList<>();
listOfIntegers.add(Integer.valueOf(238));
Logger l = Logger.getLogger("Test");
l.info("Item at index 0 is: " listOfIntegers.get(0));

In a real-world application, a List would contain records, or business objects, and you would possibly want to look over them all as part of your processing. How do you do that in a generic fashion? You want to iterate over the collection, which you can do because List implements thejava.lang.Iterable interface. (You learn about interfaces in Part 2.)

Iterable

If a collection implements java.lang.Iterable, it's called an iterable collection. You can start at one end and walk through the collection item-by-item until you run out of items.

You've already seen the special syntax for iterating over collections that implement the Iterable interface, in the "Loops" section. Here it is again:

for (objectType varName : collectionReference) {
  // Start using objectType (via varName) right away...
}

Iterating over a List

That previous example was abstract; now, here's a more realistic one:

List<Integer> listOfIntegers = obtainSomehow();
Logger l = Logger.getLogger("Test");
for (Integer i : listOfIntegers) {
  l.info("Integer value is : " + i);
}

That little code snippet does the same thing as this longer one:

List<Integer> listOfIntegers = obtainSomehow();
Logger l = Logger.getLogger("Test");
for (int aa = 0; aa < listOfIntegers.size(); aa++) {
  Integer I = listOfIntegers.get(aa);
  l.info("Integer value is : " + i);
}

The first snippet uses shorthand syntax: There is no index variable (aa in this case) to initialize, and no call to the List 's get() method.

Because List extends java.util.Collection, which implements Iterable, you can use the shorthand syntax to iterate over any List.

Sets

A Set is a collections construct that by definition contains unique elements — that is, no duplicates. Whereas a List can contain the same object hundreds of times, a Set can only contain a given instance once. A Java Set collection can only hold objects, and it defines a strict contract about how it behaves.

Because Set is an interface, you can't instantiate it directly, so here is one of my favorite implementations: HashSet. HashSet is easy to use and is similar to List.

Here are some things you do with a Set:

• Put something in the Set.
• Ask the Set how big it currently is.
• Get something out of the Set.

Using Sets

A Set's distinguishing attribute is that it guarantees uniqueness among its elements but doesn't care about the order of the elements. Consider the following code:

Set<Integer> setOfIntegers = new HashSet<Integer>();
setOfIntegers.add(Integer.valueOf(10));
setOfIntegers.add(Integer.valueOf(11));
setOfIntegers.add(Integer.valueOf(10));
for (Integer i : setOfIntegers) {
  l.info("Integer value is: " + i);
}

You might expect that the Set would have three elements in it, but it only has two because the Integer object that contains the value 10 is added only once.

Keep this behavior in mind when iterating over a Set, like so:

Set<Integer> setOfIntegers = new HashSet();
setOfIntegers.add(Integer.valueOf(10));
setOfIntegers.add(Integer.valueOf(20));
setOfIntegers.add(Integer.valueOf(30));
setOfIntegers.add(Integer.valueOf(40));
setOfIntegers.add(Integer.valueOf(50));
Logger l = Logger.getLogger("Test");
for (Integer i : setOfIntegers) {
  l.info("Integer value is : " + i);
}

Chances are the objects print out in a different order from the order you added them in, because a Set guarantees uniqueness, not order. You can see this if you paste the previous code into the main() method of your Person class and run i