Core Java for the Impatient (2013)

---

The System.getProperties method yields a Properties object with system properties. Table 7–7 describes the most useful ones.

Table 7–7 Useful System Properties

7.5.2 Bit Sets

The BitSet class stores a sequence of bits. A bit set packs bits into an array of long values, so it is more efficient to use a bit set than an array of boolean values. Bit sets are useful for sequences of flag bits or to represent sets of non-negative integers, where the ith bit is 1 to indicate that i is contained in the set.

The BitSet class gives you convenient methods for getting and setting individual bits. This is much simpler than the bit-fiddling necessary to store bits in int or long variables. There are also methods that operate on all bits together for set operations, such as union and intersection. See Table 7–8 for a complete list. Note that the BitSet class is not a collection class—it does not implement Collection<Integer>.

Table 7–8 Methods of the BitSet Class

7.5.3 Enumeration Sets and Maps

If you collect sets of enumerated values, use the EnumSet class instead of BitSet. The EnumSet class has no public constructors. Use a static factory method to construct the set:

Click here to view code image

enum Weekday { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY };
Set<Weekday> always = EnumSet.allOf(Weekday.class);
Set<Weekday> never = EnumSet.noneOf(Weekday.class);
Set<Weekday> workday = EnumSet.range(Weekday.MONDAY, Weekday.FRIDAY);
Set<Weekday> mwf = EnumSet.of(Weekday.MONDAY, Weekday.WEDNESDAY, Weekday.FRIDAY);

You can use the methods of the Set interface to work with an EnumSet.

An EnumMap is a map with keys that belong to an enumerated type. It is implemented as an array of values. You specify the key type in the constructor:

Click here to view code image

EnumMap<Weekday, String> personInCharge = new EnumMap<>(Weekday.class);
personInCharge.put(Weekday.MONDAY, "Fred");

7.5.4 Stacks, Queues, Deques, and Priority Queues

A stack is a data structure for adding and removing elements at one end (the “top” of the stack). A queue lets you efficiently add elements at one end (the “tail”) and remove them from the other end (the “head”). A double-ended queue, or deque, supports insertion and removal at both ends. With all these data structures, adding elements in the middle is not supported.

The Queue and Deque interfaces define the methods for these data structures. There is no Stack interface in the Java collections framework, just a legacy Stack class from the earliest days of Java that you should avoid. If you need a stack, queue, or deque and are not concerned about thread safety, use an ArrayDeque.

With a stack, use the push and pop methods.

Click here to view code image

ArrayDeque<String> stack = new ArrayDeque<>();
stack.push("Peter");
stack.push("Paul");
stack.push("Mary");
while (!stack.isEmpty())
System.out.println(stack.pop());

With a queue, use add and remove.

Click here to view code image

Queue<String> queue = new ArrayDeque<>();
queue.add("Peter");
queue.add("Paul");
queue.add("Mary");
while (!queue.isEmpty())
System.out.println(queue.remove());

Thread-safe queues are commonly used in concurrent programs. You will find more information about them in Chapter 10.

A priority queue retrieves elements in sorted order after they were inserted in arbitrary order. That is, whenever you call the remove method, you get the smallest element currently in the priority queue.

A typical use for a priority queue is job scheduling. Each job has a priority. Jobs are added in random order. Whenever a new job can be started, the highest priority job is removed from the queue. (Since it is traditional for priority 1 to be the “highest” priority, the remove operation yields the minimum element.)

Click here to view code image

public class Job implements Comparable<Job> { ... }
...
PriorityQueue<Job> jobs = new PriorityQueue<>();
jobs.add(new Job(4, "Collect garbage"));
jobs.add(new Job(9, "Match braces"));
jobs.add(new Job(1, "Fix memory leak"));
...
while (jobs.size() > 0) {
Job job = jobs.remove(); // The most urgent jobs are removed first
execute(job);
}

