Advanced JAVA and J2EE – II UNIT

2 marks:
1. What is Collection Framework? List any two goals of collection Framework.
The Collections Framework is a sophisticated hierarchy of interfaces and classes that provide state-
of-the-art technology for managing groups of objects. Two goals include:
• The framework had to be high-performance.
• Extending and/or adapting a collection had to be easy.
2. What are the benefits of using the Collections Framework?
It is one of java’s most powerful subsystems. It merits close attention by all programmers.
Because java.util contains a wide array of functionality, it is quite large.
3. List any two collection classes with its purpose.
• AbstractCollection : Implements most of the Collection interface
• ArrayList – Implements dynamic array by extending AbstractList.

4. Write the differences between hasNext() and next() method.

hasNext() returns true if there is a next element Otherwise, returns false. next() returns the next
element. A NoSuchElementException is thrown if there is not a next E element.
5. What is map? List any two Map interface.
A map is an object that stores associations between keys and values, or key/value pairs. Given a
key, you can find its value. Both keys and values are objects. The keys must be unique, but the
values may be duplicated. The map interfaces include:
• Map – Maps unique keys to values.
• SortedMap - ensures that entries are maintained in ascending order based on the keys.
6. Write the purpose of Array class.
The Arrays class provides various methods that are useful when working with arrays. These
methods help bridge the gap between collections and arrays.
7. Write the purpose of a. fill() b. copyOf()
The fill( ) method assigns a value to all elements in an array. In other words, it fills an array with a
specified value. The copyOf( ) method returns a copy of an array.
8. Write the usage of iterator interface.
Iterator enables you to cycle through a collection, obtaining or removing elements. An iterator
offers a general-purpose, standardized way of accessing the elements within a collection, one at a
time. Because each collection implements Iterator, the elements of any collection class can be
accessed through the methods defined by Iterator. Thus, with only small changes, the code that
cycles through a set can also be used to cycle through a list.
9. List any four interfaces provided by Collection Framework.
• Collection
• Queue
• List
• Set
10. Write any two uses of Generics.
• Generics ensure type safety by specifying the data type that a collection can hold.
• Generics eliminate the need for explicit casting when retrieving elements from a collection.
11. List any four exceptions thrown in the context of collections.
• ClassCastException
• NullPointerException
• UnsupportedOperationException
• IllegalArgumentException
12. What is the usage of containsAll() and retainAll() methods?
containsAll() returns true if the invoking collection contains all elements of the specified group.
Otherwise, returns false.
retainAll() removes all elements from the invoking collection except those of a specified group.
Returns true if the collection changed (i.e., elements were removed). Otherwise, returns false.
13. List any four methods of List interface.
void add(int index, E obj), E get(int index), E remove(int index), E set(int index, E obj)
14. What is the purpose of the NavigableSet interface in the Java Collections Framework.
The NavigableSet interface extends SortedSet and declares the behavior of a collection that
supports the retrieval of elements based on the closest match to a given value or values.
NavigableSet is a generic interface that has this declaration: interface NavigableSet<E>
Here, E specifies the type of objects that the set will hold.
15. How you can add or remove element to/from the first, last using LinkedList Class.
To add elements to the end of the list, use addLast( ) or offerLast( ).
To obtain the first element, you can use getFirst( ) or peekFirst( ).
To remove the first element, use removeFirst( ) or pollFirst( ).
To remove the last element, use removeLast( ) or pollLast( ).
16. Differentiate headset() and tailset() methods.
If you need the subset that starts with the first element in the set, use headSet( ). It returns a
SortedSet containing those elements less than end that are contained in the invoking sorted set.
If you want the subset that ends the set, use tailSet( ). It returns SortedSet that contains those
elements greater than or equal to start that are contained in the sorted set.
17. Differentiate poll() and remove() methods of Queue interface.
poll() returns the element at the head of the queue, removing the element in the process. It returns
null if the queue is empty.
remove() removes the element at the head of the queue, returning the element in the process. It
throws NoSuchElementException if the queue is empty.
18. List any four methods of deque interface.
E getFirst( ), E getLast( ), E peekFirst( ), E peekLast( )
19. What is the purpose of push() and pop() methods of Deque interface?
push(E obj) adds obj to the head of the deque. Throws an IllegalStateException if a capacity-
restricted deque is out of space.
pop() returns the element at the head of the deque, removing it in the process. It throws
NoSuchElementException if the deque is empty.
20. How does an ArrayList differ from standard arrays?
In Java, standard arrays are of a fixed length. After arrays are created, they cannot grow or shrink,
which means that you must know in advance how many elements an array will hold.
An ArrayList is a variable-length array of object references which can dynamically increase or
decrease in size. Array lists are created with an initial size. When this size is exceeded, the
collection is automatically enlarged. When objects are removed, the array can be shrunk.
21. What are the syntax/signatures of the two overloaded toArray() methods in the ArrayList
class?
object[ ] toArray( ) returns an array of Object.
<T> T[ ] toArray(T array[ ]) returns an array of elements that have the same type as T.
22. What is the difference between the HashSet() and HashSet(int capacity) constructors?
HashSet() constructs a default hashset. It creates an empty HashSet object with a default capacity of
16.
HashSet(int capacity) allows you to specify the initial capacity of the HashSet. The initial capacity
defines the initial size of the underlying hash table used by the set.
23. What is the purpose of the float fillRatio parameter in the HashSet(int capacity, float
fillRatio) constructor?
The fill ratio, also called load capacity, determines how full the hash set can be before it is resized
upward. The fill ratio must be between 0.0 and 1.0. Specifically, when the number of elements is
greater than the capacity of the hash set multiplied by its fill ratio, the hash set is expanded. For
constructors that do not take a fill ratio, 0.75 is used.
24. What is the primary advantage of using a TreeSet over other Set implementations like
HashSet?
TreeSet extends AbstractSet and implements the NavigableSet interface. It creates a collection that
uses a tree for storage. Objects are stored in sorted, ascending order. Access and retrieval times are
quite fast, which makes TreeSet an excellent choice when storing large amounts of sorted
information that must be found quickly.
25. What is the main difference between using a foreach loop and an Iterator to traverse the
elements of a Collection in Java?
Iterator enables you to cycle through a collection, obtaining or removing elements. If you won’t be
modifying the contents of a collection or obtaining elements in reverse order, then the for-each
version of the for loop is often a more convenient alternative to cycling through a collection than is
using an iterator.
26. What is the purpose of the RandomAccess interface in Java collections?
The RandomAccess interface contains no members. However, by implementing this interface, a
collection signals that it supports efficient random access to its elements. By checking for the
RandomAccess interface, client code can determine at run time whether a collection is suitable for
certain types of random access operations—especially as they apply to large collections.
27. How does a Map differ from a Collection in Java?
A Collection is a group of objects, known as its elements. In Collection, elements are stored as
individual objects. Each collection implements Iterator. Therfore, the elements of any collection
class can be accessed through the methods defined by Iterator.
A Map is an object that maps keys to values. In Map, elements are stored as key-value pairs. Map
don’t implement the Iterable interface. This means that you cannot cycle through a map using a for-
each style for loop.
28. List any four Map classes.
AbstractMap, EnumMap, HashMap, TreeMap

