Friday, October 15, 2010

Storing Information with Arrays In Java


No one benefits more from the development of the computer than Santa Claus. For centuries, humankind has put an immense burden on him to gather and process information. Old St. Nick has to keep track of the following things:

·         Naughty children

·         Nice children

·         Gift requests

·         Homes with impassable chimneys

·         Women who want more from Santa than Mrs. Claus is willing to let him give

·         Countries that shoot unidentified aircraft first and ask questions later

Computers must have been a great boon at the North Pole because they are ideal for the storage, categorization, and study of information.

The most basic way that information is stored in a computer program is by putting it into a variable. However, this method is limited to relatively simple usage. If Santa had to give each naughty child his or her own variable name, he'd be working on the program for the next 12 holiday seasons at least, to say nothing of the effect on his jolly disposition or his carpal tunnel nerves. The list of naughty children is an example of a collection of similar information. Each child's name is a string of text or some kind of Santa Information System ID number. In order to keep track of a list of this kind, you can use arrays.

Arrays are groups of related variables that share the same type. You can have arrays of any type of information that can be stored as a variable. Arrays can be used to keep track of more sophisticated types of information than a single variable, but they are almost as easy to create and manipulate as variables are.

The following topics will be covered during this hour:

·         Creating an array

·         What a dimension of an array is

·         Giving a value to an array element

·         Changing the information in an array

·         Making multidimensional arrays

Creating Arrays

Arrays are variables that are grouped together under a common name. The term should be familiar to you though the meaning might not be so clear--think of a salesman showing off his array of fabulous cleaning products or a game show with a dazzling array of prizes. Like variables, arrays are created by stating the type of the variable being organized into an array and the name of the array. The difference lies in the addition of the square bracket marks [ and ].

You can create arrays for any type of information that can be stored as a variable. For example, the following statement creates an array of string variables:

String[] naughtyChild;

Here are a few more examples:

int[] reindeerWeight;

boolean[] hostileAirTravelNations;

Java is flexible about where the square brackets are placed when an array is being created. You can put them after the variable name instead of after the variable type, as in the following:

String niceChild[];

To make arrays easier for humans to spot in your programs, you probably should stick to one style rather than switching back and forth, though Java allows both styles of usage.

The previous examples create arrays, but they do not store any values in them initially. To do this, you must use the new statement along with the variable type or store values in the array within { and } marks. You also must specify how many different items will be stored in the array. Each item in an array is called an element. The following statement creates an array and sets aside space for the values that it will hold:

int[] elfSeniority = new int[250];

This example creates an array of integers called elfSeniority. The array has 250 elements in it that can be used to store the number of months that each of Santa's elves has been employed at the Pole. If the rumors are true and Santa runs a union shop, this information is extremely important to keep track of.

When you create an array with the new statement, you must specify the number of elements. Each element of the array is given an initial value when it is set up with new; the value depends on the type of the array. All numeric arrays have the value 0, char arrays have the value `\0', and boolean arrays have the value false. A String array and all other objects are created with the initial value of null.

For arrays that are not extremely large, you can set up their initial values at the same time that you create them. The following example creates an array of strings and gives them initial values:

String[] reindeerNames = { "Dasher", "Dancer", "Prancer", "Vixen", "Comet", "Cupid", "Donner", "Blitzen" };

The information that should be put into elements of the array is put between { and } brackets, and commas separate each element. The number of elements in the array is not specified in the statement because it is set to the number of elements in the comma-separated list. Each element of the array in the list must be of the same type. The preceding example uses a string for each of the reindeer names.

Once the array is created, you cannot make more space and add another variable to the array. Even if you recall the most famous reindeer of all, you couldn't add "Rudolph" as the ninth element of the reindeerNames array. The javac compiler won't let poor Rudolph join in any reindeerNames.

Using Arrays

You use arrays in a program as you would use any variable, except for the element number in between the square brackets next to the array's name. Once you refer to the element number, you can use an array element anywhere that a variable could be used. The following statements all use arrays that have been defined already in this hour's examples:

elfSeniority[193] += 1;

niceChild[94287612] = "Jonathan Bourne";

if ( hostileAirTravelNations[currentNation] == true)

    sendGiftByMail();

An important thing to note about arrays is that the first element of an array is numbered 0 instead of 1. This means that the highest number is one less than you might expect. For example, consider the following statement:

String[] topGifts = new String[10];

This statement creates an array of String variables that are numbered from 0 to 9. If you referred to a topGifts[10] somewhere else in the program, you would get an error message like the following when you run the program:

java.lang.ArrayIndexOutOfBoundsException:

        at SantaGifts.main(SantaGifts.java:4);

Like all of the error messages Java generates, this one's a bit hard to decipher. The key thing to note is the part that mentions an exception because exceptions are another word for errors in Java programs. This exception is an "array out of bounds" error, which means that the array has gone beyond its defined boundaries.

If you want to see what the upper limit of an array is during a program so that you can avoid going beyond the limit, you can use a variable called length that is associated with each array that is created. The length variable is an integer that returns the number of elements that an array can hold. The following example creates an array and then reports its length:

String[] reindeerNames = { "Dasher", "Dancer", "Prancer", "Vixen",

    "Comet", "Cupid", "Donner", "Blitzen", "Rudolph" };

System.out.println("There are " + reindeerNames.length + " reindeer.");

In this example, the value of reindeerNames.length is 9, which means that the highest element number you can specify is 8.

Multidimensional Arrays

The arrays you have been introduced to thus far in the hour all have one dimension; one line of numbers ranging from 0 to the largest element number is used to refer to an array. But some types of information require more dimensions to store adequately as arrays. An example would be the (x,y) coordinate system that's a staple of any math class. If you needed to store a list of x and y coordinates that have a point marked on them, you could use a two-dimensional array. One dimension of the array could store the x coordinate, and the other dimension could store the y coordinate.

To create an array that has two dimensions, you must use an additional set of square brackets when creating and using the array. Consider the following:

boolean[][] selectedPoint = new int[50][50];

selectedPoint[4][13] = true;

selectedPoint[7][6] = true;

selectedPoint[11][22] = true;

This example creates an array of Boolean values called selectedPoint. The array has 50 elements in its first dimension and 50 elements in its second dimension, so there are 2,500 individual array elements that can hold values (50 multiplied by 50). When the array is created, each element is given the default value of false. Three elements are then given the value of true: A point at the (x,y) position of (4,13), one at (7,6), and one at (11,22).

Arrays can have as many dimensions as you need, but keep in mind that they take up a lot of memory if they're extremely large. Creating the 50 by 50 selectedPoint array was equivalent to creating 2,500 individual variables.

No comments:

Post a Comment