Explore topic-wise InterviewSolutions in .

LinkedHashSet is also one of the implementation of the SET INTERFACE. Actually LinkedHashSet class extends the HashSet and has no other methods of its own.

LinkedHashSet also STORES unique elements just like other implemetations of the Set interface. How LinkedHashSet differs is that it MAINTAINS the insertion-order; that is elements in the LinkedHashSet are stored in the SEQUENCE in which they are inserted. Note that insertion order is not affected if an element is re-inserted into the set.

LinkedHashSet is also one of the implementation of the Set interface. Actually LinkedHashSet class extends the HashSet and has no other methods of its own.

LinkedHashSet also stores unique elements just like other implemetations of the Set interface. How LinkedHashSet differs is that it maintains the insertion-order; that is elements in the LinkedHashSet are stored in the sequence in which they are inserted. Note that insertion order is not affected if an element is re-inserted into the set.

LINKEDHASHSET should be USED in this CASE.

LinkedHashSet should be used in this case.

HASHSET internally uses HashMap to store it's ELEMENTS. But it differs from HashMap on two points.

• HashSet only stores unique VALUES i.E. no duplicates are allowed.
• In HashSet we have add(E e) METHOD which takes just the element to be added as parameter not the (key, value) pair.

HashSet internally uses HashMap to store it's elements. But it differs from HashMap on two points.

• HashMap MAKES no guarantees as to the order of the map.
  
  LinkedHashMap maintains the insertion order of the elements which means if we iterate a LinkedHashMap we'll get the keys in the order in which they were inserted in the Map.
  
  TreeMap stores objects in sorted order.
  
  
• HashMap as well as LinkedHashMap allows one null as key, multiple values may be null though.
  
  TreeMap does not allow null as key.
  
  
• HashMap stores elements in a bucket which actually is an index of the array.
  
  LinkedHashMap also uses the same internal implementation, it also maintains a doubly-linked list running through all of its entries.
  
  TreeMap is a Red-Black tree based NavigableMap implementation.
  
  
• Performance WISE HashMap provides constant TIME performance O(1) for get() and put() method.
  
  LinkedHashMap also provides constant time performance O(1) for get() and put() method but in general a little slower than the HashMap as it has to maintain a doubly linked list.
  
  TreeMap provides guaranteed log(n) time cost for the containsKey, get, put and remove operations.

Though both HashTable and HashMap store elements as a (key, value) pair and use hashing technique to store elements, moreover from Java v1.2, HashTable class was retrofitted to implement the MAP interface, making it a member of the Java COLLECTIONS Framework. But there are certain difference between the TWO -

• HashMap is not synchronized where as HashTable is synchronized.
• HashMap allows one null value as a key and any NUMBER of null VALUES where as HashTable does not allow null values either as key or as value.
• For traversing a HashMap an iterator can be used. For traversing a HashTable either an iterator or Enumerator can be used. The iterator used for both HashMap and HashTable is fail-fast but the enumerator used with HashTable is fail-safe.
• Performance wise HashMap is faster than the HashTable reason being HashMap is not synchronized.

Though both HashTable and HashMap store elements as a (key, value) pair and use hashing technique to store elements, moreover from Java v1.2, HashTable class was retrofitted to implement the Map interface, making it a member of the Java Collections Framework. But there are certain difference between the two -

IdentityHashMap CLASS implements the Map interface with a hash table, using reference-equality in place of object-equality when comparing keys (and values). In other words, in an IdentityHashMap, TWO keys K1 and k2 are considered equal if and only if (k1==k2). Where as In normal Map implementations (like HASHMAP) two keys k1 and k2 are considered equal if and only if (k1==null ? k2==null : k1.equals(k2)).

Note that This class is not a general-purpose Map implementation. While this class implements the Map interface, it INTENTIONALLY violates Map's general contract, which mandates the use of the equals method when comparing objects. This class is designed for use only in the rare cases wherein reference-equality semantics are required.

