• Vectors can be synchronized whereas ArrayList can’t.
• Vector is a legacy class whereas ArrayList isn’t.
• Vector can enhance its size by doubling the size of the array whereas ArrayList can enhance its size by 50% of the size of the array
• Vector is thread-safe whereas ArrayList isn’t.

• The Iterator can traverse the array in the forward movement whereas ListIterator can traverse the array in backward and forward directions.
• Iterator is used in Queue, List, and Set whereas ListIterator is used in List.
• Iterator can execute only remove operation whereas ListIterator can execute add, remove, and set operation.

• Iterator can traverse both legacies elements and non-legacy elements whereas Enumeration can traverse only legacy elements.
• Iterator is fail-fast whereas Enumeration is not.
• Iterator is very slow as compared to Enumeration.
• Iterator can execute the remove operation while traversing the collection whereas Enumeration can execute only traverse operation.

It is an interface utilized in Java that can expand the Queue. It gives concurrence in different queue operations like retrieval, deletion, insertion, etc.

The Queue waits to become non-empty when it is recovering any elements. BlockingQueue should not include null elements. The execution of this Queue is thread-safe.

The syntax of BlockingQueue is:

public interface BlockingQueue extends Queue

Equals() confirm whether the number object is equivalent to the object, which is passed as an argument or not.

The syntax of the equals() method is:
public boolean equals(Object o)

Example:
import java.lang.Integer;
public class Test {
   public static void main(String args[]) {
      Integer p = 5;
      Integer q = 20;
      Integer r =5;
      Short s = 5;
      System.out.println(p.equals(q)); 
      System.out.println(p.equals(r));
      System.out.println(p.equals(s));
   }
}

• If the developers are using a generic class then they don’t need typecasting.
• It is type-safe and can be reviewed at compilation time.
• It gives the stability of the code by seeing bugs at the time of compilation.

Developers can transform an Array to ArrayList by using the asList() method of the Arrays class. It is a static technique of the Arrays class that receives the List object. The syntax of the asList() method is:

Arrays.asList(item)

Java developers can transform ArrayList to the List object using syntax:

List_object.toArray(new String[List_object.size()])

• Set: It is a collection having no same elements. It utilizes a hashtable for holding elements.
• List: It is an ordered collection that includes the same elements. It allows a programmer to access any elements from its inbox. The list is similar to an array holding a dynamic length.
• MAP: It is an object which maps keys to values. It cannot include duplicate keys. Every key can be mapped to at least one value.

• The values can be kept in a map by creating a key-value pair. The value can be recovered using the key by passing it to the proper method.
• If there is no element in the Map, it will throw a ‘NoSuchElementException’.
• HashMap holds only object references. So it makes it impossible to use primitive data types such as double or int. So Use wrapper classes (like Integer or Double).

• push(): Push item into the stack.
• empty (): This technique locates whether the stack is blank or not.
• pop (): This Java collection framework process eliminates the object from the stack.
• search (): This technique searches items in the stack.
• peek (): This Java method peeks at the stack object without eliminating it.

Method emptySet() that brings back the blank immutable set whenever the developer tries to eliminate null elements. The set which comes back by emptySet() is serializable. The syntax is:

public static final Set emptySet()

1. key set view
2. value set view
3. entry set view.

• Java collection framework delivers elevated efficiency and effective data structures that improve the precision and speed of the program.
• The Java collection framework program is easy to maintain.
• A programmer can combine classes with different types that result in enhancing the reusability of code.
• The Java collection framework allows developers to change the primitive collection types the way they like.

• Set belongs to package-java.util whereas the map belongs to package- java.util.
• Set extends the collection interface whereas map doesn’t
• Set does not permit duplicate values whereas map allows.
• Set can sort only one null value and map can sort multiple null values

It is a Java class that can store key-value pairs.

Know the Interview Criteria of these MNCs!!!

• Google Interview Preparation Guide
• Amazon Interview Preparation Guide
• Accenture Interview Preparation Guide
• Capgemini Interview Preparation Guide
• Cognizant Interview Preparation Guide

Java Collection Interview Questions For Experienced

• HashSet: Programmers use HashSet to delete the duplicate element from the ArrayList. The disadvantage is it cannot maintain the insertion order.
• LinkedHashSet: Programmers can also preserve the order of insertion by using LinkedHashSet rather than HashSet.

• Collections.synchronizedList(list);
• Collections.synchronizedMap(map);
• Collections.synchronizedSet(set);

An UnsupportedOperationException is an exception or abnormality which is thrown on processes that are unsupported by the existing collection type.

For example, Programmer is creating a read-only list using “Collections.unmodifiableList(list)” and calling call(), add() or remove() method. It should clearly give UnsupportedOperationException.

1. ArrayList
2. HashMap
3. TreeMap
4. Hashtable

• A queue is known as a single-ended queue and Deque is known as a double-ended queue
• Elements in the Queue are removed or added from one end whereas in Deque elements can be added from both ends.
• A queue is less versatile and Deque is more versatile.

Class implementing List interface: ArrayList, Vector, and LinkedList.

Class implementing Set interface: HashSet, and TreeSet.

• object peek()
• boolean add(object)
• object remove()
• boolean offer(object)
• object element()
• object poll()

• ArrayList uses a dynamic array and LinkedList uses a doubly-linked list.
• LinkedList is preferable for manipulation whereas ArrayList is not.
• ArrayList provides random access and LinkedList does not.
• ArrayList stores only object and consumes less overhead of memory whereas LinkedList stores object and address object both so it consumes more overhead of memory.

• public boolean hasNext(): It comes true if the iterator has elements; else, it returns false.
• public Object next(): This technique returns the element and drives the pointer to the next value.
• public void remove(): This Java method can delete the last elements returned by the iterator.

• boolean add(Object o): This method adds the mention feature to this set if not already available.
• boolean contains(Object o): It comes true if the set includes the specified element.
• void clear(): This method deletes set elements.
• boolean isEmpty(): It comes true if the set has no elements.
• boolean remove(Object o): It deletes the specified feature from the set.
• object clone(): This method returns a copy of the HashSet instance: the elements themselves are not cloned.
• iterator iterator(): It returns an iterator over the components in this set.
• int size(): It returns the number of features available in the set.

The list gives an addall() process that joins multiple ArrayList in Java.

For example, assume two lists 1) areaList and 2) secondAreaList. A programmer can join these ArrayLists using addall() like:

areaList.addAll(secondAreaList);