Between ArrayList and Vector
What is difference between ArrayList and vector?
1) Synchronization - ArrayList is not thread-safe whereas Vector is thread-safe. In Vector class each method like add(), get(int i) is surrounded with a synchronized block and thus making Vector class thread-safe.
2) Data growth - Internally, both the ArrayList and Vector hold onto
their contents using an Array. When an element is inserted into an ArrayList
or a Vector, the object will need to expand its internal array if it runs
out of room. A Vector defaults to doubling the size of its array, while
the ArrayList increases its array size by 50 percent.
Ans) Arraylist can be synchronized using:
• Collection.synchronizedList(List list)
Other collections can be synchronized:
• Collection.synchronizedMap(Map map)
• Collection.synchronizedCollection(Collection c)
Ans) 1) Implement Comparable interface for the Employee class and override the compareTo(Object obj) method in which compare the employeeID
2) Now call Collections.sort() method and pass list as an argument.
Now consider that Employee class is a jar file.
1) Since Comparable interface cannot be implemented, create Comparator and override the compare(Object obj, Object obj1) method .
2) Call Collections.sort() on the list and pass comparator as an argument.
Ans) Both collections implements Map. Both collections store value as key-value pairs. The key differences between the two are
1. 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.
2. 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. • Fail-safe - “if the Hashtable is structurally modified at any time after the iterator is created, in any way except through the iterator's own remove method, the iterator will throw a ConcurrentModificationException”
3. HashMap permits null values and only one null key, while Hashtable
doesn't allow key or value as null.
Ans) Arrays are created of fix size whereas ArrayList is of not fix size. It means that once array is declared as :
int  intArray= new int;
ArrayList is one dimensional but array can be multidimensional.
Ans) Adding new elements is pretty fast for either type of list. For the ArrayList, doing random lookup using "get" is fast, but for LinkedList, it's slow. It's slow because there's no efficient way to index into the middle of a linked list. When removing elements, using ArrayList is slow. This is because all remaining elements in the underlying array of Object instances must be shifted down for each remove operation. But here LinkedList is fast, because deletion can be done simply by changing a couple of links. So an ArrayList works best for cases where you're doing random access on the list, and a LinkedList works better if you're doing a lot of editing in the middle of the list.
Source : Read More - from java.sun
Ans) It can be done in two ways, using for loop or using iterator of
ArrayList. The first option is faster than using iterator. Because value
stored in arraylist is indexed access. So while accessing the value is
accessed directly from the index.
Ans) For loop does not allow the updation in the array(add or remove
operation) inside the loop whereas Iterator does. Also Iterator can be
used where there is no clue what type of collections will be used because
all collections have iterator.
Ans) It follows Iterator design pattern. Iterator Pattern is a type of behavioral pattern. The Iterator pattern is one, which allows you to navigate through a collection of data using a common interface without knowing about the underlying implementation. Iterator should be implemented as an interface. This allows the user to implement it anyway its easier for him/her to return data. The benefits of Iterator are about their strength to provide a common interface for iterating through collections without bothering about underlying implementation.
Example of Iteration design pattern - Enumeration The class java.util.Enumeration
is an example of the Iterator pattern. It represents and abstract means
of iterating over a collection of elements in some sequential order without
the client having to know the representation of the collection being iterated
over. It can be used to provide a uniform interface for traversing collections
of all kinds.
Ans) It is preferred because:
If later on code needs to be changed from ArrayList to Vector then only
at the declaration place we can do that.
Ans) To sort the elements of the List in the reverse natural order of the strings, get a reverse Comparator from the Collections class with reverseOrder(). Then, pass the reverse Comparator to the sort() method.
List list = new ArrayList();
Comparator comp = Collections.reverseOrder();
How to sort list of strings - case insensitive?
Ans) using Collections.sort(list, String.CASE_INSENSITIVE_ORDER);
Ans) A null element can be added only if the set contains one element because when a second element is added then as per set defination a check is made to check duplicate value and comparison with null element will throw NullPointerException.
Have Java Problem
Return to : Java Programming Hints and Tips
All the site contents are Copyright © www.erpgreat.com
and the content authors. All rights reserved.