IdentityHashMap class implements the Map interface with a hash table, using reference-equality in place of object-equality when comparing keys (and values). In other words, in an IdentityHashMap, two keys k1 and k2 are considered equal if and only if (k1==k2). Where as In normal Map implementations (like HashMap) two keys k1 and k2 are considered equal if and only if (k1==null ? k2==null : k1.equals(k2)).

Note that This class is not a general-purpose Map implementation. While this class implements the Map interface, it intentionally violates Map's general contract, which mandates the use of the equals method when comparing objects. This class is designed for use only in the rare cases wherein reference-equality semantics are required.

WEAKHASHMAP is a Hash table based implementation of the Map interface, with weak keys. An entry in a WeakHashMap will automatically be REMOVED when its key is no longer in ordinary use. Which MEANS storing only weak references allows GARBAGE collector to remove the entry (key-value PAIR) from the map when its key is not referenced outside of the WeakHashMap.

In WeakHashMap both null values and the null key are supported. A WeakHashMap is created as- 

Map weakHashMap = new WeakHashMap();

WeakHashMap is a Hash table based implementation of the Map interface, with weak keys. An entry in a WeakHashMap will automatically be removed when its key is no longer in ordinary use. Which means storing only weak references allows garbage collector to remove the entry (key-value pair) from the map when its key is not referenced outside of the WeakHashMap.

In WeakHashMap both null values and the null key are supported. A WeakHashMap is created as- 

Map weakHashMap = new WeakHashMap();

TreeMap is also one of the implementation of the Map interface LIKE HashMap and LinkedHashMap. TreeMap class implements the NavigableMap interface and extends the AbstractMap class.

How it differs from other implementations of the Map interface is that objects in TreeMap are stored in sorted order. The elements are ORDERED using their natural ORDERING or a comparator can be provided at map creation time to PROVIDE custom ordering.

One important point about TreeMap is, though HashMap and LinkedHashMap allow one null as key, TreeMap doesn't allow null as key. Any attempt to ADD null in a TreeMap will result in a NullPointerException.

TreeMap is also one of the implementation of the Map interface like HashMap and LinkedHashMap. TreeMap class implements the NavigableMap interface and extends the AbstractMap class.

How it differs from other implementations of the Map interface is that objects in TreeMap are stored in sorted order. The elements are ordered using their natural ordering or a comparator can be provided at map creation time to provide custom ordering.

One important point about TreeMap is, though HashMap and LinkedHashMap allow one null as key, TreeMap doesn't allow null as key. Any attempt to add null in a TreeMap will result in a NullPointerException.

TREEMAP should be USED in this CASE.

TreeMap should be used in this case.

LinkedHashMap is also one of the implementation of the Map interface, apart from implementing Map interface LinkedHashMap also extends the HashMap class. So just like HashMap, LinkedHashMap also ALLOWS one null key and multiple null values.

How it DIFFERS from other implementations of the Map interface like HashMap and TREEMAP is thatLinkedHashMap maintains the insertion order of the elements which means if we iterate a LinkedHashMap we'll get the keys in the order in which they were inserted in the Map. 

LinkedHashMap maintains a doubly-linked list RUNNING through all of its ENTRIES and that's how it maintains the iteration order.

LinkedHashMap is also one of the implementation of the Map interface, apart from implementing Map interface LinkedHashMap also extends the HashMap class. So just like HashMap, LinkedHashMap also allows one null key and multiple null values.

How it differs from other implementations of the Map interface like HashMap and TreeMap is thatLinkedHashMap maintains the insertion order of the elements which means if we iterate a LinkedHashMap we'll get the keys in the order in which they were inserted in the Map. 

LinkedHashMap maintains a doubly-linked list running through all of its entries and that's how it maintains the iteration order.

LINKEDHASHMAP should be USED in this CASE.

LinkedHashMap should be used in this case.

The default implementation of equals() method in the Object class is a simple reference EQUALITY check.

public boolean equals(Object obj){
return (this == obj);
}

The default implementation of hashCode() in the Object class just returns INTEGER VALUE of the memory address of the object.

It becomes very important to override these two methods in case we are using a custom object as KEY in a hash based collection. 

In that case we can't rely on the default implementation provided by the Object class and need to provide custom implementation of hashCode() and equals() method.