Just like a TreeSet, a priority queue can hold elements of a class that implements the Comparable interface, or you can supply a Comparator in the constructor. However, unlike a TreeSet, iterating over the elements does not necessarily yield them in sorted order. The priority queue uses algorithms for adding and removing elements that cause the smallest element to gravitate to the root, without wasting time on sorting all elements.

7.5.5 Weak Hash Maps

The WeakHashMap class was designed to solve an interesting problem. What happens with a value whose key is no longer used anywhere in your program? If the last reference to a key has gone away, there is no longer any way to refer to the value object so it should be removed by the garbage collector.

It isn’t quite so simple. The garbage collector traces live objects. As long as the map object is live, all entries in it are live and won’t be reclaimed—and neither will be the values that are referenced by the entries.

This is the problem that the WeakHashMap class solves. This data structure cooperates with the garbage collector to remove key/value pairs when the only reference to the key is the one from the hash table entry.

Technically, the WeakHashMap uses weak references to hold keys. A WeakReference object holds a reference to another object—in our case, a hash table key. Objects of this type are treated in a special way by the garbage collector. If an object is reachable only by a weak reference, the garbage collector reclaims the object and places the weak reference into a queue associated with the WeakReference object. Whenever a method is invoked on it, a WeakHashMap checks its queue of weak references for new arrivals and removes the associated entries.

7.6 Views

A collection view is a lightweight object that implements a collection interface, but doesn’t store elements. For example, the keySet and values methods of a map yield views into the map.

Another example is the Arrays.asList method. If a is an array of type E[], then Arrays.asList(a) returns a List<T> that is backed by the array elements.

Usually, a view does not support all operations of its interface. For example, it makes no sense to call add on a key set of a map or the list returned by Arrays.asList.

In the following sections, you will see some views that are provided by the Java collections framework.

7.6.1 Ranges

You can form a sublist view of a list. For example,

Click here to view code image

List<String> sentence = ...;
List<String> nextFive = sentence.subList(5, 10);

This view accesses the elements with index 5 through 9. Any mutations of the sublist (such as setting, adding, or removing elements) affect the original.

For sorted sets and maps, you specify a range by the lower and upper bound:

Click here to view code image

TreeSet<String> words = ...;
SortedSet<String> asOnly = words.subSet("a", "b");

As with subList, the first bound is inclusive, and the second exclusive.

The headSet and tailSet methods yield a subrange with no lower or upper bound.

Click here to view code image

NavigableSet<String> nAndBeyond = words.tailSet("n");

With the NavigableSet interface, you can choose for each bound whether it should be inclusive or exclusive—see Table 7–5.

For a sorted map, there are equivalent methods subMap, headMap, and tailMap.

7.6.2 Empty and Singleton Views

The Collections class has static methods yielding an immutable empty list, set, sorted set, navigable set, map, sorted map, navigable map, iterator, list iterator, or enumeration (an iterator-like legacy interface from Java 1.0).

Similarly, there are static methods yielding a set or list with a single element, and a map with a single key/value pair. These methods are shown in Table 7–3.

For example, if a method requires a map of attributes, and you have none or only one to supply, you can call

Click here to view code image

doWork(Collections.emptyMap());

or

Click here to view code image

doWork(Collections.singletonMap("id", id));

instead of creating a heavyweight HashMap or TreeMap object.

7.6.3 Unmodifiable Views

Sometimes, you want to share the contents of a collection but you don’t want it to be modified. Of course, you could copy the values into a new collection, but that is potentially expensive. An unmodifiable view is a better choice. Here is a typical situation. A Person object maintains a list of friends. If the getFriends gave out a reference to that list, a caller could mutate it. But it is safe to provide an unmodifiable list view:

Click here to view code image

public class Person {
private ArrayList<Person> friends;

public List<Person> getFriends() {
return Collections.unmodifiableList(friends);
}
...
}

All mutator methods throw an exception when they are invoked on an unmodifiable view.

As you can see from Table 7–3, you can get unmodifiable views as collections, lists, sets, sorted sets, navigable sets, maps, sorted maps, and navigable maps.