29. What is the purpose of using a Comparator with TreeSet and TreeMap in Java?
Both TreeSet and TreeMap store elements in sorted order. If you want to order elements a different
way, then specify a Comparator when you construct the set or map. Doing so gives you the ability
to govern precisely how plements are stored within sorted collections and maps.
30. List any four overloaded forms/signatures of the binarySearch() method with their proper
syntax.
static int binarySearch(byte array[ ], byte value)
static int binarySearch(char array[ ], char value)
static int binarySearch(float array[ ], float value)
static int binarySearch(int array[ ], int value)
31. Differentiate Vector and Arrays.
Vectors are dynamic in size. They can grow and shrink as needed when elements are added or
removed. They are synchronized, meaning they are thread-safe.
Arrays have a fixed size, which means you must specify the number of elements at the time of array
creation. They are not synchronized.
32. What is the relationship between the Dictionary class and the Map interface in Java?
Dictionary is an abstract class that represents a key/value storage repository and operates much like
Map. Given a key and value, you can store the value in a Dictionary object. Once the value is
stored, you can retrieve it by using its key. Thus, like a map, a dictionary can be thought of as a list
of key/value pairs. Although not currently deprecated, Dictionary is classified as obsolete, because
it is fully superseded by Map.

33. What are two advantages of using the MVC architecture in Java applications?
• Separation of Concerns: MVC promotes a clear separation of concerns between the model, view,
and controller components.
• Code Reusability: By separating the concerns into distinct components, code reuse becomes
more feasible.

