The Java collection framework is a set of important utility classes and interfaces in the java.util package for working with collections of objects. The collection framework defines two fundamental types of collections. A Collection is a group of objects, while a Map is a set of mappings, or associations, between objects. A Set is a type of Collection in which there are no duplicates, and a List is a Collection in which the elements are ordered. Collection, Set, List, and Map are all interfaces, but the java.util package also defines various concrete implementations (see Chapter 23, "The java.util Package"). Other important interfaces are Iterator and ListIterator, which allow you to loop through the objects in a collection. The collection framework is new as of Java 1.2, but prior to that release you can use Vector and Hashtable, which are approximately the same as ArrayList and HashMap.
The following code demonstrates how you might create and perform basic manipulations on sets, lists, and maps:
import java.util.*;
Set s = new HashSet(); // Implementation based on a hash table
s.add("test"); // Add a String object to the set
boolean b = s.contains("test2"); // Check whether a set contains an object
s.remove("test"); // Remove a member from a set
Set ss = new TreeSet(); // TreeSet implements SortedSet
ss.add("b"); // Add some elements
ss.add("a");
// Now iterate through the elements (in sorted order) and print them
for(Iterator i = ss.iterator(); i.hasNext();)
System.out.println(i.next());
List l = new LinkedList(); // LinkedList implements a doubly linked list
l = new ArrayList(); // ArrayList is more efficient, usually
Vector v = new Vector(); // Vector is an alternative in Java 1.1/1.0
l.addAll(ss); // Append some elements to it
l.addAll(1, ss); // Insert the elements again at index 1
Object o = l.get(1); // Get the second element
l.set(3, "new element"); // Set the fourth element
l.add("test"); // Append a new element to the end
l.add(0, "test2"); // Insert a new element at the start
l.remove(1); // Remove the second element
l.remove("a"); // Remove the element "a"
l.removeAll(ss); // Remove elements from this set
if (!l.isEmpty()) // If list is not empty,
System.out.println(l.size()); // print out the number of elements in it
boolean b1 = l.contains("a"); // Does it contain this value?
boolean b2 = l.containsAll(ss); // Does it contain all these values?
List sublist = l.subList(1,3); // A sublist of the 2nd and 3rd elements
Object[] elements = l.toArray(); // Convert it to an array
l.clear(); // Delete all elements
Map m = new HashMap(); // Hashtable an alternative in Java 1.1/1.0
m.put("key", new Integer(42)); // Associate a value object with a key object
Object value = m.get("key"); // Look up the value associated with a key
m.remove("key"); // Remove the association from the Map
Set keys = m.keySet(); // Get the set of keys held by the Map
Arrays of objects and collections serve similar purposes. It is possible to convert from one to the other:
Object[] members = set.toArray(); // Get set elements as an array Object[] items = list.toArray(); // Get list elements as an array Object[] keys = map.keySet().toArray(); // Get map key objects as an array Object[] values = map.values().toArray(); // Get map value objects as an array List l = Arrays.asList(a); // View array as an ungrowable list List l = new ArrayList(Arrays.asList(a)); // Make a growable copy of it
Just as the java.util.Arrays class defined methods to operate on arrays, the java.util.Collections class defines methods to operate on collections. Most notable are methods to sort and search the elements of collections:
Collections.sort(list); int pos = Collections.binarySearch(list, "key"); // list must be sorted first
Here are some other interesting Collections methods:
Collections.copy(list1, list2); // Copy list2 into list1, overwriting list1 Collections.fill(list, o); // Fill list with Object o Collections.max(c); // Find the largest element in Collection c Collections.min(c); // Find the smallest element in Collection c Collections.reverse(list); // Reverse list Collections.shuffle(list); // Mix up list Set s = Collections.singleton(o); // Return an immutable set with one element o List ul = Collections.unmodifiableList(list); // Immutable wrapper for list Map sm = Collections.synchronizedMap(map); // Synchronized wrapper for map
One particularly useful collection class is java.util.Properties. Properties is a subclass of Hashtable that predates the collections framework of Java 1.2, making it a legacy collection. A Properties object maintains a mapping between string keys and string values, and defines methods that allow the mappings to be written to and read from a simple-format text file. This makes the Properties class ideal for configuration and user preference files. The Properties class is also used for the system properties returned by System.getProperty():
import java.util.*;
import java.io.*;
String homedir = System.getProperty("user.home"); // Get a system property
Properties sysprops = System.getProperties(); // Get all system properties
// Print the names of all defined system properties
for(Enumeration e = sysprops.propertyNames(); e.hasMoreElements();)
System.out.println(e.nextElement());
sysprops.list(System.out); // Here's an even easier way to list the properties
// Read properties from a configuration file
Properties options = new Properties(); // Empty properties list
File configfile = new File(homedir, ".config"); // The configuration file
try {
options.load(new FileInputStream(configfile)); // Load props from the file
} catch (IOException e) { /* Handle exception here */ }
// Query a property ("color"), specifying a default ("gray") if undefined
String color = options.getProperty("color", "gray");
// Set a property named "color" to the value "green"
options.setProperty("color", "green");
// Store the contents of the Properties object back into a file
try {
options.store(new FileOutputStream(configfile), // Output stream
"MyApp Config File"); // File header comment text
} catch (IOException e) { /* Handle exception */ }
 |  |  |
| 4.5. Arrays |  | 4.7. Types, Reflection, and Dynamic Loading |
Copyright © 2001 O'Reilly & Associates. All rights reserved.