The differences between the Collection and

Collections are given below.

The Collection is an interface whereas Collections

is a class.
The Collection interface provides the standard
functionality of data structure to List, Set, and
Queue.
However, Collections class is to sort and
synchronize the collection elements.
The Collection interface provides the methods that
can be used for data structure whereas Collections
class provides the static methods which can be
used for various operation on a collection.

15) What is the difference between Comparable

and Comparator?
No. Comparable Comparator
1) Comparable provides only one sort of
sequence. The Comparator provides multiple
sorts of sequences.
2) It provides one method named compareTo().It
provides one method named compare().
3) It is found in [Link] package. It is
located in [Link] package.
4) If we implement the Comparable interface,
The actual class is modified. The actual class is
not changed.
16) What do you understand by BlockingQueue?
BlockingQueue is an interface which extends the
Queue interface. It provides concurrency in the
operations like retrieval, insertion, deletion. While
retrieval of any element, it waits for the queue to
be non-empty. While storing the elements, it waits
for the available space. BlockingQueue cannot
contain null elements, and implementation of
BlockingQueue is thread-safe.

Syntax:

public interface BlockingQueue<E> extends Queue

<E>
17) What is the advantage of Properties file?
If you change the value in the properties file, you
don't need to recompile the java class. So, it makes
the application easy to manage. It is used to store
information which is to be changed frequently.
Consider the following example.

import [Link].*;
import [Link].*;
public class Test {
public static void main(String[] args)throws
Exception{
FileReader reader=new
FileReader("[Link]");

Properties p=new Properties();

[Link](reader);
 [Link]([Link]("user"));
[Link]([Link]("password"));
}
}
Output

system
oracle
18) What does the hashCode() method?
The hashCode() method returns a hash code value
(an integer number).

The hashCode() method returns the same integer

number if two keys (by calling equals() method)
are identical.

However, it is possible that two hash code numbers

can have different or the same keys.

If two objects do not produce an equal result by

using the equals() method, then the hashcode()
method will provide the different integer result for
both the objects.

19) Why we override equals() method?

The equals method is used to check whether two
objects are the same or not. It needs to be
overridden if we want to check the objects based
on the property.
For example, Employee is a class that has 3 data
members: id, name, and salary. However, we want
to check the equality of employee object by the
salary. Then, we need to override the equals()
method.

20) How to synchronize List, Set and Map

elements?
Yes, Collections class provides methods to make
List, Set or Map elements as synchronized:

public static List synchronizedList(List l){}

public static Set synchronizedSet(Set s){}
public static SortedSet
synchronizedSortedSet(SortedSet s){}
public static Map synchronizedMap(Map m){}
public static SortedMap
synchronizedSortedMap(SortedMap m){}
21) What is the advantage of the generic
collection?
There are three main advantages of using the
generic collection.
ADVERTISEMENT

If we use the generic class, we don't need

typecasting.
It is type-safe and checked at compile time.
Generic confirms the stability of the code by
making it bug detectable at compile time.
22) What is hash-collision in Hashtable and how it
is handled in Java?
Two different keys with the same hash value are
known as hash-collision. Two separate entries will
be kept in a single hash bucket to avoid the
collision. There are two ways to avoid hash-
collision.

Separate Chaining
Open Addressing
23) What is the Dictionary class?
The Dictionary class provides the capability to
store key-value pairs.

24) What is the default size of load factor in

hashing based collection?
The default size of load factor is 0.75. The default
capacity is computed as initial capacity * load
factor. For example, 16 * 0.75 = 12. So, 12 is the
default capacity of Map.

25) What do you understand by fail-fast?

The Iterator in java which immediately throws
ConcurrentmodificationException, if any
structural modification occurs in, is called as a
Fail-fast iterator. Fail-fats iterator does not require
any extra space in memory.

26) What is the difference between Array and

ArrayList?
The main differences between the Array and
ArrayList are given below.

SN Array ArrayList
1 The Array is of fixed size, means we cannot
resize the array as per need. ArrayList is not of
the fixed size we can change the size dynamically.
2 Arrays are of the static type. ArrayList is of
dynamic size.
3 Arrays can store primitive data types as well
as objects. ArrayList cannot store the primitive
data types it can only store the objects.
27) What is the difference between the length of an
Array and size of ArrayList?
The length of an array can be obtained using the
property of length whereas ArrayList does not
support length property, but we can use size()
method to get the number of objects in the list.
ADVERTISEMENT