If two objects Obj1 and Obj2 are equal according to their equals() method then they must have the same hash code too. Though the vice-versa is not true that is if two objects have the same hash code then they do not have to be equal too.

The default implementation of equals() method in the Object class is a simple reference equality check.

public boolean equals(Object obj){
return (this == obj);
}

The default implementation of hashCode() in the Object class just returns integer value of the memory address of the object.

It becomes very important to override these two methods in case we are using a custom object as key in a hash based collection. 

In that case we can't rely on the default implementation provided by the Object class and need to provide custom implementation of hashCode() and equals() method.

If two objects Obj1 and Obj2 are equal according to their equals() method then they must have the same hash code too. Though the vice-versa is not true that is if two objects have the same hash code then they do not have to be equal too.

EQUALS() METHOD is present in the java.lang.Object class. It is used to determine the EQUALITY of TWO objects.

equals() method is present in the java.lang.Object class. It is used to determine the equality of two objects.

hashCode() METHOD is present in the java.lang.Object class. This method is used to GET a unique integer value for a given object. We can see it's USE with hash based collections like HASHTABLE or HashMap where hashCode() is used to find the correct bucket LOCATION where the particular (key, value) pair is stored.

hashCode() method is present in the java.lang.Object class. This method is used to get a unique integer value for a given object. We can see it's use with hash based collections like HashTable or HashMap where hashCode() is used to find the correct bucket location where the particular (key, value) pair is stored.

In HashMap, using the KEY, a Hash is calculated and that hash VALUE decides in which bucket the particular Map.Entry object will RESIDE.

Hash collision means more than ONE key having the same calculated hash value THUS stored in the same bucket. In HashMap, in that case Entry objects are stored as a linked-list with in the same bucket.

In HashMap, using the key, a Hash is calculated and that hash value decides in which bucket the particular Map.Entry object will reside.

Hash collision means more than one key having the same calculated hash value thus stored in the same bucket. In HashMap, in that case Entry objects are stored as a linked-list with in the same bucket.

If an attempt is made to add the same key twice, it won't CAUSE any error but the VALUE which is added later will override the PREVIOUS value. 

As Exp. If you have a Map, cityMap and you add TWO values with same key in the cityMap, Kolkata will override the New Delhi.

cityMap.put("5", "New Delhi");
cityMap.put("5", "Kolkata");

If an attempt is made to add the same key twice, it won't cause any error but the value which is added later will override the previous value. 

As Exp. If you have a Map, cityMap and you add two values with same key in the cityMap, Kolkata will override the New Delhi.

cityMap.put("5", "New Delhi");
cityMap.put("5", "Kolkata");

HashMap allows one null key and any number of null values. If another null key is added it won't cause any ERROR. But the value with the new null key will override the value with OLD null key.

As exp. If you have a Map, cityMap and you ADD TWO values with null keys in the cityMap, Kolkata will override the New Delhi as only one null key is allowed.

cityMap.put(null, "New Delhi");
cityMap.put(null, "Kolkata");

HashMap allows one null key and any number of null values. If another null key is added it won't cause any error. But the value with the new null key will override the value with old null key.

As exp. If you have a Map, cityMap and you add two values with null keys in the cityMap, Kolkata will override the New Delhi as only one null key is allowed.

cityMap.put(null, "New Delhi");
cityMap.put(null, "Kolkata");

Map.Entry is an interface in java.util, in fact Entry is a nested interface in Map interface. Nested interface must be QUALIFIED by the NAME of the class or interface of which it is a member, that's why it is qualified as Map.Entry. 

Map.Entry REPRESENTS a key/value pair that forms one element of a Map. 

The Map.entrySet method RETURNS a collection-view of the map, whose elements are of this class.

As exp. If you have a Map called cityMap then using entrySet method you can get the set view of the map whose elements are of type Map.Entry, and then using getKey and getValue methods of the Map.Entry you can get the key and value pair of the Map.

for(Map.Entry<String, String> entry: cityMap.entrySet()){

System.out.println("Key is " + entry.getKey() + " Value is " + entry.getValue());

}