34. What is Model-View-Controller?

The Model-View-Controller (MVC) architecture in Java is a design pattern that provides a
structured approach for developing applications. It separates the application’s concerns into three
main components: the model, the view, and the controller. Each component has a specific role and
responsibility within the architecture.
35. What are two responsibilities of the View component in MVC?
The view is responsible for rendering the user interface and displaying the data to the user. It
presents the data from the model to the user in a visually appealing and understandable way.
36. What are the primary roles of the Controller component in the MVC architecture?
The controller acts as an intermediary between the model and the view. It handles user input,
processes user actions, and updates the model or view accordingly. The controller interprets user
actions and triggers the appropriate methods in the model or view.
37. What are the responsibilities of the Model component in handling data and business logic?
The model represents the data and business logic of the application. It encapsulates the application’s
data and provides methods for accessing, manipulating, and updating that data. The model
component is independent of the user interface and focuses solely on the application’s functionality.

Long Answer Questions

1. Explain the benefits of Generics in Collections Framework?
• Generics ensure type safety by specifying the data type that a collection can hold.
• Generics eliminate the need for explicit casting when retrieving elements from a collection.
• Generics allow methods and classes to operate on any specified type, making code more flexible
and reusable.
• Many errors can be caught at compile time, leading to safer and more robust code.
• Generics make the intended use of collections clear, improving readability and understanding.
• Generics can slightly improve performance by eliminating the need for runtime type casting.

2. List any five methods of Collection interface with its purpose.

boolean add(E obj) Adds obj to the invoking collection. Returns true if obj was added to the
collection. Returns false if obj is already a member of the collection and
the collection does not allow duplicates.
boolean Returns true if the invoking collection and obj are equal. Otherwise,
contains(Object abj) returns false.
boolean isEmpty( ) Returns true if the invoking collection is empty. Otherwise, returns false.
void clear( ) Removes all elements from the invoking collection.
int size( ) Returns the number of elements held in the invoking collection.

3. What are the basic interfaces of Java Collections Framework? Discuss the appropriate use
of any four interfaces.
The Collections Framework defines several interfaces. They are Collection, List, NavigableSet,
Queue, Deque, Set, SortedSet.
Collection : The Collection interface is the foundation upon which the Collections Framework is
built because it must be implemented by any class that defines a collection. It is declared as:
interface Collection<E>
Here, E specifies the type of objects that the collection will hold.
List: The List interface extends Collection and declares the behavior of a collection that stores a
sequence of elements. Elements can be inserted or accessed by their position in the list, using this
declaration: interface List<E>
Here, E specifies the type of objects that the list will hold.
Queue: The Queue interface extends Collection and declares the behavior of a queue, which is
often a first-in, first-out list. It is declared as: interface SortedSet<E>
Here, E specifies the type of objects that the collection will hold.
Deque: The Deque interface extends Queue and declares the behavior of a double-ended queue.
Deque is a generic interface that has this declaration: interface Deque<E>

4. List any five methods of List interface with its purpose.

void add(int index, E obj) Inserts obj into the invoking list at the index passed in index. Any
preexisting elements at or beyond the point of insertion are shifted
up. Thus, no elements are overwritten.
E get(int index) Returns the object stored at the specified index within the invoking
collection.
E remove(int index) Removes the element at position index from the invoking list and
returns the deleted element. The indexes of subsequent elements are
decremented by one.
E set(int index, E obj) Assigns obj to the location specified by index within the invoking
list. Returns the old value.
int indexOf(Object obj) Returns the index of the first instance of obj in the invoking list. If
obj is not an element of the list, –1 is returned.

5. Explain any four methods defined by NavigableSet interface.

E ceiling(E obj) Searches the set for the smallest element e such that e >= obj. If such an
element is found, it is returned. Otherwise, null is returned.
E floor(E obj) Searches the set for the largest element e such that e <= obj. If such an
element is found, it is returned. Otherwise, null is returned.
E higher(E obj) Searches the set for the largest element e such that e > obj. If such an
element is found, it is returned. Otherwise, null is returned.
E lower(E obj) Searches the set for the largest element e such that e < obj. If such an
element is found, it is returned. Otherwise, null is returned.

