Sams Teach Yourself Java 2 in 24 Hours

By Rogers Cadenhead

• Table of Contents
  • Copyright
  • About the Author
  • About the Technical Editor
  • Acknowledgments
  • We Want to Hear from You!
  • Reader Services
  • Introduction
  • Hour 1. Becoming a Programmer
  • Hour 2. Writing Your First Program
  • Hour 3. Vacationing in Java
  • Hour 4. Understanding How Java Programs Work
  • Part II: Learning the Basics of Programming
  • Hour 5. Storing and Changing Information in a Program
  • Hour 6. Using Strings to Communicate
  • Hour 7. Using Conditional Tests to Make Decisions
  • Hour 8. Repeating an Action with Loops
  • Part III: Working with Information in New Ways
  • Hour 9. Storing Information with Arrays
    • Creating Arrays
    • Using Arrays
    • Multidimensional Arrays
    • Sorting an Array
    • Workshop: Array of Prizes, Indeed
    • Summary
    • Q&A
    • Quiz
    • Activities
  • Hour 10. Creating Your First Object
  • Hour 11. Describing What Your Object Is Like
  • Hour 12. Making the Most of Existing Objects
  • Part IV: Programming a Graphical User Interface
  • Hour 13. Building a Simple User Interface
  • Hour 14. Laying Out a User Interface
  • Hour 15. Responding to User Input
  • Hour 16. Building a Complex User Interface
  • Part V: Creating Multimedia Programs
  • Hour 17. Creating Interactive Web Programs
  • Hour 18. Handling Errors in a Program
  • Hour 19. Creating a Threaded Program
  • Hour 20. Reading and Writing Files
  • Part VI: Creating Multimedia Programs
  • Hour 21. Using Fonts and Color
  • Hour 22. Playing Sound Files
  • Hour 23. Working with Graphics
  • Hour 24. Creating Animation
  • Part VII: Appendixes
  • Appendix A. Tackling New Features of Java 2 Version 1.4
  • Appendix B. Using the Java 2 Software Development Kit
  • Appendix C. Programming with the Java 2 Software Development Kit
  • Appendix D. Using Sun ONE Studio
  • Appendix E. Where to Go from Here: Java Resources
  • Appendix F. This Book's Web Site

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 11 can't be found.

Example 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:         Arrays.sort(names); 
12:         System.out.println("The new order:"); 
13:         for (int i = 0; i < names.length; i++) 
14:             System.out.println(i + ": " + names[i]); 
15:     } 
16: } 

After you have created this source file, compile it. Using the SDK, 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 if you want better efficiency than the Arrays class provides.

Share This