Best practices while using collection API

The following are some best practices that one can follow while using collection API (as discussed in various blogs and books)

1. Code to interfaces rather than implementation; reason, you can change the implementation later on without significant effect.
2. Set the initial capacity of the collection appropriately, if you know the size you can gain on speed, else these collection classes will have to grow periodically when the size hits the limit.
3. Use ArrayList, HashMap etc as opposed to Vector and Hashtable; reason,Vector and Hashtable methods are synchronized, if you want synchronization using ArrayList, HashMap then you externally synchronize the same. I will show that in my next blog.
4. Return zero length collection or array as opposed to returning NULL; to avoid running into NullPointerException issues at runtime.
5. Immutable object should be used as keys for the HashMap; so also as values in a HashSet. 
6. Encapsulate collections; to avoid unintentional  modification of the collections.
7. Stored related objects together and avoid storing unrelated or different types in the same collection.

Abstract class and interface

When to create abstract class?
We create an abstract class when there is some common behaviour which can be reused across subclasses and certain behaviour needs to be defferred to the sublasses as they are subclass specific. We define such a behaviour using the abstract construct in java. Abstract classes help us achieve implementation inheritance.
When to create an interface?
When the client is only concerned with the behavior and does not worry about the actual implementation, then we should model such behavior using interface. Interface helps us achieve polymorphic interface inheritance.

So having said that,

1. Abstract classes should be used when there is a strict heirarchy of classes i.e there is strict IS-A relationship between the classes. Ex FlatFileReader/XMLFileReader extends FileReader method loadFile is common behaviour and the procedure to load a flat file versus a XML file is the same however readFile can be sublass specific given the file types. With interface you can relate classes which are otherwise unrelated.
   Ex SoundBehaviour interface with method makeSound() can relate a Animal Class heirachy and Instrument class heirachy.
2. Abstract classes should be used in cases where the base class needs to be changed often, the subclasses will inherit the behaviour without any change.Use of interfaces in such a case will make the design fragile, as changes to interfaces will be propogated to implementing classes.

Resources

• http://www.javaworld.com/javaworld/javaqa/2001-04/03-qa-0420-abstract.html
• Effective Java - Joshua Bloch
• http://codeofdoom.com/wordpress/2009/02/12/learn-this-when-to-use-an-abstract-class-and-an-interface/
• http://en.csharp-online.net/Should_I_use_an_abstract_class_or_an_interface%3F