6. List any five methods of Queue interface with its purpose.

E element( ) Returns the element at the head of the queue. The element is not removed.
It throws NoSuchElementException if the queue is empty.
boolean offer(E obj) Attempts to add obj to the queue. Returns true if obj was added and false
otherwise.
E peek( ) Returns the element at the head of the queue. It returns null if the queue is
empty. The element is not removed.
E poll( ) Returns the element at the head of the queue, removing the element in the
process. It returns null if the queue is empty.
E remove( ) Removes the element at the head of the queue, returning the element in
the process.
7. List any five methods of Deque interface with its purpose.
E getFirst( ) Returns the first element in the deque. The object is not removed from the
deque. It throws NoSuchElementException if the deque is empty.
E getLast( ) Returns the last element in the deque. The object is not removed from the
deque. It throws NoSuchElementException if the deque is empty.
E peekFirst( ) Returns the element at the head of the deque. It returns null if the deque is
empty. The object is not removed.
E peekLast( ) Returns the element at the tail of the deque. It returns null if the deque is empty.
The object is not removed.
E pop( ) Returns the element at the head of the deque, removing it in the process. It
throws NoSuchElementException if the deque is empty.
8. With an example explain the usage of ArrayList.
ArrayList class uses a dynamic array for storing the elements. It is like an array, but there is no size
limit. We can add or remove elements anytime. So, it is much more flexible than the traditional
array. The ArrayList in Java can have the duplicate elements also. It implements the List interface
so we can use all the methods of List interface here.
Example:
import java.util.*;
public class ArrayListExample1{
public static void main(String args[]){
ArrayList<String> list=new ArrayList<String>();
//Adding object in arraylist
list.add("Mango");
list.add("Apple");
list.add("Banana");
list.add("Grapes");
//Printing the arraylist object
System.out.println(list);
}
}
Output: [Mango, Apple, Banana, Grapes]
9. Write a Java program that demonstrates how to convert an ArrayList to an array using the
toArray() method.
import java.util.*;
class ArrayListToArray {
public static void main(String args[]) {
// Create an array list.
ArrayList<Integer> al = new ArrayList<Integer>();
// Add elements to the array list.
al.add(1);
al.add(2);
al.add(3);
al.add(4);
System.out.println("Contents of al: " + al);
// Get the array.
Integer a[] = new Integer[al.size()];
a = al.toArray(ia);
int sum = 0;
// Sum the array.
for(int i : a) sum += i;
System.out.println("Sum is: " + sum);
}}
Output: Contents of al: [1, 2, 3, 4]
Sum is: 10