Finding the length of the array

Int [] array = new int[4];

[Link]("The size of the array is " +
[Link]);

Finding the size of the ArrayList

ArrayList<String> list=new ArrayList<String>();

[Link]("ankit");
[Link]("nippun");
[Link]([Link]());

28) How to convert ArrayList to Array and Array

to ArrayList?
We can convert an Array to ArrayList by using the
asList() method of Arrays class. asList() method is
the static method of Arrays class and accepts the
List object. Consider the following syntax:

[Link](item)
We can convert an ArrayList to Array using
toArray() method of the ArrayList class. Consider
the following syntax to convert the ArrayList to the
List object.

List_object.toArray(new String[List_object.size()])
29) How to make Java ArrayList Read-Only?
We can obtain java ArrayList Read-only by calling
the [Link]() method.
When we define an ArrayList as Read-only then
we cannot perform any modification in the
collection through add(), remove() or set() method.

30) How to remove duplicates from ArrayList?

There are two ways to remove duplicates from the
ArrayList.

Using HashSet: By using HashSet we can remove

the duplicate element from the ArrayList, but it
will not then preserve the insertion order.
Using LinkedHashSet: We can also maintain the
insertion order by using LinkedHashSet instead of
HashSet.
The Process to remove duplicate elements from
ArrayList using the LinkedHashSet:

Copy all the elements of ArrayList to

LinkedHashSet.
Empty the ArrayList using clear() method, which
will remove all the elements from the list.
Now copy all the elements of LinkedHashset to
ArrayList.

31) How to reverse ArrayList?

