Sorting an Array

Sorting an Array

When you have grouped a bunch of similar items together into an array, one of the things you can do easily is rearrange items. The following statements switch the values of two elements in an integer array called numbers:

```int temp = numbers[5];

numbers[5] = numbers[6];

numbers[6] = temp;

```

These statements result in numbers[5] and numbers[6] trading values with each other. The integer variable called temp is used as a temporary storage place for one of the values being swapped.

The most common reason to rearrange elements of an array is to sort them into a specific order. Sorting is the process of arranging a list of related items into a set order. An example would be sorting a list of numbers from lowest to highest.

Santa Claus, the world's biggest user of lists, might want to use sorting to rearrange the order of gift recipients according to last name. This order could determine who receives gifts first on Christmas Eve, with people such as Willie Aames and Paul Azinger raking in their Yuletide plunder much earlier than alphabetical unfortunates such as Dweezil Zappa and Jim Zorn. (As someone whose last name begins with "C," I'm not necessarily opposed to this practice.)

Sorting an array is easy in Java because the Arrays class does all of the work for you. Arrays, which is part of the java.util group of classes, can rearrange arrays of all variable types as well as strings.

To use the Arrays class in a program to sort an array, undertake the following steps:

• Use the import java.util.* statement to make all of the java.util classes available in the program.

• Create the array.

• Use the sort() method of the Arrays class to rearrange an array.

An array of variables that is sorted by the Arrays class will be rearranged into ascending numerical order. This will be easy to see with an array of numbers such as float values. Characters and strings will be arranged according to the alphabet, with the first letters such as A, B, and C coming first, and the last letters such as X, Y, and Z coming last.

Listing 9.2 contains a short program that sorts five names. Enter this with your word processor and save the file as Name.java. Make sure not to overlook line 1. If you do, the program will fail to compile because the Arrays class in line 12 can't be found.

Listing 9.2. The Full Source Code of Name.java
``` 1: import java.util.*;

2:

3: class Name {

4:     public static void main(String[] arguments) {

5:         String names[] = { "Peter", "Patricia", "Hunter", "Sarah",

6:             "Gabe", "Gina", "Rob", "John", "Zoey", "Tammy", "Robert",

7:             "Sean", "Paschal", "Kathy", "Neleh", "Vecepia" };

8:         System.out.println("The original order:");

9:         for (int i = 0; i < names.length; i++) {

10:             System.out.println(i + ": " + names[i]);

11:         }

12:         Arrays.sort(names);

13:         System.out.println("The new order:");

14:         for (int i = 0; i < names.length; i++) {

15:             System.out.println(i + ": " + names[i]);

16:         }

17:     }

18: }

```

After you have created this source file, compile it. Using the JDK, you can compile it at a command line by entering this command:

```javac Name.java

```

This Java program displays a list of five names in their original order, sorts the names, and then redisplays the list.

The following output is produced:

```The original order:

0: Peter

1: Patricia

2: Hunter

3: Sarah

4: Gabe

5: Gina

6: Rob

7: John

8: Zoey

9: Tammy

10: Robert

11: Sean

12: Paschal

13: Kathy

14: Neleh

15: Vecepia

The new order:

0: Gabe

1: Gina

2: Hunter

3: John

4: Kathy

5: Neleh

6: Paschal

7: Patricia

8: Peter

9: Rob

10: Robert

11: Sarah

12: Sean

13: Tammy

14: Vecepia

15: Zoey

```

When you're working with strings and the basic types of variables such as integers and floating-point numbers, you can only sort them by ascending order using the Arrays class. You can write code to do your own sorts by hand if you desire a different arrangement of elements during a sort, or you want better efficiency than the Arrays class provides.

By the Way

There are numerous sorting techniques that have been created for use in computer programs. The Arrays class uses a technique called a "tuned quicksort," which was described by Jon L. Bentley and M. Douglas McIlroy in a 1993 issue of Software-Practice and Experience. Different techniques have their own names, including the heap sort, tree sort, and bubble sort. Jason Harrison has a web page that uses Java to visually demonstrate the speed of different sorting techniques. To see it, visit the web address http://www.cs.ubc.ca/spider/harrison/Java/sorting-demo.html.