10. Write a Java program that demonstrates the usage of the LinkedList class from the Java
Collections Framework.
import java.util.*;
class LinkedListDemo {
public static void main(String args[]) {
// Create a linked list.
LinkedList<String> ll = new LinkedList<String>();
// Add elements to the linked list.
ll.add("F"); ll.add("B"); ll.add("D"); ll.add("E"); ll.add("C");
ll.addLast("Z"); ll.addFirst("A"); ll.add(1, "A2");
 System.out.println("Original contents of ll: " + ll);
// Remove elements from the linked list.
ll.remove("F");
ll.remove(2);
System.out.println("Contents of ll after deletion: " + ll);
// Remove first and last elements.
ll.removeFirst();
ll.removeLast();
System.out.println("ll after deleting first and last: " + ll);
// Get and set a value.
String val = 11.get(2);
ll.set(2, val + " Changed");
System.out.println("ll after change: " + ll);
}
}
Output: Original contents of ll: [A, A2, F, B, D, E, C, Z]
Contents of ll after deletion: [A, A2, D, E, C, Z]
ll after deleting first and last: [A2, D, E, C]
ll after change: [A2, D, E Changed, C]
11. Explain four constructors of the HashSet class from the Java Collections Framework,
including their parameters.
HashSet( ) constructs a default hashset. It creates an empty HashSet object with a default capacity
of 16.
HashSet(Collection<? extends E> c) initializes the hash set by using the elements of c.
HashSet(int capacity) allows you to specify the initial capacity of the HashSet. The initial capacity
defines the initial size of the underlying hash table used by the set.
HashSet(int capacity, float fillRatio) initializes both the capacity and the fill ratio (also called load
capacity ) of the hash set from its arguments. The fill ratio must be between 0.0 and 1.0, and it
determines how full the hash set can be before it is resized upward. Specifically, when the number
of elements is greater than the capacity of the hash set multiplied by its fill ratio, the hash set is
expanded. For constructors that do not take a fill ratio, 0.75 is used.
12. What is an iterator? Explain with an example.
Each of the collection classes provides an iterator( ) method that returns an iterator to the start of the
collection. By using this iterator object, you can access each element in the collection, one element
at a time. In general, to use an iterator to cycle through the contents of a collection, follow these
steps:
i. Obtain an iterator to the start of the collection by calling the collection’s iterator( ) method.
ii. Setup a loop to make a call to hasNext( ).Have the loop iterate as long as hasNext( )returns true.
iii. Within the loop, obtain each element by calling next( ).
Example:
import java.util.*;
public class IteratorExample {
public static void main(String[] args) {
// Create an ArrayList of strings
ArrayList<String> list = new ArrayList<>();
list.add("Apple"); list.add("Banana"); list.add("Cherry"); list.add("Date");
// Get an iterator for the list
Iterator<String> i = list.iterator();
 // Use the iterator to traverse the list
while (i.hasNext()) {
String element = i.next();
System.out.println(element);
// Optionally remove an element during iteration
if (element.equals("Banana")) {
i.remove();
}
}
// Print the list after iteration
System.out.println("List after iteration and removal: " + list);
}
}

13. Explain the usage of the for-each loop in Java when working with collections. Compare
and contrast the for-each loop with the traditional approach of using an Iterator.
The for-each loop provides a concise and readable way to iterate over elements in a collection. It
simplifies the process of iterating through arrays and collections without the need for explicit
initialization, condition checking, or incrementing, making the code more readable and less error-
prone.
Feature for-each Loop Iterator
Syntax Concise More verbose
Readability More readable Less readable due to boilerplate code
Control Flow Limited control over collection Allows modification of collection structure
modification
Index Access No direct index access Can access element index using loop counter
Use Cases Simple iteration, focus on processing Complex iteration scenarios, modifying
elements collection

