1.What is meant by compatible equals() and hashCode() methods ? In
order for the Java Collections to work properly (and everything else in
Java), the equals() and hashCode() methods must be compatible. Here,
compatible means that if equals() reports that two instances are the
same, then the hashCode() of both instances must be the same value.
2.Since Properties extends Hashtable, can I use the Hashtable methods to add elements to a Properties list ? Technically
speaking you can. However, you have to make sure you only add key-value
pairs where both are strings. If you add something other than a String,
the listing, loading, and saving methods won’t work as expected.
Like
the Stack/Vector subclass relationship, Properties/Hashtable should be a
has-a relationship, not an is-a/subclass relationship.
3.When I wrap a collection to be
read-only or synchronized, why can’t I call any of the collection
methods via reflection without getting an IllegalAccessException ? When
you wrap a collection through the static methods of the Collections
class, this creates an instance of a package-private (default access)
class. Because you don’t have access to these classes, you can’t call
their methods via reflection (though you can call their methods directly
through the appropriate interface).
4.What is a weak reference and what are they used for ? Normally
the Java garbage collector plays safe. It will only free up the memory
used by an object when that object can no longer be accessed by the
program. Once an object become impossible to reach it is eligible for
collection, and eventually its memory will be reclaimed.
This
eliminates one of the most common programming errors in some other
languages (like C++), where code accidentally tries to access an object
that has been freed. Unfortunately it can lead to another problem, where
you leave open a potential access route to an object that you don’t
need any more. Memory fills up, and the program slows down or reports an
“Out of Memory” error.
To avoid this, you can be very careful to close off access paths
to an object once you have finished using it. Java 2 introduces another
alternative, the weak reference. Weak references provide access to an
object without preventing it from being freed. When you use a weak
reference you have to accept that the object referred to may have
disappeared, which results in the reference being automatically set to
null. On the other hand, the weak reference will not hold the object in
memory once it is inaccessible via normal references (or via “soft”
references – see below). Weak references are not appropriate in all
circumstances, but sometimes they can make code easier to write and
understand.
The most common use of weak references is indirect – they are
used internally by the WeakHashMap class. Like HashMap, WeakHashMap
associates key objects with values. However, once the key object becomes
inaccessible via stronger references it becomes eligible for garbage
collection. When it is freed, the map entry magically disappears. The
assumption here is that if you are not using the key anywhere other than
in the map you will have no need to look it up, so it should be freed.
Other specialist references are soft references (which inhibit
collection until memory runs short), and phantom references (used for
cleanup when objects are freed).
5.What is the minimum number of
key-value pairs for which it makes sense to use a HashMap, as opposed to
using a pair of arrays (one for keys, the other for values) with
brute-force key searches ?
Many people often need maps for very small numbers (2-5) of
key-value pairs. When does it make sense to forgo the convenience of the
HashMap to avoid the associated overhead?
Well, is there really that
much of a performance loss using a HashMap? There is no synchronization
penalty (unless you impose your own). You can tune the sizing by
adjusting the initial size and load factor. Plus, do you really want to
be responsible for “rolling your own” code to handle the dynamic
resizing of the key and value arrays, inserting/removing data from these
arrays, optimizing the searching algorithm, etc. Yuck!
In general, the performance hit associated with using a general
purpose Map (such as the HashMap) is far outweighed by the benefits of
using a simple interface backed by a tested algorithm.
The only reason I could see wanting to use arrays is to guaruntee
the type of your key/values to add type checking and avoid casting.
Still, if this is a critical aspect of your application, you can wrap
your HashMap in another object to provide type-safety, and the casting
overhead should be minimal.
Another alternative to creating a custom solution is to explore
other collection classes, such as ObjectSpaces’s JGL Libraries. There
may be something there that would suit your needs.
So, to answer your question, I would say that the fewer the
key-value pairs you have, the more reason you have to use a HashMap.
Since the fewer the keys, the faster the search, why not use it for 2-5
key-value pairs. I would think that only when you get to many pairs
(tens of thousands) and there is a performance problem you should
consider an alternative. Basically, exhaust your search of
tried-and-true collections before you try a custom solution. Let other
people create these collections so you can focus on your application.
6.How does ArrayList increase its capacity ? Unlike
Vector where you can specify a capacity increment, ArrayList doesn’t
support this. Instead, ArrayList will increase capacity by about a half
when it runs out of space. The refernece implementation uses the
forumla:
newCapacity = (oldCapacity * 3)/2 + 1
though, this isn’t part of the class definition so others can implement it differently.
7.What is the default initial size for a Hashtable / HashMap ? This depends on what version of Java you are using. For JDK 1.2, the size was 101. For JDK 1.3, the size changed to 11.
8.How do you create a multi-dimensional List ?
Since
the elements of a List are objects, in order to make the List
multi-dimensional, each object in the outer list needs to be a List,
too. For instance, …
List list = new ArrayList(10);
for (int i=0; i<10; i++) {
list.set(i, new LinkedList());
}
Then just fill up each inner list with items.
9.In a TreeMap, can I use a sorting algorithm other than the natural sorting for the keys ?
You can pass a Comparator to the TreeMap constructor to use a sorting order other than the natural order.
10.What are the differences between HashMap and Hashtable ? Both
provide key-value access to data. The Hashtable is one of the original
collection classes in Java. HashMap is part of the new Collections
Framework, added with Java 2, v1.2.
The key difference between the
two is that access to the Hashtable is synchronized on the table while
access to the HashMap isn’t. You can add it, but it isn’t there by
default.
Another difference is that iterator in the HashMap is fail-safe
while the enumerator for the Hashtable isn’t. If you change the map
while iterating, you’ll know.
And, a third difference is that HashMap permits null values in it, while Hashtable doesn’t.
For new code, I would tend to always use HashMap.
11.What are the differences between Vector and ArrayList? Which is best to use ? Vector
and ArrayList are very similar. Both of them represent a ‘growable
array’, where you access to the elements in it through an index.
ArrayList it’s part of the Java Collection Framework, and has
been added with version 1.2, while Vector it’s an object that is present
since the first version of the JDK. Vector, anyway, has been
retrofitted to implement the List interface.
The main difference is that Vector it’s a synchronized object, while ArrayList it’s not.
While the iterator that are returned by both classes are
fail-fast (they cleanly thrown a ConcurrentModificationException when
the orignal object has been modified), the Enumeration returned by
Vector are not.
Unless you have strong reason to use a Vector, the suggestion is to use the ArrayList.
12.How should I implement object
comparisons in a flexible manner? For example, I have a Person class and
sometimes I will compare based on name and sometimes I will compare
based on age. Instead of having the Person class
implement the Comparable interface, you could delegate the comparing to
another class. Perhaps you could have a PersonComparator interface that
you could implement for the various types of comparisons. For example:
public interface Person {
public String getName();
public int getAge();
}
public interface PersonComparator {
public int compare(Person p1, Person p2);
}
public class AgeComparator implements PersonComparator {
public int compare(Person p1, Person p2) {
if (p1.getAge() == p2.getAge()) return 0;
return p1.getAge() > p2.getAge() ? 1 : -1;
}
}
public class NameComparator implements PersonComparator {
public int compare(Person p1, Person p2) {
return p1.getName().compareTo(p2.getName());
}
}
This is a very simple example of the Strategy Pattern. This
allows your comparisons and your object to change independent of one
another.
13.Does the equals() method of an array do element-level checking ? If
you have two arrays in memory with the same elements, and ask
first.equals(second), this does not do an element-by-element comparison.
Instead, it behaves just like Object’s equals() method, essentially
asking if the variables point to the same place in memory:
int a[] = {1, 2, 3};
int b[] = {1, 2, 3};
// This prints false
System.out.println(a.equals(b));
To check for equality of two arrays, use Arrays.equals().
// This prints true
System.out.println(Arrays.equals(a,b));
14.How can I retrieve the items in my HashSet / HashMap in the order they were added ?
Prior
to Java 1.4, you had to manage a separate insertion order list
yourself. Starting with Java 1.4, you can use the new LinkedHashMap /
LinkedHashSet classes. The iterators you get back from them return the
items in insertion order.
15.How do you sort an ArrayList (or any list) of user-defined objects ? Create
an implementation of the java.lang.Comparable interface that knows how
to order your objects and pass it to java.util.Collections.sort(List,
Comparator).
16.How can you get the hash code for an instance of a class if the class overrode hashCode() ?
The System class method identityHashCode() allows you to get this information:
int code = System.identityHashCode(anObject);
17.How can I easily shift the elements in a List / Vector such that all the elements rotate n elements ?
The
Java 1.4 API adds a rotate() method to the Collections class:
rotate(List list, int distance) that will shift the elements for you.
18.What’s the most optimum way of swapping two elements in a List ? The
1.4 version of Collections has a swap() method to do this for you.
However, for earlier version of Java, you can swap two elements w/o an
intermediate variable with:
list.set(index1, list.set(index2, list.get(index1)));
This works because the set() method returns the original element.
19.What’s the purpose of the IdentityHashMap ?
The
IdentityHashMap uses == for equality checking instead of equals(). This
can be used for both performance reasons, if you know that two
different elements will never be equals and for preventing spoofing,
where an object tries to imitate another.
20.How do I convert an old-style Enumeration to something in the Collections Framework ?
Prior
to Java 1.4, any conversion had to be manually done. With the
introduction of 1.4, you can call Collections.list(enumeration) to
automatically convert the Enumeration to an ArrayList.
21.How do I retrieve the values of a Hashtable/HashMap in sorted order ?
Basically,
you can’t directly do this. What you can do is get the Collection of
values() back from the map and create a sorted collection, or maintain
two maps, one in each direction, and keep the second map sorted by being
a TreeMap. Which you use depends on the frequency you must sort the
elements.
22.How can I add a Collection to another Collection ? The java.util.Collection interface includes an addAll(Collection c) method to add one collection to another.
23.How can I use two iterators to go through a collection ?
Just get a separate iterator for each loop:
Collection l = …;
for(Iterator i = l.iterator(); …) {
for(Iterator j = l.iterator();…) {
}
}
24.How do I traverse a map backwards ?
Just keep getting the last key and the head map before it:
if (!map.isEmpty()) {
Object last = map.lastKey();
boolean first = true;
do {
if (!first) {
System.out.print(“, “);
}
System.out.print(last);
last=map.headMap(last).lastKey();
first=false;
} while (last != map.firstKey());
System.out.println();
}
25.How do I traverse a sorted set backwards ?Just keep getting the last element and the head set before it:
if (!set.isEmpty()) {
Object last = set.last();
boolean first = true;
do {
if (!first) {
System.out.print(“, “);
}
System.out.print(last);
last=set.headSet(last).last();
first=false;
} while (last != set.first());
System.out.println();
}
26.How can I go through an Iterator mulitple times ?
There
is no direct support for this. You’ll need to create your own caching
mechanism. For instance, as you go through the Iterator the first time,
add the elements to a LinkedList. Then, you can just get an Iterator
from the LinkedList for the second pass through.
27.What’s new to the Collections Framework in Java 1.4 ?
There are three new implementations:
LinkedHashSet
LinkedHashMap
IdentityHashMap
One marker interface:
RandomAccess
And six new utility methods for the Collections class:
rotate(List list, int distance)
replaceAll(List list, Object oldVal, Object newVal)
indexOfSubList(List source, List target)
lastIndexOfSubList(List source, List target)
swap(List list, int i, int j)
list(Enumeration e)
28.How can I add an array of objects to a collection ? First
you need to convert the array to a Collection. This can be done with
Arrays.asList(objectArray). Once you have the array as a List, you can
add it to another Collection with theCollection.addAll(theList).
29.Is Vector’s clone method thread-safe ? Sure it is, since it is a Vector which is thread-safe.
30.How do I load property settings with the Properties class ? java.util.Properties objects can load values from a file using the method load(InputStream).
Here is the code you need:
Properties props = new Properties();
props.load(new FileInputStream(“propertyfile.properties”));
String value = props.getProperty(“propertyname”);
//Just a trick: in a web archive (war) you can get the InputStream inside the war archive using
ClassLoader cl = this.getClass().getClassLoader();
InputStream is = cl.getResourceAsStream(“it/package/application.properties”);
This is better than using a FileInputStream, because you are
loading the file within the archive as it was a resource. You should use
this.getClass().getClassLoader() to use the same ClassLoader as the one
used the servlet container to load your JSP/Servlet. This code is
snipped from a JSP page inside Tomcat.
31.How do I save properties settings with the Properties class ? Try this:
Properties prop = new Properties();
FileOutputStream output = new FileOutputStream(“Test.properties”);
prop.store(output,”my testproperties”);
output.flush();
output.close();
You’ll need to catch an IOException.
32.What happens if two threads perform a get of one hashmap at the same time ?
Synchronization
needs to be done only when there is a chance of changing the data from
different threads simultaneously. In your case, it is simply going to be
a read, the synchronization is not required. If you need to remove or
modify the values in the hashmap, then you [may] need to synchronize
that.
For synchronizing a HashMap, you can use
Collections.synchronizedMap(<your hashmap reference>) which will
return a synchronized map for you, which is thread-safe.
Remember, synchronization will cause a performance problem. So, it needs to be used carefully, when really required.
33.How can I convert a Collection to an Array then back to a Collection ? The
Collection interface provides a mechanism to turn a Collection into an
Array using the methods <T> T[] toArray(T[] a) or Object[]
toArray(). The first method will return a Array containing all the
elements of the Collection with the array being that of the type
provided in the method call. The second method just returns an array
being of an Object[] type.
The Arrays class provides the opposite. A way to turn an array
into a List using the List<T> asList(Array[] a) method. The List
returned is of a fixed length with any attempts to add an element
throwing an UnsupportedOperationException.
import java.util.*;
public class G{
public static void main(String[] args){
List<String> sun = new ArrayList<String>();
sun.add(“Feel”);
sun.add(“the”);
sun.add(“power”);
sun.add(“of”);
sun.add(“the”);
sun.add(“Sun”);
String[] s1 = sun.toArray(new String[0]); //Collection to array
for(int i = 0; i < s1.length; ++i){
String contents = s1[i];
System.out.print(contents);
}
System.out.println();
List<String> sun2 = Arrays.asList(s1); //Array back to Collection
for(String s2: sun2){
String s3 = s2; System.out.print(s3);
}
//sun2.add(new String(“Hello”)); // throws UnsupportedOperationException
}
}
34.How can I create a Collection based on another Collection ?Every
concrete implementation provides a constructor, which takes a
Collection as an argument. Care must be taken when creating a Collection
based another Collection, this is because depending on the target
concrete implementation being created, specific rules regarding
duplicates may be be enforced. Such as creating a Set based on a List.
The following is a short list of the constructors provided by
some of the concrete Classes of the JCF (Java Collections Framework),
which enable the creation of a Collection based an another
implementation.
ArrayList(Collection<? extends E> c)
LinkedList(Collection<? extends E> c)
Vector(Collection<? extends E> c)
TreeSet(Collection<? extends E> c)
Creating a Collection based on another Collection is quite easy.
The hard part is knowing which Collection to use based on performance
and other issues.
For example the ArrayList created will contain the same elements in the same order as the first ArrayList created.
List<String> slist = new ArrayList<String>();
slist.add(“g”);
slist.add(“a”);
slist.add(“d”);
slist.add(“a”);
slist.add(“f”);
slist.add(“e”);
slist.add(“c”);
slist.add(“b”);
for(String s : slist){
System.out.print(s + “\t”);
}
System.out.println();
List<String> s2list = new ArrayList<String>(slist);
for(String s : s2list){
System.out.print(s + “\t”);
}
When creating a Set based on an existing List the Set will be void of duplicates.
List<String> slist = new ArrayList<String>();
slist.add(“g”);
slist.add(“a”);
slist.add(“d”);
slist.add(“a”);
slist.add(“f”);
slist.add(“e”);
slist.add(“c”);
slist.add(“b”);
for(String s : slist){
System.out.print(s + “\t”);
}
System.out.println();
Set<String> s2set = new TreeSet<String>(slist);
for(String s : s2set){
System.out.print(s + “\t”);
}
35.How can I define my own Comparable type so that it can be naturally sorted within a List ?
When
taking a peek at the Java docs you will notice certain classes
implement an interface named Comparable. Take a look at some of the
subclasses of Number such as Byte, Integer, Long, Float or some of the
classes like String and Date. What the Comparable interface provides is a
way for a class to be sorted by it’s natural ordering. So what do we
mean by natural ordering? Depending on the type wishing to be sorted the
natural ordering can be different things. If we are sorting Strings the
ordering is lexicographic or alphabetic if we are sorting Dates the
ordering is chronological if we are sorting Integers the ordering is
numerical.
Comparable only contains one method that needs to be implemented
by the class wishing to be sorted naturally. Remember if you try and
sort a list that contains elements that do not implement the Comparable
interface then Collections.sort() will throw an exception specifically a
ClassCastException.
public interface Comparable<T>{
public int compareTo(T o);
}
The following is a short example on how to implement the Comparable interface and use the compareTo(T o) method.
import java.util.*;
public final class Alpha implements Comparable<Alpha>{
public static void main(String[] args){
List<Alpha> alpha = new ArrayList<Alpha>();
alpha.add(new Alpha(“z”));
alpha.add(new Alpha(“g”));
alpha.add(new Alpha(“k”));
alpha.add(new Alpha(“q”));
alpha.add(new Alpha(“a”));
alpha.add(new Alpha(“b”));
alpha.add(new Alpha(“o”));
alpha.add(new Alpha(“v”));
alpha.add(new Alpha(“c”));
Collections.sort(alpha);
System.out.println(alpha);
}
private String letter;
public Alpha(String letter){
if(letter == null){throw new NullPointerException();}
this.letter = letter;
}
public String toString(){return letter;}
public boolean equals(Alpha a){
if(!(a instanceof Alpha))
return false;
return letter.equals(a.letter);
}
public int compareTo(Alpha a){
int i = letter.compareTo(a.letter);
return i;
}
}
More complex examples might included sorting on multiple fields.
Most things that you would have to sort probably have more then one part
like a name for instance (First:Middle:Last) or maybe you have to sort
in (Brand:Model) order.
import java.util.*;
public final class Car implements Comparable<Car>{
public static void main(String[] args){
Car[] cararry = {new Car(“Toyota”,”Celica”), new Car(“Honda”,”Civic”),
new Car(“Ford”,”Mustang”), new Car(“Lexus”,”ES”), new Car(“Acura”,”Integra”),
new Car(“Honda”,”Accord”), new Car(“Acura”,”RL”), new Car(“Toyota”,”Avalon”)
};
List<Car> car = Arrays.asList(cararry);
Collections.sort(car);
System.out.println(car);
}
private String brand;
private String model;
public Car(String brand, String model){
if(brand == null || model == null){throw new NullPointerException();}
this.brand = brand;
this.model = model;
}
public String toString(){return brand + ” ” + model;}
public boolean equals(Car car){
if(!(car instanceof Car))
return false;
boolean samebrand = brand.equals(car.brand);
return samebrand != true ? samebrand: model.equals(car.model);
}
public int compareTo(Car car){
int i = brand.compareTo(car.brand);
return(i != 0 ? i : model.compareTo(car.model));
}
}
36.What are Generics and how can I use them ?
One
of the biggest additions since the creation of the Collections
framework is Generics.This long awaited update to the type system is a
welcomed feature, which C++ developers have had in their toolbox for
years using the STL. A generic type is defined using one or more type
variables with it’s contained methods using that type variable as a
place holder to mark a parameter or return type. For instance the
interface List has now been defined as.
public interface List<E>{
public add(E e);
Iterator<E> iterator();
}
public interface Iterator<E>{
E next();
boolean hasNext();
}
Type Safe Collections
So you might ask. What are Generics and why should I use them?
Generics are a way to restrict a data structure to hold only a specific
type thus providing compile time type checking. One of the added bonuses
is that it is no longer necessary to cast a returned Object to a
specific type because the compiler is aware of what type is being held
by the Collection and what type is to be returned.
Set s = new SortedSet();
s.add(new String(“Java”));
String j = (String) s.get(0); // cast required;
// java 5
Set<String> s = new SortedSet<String>();
s.addElement(new String(“String Type”));
String s = s.get(0); // no cast required!
Having a type safe system not only obviates the need to cast to a
specific type but shields the programmer against miss-casting or
casting to an unrelated type at runtime.
String s = “Java, write once run anywhere”
List l = new ArrayList();
l.add(new String(“Java”));
Integer i = (Integer)l.get(0); // Runtime exception! ClassCastException!
// Using Generics the compiler catches
String s = “Java. Write once run anywhere!”
List<String> l = new ArrayList<String>();
l.add(new String(“Java”));
Integer i = l.get(0);
Generics and Subtyping
Generics do not share some of the things that are commonly held
true in the Java language and one of them is subtyping. One would assume
the following perfectly legal since it is true that Object is a
supertype of String. But the following is in fact illegal and will cause
a compile time error.
List<Object> l = new ArrayList<String>();
As a rule. If X is a superclass or superinterface of Y and E is a
generic type declaration then it not the case that E<X> is a
supertype of E<Y>. So if E<Object> is not a super type of
E<String> then what is the super type of E<String>? Read on
and find out!
Wild Cards
Wild Cards represent what is called “the unknown type”.
Essentially they can be thought of as the supertype of any Collection.
Wildcards allow some flexibility in certain situations where it is
needed that a type be abstracted out. For instance what if we define the
following method, printSet(Collection<Object> x). We just saw in
the previous example that E<Object> is not the super type of
E<String> or any other type for that matter. In this case we can
change the printSet’s parameter to Collection<?>. This allows us
to pass in E<X> where X is any type.
public void printElements(Collection<?> c){
for(Object o: c){
System.out.println(o);
}
}
When working with wildcards it is always legal to read and assign the contents to an Object type
List<String> l = new ArrayList<String>();
l.add(new String(“Java”));
Object o = getElement(l, 0); // legal
public Object getElement(List<?> l, int index){
Object o = null;
try{
o = l.get(0);
}catch(IndexOutOfBoundsException e){
//…….
}
return o;
}
assigning values is another matter. The add() method takes an
argument of type E which is the type that the Collection is to hold. Any
type wishing to be added to the Collection would have to be of the same
type. Since<?> represents an unknown type it is impossible to
determine what the type parameter of the collection represents.
Bounded Wildcards
A Bounded Wildcard allows as type to be constrained. Bounded
Wildcards are useful when there is some type of partial knowledge about
the type arguments. While it is still illegal to try and add an element
to a unknown Collection with a bounded type they come in handy in other
situations. One use is to be able to pass not only types into a method
but sub-types also. In doing this we are able to implement polymorphic
behavior.
import java.util.*;
class Printer{
public void print(String s){
for(int i = 0; i < s.length(); i++){
System.out.print(s.charAt(i));
}
}
}
class ReversePrinter extends Printer{
public void print(String s){
for(int i = s.length() – 1 ; i >= 0; i–){
System.out.print(s.charAt(i));
}
}
}
public class G{
public static void main(String[] args){
String s = “Nothing like a good cup of Java in the morning!”
List<Printer> l = new ArrayList<Printer>();
l.add(new Printer());
printElements(l,s);
List<ReversePrinter> rl = new ArrayList<ReversePrinter>();
rl.add(new ReversePrinter());
printElements(rl,s);
}
public static void printElements(List<? extends Printer> l, String s){
Printer printer = l.get(0);
printer.print(s);
System.out.println();
}
}
37.How can I shuffle the elements of a Collection ?
The
Collections class which can be found within the java.util namespace
provides two methods which suffle the elements of a Collection.
static void shuffle(List<?> list)
static void shuffle(List<?> list, Random rnd)
The first method shuffles the elements according to a default
source of randomness, with the second using a specified source of
randomness.
import java.util.*;
public class ShuffleTest{
public static void main(String[] args){
List<String> sl = new ArrayList<String>();
sl.add(“One”);
sl.add(“Two”);
sl.add(“Three”);
sl.add(“Four”);
sl.add(“Five”);
sl.add(“Six”);
for(String s: sl){
System.out.println(s);
}
System.out.println();
Collections.shuffle(sl);
for(String s: sl){
System.out.println(s);
}
}
}
38.How can i tell if two Collections contain the same elements or have no elements in common ?
Two methods are needed in this case.
boolean containsAll(Collection<?> c)
boolean disjoint(Collection<?>c1 Collection<?>c2)
Since containsAll(Collection<?> c) is defined within the
Collection interface all concrete implementations will be able to use
this method. disjoint(Collection<?>c1 Collection<?>c2) is
defined within the Collections class.
Using both of these methods is pretty straightforward.
containsAll(Collection<?> c) is an instance method so naturally it
must be invoked on an object. disjoint(Collection<?>c1
Collection<?>c2) is defined as Static within the Collections class
so all that is needed is to invoke it using the class name ie
Collections.disjoint(Collection<?>c1 Collection<?>c2)
39.How can I traverse a List backwards ?
In
order to traverse a List backwards a ListIterator must be used. The
List interface provides a method, which returns a ListIterator.
ListIterator<E> listIterator()
Using a returned ListIterator, concrete implementations of List can be traverse backwards using the following methods.
boolean hasPrevious()
E previous()
Since ListIterator extends the Iterator interface forward direction is still possible via Iterators methods.
boolean hasNext()
E next()
import java.util.List;
import java.util.ArrayList;
import java.util.ListIterator;
public class {
public static void main(String[] args){
List<String> slist = new ArrayList<String>();
slist.add(“1″);
slist.add(“2″);
slist.add(“3″);
slist.add(“4″);
ListIterator i = slist.listIterator();
while(i.hasNext()){
System.out.print(i.next());
}
System.out.println();
while(i.hasPrevious()){
System.out.print(i.previous());
}
}
}
40.How can I get a sorted list of keys that are contained within a Map ? The
Map interface defines a method named keySet() which concrete classes
such as HashMap and TreeMap implement. Depending on the implementation
on which keySet() is invoked the returned Set might not contain it’s
elements (keys) in sorted order. For instance the HashMap class makes no
guarantees as to the order of the elements contained within. Whereas
the TreeMap class does guarantee element ordering since it implements
the SortedMap interface.
/* TreeMap used. Keys stored in ascending order */
Map<String,String> book = new TreeMap<String,String>();
book.put(new
String(“Java”),new String(“A trademark used for a programming language
designed to develop applications, especially ones for the Internet, that
can operate on different platforms.”));
book.put(new
String(“C#”),new String(“An object-oriented language devised and
promoted by Microsoft, intended to replace Java, which it strongly
resembles.”));
book.put(new String(“Python”),new String(“A simple, high-level interpreted language by Guido van Rossum”));
book.put(new
String(“LISP”),new String(“A programming language designed to process
data consisting of lists. It is widely used in artificial intelligence
research.”));
Set words = book.keySet();
for(Iterator i = words.iterator();i.hasNext();){
System.out.print(i.next() + “\t”);
}
41.How can I create a read only Collection ? Unmodifiable
Collections can be easily created using various static methods which
the Collections class provides. Any attempts to modify the returned
Collection, whether direct or via its iterator, result in an
UnsupportedOperationException.
Collection<T> unmodifiableCollection(Collection<? extends T> c)
List<T> unmodifiableList(List<? extends T> list)
Set<T> unmodifiableSet(Set<? extends T> s)
SortedSet<T> unmodifiableSortedSet(SortedSet<T> s)
import java.util.*;
public class Unmod{
public static void main(String[] args){
List<String> strlist = new ArrayList<String>();
strlist.add(“C”);
strlist.add(“B”);
strlist.add(“A”);
Collection<String> unmodstrlist = Unmod.makeUnmodifiable(strlist);
// unmodstrlist.add(“G”); throws UnsupportedOperationException
Set<String> strset = new TreeSet<String>();
strset.add(“C”);
strset.add(“B”);
strset.add(“A”);
Collection<String> unmodstrset = Unmod.makeUnmodifiable(strset);
// unmodstrset.add(“G”); throws UnsupportedOperationException
}
public static Collection<String> makeUnmodifiable(Collection<String> c){
return(Collections.unmodifiableCollection(c));
}
}
42.Is there a way determine how many times an Object occurs within a Collection ? The Collections class provides a method which returns the number of times an Object appears within a given Collection.
public static int frequency(Collection<?> c, Object o)
If a null Collection is passed in then a NullPointerException is thrown.
import java.util.*;
public class Freq {
public static void main(String[] args){
List<Integer> password = new ArrayList<Integer>();
password.add(new Integer(4));
password.add(new Integer(6));
password.add(new Integer(8));
password.add(new Integer(4));
password.add(new Integer(9));
Integer passwordelement = new Integer(4);
System.out.println(passwordelement + ” appears “
+ getFrequency(password,passwordelement) + ” times within password”);
}
private static int getFrequency(Collection c, Object o){
return(Collections.frequency(c,o));
}
}
43.What is the easiest way to obtain a Map Entry ? The easiest way to obtain a Map Entry or (key-value pair) is by invoking the following method provided by the Map interface.
Set<Map.Entry<K,V>> entrySet();
The entrySet() method returns a Set which is populated with
Map.Entry objects. The only way to obtain a reference to a Map.Entry is
by using an Iterator on the returned Set view. Once a reference to a
Map.Entry is obtained the follow methods can be invoked which return the
key and value corresponding to the entry.
K getKey()
V getValue()
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.Iterator;
public class Emps{
public static void main(String[] args){
Map<String,String> empmap = new TreeMap<String,String>();
empmap.put(“956544″,”Bob Jones”);
empmap.put(“132485″,”Phil Harris”);
empmap.put(“102161″,”Kamal Uganda”);
empmap.put(“226545″,”Bill Russel”);
empmap.put(“116423″,”Dorris Smith”);
Set s = empmap.entrySet();
for(Iterator i = s.iterator();i.hasNext();){
Map.Entry me = (Map.Entry)i.next();
System.out.println(me.getKey() + ” : ” + me.getValue());
}
}
}
44.How can I find the maximum element contained within a Collection ? Finding
the maximum element within a Collection is easy. The following method
can be used which can be found within the Collections class.
public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
This method returns the maximum element of the given Collection
according to the natural ordering of it’s elements. This means that all
elements must implement the Comparable interface. With the following
code below the implementation of the Comparable interface is already
taken care of since the class Byte already implements this interface.
import java.util.Set;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
public class Max{
public static void main(String[] args){
Collection<Byte> numl = new ArrayList<Byte>();
numl.add(new Byte(“2″));
numl.add(new Byte(“6″));
numl.add(new Byte(“3″));
numl.add(new Byte(“1″));
numl.add(new Byte(“5″));
numl.add(new Byte(“4″));
System.out.print(“Max element is ” + getMax(numl));
}
public static Byte getMax(Collection<Byte> c){
return Collections.max(c);
}
}
If the element type being store within the Collection is user
defined, implementation of the Comparable interface must be provided.
import java.util.Set;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
public class Max{
public static void main(String[] args){
Collection<Num> numl = new ArrayList<Num>();
numl.add(new Num(“2″));
numl.add(new Num(“6″));
numl.add(new Num(“3″));
numl.add(new Num(“1″));
numl.add(new Num(“5″));
numl.add(new Num(“4″));
System.out.print(“Max element is ” + getMax(numl).getNum());
}
public static Num getMax(Collection<Num> c){
return Collections.max(c);
}
}
class Num implements Comparable<Num>{
private String i;
public Num(String i){
this.i = i;
}
public int compareTo(Num num){
int x = i.compareTo(num.i);
return x;
}
public String getNum(){
return i;
}
}
45.How can I create an immutable List consisting of n Copies of an Object ? nCopies(int
n, T o) can be used to create an immutable List which contains a
specific number of copies of an Object. Care must be taken when trying
to add elements to or extract elements from the returned List. Both
attempts will throw UnsupportedOperationExceptions.
public static <T> List<T> nCopies(int n, T o)
import java.util.List;
import java.util.Collections;
public class NCopiesTest{
public static void main(String[] args){
List<String> slist = Collections.nCopies(5, “Java Blend”); //immutable list!
slist.add(“Moca Blend”); // throws UnsupportedOperationException!
String selement = slist.remove(0); // throws UnsupportedOperationException!
}
}
46.What is the difference between a Stack and a Queue ? First
things first. Where can Stacks and Queue’s be found? Java provides a
Stack class, which can be found within the java.util namespace. Within
the same namespace you will find a Queue interface. All concrete Queue
implementations can be located within the java.util.concurrent package.
What is a Stack?
Java’s Stack class extends the Vector class. A Stack represents a
Collection of objects that are in LIFO (Last In First Out Order). The
Stack class provides operations that allow testing for zero elements,
inspection of it’s top most element, removal of it’s top most element,
and the addition of elements.
boolean empty() Tests if this stack is empty.
E peek() Looks at the object at the top of this stack without removing it from the stack.
E pop() Removes the object at the top of this stack and returns that object as the value of this function.
E push(E item) Pushes an item onto the top of this stack.
int search(Object o) Returns the 1-based position where an object is on this stack.
What is a Queue?
A Queue is also a Collection of Objects similar to a Stack.
Queues typically order the elements contained within in FIFO order but
this is not always the case. Elements that are inserted into a Queue are
inserted at the tail end as opposed to a Stack where the elements are
pushed into it at the head. Looking at the Queue interface the
operations are similar to what a Stack provides.
E element() Retrieves, but does not remove, the head of this queue.
boolean offer(E o) Inserts the specified element into this queue, if possible.
E peek() Retrieves, but does not remove, the head of this queue, returning null if this queue is empty.
E poll() Retrieves and removes the head of this queue, or null if this queue is empty.
E remove() Retrieves and removes the head of this queue.
So what are the differences between Queues and Stacks?
Besides how each order their elements there really isn’t much
difference. Both provided pretty much the same operations. The big
difference is that one is a concrete implementation (Stack) while the
other is an interface (Queue) thus implying that additional
functionality is provided by the concrete classes that implement the
Queue interface such as blocking, and synchronization.
47.How can I insert an element into a List ? In
order to insert an element into a List add(int index, E element) must
be used since the List interface does not provide an insert method. If
the index is out of rage ie. index < 0 || index > size() an
exception will be thrown.
import java.util.*;
public class Insert{
public static void main(String[] args){
List<String> slist = new ArrayList<String>();
slist.add(new String(“Java”));
slist.add(new String(“Write”));
slist.add(new String(“run”));
slist.add(new String(“anywhere!”));
slist.add(2,new String(“once”));
for(String s:slist){
System.out.println(s);
}
}
}
48.How do I make a copy of an array ?The
clone() in Clonable interface allows to make a copy of the array. In
the previous case i.e. arraycopy() we must mention the source array,the
source offset(starting position),the destination array,the destination
offset(Starting position),and the final one is the number of elements to
be copied.This method is useful when you copy a part of the array to a
new one. But when we need to copy a whole array to another,then we need
not mention all the arguments and have a tough time instead we go for
clone() method.In case of the clone() we need to mention the source
array and destination array. eg: Array a2=a1.clone(); here the elements
of the Array a1 is copied to the Array a2.If we add new elements in
Array a1 it will not be reflected in a2.For doing so we need to use the
Object refrences.
49.What is the purpose of the CopyOnWriteArrayList and CopyOnWriteArraySet collections ?
Synchronized
operations are costly and if you aren’t modifying a collection much, it
is best not to synchronize all collection accesses. The CopyOnWriteXXX
collections avoid concurrent modification issues during traversal by
traversing through the original collection and the modifications
happening in a copy of the original store. Think of CopyOnWriteArrayList
as a thread-safe version of ArrayList without the syncrhonized access
limitations. CopyOnWriteArraySet acts as like a Set, backed by a
CopyOnWriteArrayList.
50.What implementations of the Deque interface does Java offer ? ArrayDeque
offers an array backed deque. LinkedList offers a linked list version.
LinkedBlockingDeque offers an optionally bounded blocking version.
51.Why do I keep getting an UnsupportedOperationException thrown when I try some collection operations ? Several
methods of the collection interfaces are considered optional. If an
unsupported operation is called, that is when you’ll see the
UnsupportedOperationException thrown. The javadoc for a collection
implementation should document which methods are optional.
53.Is it better to use a for-each loop or an Iterator with a collection ?
It
depends on what you need to do. The remove() method of an Iterator is
the safe way to remove elements from an underlying collection. You can’t
safely remove elements with a for-each loop. For just “visiting” each
element, either way works.
54.How can I detect if a duplicate is added to a Set ? The
add() method returns a boolean. If the set did not previously contain
the element, true is returned. If the set previoulsy did contain the
element, false is returned. Of course, you can also check with the
contains() method to see if the element is contained in the Set first.
55.What is a multimap ? A multimap is a map where a single key can map to multiple values.(And a value can be associated with multiple keys.)
54.How do I create a multimap in Java ? Typically
a Map maps a key to a single value. To have a multimap, the values of a
Map should be a List instead. Thus there can be multiple values in the
List associated with a single key.
56.What is the natural ordering of a Boolean? Does FALSE come first or second ? Boolean.FALSE < Boolean.TRUE
57.What does Class<String> mean ? Class<String> is the generics way of writing String.class. It allows you to improve type safety.
58.What type of data structure would you use to store java objects (Element) with the following requirements ? I.
Created/loaded only once
Elements are frequently read by multiple threads
No updates (add/remove) to the data structure are required once loaded
Order is not important
Random object access is required by a unique key search.
Answer: HashMap
II.
Created once
Elements are added / removed in a multi threaded environment
Elements are frequently read in a multi threaded environment
Order is not important
Random object access is required by a unique key search.
Answer: HashTable is synchronized
III.
Created/loaded only once
Elements are frequently read in a multi threaded environment
Elements are added / removed in a multi threaded environment
Elements are frequently read in a multi threaded environment
Order is important
Random object access is require based on an index
Duplicate objects allowed
Answer: Vector is synchronized
IV.
Created once
Order is important
Random object access is require based on an index
Elements are frequently read in a multi threaded environment
Answer: ArrayList