To reverse an ArrayList, we can use reverse()
method of Collections class. Consider the following
example.

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
public class ReverseArrayList {
public static void main(String[] args) {
List list = new ArrayList<>();
[Link](10);
[Link](50);
[Link](30);
Iterator i = [Link]();
[Link]("printing the list....");
 while([Link]())
{
[Link]([Link]());
}
Iterator i2 = [Link]();
[Link](list);
[Link]("printing list in reverse
order....");
while([Link]())
{
[Link]([Link]());
}
}
}
Output

printing the list....

10
50
30

Vector Class in Java

·
The Vector class implements a growable array of objects. Vectors fall in legacy classes, but now it is
fully compatible with collections. It is found in [Link] package and implement the List interface, so
we can use all the methods of the List interface as shown below as follows:
 Vector implements a dynamic array which means it can grow or shrink as required. Like an array, it
contains components that can be accessed using an integer index.
 They are very similar to ArrayList, but Vector is synchronized and has some legacy methods that
the collection framework does not contain.
 It also maintains an insertion order like an ArrayList. Still, it is rarely used in a non-thread
environment as it is synchronized, and due to this, it gives a poor performance in adding,
searching, deleting, and updating its elements.
 The Iterators returned by the Vector class are fail-fast. In the case of concurrent modification, it
fails and throws the ConcurrentModificationException.
Syntax:
public class Vector<E> extends AbstractList<E> implements List<E>,
RandomAccess, Cloneable, Serializable
Here, E is the type of element.
 It extends AbstractList and implements List interfaces.
 It implements Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess
interfaces.
 The directly known subclass is Stack.
Important points regarding the Increment of vector capacity are as follows:
If the increment is specified, Vector will expand according to it in each allocation cycle. Still, if the
increment is not specified, then the vector’s capacity gets doubled in each allocation cycle. Vector
defines three protected data members:
 int capacityIncreament: Contains the increment value.
 int elementCount: Number of elements currently in vector stored in it.
 Object elementData[]: Array that holds the vector is stored in it.
Common Errors in the declaration of Vectors are as follows:
 Vector throws an IllegalArgumentException if the InitialSize of the vector defined is negative.
 If the specified collection is null, It throws NullPointerException.
Constructors

1. Vector(): Creates a default vector of the initial capacity is 10.

Vector<E> v = new Vector<E>();
2. Vector(int size): Creates a vector whose initial capacity is specified by size.
Vector<E> v = new Vector<E>(int size);
3. Vector(int size, int incr): Creates a vector whose initial capacity is specified by size and increment
is specified by incr. It specifies the number of elements to allocate each time a vector is resized
upward.
Vector<E> v = new Vector<E>(int size, int incr);
4. Vector(Collection c): Creates a vector that contains the elements of collection c.
vect
Vector<E> v = new Vector<E>(Collection c);

Methods in Vector Class

METHOD DESCRIPTION

Appends the specified element to the end of

add(E e)
this Vector.

Inserts the specified element at the specified

add(int index, E element)
position in this Vector.

Appends all of the elements in the specified

addAll(Collection<? Collection to the end of this Vector, in the
extends E> c) order that they are returned by the specified
Collection’s Iterator.

addAll(int index, Insert all of the elements in the specified

Collection into this Vector at the specified
Collection<? extends E> c)
position.

Adds the specified component to the end of

addElement(E obj)
this vector, increasing its size by one.

capacity() Returns the current capacity of this vector.

clear() Removes all of the elements from this Vector.

clone() Returns a clone of this vector.

contains(Object o) Returns true if this vector contains the

METHOD DESCRIPTION

specified element.

Returns true if this Vector contains all of the

containsAll(Collection<?> c)
elements in the specified Collection.

Copies the components of this vector into the

copyInto(Object[] anArray)
specified array.

elementAt(int index) Returns the component at the specified index.

Returns an enumeration of the components of

elements()
this vector.

Increases the capacity of this vector, if

ensureCapacity(int necessary, to ensure that it can hold at least the
minCapacity) number of components specified by the
minimum capacity argument.

Compares the specified Object with this

equals(Object o)
Vector for equality.

Returns the first component (the item at index

firstElement()
0) of this vector.

forEach(Consumer<? Performs the given action for each element of

the Iterable until all elements have been
super E> action)
processed or the action throws an exception.

Returns the element at the specified position in

get(int index)
this Vector.

hashCode() Returns the hash code value for this Vector.

Returns the index of the first occurrence of the

specified element in this vector,
indexOf(Object o)
or -1 if this vector does not contain the
element.

Returns the index of the first occurrence of the

specified element in this vector, searching
indexOf(Object o, int index)
forwards from the index, or returns -1 if the
element is not found.
METHOD DESCRIPTION

insertElementAt(E obj, int Inserts the specified object as a component in

index) this vector at the specified index.

isEmpty() Tests if this vector has no components.

Returns an iterator over the elements in this

iterator()
list in a proper sequence.

lastElement() Returns the last component of the vector.

Returns the index of the last occurrence of the

specified element in this vector,
lastIndexOf(Object o)
or -1 if this vector does not contain the
element.

Returns the index of the last occurrence of the

specified element in this vector, searching
lastIndexOf(Object o, int index)
backward from the index, or returns -1 if the
element is not found.

Returns a list iterator over the elements in this

listIterator()
list (in proper sequence).

Returns a list iterator over the elements in this

listIterator(int index) list (in proper sequence),
starting at the specified position in the list.

Removes the element at the specified position

remove(int index)
in this Vector.

Removes the first occurrence of the specified

remove(Object o) element in this Vector. If the Vector does not
contain the element, it is unchanged.

Removes from this Vector all of its elements

removeAll(Collection<?> c)
contained in the specified Collection.

Removes all components from this vector and

removeAllElements()
sets its size to zero.

removeElement(Object obj) Removes the first (lowest-indexed) occurrence

METHOD DESCRIPTION

of the argument from this vector.

removeElementAt(int index) Deletes the component at the specified index.

removeIf(Predicate<? super E> Removes all of the elements of this collection

filter) that satisfy the given predicate.

removeRange(int fromIndex, Removes from this list all of the elements

whose index is between fromIndex, inclusive,
int toIndex)
and toIndex, exclusive.

replaceAll(UnaryOperator<E> Replaces each element of this list with the

operator) result of applying the operator to that element.

Retains only the elements in this Vector

retainAll(Collection<?> c)
contained in the specified Collection.

Replaces the element at the specified position

set(int index, E element)
in this Vector with the specified element.

Sets the component at the specified index of

setElementAt(E obj, int index)
this vector to be the specified object.

setSize(int newSize) Sets the size of this vector.

Returns the number of components in this

size()
vector.

Sorts this list according to the order induced

sort(Comparator<? super E> c)
by the specified Comparator.

Creates a late-binding and fail-fast Spliterator

spliterator()
over the elements in this list.

Returns a view of the portion of this List

subList(int fromIndex, int
between fromIndex, inclusive, and toIndex,
toIndex)
exclusive.

Returns an array containing all of the elements

toArray()
in this Vector in the correct order.

toArray(T[] a) Returns an array containing all of the elements

METHOD DESCRIPTION

in this Vector in the correct order; the runtime

type of the returned array is that of the
specified array.

Returns a string representation of this Vector,

toString() containing the String representation of each
element.

Trims the capacity of this vector to be the

trimToSize()
vector’s current size.

Example:

Java
// Java Program to Demonstrate Working of Vector
// Via Creating and Using It

// Importing required classes

import [Link].*;
import [Link].*;

// Main class
class {

// Main driver method

public static void main(String[] args)
{
// Size of the Vector
int n = 5;

// Declaring the Vector with

// initial size n
Vector<Integer> v = new Vector<Integer>(n);

// Appending new elements at

// the end of the vector
for (int i = 1; i <= n; i++)
[Link](i);

// Printing elements
[Link](v);

// Remove element at index 3

[Link](3);

// Displaying the vector

// after deletion
 [Link](v);

// iterating over vector elements

// using for loop
for (int i = 0; i < [Link](); i++)

// Printing elements one by one

[Link]([Link](i) + " ");
}
}
Output
[1, 2, 3, 4, 5]
[1, 2, 3, 5]
1235
Note:
 If the vector increment is not specified then it’s capacity will be doubled in every
increment cycle.
 The capacity of a vector cannot be below the size, it may equal to it.

Performing Various Operations on Vector class in Java

Let us discuss various operations on Vector class that are listed as follows:
1. Adding elements
2. Updating elements
3. Removing elements
4. Iterating over elements
Operation 1: Adding Elements
In order to add the elements to the Vector, we use the add() method. This method is overloaded to
perform multiple operations based on different parameters. They are listed below as follows:
 add(Object): This method is used to add an element at the end of the Vector.
 add(int index, Object): This method is used to add an element at a specific index in the Vector.
Example:

// Java Program to Add Elements in Vector Class

// Importing required classes

import [Link].*;
import [Link].*;
// Main class
// AddElementsToVector
class GFG {

// Main driver method

public static void main(String[] arg)
{

// Case 1
// Creating a default vector
Vector v1 = new Vector();

// Adding custom elements

// using add() method
[Link](1);
[Link](2);
[Link]("geeks");
[Link]("forGeeks");
[Link](3);

// Printing the vector elements to the console

[Link]("Vector v1 is " + v1);

// Case 2
// Creating generic vector
Vector<Integer> v2 = new Vector<Integer>();

// Adding custom elements

// using add() method
[Link](1);
[Link](2);
[Link](3);

// Printing the vector elements to the console

[Link]("Vector v2 is " + v2);
}
}

Output:
Vector v1 is [1, 2, geeks, forGeeks, 3]
Vector v2 is [1, 2, 3]
Operation 2: Updating Elements
After adding the elements, if we wish to change the element, it can be done using the set() method.
Since a Vector is indexed, the element which we wish to change is referenced by the index of the
element. Therefore, this method takes an index and the updated element to be inserted at that index.
Example

Java
// Java code to change the
// elements in vector class

import [Link].*;

public class UpdatingVector {

public static void main(String args[])

{
// Creating an empty Vector
Vector<Integer> vec_tor = new Vector<Integer>();

// Use add() method to add elements in the vector

vec_tor.add(12);
vec_tor.add(23);
vec_tor.add(22);
vec_tor.add(10);
vec_tor.add(20);

// Displaying the Vector

[Link]("Vector: " + vec_tor);

// Using set() method to replace 12 with 21

[Link]("The Object that is replaced is: "
+ vec_tor.set(0, 21));

// Using set() method to replace 20 with 50

[Link]("The Object that is replaced is: "
 + vec_tor.set(4, 50));

// Displaying the modified vector

[Link]("The new Vector is:" + vec_tor);
}
}
Output
Vector: [12, 23, 22, 10, 20]
The Object that is replaced is: 12
The Object that is replaced is: 20
The new Vector is:[21, 23, 22, 10, 50]
Operation 3: Removing Elements
In order to remove an element from a Vector, we can use the remove() method. This method is
overloaded to perform multiple operations based on different parameters. They are:
 remove(Object): This method is used to remove an object from the Vector. If there are multiple
such objects, then the first occurrence of the object is removed.
 remove(int index): Since a Vector is indexed, this method takes an integer value which simply
removes the element present at that specific index in the Vector. After removing the element, all the
elements are moved to the left to fill the space and the indices of the objects are updated.
Example

Java
// Java code illustrating the removal
// of elements from vector

import [Link].*;
import [Link].*;

class RemovingElementsFromVector {

public static void main(String[] arg)

{

// create default vector of capacity 10

Vector v = new Vector();

// Add elements using add() method

[Link](1);
[Link](2);
[Link]("Geeks");
[Link]("forGeeks");
[Link](4);

// removing first occurrence element at 1

[Link](1);

// checking vector
[Link]("after removal: " + v);
}
 }

Output:
after removal: [1, Geeks, forGeeks, 4]
Operation 4: Iterating the Vector
There are multiple ways to iterate through the Vector. The most famous ways are by using the basic for
loop in combination with a get() method to get the element at a specific index and the advanced for a
loop.
Example

// Java program to iterate the elements

// in a Vector

import [Link].*;

public class IteratingVector {

public static void main(String args[])

{
// create an instance of vector
Vector<String> v = new Vector<>();

// Add elements using add() method

[Link]("Geeks");
[Link]("Geeks");
[Link](1, "For");

// Using the Get method and the

// for loop
for (int i = 0; i < [Link](); i++) {

[Link]([Link](i) + " ");

}

[Link]();

// Using the for each loop

for (String str : v)
[Link](str + " ");
}
}
Output
Geeks For Geeks
Geeks For Geeks
Note: Do give a read to the ArrayList vs Vector class in Java to grasp it better.
In Java, the Vector class is a part of the Java Collections Framework and provides a dynamic array
implementation of the List interface. It was added in the original release of Java (Java 1.0) and provides
a number of methods for manipulating the elements of a vector, including adding, inserting, and
removing elements.
Here is a simple example that demonstrates how to use a Vector in Java:

Java
import [Link];

public class VectorExample {

public static void main(String[] args) {
// Create a new vector
Vector<Integer> v = new Vector<>(3, 2);

// Add elements to the vector

[Link](1);
[Link](2);
[Link](3);

// Insert an element at index 1

[Link](0, 1);

// Remove the element at index 2

[Link](2);

// Print the elements of the vector

for (int i : v) {
[Link](i);
}
}
}
Output
1
0
3
Note that the Vector class is synchronized, meaning that multiple threads can access the same vector
without causing problems. However, this synchronization comes at the cost of performance, so if you
don’t need to share a vector between multiple threads, it’s generally better to use an alternative class
like ArrayList which is not synchronized.

Advantages of using Vector in Java:

 Synchronization: As mentioned before, Vector is synchronized, making it safe to use in a multi-

threaded environment.
 Dynamic Size: The size of a Vector can grow or shrink dynamically as elements are added or
removed, so you don’t have to worry about setting an initial size that will accommodate all
elements.
 Legacy support: Vector has been part of Java since its inception and is still supported, so it’s a
good option if you need to work with older Java code that uses Vector.

Disadvantages of using Vector in Java:

1. Performance: The synchronization in Vector can lead to slower performance compared to other
collection classes, such as ArrayList.
2. Legacy Code: While Vector is still supported, newer Java code is often written using the more
modern collection classes, so it may be harder to find examples and support for Vector.
3. Unnecessary overhead: If you don’t need the synchronization features of Vector, using it will
add unnecessary overhead to your code.

Reference Book

A good reference book for learning about the Java Collections Framework and Vector is “Java
Collections” by Naftalin and Wadler. This book provides a comprehensive look at the Java collections
framework, including Vector, and includes many examples and exercises to help you understand how
to use these classes effectively.
Th