14. Explain how to store objects of user-defined classes in Java collections like ArrayList.
For the sake of simplicity, the foregoing examples have stored built-in objects, such as String or
Integer, in a collection. Of course, collections are not limited to the storage of built-in objects. Quite
the contrary. The power of collections is that they can store any type of object, including objects of
classes that you create.
Example:
public class Person {
private String name;
private int age;

public Person(String name, int age) {

this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
 public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class ArrayListExample {
public static void main(String[] args) {
ArrayList<Person> people = new ArrayList<>();
Person person1 = new Person("Alice", 30);
Person person2 = new Person("Bob", 25);
people.add(person1);
people.add(person2);
for (Person person : people) {
System.out.println(person.getName() + " (" + person.getAge() + ")");
}}}

15. Write how Vector is differ from ArrayList.

16. Write the usage of any four methods of Map interface.

void clear( ) Removes all key/value pairs from the invoking map.
boolean containsKey(Object k) Returns true if the invoking map contains k as a key.
Otherwise, returns false.
boolean containsValue(Object v) Returns true if the map contains v as a value. Otherwise,
returns false.
boolean isEmpty( ) Returns true if the invoking map is empty. Otherwise, returns
false.

17. What is a map?

A map is an object that stores associations between keys and values, or key/value pairs. Given a
key, you can find its value. Both keys and values are objects. The keys must be unique, but the
values may be duplicated. Some maps can accept a null key and null values, others cannot.
Map is generic and is declared as shown here:
interface Map<K,V>
Here, K specifies the type of keys, and V specifies the type of values.
18. Write a Java program that demonstrates the usage of the HashMap class from the Java
Collections Framework.
import java.util.*;
class HashMapDemo {
public static void main(String args[]) {
// Create a hash map.
HashMap<String, Double> hm = new HashMap<String, Double>();
// Put elements to the map
hm.put("John Doe", new Double(3434.34));
hm.put("Tom Smith", new Double(123.22));
// Get a set of the entries.
Set<Map.Entry<String, Double>> set = hm.entrySet();
// Display the set.
for(Map.Entry<String, Double> me : set) {
System.out.print(me.getKey() + ": ");
System.out.println(me.getValue());
}
System.out.println();
// Deposit 1000 into John Doe's account.
double balance = hm.get("John Doe");
hm.put("John Doe", balance + 1000);
System.out.println("John Doe's new balance: " +hm.get("John Doe"));
}}
Output: John Doe: 3434.34
Tom Smith: 123.22
John Doe's new balance: 4434.34

19. Write a Java program that demonstrates the usage of a custom Comparator for sorting
strings in reverse order.
import java.util.*;
class MyComp implements Comparator<String> {
public int compare(String a, String b) {
return a.compareTo(b); // Reverse the comparison.
}}
class Demo {
public static void main(String args[]) {
TreeSet<String> ts = new TreeSet<String>(new MyComp()); //TreeSet
ts.add("C");
ts.add("A");
ts.add("B");
ts.add("E");
ts.add("F");
ts.add("D");
for(String element : ts)
System.out.print(element + " "); // Display the elements.
System.out.println();
}}
As the following output shows, the tree is now stored in reverse order: F E DC BA
20. Write the usage of any 4 collection algorithms.
Collections.sort : The sort method sorts the elements of a list into their natural order or according to
a specified comparator.
Collections.binarySearch : The binarySearch method searches for a specified element in a sorted list
and returns the index of the element. The list must be sorted before performing the binary search.
Collections.shuffle : The shuffle method randomly permutes the elements of a list. This can be
useful for tasks like creating a deck of cards or randomizing elements.
Collections.max and Collections.min : The max and min methods find the maximum and minimum
elements in a collection according to their natural order or a specified comparator.
21. Write a program to convert a given array into a collection with the asList() method.
The asList() method returns a List that is backed by a specified array. Both the list and the array
refer to the same location.
import java.util.*;
public class ArrayToCollection {
public static void main(String[] args) {
// Given array
Integer[] array = {1, 2, 3, 4, 5};
// Convert array to a collection
List<Integer> list = Arrays.asList(array);
// Print the collection
System.out.println("Collection from array: " + list);
}
}
22. Explain any four legacy methods of vector.
void addElement(E element) The object specified by element is added to the vector.
int capacity( ) Returns the capacity of the vector.
Object clone( ) Returns a duplicate of the invoking vector.
E elementAt(int index) Returns the element at the location specified by index.
E firstElement( ) Returns the first element in the vector.

23. Explain the roles and responsibilities of the Model, View, and Controller components in
the MVC architecture.
• Model: The model represents the data and business logic of the application. It encapsulates the
application’s data and provides methods for accessing, manipulating, and updating that data. The
model component is independent of the user interface and focuses solely on the application’s
functionality.
• View: The view is responsible for rendering the user interface and displaying the data to the user.
It presents the data from the model to the user in a visually appealing and understandable way. The
view component does not contain any business logic but instead relies on the model for data.
• Controller: The controller acts as an intermediary between the model and the view. It handles
user input, processes user actions, and updates the model or view accordingly. The controller
interprets user actions and triggers the appropriate methods in the model or view. It ensures the
separation of concerns by keeping the view and mode independent of each other.
24. Explain the flow of execution when a user interacts with an MVC-based Java web
application. Walk through the steps involved, starting from the user's request, the role of the
controller, the interaction with the model and view, and finally, the response sent back to the
user.
In Java programming, the Model comprises basic Java classes that encapsulate data and business
logic. The View is responsible for presenting the data to the user interface, while the Controller
consists of servlets that handle user requests. This clear separation of components enables the
following processing flow for user requests:

In the context of the server-client architecture, the process of handling a page request can be
described as follows:
A client, typically a web browser, initiates a request and sends it to the server-side controller.
The controller receives the request and interacts with the model component. It retrieves the
necessary data from the model, which may involve processing and manipulating the data as
required.
Once the controller has gathered the requested data, it transfers this data to the view layer.
The view layer, utilizing the provided data, generates the appropriate output or representation of
the requested page. Finally, the generated result is sent back to the client’s browser, completing the
request-response cycle.