Map.Entry is an interface in java.util, in fact Entry is a nested interface in Map interface. Nested interface must be qualified by the name of the class or interface of which it is a member, that's why it is qualified as Map.Entry. 

Map.Entry represents a key/value pair that forms one element of a Map. 

The Map.entrySet method returns a collection-view of the map, whose elements are of this class.

As exp. If you have a Map called cityMap then using entrySet method you can get the set view of the map whose elements are of type Map.Entry, and then using getKey and getValue methods of the Map.Entry you can get the key and value pair of the Map.

for(Map.Entry<String, String> entry: cityMap.entrySet()){

System.out.println("Key is " + entry.getKey() + " Value is " + entry.getValue());

}

MAPS themselves are not COLLECTIONS because they don't IMPLEMENT COLLECTION INTERFACE.

Maps themselves are not collections because they don't implement Collection interface.

Though we can't ITERATE a MAP as such but Map interface has methods which provide a set view of the Map. That set can be iterated. Those two methods are -

• Set<Map.Entry<K, V>>entrySet() - This METHOD returns a set that contains the entries in the map. The entries in the set are actually object of type Map.Entry.
• Set<K>KEYSET() - This method returns a set that contains the keys of the map.

There is also a values() method in the Map that returns a Collection view of the values CONTAINED in this map.

Though we can't iterate a Map as such but Map interface has methods which provide a set view of the Map. That set can be iterated. Those two methods are -

There is also a values() method in the Map that returns a Collection view of the values contained in this map.

• fail-fast iterator THROWS a CONCURRENTMODIFICATIONEXCEPTION if the underlying COLLECTION is structurally modified whereas fail-safe iterator doesn't throw ConcurrentModificationException.
• fail-fast iterator doesn't CREATE a copy of the collection whereas fail-safe iterator makes a copy of the underlying structure and iteration is done over that snapshot.
• fail-fast iterator provides operations like REMOVE, add and set (in case of ListIterator) whereas in case of fail-safe iterators element-changing operations on iterators themselves (remove, set and add) are not supported. These methods throw UnsupportedOperationException.

An iterator is considered fail-safe if it does not throw ConcurrentModificationException. ConcurrentModificationException is not THROWN as the fail-safe iterator makes a copy of the underlying STRUCTURE and iteration is done over that snapshot. 

SINCE iteration is done over a copy of the collection so interference is IMPOSSIBLE and the iterator is guaranteed not to throw ConcurrentModificationException.

An iterator is considered fail-safe if it does not throw ConcurrentModificationException. ConcurrentModificationException is not thrown as the fail-safe iterator makes a copy of the underlying structure and iteration is done over that snapshot. 

Since iteration is done over a copy of the collection so interference is impossible and the iterator is guaranteed not to throw ConcurrentModificationException.

An iterator is considered fail-fast if it throws a CONCURRENTMODIFICATIONEXCEPTION under either of the following two conditions:

• In multi-threaded environment, if one thread is trying to modify a Collection while another thread is iterating over it.
• EVEN with SINGLE thread, if a thread modifies a collection directly while it is iterating over the collection with a fail-fast iterator, the iterator will throw this EXCEPTION.

fail-fast iterator will throw a ConcurrentModificationException if the underlying collection is structurally modified in any way except through the iterator's own remove or add (if applicable as in list-iterator) methods.

Note that structural modification is any operation that adds or deletes one or more elements; merely SETTING the value of an element (in case of list) or changing the value associated with an existing key (in case of map) is not a structural modification.

An iterator is considered fail-fast if it throws a ConcurrentModificationException under either of the following two conditions:

fail-fast iterator will throw a ConcurrentModificationException if the underlying collection is structurally modified in any way except through the iterator's own remove or add (if applicable as in list-iterator) methods.

Note that structural modification is any operation that adds or deletes one or more elements; merely setting the value of an element (in case of list) or changing the value associated with an existing key (in case of map) is not a structural modification.

Iterator can be OBTAINED on any Collection CLASS like List or SET so contract for Iterator makes no guarantees about the order of ITERATION. 

But ListIterator can only be used to traverse a List so it does guarantee the order of the iteration. That is why ListIterator provides an ADD operation.

Iterator can be obtained on any Collection class like List or Set so contract for Iterator makes no guarantees about the order of iteration. 

But ListIterator can only be used to traverse a List so it does guarantee the order of the iteration. That is why ListIterator provides an add operation.

Iterator is an INTERFACE which is part of the Java Collections FRAMEWORK. An Iterator enables you to iterate a collection. Iterators also allow the caller to remove elements from the underlying collection during the iteration.

Collection CLASSES provide iterator method which RETURNS an iterator. This iterator can be used to traverse a collection.

As exp. if there is a set called citySet, an iterator on this set can be obtained as -

Iterator&LT;String> itr = citySet.iterator();
while (itr.hasNext()) {
String city = (String) itr.next();
System.out.println("city " + city);
}

Iterator is an interface which is part of the Java Collections framework. An Iterator enables you to iterate a collection. Iterators also allow the caller to remove elements from the underlying collection during the iteration.

Collection classes provide iterator method which returns an iterator. This iterator can be used to traverse a collection.

As exp. if there is a set called citySet, an iterator on this set can be obtained as -

Iterator<String> itr = citySet.iterator();
while (itr.hasNext()) {
String city = (String) itr.next();
System.out.println("city " + city);
}

• ARRAY is fixed in size which is provided at the time of creating an Array. ArrayList grows DYNAMICALLY and also known as dynamically growing array.
• Array can store PRIMITIVE types as well as objects. In ArrayList only Objects can be stored.
• Arrays can be multi-dimensional whereas ArrayList is always unidimensional.
  
  As Exp. a two dimensional array can be created as -
  
  Integer MYARRAY[][] = new Integer[4][3];
  
  
• Performance wise both Array and ArrayList are almost same as internally ArrayList also uses an Array. But there is overhead of resizing the array and copying the elements to the new Array in case of ArrayList.

• ARRAYLIST is not synchronized WHEREAS Vector is synchronized.
• Performance wise ArrayList is fast in comparison to Vector as ArrayList is not synchronized.
• ArrayList, by default, grows by 50% in case the initial capacity is EXHAUSTED. In case of Vector the backing array's size is doubled by default.
• For TRAVERSING an ArrayList iterator is used. For traversing Vecor Iterator/Enumerator can be used. NOTE that Iterator is fail-fast for both Vector and ArrayList. Enumerator which can be used with Vector is not fail-fast.

In Java collections FRAMEWORK ArrayList and LinkedList are TWO different implementations of List INTERFACE 

• LinkedList is implemented using a doubly linked list concept where as ArrayList internally uses an array of Objects which can be RESIZED dynamically
• For LinkedList add(e Element) is always O(1) where as for ArrayList add(e Element) operation runs in amortized constant time, that is, adding n elements requires O(n) time.
• For LinkedList get(INT index) is O(n) where as for ArrayList get(int index) is O(1).
• If you are removing using the remove(int index) method then for LinkedList class it will be O(n). In case of ArrayList getting to that index is fast but removing will mean shuffling the remaining elements to fill the gap created by the removed element with in the underlying array.

In Java collections framework ArrayList and LinkedList are two different implementations of List interface 

Java.util.Deque is an interface in Java which EXTENDS QUEUE interface and provides support for element insertion and removal at both ends. The name deque is SHORT for "DOUBLE ENDED queue" and is usually pronounced "deck".

Some of the implementing classes of the Deque interface are LinkedList, ConcurrentLinkedDeque, LinkedBlockingDeque. Note that addFirst() and addLast() methods provided in the LinkedList implementation are specified by the Deque interface.

Java.util.Deque is an interface in Java which extends Queue interface and provides support for element insertion and removal at both ends. The name deque is short for "double ended queue" and is usually pronounced "deck".

Some of the implementing classes of the Deque interface are LinkedList, ConcurrentLinkedDeque, LinkedBlockingDeque. Note that addFirst() and addLast() methods provided in the LinkedList implementation are specified by the Deque interface.

LinkedList class in JAVA implements List and Deque interfaces and LinkedList implements it using doubly linkedlist.

WITHIN the LinkedList implementation there is a private class NODE which provides the structure for a node in a doubly linked list. It has ITEM variable for holding the value and two reference to Node class itself for connecting to next and previous nodes.

LinkedList class in Java implements List and Deque interfaces and LinkedList implements it using doubly linkedlist.

Within the LinkedList implementation there is a private class Node which provides the structure for a node in a doubly linked list. It has item variable for holding the value and two reference to Node class itself for connecting to next and previous nodes.

• Adding an element - If you are adding at the end using ADD(E e) method it is O(1). In the worst case it may go to O(n). That will happen if you add more elements than the capacity of the underlying array.
• Retrieving an element - Since ArrayList INTERNALLY uses an array to store elements so get(int index) means going to that index directly in the array. So, for ArrayList get(int index) is O(1).
• Removing an element - If you are removing using the remove(int index) method then, in case of ArrayList getting to that index is fast but removing will MEAN shuffling the remaining elements to fill the gap CREATED by the removed element with in the underlying array. Thus it can be said remove(int index) OPERATION is O(n - index) for the arraylist.

Arrays class contains a STATIC factory method asList() that allows arrays to be VIEWED as LISTS.

public static <T> List<T> asList(T... a)

As Exp.

String cityArray[] = {"Delhi", "Mumbai", "Bangalore", "Hyderabad", "CHENNAI"};

//Converting array to List

List<String> cityList = Arrays.asList(cityArray);

Arrays class contains a static factory method asList() that allows arrays to be viewed as lists.

public static <T> List<T> asList(T... a)

As Exp.

String cityArray[] = {"Delhi", "Mumbai", "Bangalore", "Hyderabad", "Chennai"};

//Converting array to List

List<String> cityList = Arrays.asList(cityArray);

Within Collection interface there are two versions of toArray() which can be used to convert ARRAYLIST to ARRAY.

• Object[] toArray()
• <T&GT; T[] toArray(T array[])

The first version RETURNS an array of Object. 

The second version returns an array containing the elements of the LIST. Normally we go with the second version because it returns the array of the same type as List.

If you have a List called cityList, it can be converted to an array like this -

String cityArray[] = new String[cityList.size()];
cityArray = cityList.toArray(cityArray);

Within Collection interface there are two versions of toArray() which can be used to convert ArrayList to array.

The first version returns an array of Object. 

The second version returns an array containing the elements of the list. Normally we go with the second version because it returns the array of the same type as List.

If you have a List called cityList, it can be converted to an array like this -

String cityArray[] = new String[cityList.size()];
cityArray = cityList.toArray(cityArray);

In order to have better performance most of the COLLECTIONS are not synchronized. Which means sharing an instance of arrayList among many threads where those threads are MODIFYING (by adding or removing the values) the COLLECTION may RESULT in unpredictable behaviour. 

To synchronize a List Collections.synchronizedList() method can be used.

In order to have better performance most of the Collections are not synchronized. Which means sharing an instance of arrayList among many threads where those threads are modifying (by adding or removing the values) the collection may result in unpredictable behaviour. 

To synchronize a List Collections.synchronizedList() method can be used.

Collections.sort() METHOD will sort the ARRAYLIST of STRING in ascending order. 

To have a descending order EITHER comparator has to be provided or reverseOrder method of the Collections class can be used.

Collections.sort(cityList, Collections.reverseOrder());

Collections.sort() method will sort the ArrayList of String in ascending order. 

To have a descending order either comparator has to be provided or reverseOrder method of the Collections class can be used.

Collections.sort(cityList, Collections.reverseOrder());

Collections class has a STATIC method sort which can be used for SORTING an arraylist.

There are TWO overloaded versions of sort method -

• public static <T extends Comparable<? super T>> void sort(List<T> list) - Sorts the specified list into ascending order, according to the NATURAL ordering of its elements.
• public static <T> void sort(List<T> list, Comparator<? super T> c) - Sorts the specified list according to the order induced by the specified comparator.

If you have a List called cityList it can be sorted LIKE this - 

Collections.sort(cityList);

Collections class has a static method sort which can be used for sorting an arraylist.

There are two overloaded versions of sort method -

If you have a List called cityList it can be sorted like this - 

Collections.sort(cityList);

ListIterator provides the FUNCTIONALITY to iterate a LIST in both directions. The interesting POINT about list iterator is that it has no current element. Its current cursor position always lies between the element that would be returned by a CALL to previous() and the element that would be returned by a call to NEXT().

ListIterator provides the functionality to iterate a list in both directions. The interesting point about list iterator is that it has no current element. Its current cursor position always lies between the element that would be returned by a call to previous() and the element that would be returned by a call to next().

There are many WAYS to loop/iterate an ARRAYLIST in Java. Options are -

• for loop
• for-each loop
• iterator
• list iterator
• Java 8 FOREACH loop

for-each loop is the best WAY to iterate a list if you just need to traverse SEQUENTIALLY through a list.

There are many ways to loop/iterate an arrayList in Java. Options are -

for-each loop is the best way to iterate a list if you just need to traverse sequentially through a list.

We can USE a HashSet to do the job of removing the DUPLICATE elements. HashSet only stores UNIQUE elements and we'll use that FEATURE of HashSet to remove duplicates.

If you have a LIST called cityList you can create a HashSet using this list - 

Set<String> citySet = new HashSet<String>(cityList);
then add this set back to the cityList 
cityList.clear();
cityList.addAll(citySet);

That will remove all the duplicate elements from the given list. Note that insertion order won't be retained if a HashSet is used. In case insertion order is to be retained use LinkedHashSet.

We can use a HashSet to do the job of removing the duplicate elements. HashSet only stores unique elements and we'll use that feature of HashSet to remove duplicates.

If you have a List called cityList you can create a HashSet using this list - 

Set<String> citySet = new HashSet<String>(cityList);
then add this set back to the cityList 
cityList.clear();
cityList.addAll(citySet);

That will remove all the duplicate elements from the given list. Note that insertion order won't be retained if a HashSet is used. In case insertion order is to be retained use LinkedHashSet.

ArrayList provides several methods to remove elements from the LIST. Since ArrayList internally uses array to store elements, one point to note is that when an element is removed from the List the remaining elements have to be shifted to fill the GAP created in the underlying array.

• clear() - Removes all of the elements from this list.
• remove(int INDEX) - Removes the element at the SPECIFIED position in this list.
• remove(Object o) - Removes the first occurrence of the specified element from this list, if it is present.
• removeAll(Collection<?> c) - Removes from this list all of its elements that are contained in the specified collection.
• removeIf(Predicate<? super E> filter) - Removes all of the elements of this collection that SATISFY the given predicate.

ArrayList provides several methods to remove elements from the List. Since ArrayList internally uses array to store elements, one point to note is that when an element is removed from the List the remaining elements have to be shifted to fill the gap created in the underlying array.

List provides a method addAll to join TWO or more lists in JAVA. 

If you have one list cityList and ANOTHER List secondCityList then you can join them using addAll LIKE this - 

cityList.addAll(secondCityList);

List provides a method addAll to join two or more lists in Java. 

If you have one list cityList and another List secondCityList then you can join them using addAll like this - 

cityList.addAll(secondCityList);

In ARRAYLIST any NUMBER of NULLS can be ADDED.

In ArrayList any number of nulls can be added.

Yes. List ALLOWS DUPLICATE ELEMENTS to be ADDED.

Yes. List allows duplicate elements to be added.

• List provides a method ADD(E e) which appends specified element to the end of the list. USING add(E e) method will MEAN keep adding elements SEQUENTIALLY to the list.
• Another add method - add(int INDEX, E element) inserts the specified element at the specified position in this list.
• Third method addAll(int index, Collection<? extends E> c) inserts all of the elements in the specified collection into this list, starting at the specified position.

Basic data structure USED by ARRAYLIST to store objects is an array of Object class, which is defined like -

transient Object[] elementData; 

When we ADD an element to an ArrayList it first verifies whether it has that much capacity in the array to store new element or not, in case there is not then the new capacity is CALCULATED which is 50% more than the old capacity and the array is increased by that much capacity (Actually uses Arrays.copyOf which returns the original array increased to the new length)

Basic data structure used by ArrayList to store objects is an array of Object class, which is defined like -

transient Object[] elementData; 

When we add an element to an ArrayList it first verifies whether it has that much capacity in the array to store new element or not, in case there is not then the new capacity is calculated which is 50% more than the old capacity and the array is increased by that much capacity (Actually uses Arrays.copyOf which returns the original array increased to the new length)

In the case of ArrayList you don't have to anticipate in advance, like in the case of array, how many ELEMENTS you are going to STORE in the arraylist. As and when elements are added list keeps GROWING. That is why ArrayList is called dynamically growing array.

For ArrayList, data structure used for storing elements is array itself. When ArrayList is created it initializes an array with an INITIAL capacity (default is array of length 10). When that limit is crossed another array is created which is 1.5 TIMES the original array and the elements from the old array are copied to the new array.

In the case of ArrayList you don't have to anticipate in advance, like in the case of array, how many elements you are going to store in the arraylist. As and when elements are added list keeps growing. That is why ArrayList is called dynamically growing array.

For ArrayList, data structure used for storing elements is array itself. When ArrayList is created it initializes an array with an initial capacity (default is array of length 10). When that limit is crossed another array is created which is 1.5 times the original array and the elements from the old array are copied to the new array.

Some of the COLLECTION classes that implement List interface are ARRAYLIST, CopyOnWriteArrayList, LinkedList, Stack, VECTOR.

Some of the Collection classes that implement List interface are ArrayList, CopyOnWriteArrayList, LinkedList, Stack, Vector.

List INTERFACE EXTENDS the ROOT interface Collection and adds behaviour for the collection that stores a sequence of elements. These elements can be INSERTED or ACCESSED by their position in the list using a zero-based index.

List interface extends the root interface Collection and adds behaviour for the collection that stores a sequence of elements. These elements can be inserted or accessed by their position in the list using a zero-based index.

COLLECTIONS class provides static method to MAKE a Collection unmodifiable. Each of the SIX core collection interfaces -Collection, Set, List, Map, SortedSet, and SortedMap - has one static factory method.

public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> C);

public static <T> Set<T> unmodifiableSet(Set<? extends T> s);

public static <T> List<T> unmodifiableList(List<? extends T> list);

public static <K,V> Map<K, V> unmodifiableMap(Map<? extends K, ? extends V> m);

public static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<? extends T> s);

public static <K,V> SortedMap<K, V> unmodifiableSortedMap(SortedMap<K, ? extends V> m);

Collections class provides static method to make a Collection unmodifiable. Each of the six core collection interfaces -Collection, Set, List, Map, SortedSet, and SortedMap - has one static factory method.

public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c);

public static <T> Set<T> unmodifiableSet(Set<? extends T> s);

public static <T> List<T> unmodifiableList(List<? extends T> list);

public static <K,V> Map<K, V> unmodifiableMap(Map<? extends K, ? extends V> m);

public static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<? extends T> s);

public static <K,V> SortedMap<K, V> unmodifiableSortedMap(SortedMap<K, ? extends V> m);

Collections class has several STATIC methods that RETURN synchronized collections. Each of the six core collection interfaces -Collection, SET, List, Map, SortedSet, and SortedMap - has one static factory method.

public static &LT;T> Collection<T> synchronizedCollection(Collection<T> c);
public static <T> Set<T> synchronizedSet(Set<T> s);
public static <T> List<T> synchronizedList(List<T> list);
public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m);
public static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s);
public static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m); 

Each of these methods returns a synchronized (thread-safe) Collection backed up by the specified collection.

Collections class has several static methods that return synchronized collections. Each of the six core collection interfaces -Collection, Set, List, Map, SortedSet, and SortedMap - has one static factory method.

public static <T> Collection<T> synchronizedCollection(Collection<T> c);
public static <T> Set<T> synchronizedSet(Set<T> s);
public static <T> List<T> synchronizedList(List<T> list);
public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m);
public static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s);
public static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m); 

Each of these methods returns a synchronized (thread-safe) Collection backed up by the specified collection.