AJAY KUMAR GARG ENGINEERING COLLEGE

IT DEPARTMENT
SUB: OOPS WITH JAVA SUB CODE: BCS 403
QUESTION BANK
Q1. What is the difference between an Inner Class and a Sub-Class.

Ans: An Inner class is a class which is nested within another class. An Inner class has access
rights for the class which is nesting it and it can access all variables and methods defined in the
outer class .A sub-class is a class which inherits from another class called super class. Sub-class
can access all public and protected methods and fields of its super class.

Q2. What are the various access specifiers for Java classes.

Ans: In Java, access specifiers are the keywords used before a class name which defines the
access scope. The types of access specifiers for classes are:
1.Public: Class,Method,Field is accessible from anywhere.
2.Protected: Method, Field can be accessed from the same class to which they belong or from the
sub-classes ,and from the class of same package, but not from outside.
3.Default: Method, Field, class can be accessed only from the same package and not
from outside of its native package.
4. Private: Method, Field can be accessed from the same class to which they belong.

Q3. What's the purpose of Static methods and static variables.

Ans: When there is a requirement to share a method or a variable between multiple objects of a
class instead of creating separate copies for each object, we use static keyword to make a method
or variable shared for all objects.

Q4. What is data encapsulation and what's its significance.

Ans: Encapsulation is a concept in Object Oriented Programming for combining properties and
methods in a single unit .Encapsulation helps programmers to follow a modular approach for
software development as each object has its own set of methods and variables and serves its
functions independent of other objects. Encapsulation also serves data hiding purpose.

Q5. What is a singleton class? Give a practical example of its usage.

A singleton class in java can have only one instance and hence all its methods and variables
belong to just one instance. Singleton class concept is useful for the situations when there is a
need to limit the number of objects for a class.
Q6. What’s the difference between an Abstract Class and Interface in Java.

Ans: The primary difference between an abstract class and interface is that an interface can only
possess declaration of public static methods with no concrete implementation while an abstract
class can have members with any access specifiers (public, private etc) with or without concrete
implementation. Another key difference in the use of abstract classes and interfaces is that a class
which implements an interface must implement all the methods of the interface while a class
which inherits from an abstract class doesn’t require implementation of all the methods of
Its super class.

Q7. Is Java Platform Independent if then how.

Yes, Java is a Platform Independent language. Unlike many programming languages javac
compiler compiles the program to form a bytecode or .class file. This file is independent of the
software or hardware running but needs a JVM(Java Virtual Machine) file preinstalled in the
operating system for further execution of the bytecode.
Although JVM is platform dependent, the bytecode can be created on any System and can be
executed in any other system despite hardware or software being used which makes Java
platform independent.

Q8. Difference between JVM, JRE, and JDK.

JVM: JVM also known as Java Virtual Machine is a part of JRE. JVM is a type of interpreter
responsible for converting bytecode into machine-readable code. JVM itself is platform
dependent but it interprets the bytecode which is the platform-independent reason why Java is
platform-independent.
JRE: JRE stands for Java Runtime Environment, it is an installation package that provides an
environment to run the Java program or application on any machine.
JDK: JDK stands for Java Development Kit which provides the environment to develop and
execute Java programs. JDK is a package that includes two things Development Tools to provide
an environment to develop your Java programs and, JRE to execute Java programs or
applications.

Q9. Explain public static void main(String args[]) in Java.

Unlike any other programming language like C, C++, etc. In Java, we declared the main function
as a public static void main (String args[]). The meanings of the terms are mentioned below:
1. public: the public is the access modifier responsible for mentioning who can access
the element or the method and what is the limit. It is responsible for making the main
function globally available. It is made public so that JVM can invoke it from outside
the class as it is not present in the current class.
2. static: static is a keyword used so that we can use the element without initiating the
class so to avoid the unnecessary allocation of the memory.
3. void: void is a keyword and is used to specify that a method doesn’t return anything.
As the main function doesn’t return anything we use void.
4. main: main represents that the function declared is the main function. It helps JVM to
identify that the declared function is the main function.
5. String args[]: It stores Java command-line arguments and is an array of type
java.lang.String class.

Q10. What will happen if we declare don’t declare the main as static.
We can declare the main method without using static and without getting any errors. But, the
main method will not be treated as the entry point to the application or the program.

Q11) Write a Java program that throws an exception and catch it using a try-catch block.
Ans) public class Exception_Example {
public static void main(String[] args) {
try {
int result = divideNumbers(5, 0);
System.out.println("Result: " + result);
} catch (ArithmeticException e) {
System.out.println("Error: " + e.getMessage());
}
}
public static int divideNumbers(int dividend, int divisor) {
if (divisor == 0) {
throw new ArithmeticException("Cannot divide the given number by zero!");
}
return dividend / divisor;
}
}
Q12) Write a Java program to create a method that reads a file and throws an exception if
the file is not found.
Ans) import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class File_Read {

public static void main(String[] args) {
try {
readFile("test1.txt");
} catch (FileNotFoundException e) {
System.out.println("Error: " + e.getMessage());
}
}

public static void readFile(String fileName) throws FileNotFoundException {

File file = new File(fileName);
Scanner scanner = new Scanner(file);

// Read and process the contents of the file

while (scanner.hasNextLine()) {
String line = scanner.nextLine();
System.out.println(line);
}

scanner.close();
}
}
Q13) what is Exception handling.
Ans) An exception is an error event that can happen during the execution of a program and
disrupts its normal flow. The exception can arise from different kinds of situations such as wrong
data entered by the user, hardware failure, network connection failure, etc. Whenever any error
occurs while executing a java statement, an exception object is created, and then JRE tries to find
an exception handler to handle the exception. If a suitable exception handler is found then the
exception object is passed to the handler code to process the exception, known as catching the
exception. If no handler is found then the application throws the exception to the runtime
environment and JRE terminates the program. Java Exception handling framework is used to
handle runtime errors only, compile-time errors are not handled by exception handling
framework.

Q14) what are exception handling techniques in java.

Ans) There are four keywords used in java exception handling.
throw: Sometimes we explicitly want to create an exception object and then throw it to halt the
normal processing of the program. The throw keyword is used to throw exceptions to the runtime
to handle it.
throws: When we are throwing any checked exception in a method and not handling it, then we
need to use the throws keyword in the method signature to let the caller program know the
exceptions that might be thrown by the method. The caller method might handle these exceptions
or propagate them to its caller method using the throws keyword. We can provide multiple
exceptions in the throws clause and it can be used with the main() method also.
try-catch: We use try-catch block for exception handling in our code. try is the start of the block
and catch is at the end of the try block to handle the exceptions. We can have multiple catch
blocks with a try and try-catch blocks can be nested also. catch block requires a parameter that
should be of type Exception.
finally: The finally block is optional and can be used only with a try-catch block. Since exception
halts the process of execution, we might have some resources open that will not get closed, so we
can use the finally block. The finally block gets executed always, whether an exception occurs or
not.

Q15) what are the important methods of java Exception class.

Ans) Exception and all of its subclasses don’t provide any specific methods and all of the
methods are defined in the base class Throwable.
String getMessage() - This method returns the message String of Throwable and the message can
be provided while creating the exception through its constructor.
String getLocalizedMessage() - This method is provided so that subclasses can override it to
provide the locale-specific messages to the calling program. Throwable class implementation of
this method simply use getMessage() method to return the exception message.
synchronized Throwable getCause() - This method returns the cause of the exception or null if
the cause is unknown.
String toString() - This method returns the information about Throwable in String format, the
returned String contains the name of Throwable class and localized message.
void printStackTrace() - This method prints the stack trace information to the standard error
stream, this method is overloaded and we can pass PrintStream or PrintWriter as an argument to
write the stack trace information to the file or stream.

Q16) what is the difference between checked and unchecked exception.

Ans) Checked Exceptions should be handled in the code using try-catch block or else the method
should use the throws keyword to let the caller know about the checked exceptions that might be
thrown from the method. Unchecked Exceptions are not required to be handled in the program or
to mention them in the throws clause of the method.
Exception is the superclass of all checked exceptions whereas RuntimeException is the
superclass of all unchecked exceptions. Note that RuntimeException is the child class of
Exception.
Checked exceptions are error scenarios that require to be handled in the code, or else you will get
compile time error. For example, if you use FileReader to read a file, it
throws FileNotFoundException and we must catch it in the try-catch block or throw it again to
the caller method. Unchecked exceptions are mostly caused by poor programming, for example,
NullPointerException when invoking a method on an object reference without making sure that
it’s not null. For example, I can write a method to remove all the vowels from the string. It’s the
caller’s responsibility to make sure not to pass a null string.

Q17) How to write custom exception in java.

Ans) We can extend Exception class or any of its subclasses to create our custom exception class.
The custom exception class can have its own variables and methods that we can use to pass error
codes or other exception-related information to the exception handler.
package com.journaldev.exceptions;

import java.io.IOException;

public class MyException extends IOException {

 private static final long serialVersionUID = 4664456874499611218L;

private String errorCode="Unknown_Exception";

public MyException(String message, String errorCode){

super(message);
this.errorCode=errorCode;
}

public String getErrorCode(){

return this.errorCode;
}

Q18) what is the concept of Byte stream and Character Stream in Java. How reading and
writing files will be done.
Ans) A stream is a way of sequentially accessing a file. A byte stream access the file byte by
byte. A byte stream is suitable for any kind of file, however not quite appropriate for text files.
For example, if the file is using a unicode encoding and a character is represented with two
bytes, the byte stream will treat these separately and you will need to do the conversion yourself.

A character stream will read a file character by character. A character stream needs to be given
the file's encoding in order to work properly.

Programs use byte streams to perform input and output of 8-bit bytes. All byte stream classes are
descended from InputStream and OutputStream.
The java.io package is used for file handling in Java. It provides various classes for handling
files, such as File, FileReader, FileWriter, FileInputStream, and FileOutputStream.

Q19) Differentiate between process and thread.

Ans) A Program in the execution is called the process whereas; A thread is a subset of the
process

● Processes are independent whereas threads are the subset of process.

● Process have different address space in memory, while threads contain a shared address
space.
● Context switching is faster between the threads as compared to processes.
● Inter-process communication is slower and expensive than inter-thread communication.
● Any change in Parent process doesn't affect the child process whereas changes in parent
thread can affect the child thread.

Q20) what are the states in the lifecycle of a Thread.

A thread can have one of the following states during its lifetime:

1. New: In this state, a Thread class object is created using a new operator, but the thread is
not alive. Thread doesn't start until we call the start() method.
2. Runnable: In this state, the thread is ready to run after calling the start() method.
However, the thread is not yet selected by the thread scheduler.
3. Running: In this state, the thread scheduler picks the thread from the ready state, and the
thread is running.
4. Waiting/Blocked: In this state, a thread is not running but still alive, or it is waiting for
the other thread to finish.
5. Dead/Terminated: A thread is in terminated or dead state when the run() method exits.

Q21) What are Java functional interfaces, and how do they contribute to the paradigm
shift towards functional programming within the Java ecosystem.
In Java, a functional interface is an interface that contains only one abstract method. These
interfaces facilitate the implementation of lambda expressions, which are concise representations
of anonymous functions. Java's functional interfaces are annotated with the
@FunctionalInterface annotation, which ensures that they abide by the single abstract method
constraint.
@FunctionalInterface Annotation: While not strictly required, it's a good practice to annotate
functional interfaces with @Functional Interface. This annotation ensures that the interface has
only one abstract method. If you accidentally add another abstract method to an interface
annotated with @FunctionalInterface, the compiler will raise an error.
Purpose: Functional interfaces serve as the cornerstone for leveraging functional programming
concepts within Java. By enabling the use of lambda expressions, they allow developers to write
more expressive, concise, and readable code.
Contributions to Functional Programming: Java's adoption of functional interfaces marks a
significant step towards embracing functional programming paradigms. Functional programming
emphasizes the use of pure functions, immutability, and higher-order functions. While Java
remains primarily an object-oriented language, the incorporation of functional interfaces enables
developers to apply functional programming principles where appropriate, promoting cleaner
and more modular code.
Lambda Expressions and Stream API: Functional interfaces are closely intertwined with
lambda expressions, which provide a concise syntax for defining anonymous functions. Lambda
expressions, in conjunction with functional interfaces, form the backbone of Java's Stream API.
Streams enable developers to process collections of data in a functional style, facilitating
operations such as mapping, filtering, and reducing with ease and efficiency.
Parallelism and Concurrency: The functional programming paradigm encourages stateless
operations and immutability, which inherently support parallelism and concurrency. Java's
functional interfaces, when combined with parallel streams, empower developers to exploit
multicore processors effectively, thereby enhancing the performance of their applications.
Enhanced Expressiveness and Readability: By leveraging functional interfaces and lambda
expressions, developers can express their intent more clearly and concisely. This leads to code
that is easier to understand, maintain, and reason about. Functional programming constructs
encourage declarative rather than imperative programming styles, resulting in code that focuses
on what needs to be done rather than how it should be done.
Q22) what is functional interface. Explain with suitable example.
A functional interface in Java is an interface that contains exactly one abstract method. It may
contain any number of default methods or static methods, but it must have only one abstract
method.
@FunctionalInterface
interface Calculator {
int calculate(int a, int b);
}
@FunctionalInterface annotation ensures that Calculator is indeed a functional interface. While
this annotation is not mandatory, it's good practice to use it for clarity and to prevent accidental
addition of more abstract methods.
Calculator interface has a single abstract method calculate that takes two integer parameters a
and b and returns an integer result.
We can provide different implementations of the calculate method using lambda expressions.
Here's how we can use the Calculator functional interface with lambda expressions:
public class Main {
public static void main(String[] args) {
// Addition using lambda expression
Calculator addition = (a, b) -> a + b;
int sum = addition.calculate(5, 3); // Output: 8
System.out.println("Sum: " + sum);

// Subtraction using lambda expression

Calculator subtraction = (a, b) -> a - b;
int difference = subtraction.calculate(10, 5); // Output: 5
System.out.println("Difference: " + difference);
}
}
Q23) what is Lambda expression, what is purpose of this in java.
A lambda expression in Java is a concise way to represent an anonymous function—a function
without a name that can be passed around as a parameter to other methods or stored in variables.
Purpose:
The primary purpose of lambda expressions in Java is to enable the implementation of functional
interfaces, which serve as the foundation for functional programming constructs within the
language.
Key Benefits and Purposes of Lambda Expressions:

Conciseness: Lambda expressions allow you to express behavior more concisely compared to
traditional anonymous inner classes. They help reduce boilerplate code, making the code base
more readable and maintainable.
Expressiveness: Lambda expressions enhance code expressiveness by enabling developers to
focus on the what (the behavior) rather than the how (the implementation details). This leads to
more declarative and understandable code.

Flexibility: Lambda expressions provide a flexible way to pass behavior as an argument to

methods or store it in variables. This enables the use of higher-order functions, which can accept
other functions as parameters or return functions as results.

Readability: Lambda expressions often result in more readable code, especially when used in
conjunction with functional interfaces. They can make the code more self-explanatory by clearly
indicating the intention behind certain operations.

Functional Programming Paradigm: Lambda expressions play a crucial role in promoting

functional programming paradigms within Java. They facilitate the adoption of functional
programming concepts such as higher-order functions, immutability, and function composition.

Stream API: Lambda expressions are extensively used in Java's Stream API, which provides a
powerful way to process collections of data in a functional style. Streams enable operations such
as mapping, filtering, and reducing, and lambda expressions are used to specify the behaviour for
these operations succinctly.

Q24) Explain Lambda expression with suitable example.

import java.util.ArrayList;
import java.util.List;

public class Main {

public static void main(String[] args) {
// List of strings
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
 names.add("Charlie");
names.add("David");

// Sorting the list alphabetically using lambda expression

names.sort((String s1, String s2) -> s1.compareTo(s2));

// Printing the sorted list

System.out.println("Sorted Names:");
for (String name : names) {
System.out.println(name);
}
}
}

Q25) Explain the concept of Base64 encoding and decoding in detail, covering its purpose,
principles, and applications in computer science and beyond.

Introduction to Base64 Encoding and Decoding:

Base64 encoding is a method used to encode binary data into ASCII characters, making it
suitable for transmission over protocols that require text data. Conversely, Base64 decoding is
the process of converting encoded Base64 data back to its original binary form. This encoding
scheme is widely used in various applications, including email systems, web technologies,
cryptography, and data storage.
Principles of Base64 Encoding:
Base64 encoding works by dividing binary data into groups of 6 bits, which are then represented
using a set of 64 ASCII characters. Each group of 6 bits corresponds to one of the 64 characters,
resulting in a compact representation of binary data as text. The padding character '=' is often
added to ensure that the length of the encoded data is a multiple of 4, facilitating proper
decoding.
Purpose of Base64 Encoding and Decoding:
The primary purpose of Base64 encoding and decoding is to enable the transmission of binary
data over text-based channels, such as email, XML, or HTTP headers, where only ASCII
characters are allowed. By converting binary data to a text format, Base64 ensures that it can be
safely transmitted without loss of information or corruption.
Advantages of Base64 Encoding:
Compatibility: Base64 encoding allows binary data to be transmitted over channels that only
support text data, ensuring compatibility with various protocols and systems.
Data Integrity: Base64 encoding preserves the integrity of binary data during transmission, as it
can accurately represent all possible byte values without loss.
Text Representation: Encoded Base64 data consists of printable ASCII characters, making it
human-readable and suitable for inclusion in textual documents or messages.

Applications of Base64 Encoding and Decoding:

Email Attachments: Base64 encoding is commonly used to encode email attachments, such as
images or documents, for transmission over SMTP servers.

Data URI Scheme: In web development, Base64 encoding is employed to embed binary data,
such as images or fonts, directly into HTML or CSS files using the data URI scheme.

Authentication Tokens: Base64 encoding is utilized in authentication mechanisms, such as Basic

Authentication, where credentials are encoded as Base64 strings in HTTP headers.

Cryptography: Base64 encoding is employed in cryptographic algorithms and protocols to

represent binary data, such as cryptographic keys or digital signatures, in a human-readable
format.

Q26) what is for-each method in java. Explain with suitable example.

The forEach method in Java is a convenient way to iterate over elements in a collection (like
lists, sets, or maps) and perform an operation on each element.
Syntax:
void forEach(Consumer<? super T> action)
Here, action represents the operation to be performed on each element, and Consumer is a
functional interface with a single abstract method, accept, that takes one argument and returns no
result.

Suppose we have a list of strings, and we want to print each element of the list using the forEach
method:
import java.util.ArrayList;
import java.util.List;

public class Main {

public static void main(String[] args) {
// Create a list of strings
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");
names.add("David");

// Using forEach to print each element of the list

names.forEach(name -> System.out.println(name));
}
}

Q27) Explain try-with-resource with suitable example.

The try-with-resources statement in Java is used to automatically close resources that are opened
within its scope. This ensures that the resources are closed properly, regardless of whether an
exception occurs during their use.
Syntax:
try (resource initialization) {
// code that uses the resource
} catch (ExceptionType e) {
// exception handling
}

Suppose we have a file that we want to read using BufferedReader. With try-with-resources, we
can ensure that the file is closed properly after reading, even if an exception occurs.
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class Main {

public static void main(String[] args) {
// Specify the file path
String filePath = "example.txt";

// Using try-with-resources to open and read the file

try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

Q28) Explain switch expression in java with suitable example.

Switch expressions in Java provide a more concise and expressive way to write switch
statements, especially when dealing with complex conditions or multiple cases. Introduced as a
preview feature in Java 12 and made a standard feature in Java 14, switch expressions allow you
to use switch as an expression rather than just a statement
Syntax:
result = switch (expression) {
case value1 -> expression1;
case value2 -> expression2;
// more cases
default -> defaultExpression;
};
Example: We want to assign a message based on the day of the week using a switch
expression:
public class Main {
public static void main(String[] args) {
int day = 3;
String message = switch (day) {
case 1 -> "Monday";
case 2 -> "Tuesday";
case 3 -> "Wednesday";
case 4 -> "Thursday";
case 5 -> "Friday";
default -> throw new IllegalArgumentException("Invalid day: " + day);
};
System.out.println("Message: " + message);
}
}

Q29) What is local variable type inference in java.

Local variable type inference, introduced in Java 10, allows you to declare local variables
without explicitly specifying their type. Instead, the compiler infers the type of the variable based
on the initializer expression used to initialize it. This feature is also known as "var" type.
Syntax:
var variableName = initializerExpression;

Here, var is a reserved keyword indicating that the type of the variable will be inferred by the
compiler. variableName is the name of the variable, and initializerExpression is the expression
used to initialize the variable.
Consider the following example:
var message = "Hello, world!";

In this example, the type of the variable message is inferred to be String based on the initializer
expression "Hello, world!".
Benefits of Local Variable Type Inference:
Conciseness: Local variable type inference reduces boilerplate code by allowing you to omit
explicit type declarations, making the code more concise and readable.
Flexibility: It allows you to focus on the intent of the code rather than the specific types,
enhancing code readability and maintainability.
Compatibility: It is backward-compatible with existing code, as it does not introduce any
changes to the underlying type system or bytecode representation.
Encapsulation: It encourages encapsulation by reducing the visibility of implementation details,
as the type of the variable is inferred locally and does not need to be exposed.

Q30) Explain inner anonymous class in Java with suitable example.

An inner anonymous class in Java is a class that is declared and instantiated at the same time,
typically within the body of another class or method. Anonymous inner classes are useful when
you need to implement a simple interface or extend a class and don't want to create a separate
named class for it.
Syntax:
Anonymous inner classes are declared and instantiated using the following syntax:
For implementing an interface:
InterfaceName obj = new InterfaceName() {
// Method implementations
};
For extending a class:
ClassName obj = new ClassName() {
// Method implementations
};
Example : Implementing an Interface with Anonymous Inner Class:
Suppose we have a Runnable interface and want to create a thread using an anonymous inner
class.
public class Main {
public static void main(String[] args) {
// Using anonymous inner class to implement Runnable interface
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("Hello from anonymous inner class!");
}
};
// Creating and starting a thread with the anonymous inner class
Thread thread = new Thread(runnable);
thread.start();
}
}

Q31) what is java Collection framework? List out some benefits of collection framework
and Explain it.
1. The Java Collections
Framework is a set of classes
and interfaces that provide a
2. unified way to store and
manipulate collections of
objects in Java. The
Collections
3. Framework includes classes
for representing different
types of collections, such as
4. lists, sets, and maps. It also
includes classes for
performing operations on
5. collections, such as sorting,
searching, and iterating.
Collections are used in every programming language and initial java release contained few
classes for collections: Vector, Stack, Hashtable, Array. But looking at the larger scope and
usage, Java 1.2 came up with Collections Framework that group all the collections interfaces,
implementations and algorithms. Java Collections have come through a long way with the usage
of Generics and Concurrent Collection classes for thread-safe operations. It also includes
blocking interfaces and their implementations in java concurrent package. Some of the benefits
of collections framework are;
Reduced development effort by using core collection classes rather than implementing our own
collection classes.
Code quality is enhanced with the use of well tested collections framework classes.
Reduced effort for code maintenance by using collection classes shipped with JDK.
Reusability and Interoperability

The Java Collections

Framework is a set of classes
and interfaces that provide a
unified way to store and
manipulate collections of
objects in Java. The
Collections
Framework includes classes
for representing different types
of collections, such as
lists, sets, and maps. It also
includes classes for
performing operations on
collections, such as sorting,
searching, and iterating.
The Java Collection Framework is a set of classes and interfaces that implement commonly
reusable collection data structures. It provides the architecture to store and manipulate a group of
objects in a standard way. The framework includes implementations for various types of
collections such as lists, sets, and maps, and provides algorithms for sorting, searching, and
manipulating collections.
Benefits of the Java Collection Framework
1. Unified Architecture:
o Consistent API: All collections in the framework implement standard interfaces, which
provides a uniform way to work with different types of collections.
o Interoperability: Since collections implement common interfaces, they can be used
interchangeably, making the code more flexible and reusable.
2. Reduces Programming Effort:
o Reusable Data Structures: The framework provides standard implementations for
common data structures (e.g., ArrayList, LinkedList, HashSet, TreeSet, HashMap,
TreeMap), so developers don’t need to implement these themselves.
o Pre-built Algorithms: The framework includes utility classes like Collections and
Arrays that provide methods for sorting, searching, and manipulating collections.
3. Increases Program Speed and Quality:
 o Optimized Implementations: The collection classes are highly optimized, providing
better performance than custom implementations.
o Exception Handling: The framework provides runtime exception handling, which helps in
identifying programming errors quickly.
4. Reduces Effort to Learn New APIs:
o Standard Interfaces: Once you learn the interfaces, you can use any of the collection
classes that implement these interfaces without learning new APIs.
5. Encapsulation:
o Data Abstraction: The framework allows for the abstraction of data structures and
algorithms, making it easier to change the underlying implementation without affecting
the code that uses the collections.

Key Components of the Java Collection Framework

1. Interfaces:
o Collection: The root interface for all collections.
o List: Ordered collection (e.g., ArrayList, LinkedList).
o Set: Unordered collection that does not allow duplicates (e.g., HashSet, TreeSet).
o Queue: Collection used to hold multiple elements prior to processing (e.g.,
PriorityQueue, LinkedList).
o Map: Object that maps keys to values (e.g., HashMap, TreeMap).
2. Classes:
o ArrayList: Resizable array implementation of the List interface.
o LinkedList: Doubly-linked list implementation of the List and Deque interfaces.
o HashSet: Hash table-based implementation of the Set interface.
o TreeSet: Sorted tree-based implementation of the Set interface.
o HashMap: Hash table-based implementation of the Map interface.
o TreeMap: Red-Black tree-based implementation of the Map interface.
3. Algorithms:
o Sorting: Methods to sort collections (e.g., Collections.sort(), Arrays.sort()).
o Searching: Methods to search elements within collections (e.g.,
Collections.binarySearch()).
o Shuffling and Randomizing: Methods to shuffle or randomize elements (e.g.,
Collections.shuffle()).

Example Usage

import java.util.*;

public class CollectionFrameworkExample {

public static void main(String[] args) {

 // List Example

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

list.add("Apple");

list.add("Banana");

list.add("Cherry");

Collections.sort(list);

System.out.println("Sorted List: " + list);

// Set Example

Set<String> set = new HashSet<>();

set.add("Apple");

set.add("Banana");

set.add("Apple"); // Duplicate element

System.out.println("Set: " + set);

// Map Example

Map<String, Integer> map = new HashMap<>();

map.put("Apple", 1);

map.put("Banana", 2);

System.out.println("Map: " + map);

}
In this example, a List is used to store and sort elements, a Set is used to store unique elements, and a
Map is used to store key-value pairs. The Java Collection Framework makes it easy to perform these
common operations with minimal effort.

Q32) what is difference between ArrayList and LinkedList in collection framework.

Explain.

Ans: In Java, both ArrayList and LinkedList implement the List interface, but they have
different underlying data structures and performance characteristics.
ArrayList
Underlying Data Structure

● ArrayList is backed by a dynamically resizable array.

Performance Characteristics

● Access Time: O(1) - Direct access using index.

● Insertion/Deletion: O(n) - Adding or removing elements in the middle of the list requires shifting
elements.
● Memory Consumption: Less overhead compared to LinkedList as it only stores data elements
and not node pointers.

Use Case

● Best suited for applications where frequent access to elements via index is required.
● Ideal for read-heavy operations where the list size is relatively stable.

Example

List<String> arrayList = new ArrayList<>();

arrayList.add("Apple");

arrayList.add("Banana");

arrayList.add("Cherry");

System.out.println(arrayList.get(1)); // Access element at index 1

LinkedList
Underlying Data Structure

● LinkedList is implemented as a doubly linked list where each element is a node containing data
and pointers to the previous and next nodes.
Performance Characteristics

● Access Time: O(n) - Requires traversal from the beginning or end of the list to access elements.
● Insertion/Deletion: O(1) - Adding or removing elements from the beginning or end of the list is
efficient; in the middle, it requires traversal but no shifting.
● Memory Consumption: More overhead due to storing pointers to next and previous nodes.

Use Case

● Best suited for applications where frequent insertion and deletion of elements occur, especially
at the beginning or end of the list.
● Ideal for write-heavy operations where the list size changes frequently.

Example

List<String> linkedList = new LinkedList<>();

linkedList.add("Apple");

linkedList.add("Banana");

linkedList.add("Cherry");

System.out.println(linkedList.get(1)); // Access element at index 1

Summary of Differences
Feature ArrayList LinkedList

Data Structure Dynamic array Doubly linked list

Access Time O(1) for random access O(n) for random access

Insertion/Deletion O(n) for middle operations (requires O(1) for middle operations (no shifting,
Time shifting) just pointer updates)

Memory Usage Less overhead More overhead (due to pointers)

Best for read-heavy scenarios with Best for write-heavy scenarios with
Use Case
infrequent insertions/deletions frequent insertions/deletions

Choosing Between ArrayList and LinkedList

● Use ArrayList when you need fast random access and your application does not require frequent
insertion/deletion operations.
● Use LinkedList when you need efficient insertion and deletion operations, especially at the
beginning or end of the list, and random access is less critical.
Q33) Discuss differences between HashList and HashMap, Set and List.

Ans: In Java, HashMap, HashSet, and List are commonly used data structures with distinct
characteristics and use cases. Here's a detailed comparison:
HashMap
Description

● HashMap is an implementation of the Map interface.

● It stores key-value pairs where each key is unique, and each key maps to exactly one value.

Key Features

● No Order: Does not guarantee any order of the keys or values.

● Null Values: Allows one null key and multiple null values.
● Efficiency: Provides O(1) average time complexity for insertion, deletion, and retrieval
operations.

Use Case

● Best suited for scenarios where you need to associate unique keys with specific values and
require fast lookup based on the key.

Example
java
Copy code
Map<String, Integer> hashMap = new HashMap<>();
hashMap.put("Apple", 1);
hashMap.put("Banana", 2);
System.out.println(hashMap.get("Apple")); // Output: 1
HashSet
Description

● HashSet is an implementation of the Set interface.

● It stores unique elements and does not allow duplicate values.

Key Features

● No Order: Does not guarantee any order of the elements.

● Null Values: Allows a single null value.
● Efficiency: Provides O(1) average time complexity for basic operations like add, remove, and
contains.
Use Case

● Best suited for scenarios where you need a collection of unique elements and require fast
operations for checking the presence of elements.

Example
java
Copy code
Set<String> hashSet = new HashSet<>();
hashSet.add("Apple");
hashSet.add("Banana");
hashSet.add("Apple"); // Duplicate element
System.out.println(hashSet); // Output: [Apple, Banana]
List (ArrayList and LinkedList)
Description

● List is an interface that provides an ordered collection of elements.

● Common implementations are ArrayList and LinkedList.

Key Features

● Ordered: Maintains the order of elements based on insertion order.

● Duplicates: Allows duplicate elements.
● Access by Index: Elements can be accessed by their index.

Use Case

● Best suited for scenarios where you need an ordered collection of elements, may have
duplicates, and require access to elements by their index.

Example
java
Copy code
List<String> arrayList = new ArrayList<>();
arrayList.add("Apple");
arrayList.add("Banana");
arrayList.add("Apple"); // Duplicate element
System.out.println(arrayList); // Output: [Apple, Banana, Apple]
Summary of Differences
Feature HashMap HashSet List (ArrayList/LinkedList)

Interface Map Set List

Unique
Data Structure Key-value pairs Ordered collection of elements
elements
 Feature HashMap HashSet List (ArrayList/LinkedList)

No duplicate keys,
Duplicates No duplicates Allows duplicates
values can repeat

Allows one null key, Allows one null Allows multiple null values (depending on
Null Values
multiple null values value implementation)

Order No order No order Maintains insertion order

Access by Index No No Yes

Average Time O(1) for basic O(1) for basic O(1) for ArrayList (random access), O(n) for
Complexity operations operations LinkedList (random access)

Unique
Use Case Key-value association Ordered collection with duplicates allowed
collection

Choosing the Right Data Structure

● HashMap: Use when you need to map unique keys to specific values and require fast lookups,
insertions, and deletions.
● HashSet: Use when you need a collection of unique elements with no particular order.
● List: Use when you need an ordered collection that allows duplicates and requires access to
elements by their index. Choose ArrayList for fast random access and LinkedList for
frequent insertions and deletions.

Q34) Differentiate Comparator and Comparable

Ans : In Java, both Comparator and Comparable interfaces are used to sort collections or arrays
of objects. However, they serve different purposes and are used in different contexts. Here’s a
detailed comparison of Comparator and Comparable:
Comparable
Description

● The Comparable interface is used to define the natural ordering of objects of a class. It is
implemented by the class whose objects need to be sorted.

Key Features

● Single Sort Sequence: A class can implement Comparable to provide a single way of sorting its
instances.
● Method to Implement: The compareTo() method must be overridden.
● Used In: Arrays.sort() and Collections.sort() when no Comparator is provided.

Syntax
java
Copy code
public class MyClass implements Comparable<MyClass> {
private int value;

public MyClass(int value) {

this.value = value;
}

@Override
public int compareTo(MyClass other) {
return Integer.compare(this.value, other.value);
}
}
Example
java
Copy code
List<MyClass> list = new ArrayList<>();
list.add(new MyClass(3));
list.add(new MyClass(1));
list.add(new MyClass(2));

Collections.sort(list); // Uses compareTo method

Comparator
Description

● The Comparator interface is used to define multiple ways of sorting objects. It is typically
implemented in a separate class and can be passed to sorting methods.

Key Features

● Multiple Sort Sequences: A class can have multiple Comparator implementations to sort
objects in different ways.
● Method to Implement: The compare() method must be overridden.
● Used In: Arrays.sort() and Collections.sort() when a Comparator is provided.

Syntax
java
Copy code
public class MyClass {
private int value;

public MyClass(int value) {

this.value = value;
}

// Getters and setters

}

public class MyClassComparator implements Comparator<MyClass> {

@Override
public int compare(MyClass o1, MyClass o2) {
return Integer.compare(o1.getValue(), o2.getValue());
 }
}
Example
java
Copy code
List<MyClass> list = new ArrayList<>();
list.add(new MyClass(3));
list.add(new MyClass(1));
list.add(new MyClass(2));

Collections.sort(list, new MyClassComparator()); // Uses compare method

Summary of Differences
Feature Comparable Comparator

Interface Comparable<T> Comparator<T>

Method to
compareTo(T o) compare(T o1, T o2)
Implement

Sorting Logic
Defined within the class itself Defined in a separate class
Location

Number of
Single natural ordering Multiple custom orderings
Sorting Sequences

Automatically used by Collections.sort() Explicitly passed to

Usage and Arrays.sort() when no Comparator is Collections.sort() and
provided Arrays.sort()

Modification Requires modifying the class Does not require modifying the class

Multiple orderings, especially for

Typical Use Case Natural ordering of objects
third-party classes

When to Use Which

● Use Comparable:
o When you want to define a natural ordering for objects of a class.
o When there is a single, commonly accepted way of ordering instances of the class.
● Use Comparator:
o When you need multiple ways of ordering objects.
o When you cannot modify the class whose objects need to be sorted.
o When you need to sort objects based on different criteria at different times.

Q34) Explain Hashtable class in java. Write a program to illustrate the use of Hashtable
class for storing and retrieving employee record.
Ans: The Hashtable class in Java is part of the java.util package and provides a means to
store key-value pairs in a hash table data structure. It is similar to the HashMap class, but with
some key differences, primarily regarding synchronization and how it handles nulls.
Key Characteristics of Hashtable
1. Synchronized:
o Hashtable is synchronized, meaning it is thread-safe. Multiple threads can access a
Hashtable without causing concurrency issues. This makes it suitable for use in
multi-threaded environments.
2. Null Keys and Values:
o Hashtable does not allow null keys or values. Attempting to insert a null key or value
will result in a NullPointerException.
3. Legacy Class:
o Hashtable is a legacy class that was part of the original version of Java. It has been
retrofitted to implement the Map interface but still retains some of its original design
characteristics.
4. Performance:
o Due to its synchronized nature, Hashtable can be slower than HashMap when only one
thread is accessing it. For non-thread-safe environments, HashMap is typically preferred
due to its better performance.

import java.util.Hashtable;

public class EmployeeRecords {

public static void main(String[] args) {

// Create a Hashtable to store employee records

Hashtable<Integer, String> employees = new Hashtable<>();

// Add employee records to the Hashtable

employees.put(101, "John Doe");

employees.put(102, "Jane Smith");

employees.put(103, "Michael Johnson");

 employees.put(104, "Emily Davis");

// Retrieve and print employee records

System.out.println("Employee ID: 101, Name: " + employees.get(101));

System.out.println("Employee ID: 102, Name: " + employees.get(102));

System.out.println("Employee ID: 103, Name: " + employees.get(103));

System.out.println("Employee ID: 104, Name: " + employees.get(104));

// Display all employee records

System.out.println("\nAll Employee Records:");

for (Integer id : employees.keySet()) {

System.out.println("Employee ID: " + id + ", Name: " + employees.get(id));

// Check if a particular employee ID exists

int searchID = 102;

if (employees.containsKey(searchID)) {

System.out.println("\nEmployee ID " + searchID + " exists with name: " +

employees.get(searchID));

} else {

System.out.println("\nEmployee ID " + searchID + " does not exist.");

}
 // Remove an employee record

int removeID = 103;

employees.remove(removeID);

System.out.println("\nEmployee ID " + removeID + " removed.");

// Display all employee records after removal

System.out.println("\nAll Employee Records After Removal:");

for (Integer id : employees.keySet()) {

System.out.println("Employee ID: " + id + ", Name: " + employees.get(id));

Q36) Explain the process of accessing collection through iterator.

Ans: Accessing a collection through an iterator in Java allows you to traverse the collection and
access its elements sequentially without exposing the underlying structure. The Iterator
interface provides methods to iterate over any collection that implements the Iterable interface,
such as ArrayList, HashSet, HashMap, etc.
Key Methods of the Iterator Interface
1. hasNext():
o Returns true if the iteration has more elements.
o Returns false when all elements have been accessed.
2. next():
o Returns the next element in the iteration.
o Throws NoSuchElementException if there are no more elements.
3. remove():
o Removes the last element returned by the iterator.
o Can be called only once per call to next().
o Throws UnsupportedOperationException if the remove operation is not supported
by the iterator.
Example: Using an Iterator with an ArrayList
Here’s an example of how to use an Iterator to traverse an ArrayList:
java
Copy code
import java.util.ArrayList;
import java.util.Iterator;

public class IteratorExample {

public static void main(String[] args) {
// Create an ArrayList and add some elements
ArrayList<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Cherry");

// Get an iterator for the list

Iterator<String> iterator = list.iterator();

// Traverse the list using the iterator

while (iterator.hasNext()) {
String element = iterator.next();
System.out.println(element);

// Remove an element conditionally

if (element.equals("Banana")) {
iterator.remove();
}
}

// Print the list after iteration

System.out.println("List after iteration: " + list);
}
}
Explanation
1. Create a Collection:
o An ArrayList is created, and elements ("Apple", "Banana", "Cherry") are added to it.
2. Get an Iterator:
o The iterator() method of the ArrayList is called to obtain an Iterator object.
3. Traverse the Collection:
o The while (iterator.hasNext()) loop is used to iterate through the collection.
o Inside the loop, iterator.next() is called to get the next element in the collection.
o The element is printed, and if the element is "Banana", it is removed from the collection
using iterator.remove().
4. Print the Updated Collection:
o After the iteration, the updated ArrayList is printed to show the removal of "Banana".

Advantages of Using Iterators

 1. Encapsulation:
o Iterators provide a way to access elements of a collection without exposing the
underlying implementation details.
2. Uniform Interface:
o The Iterator interface provides a standard way to traverse collections, making code
more consistent and easier to maintain.
3. Safe Removal:
o The remove method of the Iterator allows for safe removal of elements during
iteration without causing ConcurrentModificationException.

Example: Using an Iterator with a HashSet

Here’s an example of how to use an Iterator to traverse a HashSet:
java
Copy code
import java.util.HashSet;
import java.util.Iterator;

public class HashSetIteratorExample {

public static void main(String[] args) {
// Create a HashSet and add some elements
HashSet<String> set = new HashSet<>();
set.add("Dog");
set.add("Cat");
set.add("Bird");

// Get an iterator for the set

Iterator<String> iterator = set.iterator();

// Traverse the set using the iterator

while (iterator.hasNext()) {
String element = iterator.next();
System.out.println(element);
}
}
}
Example: Using an Iterator with a HashMap
Here’s an example of how to use an Iterator to traverse a HashMap:
java
Copy code
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class HashMapIteratorExample {

public static void main(String[] args) {
// Create a HashMap and add some key-value pairs
HashMap<Integer, String> map = new HashMap<>();
 map.put(1, "One");
map.put(2, "Two");
map.put(3, "Three");

// Get a set of the entries

Set<Map.Entry<Integer, String>> entrySet = map.entrySet();

// Get an iterator for the entry set

Iterator<Map.Entry<Integer, String>> iterator = entrySet.iterator();

// Traverse the map using the iterator

while (iterator.hasNext()) {
Map.Entry<Integer, String> entry = iterator.next();
System.out.println("Key: " + entry.getKey() + ", Value: " +
entry.getValue());
}
}
}
In these examples, the Iterator is used to traverse different types of collections (HashSet,
HashMap). The process remains consistent across different collection types, highlighting the
flexibility and utility of the Iterator interface in Java.

Q37) what is cursor? Explain different cursor in java.

Ans: In Java, a "cursor" is a concept that allows traversal or iteration over the elements of a
collection. Cursors are interfaces provided by the Java Collections Framework that enable
navigating through the elements of collections like lists, sets, and maps. The primary cursor
interfaces in Java are Iterator, ListIterator, and Enumeration.
Types of Cursors in Java

1. Iterator
2. ListIterator
3. Enumeration

1. Iterator
Description:

● The Iterator interface provides a way to traverse elements of a collection sequentially without
exposing its underlying representation.

Key Methods:

● hasNext(): Returns true if the iteration has more elements.

● next(): Returns the next element in the iteration.
● remove(): Removes the last element returned by the iterator.

Usage:
 ● Suitable for any collection that implements the Iterable interface, including ArrayList,
HashSet, and HashMap.

Example:
java
Copy code
import java.util.ArrayList;
import java.util.Iterator;

public class IteratorExample {

public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Cherry");

Iterator<String> iterator = list.iterator();

while (iterator.hasNext()) {
String element = iterator.next();
System.out.println(element);

if (element.equals("Banana")) {
iterator.remove();
}
}

System.out.println("List after iteration: " + list);

}
}
2. ListIterator
Description:

● The ListIterator interface extends Iterator and provides additional methods to traverse
the list in both forward and backward directions.

Key Methods:

● hasNext(): Returns true if the list iterator has more elements when traversing forward.
● next(): Returns the next element in the list.
● hasPrevious(): Returns true if the list iterator has more elements when traversing backward.
● previous(): Returns the previous element in the list.
● add(E e): Inserts the specified element into the list.
● set(E e): Replaces the last element returned by next() or previous() with the specified
element.

Usage:

● Only for lists, such as ArrayList and LinkedList.

Example:
java
Copy code
import java.util.ArrayList;
import java.util.ListIterator;

public class ListIteratorExample {

public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Cherry");

ListIterator<String> listIterator = list.listIterator();

System.out.println("Forward traversal:");
while (listIterator.hasNext()) {
System.out.println(listIterator.next());
}

System.out.println("Backward traversal:");
while (listIterator.hasPrevious()) {
System.out.println(listIterator.previous());
}
}
}
3. Enumeration
Description:

● The Enumeration interface provides methods to enumerate (obtain one at a time) through a
collection of elements.

Key Methods:

● hasMoreElements(): Returns true if there are more elements to be enumerated.

● nextElement(): Returns the next element in the enumeration.

Usage:

● Mainly used with legacy classes like Vector and Stack.

Example:
java
Copy code
import java.util.Vector;
import java.util.Enumeration;

public class EnumerationExample {

public static void main(String[] args) {
Vector<String> vector = new Vector<>();
vector.add("Apple");
 vector.add("Banana");
vector.add("Cherry");

Enumeration<String> enumeration = vector.elements();

while (enumeration.hasMoreElements()) {
System.out.println(enumeration.nextElement());
}
}
}
Summary
Modify Supports
Cursor Traversal Direction Suitable For
Collection List

Iterator Forward Yes No All collections

Forward and Lists (e.g., ArrayList,

ListIterator Yes Yes
Backward LinkedList)

Legacy collections (e.g., Vector,

Enumeration Forward No No
Stack)

Each cursor type has its use case depending on the collection and the type of traversal required.
Iterator is versatile and can be used with any collection, while ListIterator provides
additional functionality for lists, and Enumeration is mainly for legacy classes.

Q38) What is map in java. How is it different from collection. Explain.

Ans: In Java, the Map interface is part of the Java Collections Framework and represents a
collection of key-value pairs. Each key in a Map is unique, and each key maps to exactly one
value. The Map interface is implemented by various classes such as HashMap, TreeMap,
LinkedHashMap, and Hashtable.

Key Characteristics of Map

1. Key-Value Pairs:
o A Map stores elements as key-value pairs (Map.Entry<K, V>).
o Keys are unique; a key maps to only one value.
2. No Direct Inheritance from Collection:
o Unlike other collection interfaces (List, Set), Map does not inherit from the
Collection interface.
3. Common Implementations:
o HashMap: Hash table-based implementation, allows null values and null keys,
unsynchronized.
o TreeMap: Red-Black tree-based implementation, ordered by the natural ordering of its
keys or by a comparator provided at map creation time.
 o LinkedHashMap: Hash table and linked list implementation, maintains a doubly-linked
list running through all entries, provides predictable iteration order.
o Hashtable: Synchronized version of HashMap, does not allow null keys or values.

Key Methods of Map

1. put(K key, V value):
o Associates the specified value with the specified key in the map.
2. get(Object key):
o Returns the value to which the specified key is mapped, or null if the map contains no
mapping for the key.
3. remove(Object key):
o Removes the mapping for a key from the map if it is present.
4. containsKey(Object key):
o Returns true if the map contains a mapping for the specified key.
5. containsValue(Object value):
o Returns true if the map contains one or more mappings for the specified value.
6. keySet():
o Returns a Set view of the keys contained in the map.
7. values():
o Returns a Collection view of the values contained in the map.
8. entrySet():
o Returns a Set view of the key-value mappings contained in the map.

Example Usage
java
Copy code
import java.util.HashMap;
import java.util.Map;

public class MapExample {

public static void main(String[] args) {
// Create a HashMap
Map<Integer, String> map = new HashMap<>();

// Add key-value pairs to the map

map.put(1, "One");
map.put(2, "Two");
map.put(3, "Three");

// Retrieve a value by key

System.out.println("Value for key 2: " + map.get(2));

// Check if a key exists

if (map.containsKey(3)) {
 System.out.println("Key 3 exists in the map.");
}

// Check if a value exists

if (map.containsValue("One")) {
System.out.println("Value 'One' exists in the map.");
}

// Remove a key-value pair

map.remove(2);
System.out.println("Map after removing key 2: " + map);

// Iterate over the map

for (Map.Entry<Integer, String> entry : map.entrySet()) {
System.out.println("Key: " + entry.getKey() + ", Value: " +
entry.getValue());
}
}
}
Differences Between Map and Collection
1. Storage Mechanism:
o Map: Stores data as key-value pairs.
o Collection: Stores individual elements.
2. Interfaces:
o Map: Does not extend the Collection interface.
o Collection: List, Set, and Queue extend the Collection interface.
3. Data Access:
o Map: Access elements using keys.
o Collection: Access elements using iterators or index (in case of List).
4. Uniqueness:
o Map: Keys are unique.
o Collection: Depends on the type of collection (Set ensures uniqueness, List allows
duplicates).
5. Methods:
o Map: Methods like put, get, remove, keySet, values, entrySet.
o Collection: Methods like add, remove, iterator, size, contains.

Summary
● Map:
o Designed for key-value pairs.
o Keys are unique.
o Provides methods to access keys, values, and key-value pairs.
o Not a subtype of Collection.
● Collection:
 o Designed for storing individual elements.
o Includes subtypes like List, Set, and Queue.
o Provides methods to add, remove, and access elements.
o Allows different rules for duplicates and ordering depending on the specific
implementation (e.g., ArrayList, HashSet).

The choice between using a Map or a Collection depends on the specific requirements of the
data structure you need, such as whether you need to associate keys with values or store
individual elements.

Q39) Explain Properties class in java with example.

Ans: The Properties class in Java is part of the java.util package and extends the Hashtable
class. It is used to maintain lists of key-value pairs where both keys and values are String
objects. The Properties class is commonly used for configuration settings and for managing
application properties.
Key Characteristics of Properties
1. Key-Value Pairs:
o Stores data as key-value pairs, both of which are String objects.
2. Default Properties:
o Can have a set of default properties that provide default values.
3. Persistence:
o Provides methods to read from and write to properties files, which are plain text files
with key-value pairs.
4. Usage:
o Commonly used for configuration files, environment settings, and internationalization
(i18n) support.

Key Methods of Properties

1. load(InputStream inStream):
o Reads a property list (key-value pairs) from an input stream.
2. load(Reader reader):
o Reads a property list (key-value pairs) from a reader.
3. store(OutputStream out, String comments):
o Writes the properties list to the output stream.
4. store(Writer writer, String comments):
o Writes the properties list to the writer.
5. getProperty(String key):
 o Searches for the property with the specified key in this property list.
6. setProperty(String key, String value):
o Calls the put method of Hashtable.
7. list(PrintStream out):
o Prints this property list out to the specified output stream.
8. list(PrintWriter out):
o Prints this property list out to the specified writer.
9. getProperty(String key, String defaultValue):
o Searches for the property with the specified key. If the key is not found, returns the
default value.

Example: Using the Properties Class

Here’s an example of how to use the Properties class to read from and write to a properties file.
Example Properties File (config.properties)
makefile
Copy code
username=admin
password=secret
url=http://example.com
Java Program to Read and Write Properties
java
Copy code
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Properties;

public class PropertiesExample {

public static void main(String[] args) {
Properties properties = new Properties();

// Load properties from a file

try (InputStream input = new FileInputStream("config.properties")) {
properties.load(input);
System.out.println("Properties loaded:");
properties.list(System.out);
} catch (IOException e) {
e.printStackTrace();
}

// Accessing properties
String username = properties.getProperty("username");
String password = properties.getProperty("password");
String url = properties.getProperty("url");

System.out.println("\nUsername: " + username);

System.out.println("Password: " + password);
 System.out.println("URL: " + url);

// Modifying properties
properties.setProperty("username", "newAdmin");
properties.setProperty("password", "newSecret");

// Save properties to a file

try (OutputStream output = new FileOutputStream("config.properties")) {
properties.store(output, "Updated properties");
System.out.println("\nProperties updated and saved to file.");
} catch (IOException e) {
e.printStackTrace();
}

// Load and print updated properties

try (InputStream input = new FileInputStream("config.properties")) {
properties.load(input);
System.out.println("\nUpdated properties loaded:");
properties.list(System.out);
} catch (IOException e) {
e.printStackTrace();
}
}
}
Explanation
1. Loading Properties:
o The properties file (config.properties) is loaded using the load method of the
Properties class.
2. Accessing Properties:
o The properties are accessed using the getProperty method.
3. Modifying Properties:
o Properties are modified using the setProperty method.
4. Saving Properties:
o The modified properties are saved back to the file using the store method.
5. Listing Properties:
o The list method prints all key-value pairs to the standard output.

Summary

● The Properties class is a powerful tool for handling configuration and application settings in
Java.
● It supports easy reading and writing of properties files.
● It ensures that key-value pairs are always strings, simplifying data handling.
● It can be used in various contexts such as setting application parameters, managing
internationalization (i18n) resources, and more.

Q40) Explain Set and Queue interface in java.

Ans: In Java, Set and Queue are interfaces that are part of the Java Collections Framework. They
define behaviors for collections that have specific characteristics and are implemented by various
classes to provide different implementations of these behaviors.
Set Interface
The Set interface represents a collection that cannot contain duplicate elements. It models the
mathematical set abstraction and is used when you want to ensure that no duplicates are stored.
Here are some key characteristics and methods of the Set interface:
Key Characteristics
1. No Duplicates:
o A Set does not allow duplicate elements. Adding duplicate elements has no effect.
2. Unordered:
o There is no guarantee on the order of elements in a Set. The specific implementation
decides the order, which can vary between iterations.
3. Implementations:
o Common implementations include HashSet, TreeSet, and LinkedHashSet.

Key Methods

● add(E e): Adds the specified element to the set if it is not already present.
● remove(Object o): Removes the specified element from the set if it is present.
● contains(Object o): Returns true if the set contains the specified element.
● size(): Returns the number of elements in the set.
● isEmpty(): Returns true if the set contains no elements.

Example Usage of Set

java
Copy code
import java.util.HashSet;
import java.util.Set;

public class SetExample {

public static void main(String[] args) {
Set<String> set = new HashSet<>();

// Adding elements to the set

set.add("Apple");
set.add("Banana");
set.add("Apple"); // This duplicate will be ignored

System.out.println("Set elements: " + set);

// Removing an element from the set

set.remove("Banana");

System.out.println("Set elements after removal: " + set);

// Checking if an element exists in the set

 if (set.contains("Apple")) {
System.out.println("Set contains 'Apple'");
}

// Iterating over the set (order may vary)

for (String element : set) {
System.out.println("Element: " + element);
}
}
}
Queue Interface
The Queue interface represents a collection designed for holding elements prior to processing. It
follows the FIFO (First-In-First-Out) principle, where elements are added at the end (tail) and
removed from the beginning (head) of the queue. Here are some key characteristics and methods
of the Queue interface:
Key Characteristics
1. FIFO Ordering:
o Elements are inserted at the end of the queue and removed from the beginning,
maintaining the order in which elements were added.
2. Implementations:
o Common implementations include LinkedList (provides more efficient queue
operations than ArrayList) and PriorityQueue (orders elements according to their
natural ordering or by a specified comparator).
3. Special Methods:
o Besides the basic Collection methods (add, remove, peek, poll), Queue interface
also includes methods like offer, element, remove, which throw exceptions if the
operation fails.

Key Methods

● add(E e): Adds the specified element to the queue.

● remove(): Removes and returns the head of the queue.
● peek(): Retrieves, but does not remove, the head of the queue.
● poll(): Retrieves and removes the head of the queue.
● offer(E e): Adds the specified element to the queue if possible.

Example Usage of Queue

java
Copy code
import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {

public static void main(String[] args) {
Queue<String> queue = new LinkedList<>();

// Adding elements to the queue

 queue.add("Apple");
queue.add("Banana");
queue.add("Cherry");

System.out.println("Queue elements: " + queue);

// Removing an element from the queue

String removedElement = queue.remove();
System.out.println("Removed element: " + removedElement);
System.out.println("Queue elements after removal: " + queue);

// Checking the head of the queue

String headElement = queue.peek();
System.out.println("Head element: " + headElement);

// Iterating over the queue (FIFO order)

while (!queue.isEmpty()) {
System.out.println("Processing element: " + queue.poll());
}
}
}
Summary
● Set Interface:
o Stores unique elements.
o No defined ordering of elements.
o Common implementations include HashSet, TreeSet, and LinkedHashSet.
● Queue Interface:
o Follows FIFO ordering.
o Common implementations include LinkedList and PriorityQueue.
o Useful for tasks such as processing elements in the order they were added.

Both Set and Queue interfaces provide specialized behaviors for handling collections of elements
with specific requirements regarding uniqueness and order of processing, respectively. They are
integral parts of the Java Collections Framework and offer various implementations tailored to
different use cases.

Q41) Define String framework with its advantages.

Spring Framework:
● Spring is a lightweight framework.
● It can be thought of as a framework of frameworks because it provides support to various
frameworks such as Struts, Hibernate, Tapestry, EJB, JSF, etc.
● The framework, in broader sense, can be defined as a structure where we find solution of the
various technical problems.
● The Spring framework comprises several modules such as IOC, AOP, DAO, Context, ORM,
WEB MVC etc.

Advantages of Spring Framework

There are many advantages of Spring Framework. They are as follows:

1) Predefined Templates
Spring framework provides templates for JDBC, Hibernate, JPA etc. technologies. So there is no
need to write too much code. It hides the basic steps of these technologies.
Let's take the example of JdbcTemplate, you don't need to write the code for exception handling,
creating connection, creating statement, committing transaction, closing connection etc. You
need to write the code of executing query only. Thus, it save a lot of JDBC code.
2) Loose Coupling
The Spring applications are loosely coupled because of dependency injection.
3) Easy to test
The Dependency Injection makes easier to test the application. The EJB or Struts application
require server to run the application but Spring framework doesn't require server.
4) Lightweight
Spring framework is lightweight because of its POJO implementation. The Spring Framework
doesn't force the programmer to inherit any class or implement any interface. That is why it is
said non-invasive.
5) Fast Development
The Dependency Injection feature of Spring Framework and it support to various frameworks
makes the easy development of JavaEE application.
6) Powerful abstraction
It provides powerful abstraction to JavaEE specifications such as JMS, JDBC, JPA and JTA.
7) Declarative support
It provides declarative support for caching, validation, transactions and formatting.

Q42) Describe the Dependency Injection and its types.

Dependency Injection in Spring

Dependency Injection (DI) is a design pattern that removes the dependency from the
programming code so that it can be easy to manage and test the application. Dependency
Injection makes our programming code loosely coupled. To understand the DI better, Let's
understand the Dependency Lookup (DL) first:

Dependency Lookup

The Dependency Lookup is an approach where we get the resource after demand. There can be
various ways to get the resource for example:
A obj = new AImpl();
In such way, we get the resource(instance of A class) directly by new keyword. Another way is
factory method:
A obj = A.getA();
This way, we get the resource (instance of A class) by calling the static factory method getA().
Problems of Dependency Lookup
There are mainly two problems of dependency lookup.
o tight coupling The dependency lookup approach makes the code tightly coupled. If resource
is changed, we need to perform a lot of modification in the code.
o Not easy for testing This approach creates a lot of problems while testing the application
especially in black box testing.
There three types of dependency Injections.
● Constructor injection: This is the most common type of DI in Spring Boot. In constructor
injection, the dependency object is injected into the dependent object’s constructor.
● Setter injection: In setter injection, the dependency object is injected into the dependent
object’s setter method.
● Field injection: In field injection, the dependency object is injected into the dependent
object’s field.

Q43) Describe the types of IOC container in spring.

The IoC container is responsible to instantiate, configure and assemble the objects. The IoC
container gets information from the XML file and works accordingly. The main tasks performed
by IoC container are:
o to instantiate the application class
o to configure the object
o to assemble the dependencies between the objects
There are two types of IoC containers. They are:
1. BeanFactory
2. ApplicationContext
BeanFactory is the basic container whereas ApplicationContext is the advanced container.
ApplicationContext extends the BeanFactory interface. ApplicationContext provides more
facilities than BeanFactory such as integration with spring AOP, message resource handling for
i18n etc.

Q44) what is the difference between constructor injection and setter injection?

No. Constructor Injection Setter Injection

1) No Partial Injection Partial Injection

2) Desn't override the setter property Overrides the constructor property if both are
defined.

3) Creates new instance if any Doesn't create new instance if you change the
modification occurs property value

4) Better for too many properties Better for few properties.

Q45) what is autowiring in spring. Define the autowiring modes.

Autowiring enables the programmer to inject the bean automatically. We don't need to write
explicit injection logic.
Let's see the code to inject bean using dependency injection.
<bean id="emp" class="com.javatpoint.Employee" autowire="byName" />

The autowiring modes are given below:

No. Mode Description

1) No this is the default mode, it means autowiring is not enabled.

2) Byname injects the bean based on the property name. It uses setter method.

3) byType injects the bean based on the property type. It uses setter method.

4) Constructor It injects the bean using constructor

Q46) Describe Bean Definition with Bean Scopes.

The objects that form the backbone of your application and that are managed by the Spring IoC
container are called beans. A bean is an object that is instantiated, assembled, and otherwise
managed by a Spring IoC container. These beans are created with the configuration metadata that
you supply to the container. For example, in the form of XML <bean/> definitions.

Bean Scopes

When defining a <bean> you have the option of declaring a scope for that bean. For example, to
force Spring to produce a new bean instance each time one is needed, you should declare the
bean's scope attribute to be prototype. Similarly, if you want Spring to return the same bean
instance each time one is needed, you should declare the bean's scope attribute to be singleton.

The Spring Framework supports the following five scopes, three of which are available only if
you use a web-aware ApplicationContext.
Sr.No
Scope & Description
.

Singleton
1 This scopes the bean definition to a single instance per Spring IoC container
(default).

Prototype
2
This scopes a single bean definition to have any number of object instances.

Request
3 This scopes a bean definition to an HTTP request. Only valid in the context of
a web-aware Spring ApplicationContext.

Session
4 This scopes a bean definition to an HTTP session. Only valid in the context of
a web-aware Spring ApplicationContext.

global-session
5 This scopes a bean definition to a global HTTP session. Only valid in the
context of a web-aware Spring ApplicationContext.
Q47) what is Spring Boot and what are its Benefits.
● A Java-based, open-source framework to create web applications, Spring Boot has been
dominating the web development landscape ever since the official release of Spring Boot
1.0.0 in April 2014.
● Because of its ability to simplify the process of developing complex applications, the
enterprise-grade Spring Boot framework is today among the most widely used Java-based
technologies to build scalable and robust web applications.
● Spring Boot represents a fusion of the lightweight Spring application framework,
configuration annotations, and embedded HTTP server.
● Made available with an auto-configuration feature, and support for Spring Initializer,
Groovy, and Java, Spring Boot reduces Integration Test, Development, and Unit Test
time.
● It aids the development of fast, responsive, and secure web applications, providing users
with a complete configuration and programming model for Java enterprise applications.
● Spring Boot, utilizing the core features of the Spring application framework, offers a
faster development technique for RESTful or REST architecture-based web services.

The advantages of Spring Boot are as follows:

● It is very simple to create Spring-based apps in Java or Groovy.
● It cuts down on development time and also increases the output.
● It eliminates the requirement to write repetitive code, annotations, and XML
configuration.
 ● It is very simple to combine Spring Boot Application with its Spring Ecosystem, which
includes Spring JDBC, Spring ORM, Spring Data, and Spring Security, among other
things.
● To minimize developer effort, it employs the "Opinionated Defaults Configuration"
approach.
● It provides Embedded HTTP servers such as Tomcat, Jetty, and others to help us build and
test our web applications quickly.

Q48) Why Spring Boot is preferred over any other framework? Describe the key
dependencies of Spring Boot.

The Spring cloud that comes with Spring Boot, includes vast libraries, which is one of the major
reasons why most developers prefer the Java-based Spring Boot. In addition, Spring Boot offers
superior compatibility with Spring frameworks, and it also provides excellent support for docker
containerization, heightening performance, and usability. Some of the most compelling reasons
for using Spring Boot include:
● Provides the best means to configure Java beans
● Offers robust batch processing
● Helps users effectively manage Representational State Transfer (REST) endpoints
● Integrates an auto-configuration tool, eliminating the need for manual configuration
● Enables annotation-based configurations
● Ease of dependency management
● Includes embedded servlet containers

Key dependencies of Spring Boot

Mentioned below are important Spring Boot dependencies that need to be added to a
Gradle-based or Maven-based application, to ensure application compatibility with Spring Boot
features.
● spring-boot-starter-parent
● spring-boot-maven-plugin
● spring-boot-starter-test
● spring-boot-starter-security
● spring-boot-starter-actuator
● Spring-boot-starter-web

Q49)Describe the flow of HTTPS requests through the Spring Boot application.
The flow of HTTPS requests through a Spring Boot application is as follows:
● First client makes an HTTP request (GET, POST, PUT, DELETE) to the browser.
● After that the request will go to the controller, where all the requests will be mapped and
handled.
● After this in Service layer, all the business logic will be performed. It performs the business
logic on the data that is mapped to JPA (Java Persistence API) using model classes.
● In repository layer, all the CRUD operations are being done for the REST APIs.
● A JSP page is returned to the end users if no errors are there.

Q50) Explain the basic Spring Boot Annotations.

@SpringBootApplication: This is the main annotation used to bootstrap a Spring Boot
application. It combines three annotations: @Configuration, @EnableAutoConfiguration,
and @ComponentScan. It is typically placed on the main class of the application.
@Configuration: This annotation is used to indicate that a class contains configuration methods
for the application context. It is typically used in combination with @Bean annotations to define
beans and their dependencies.
@Component: This annotation is the most generic annotation for any Spring-managed
component. It is used to mark a class as a Spring bean that will be managed by the Spring
container.
@RestController: This annotation is used to define a RESTful web service controller. It is a
specialized version of the @Controller annotation that includes the @ResponseBody annotation
by default.
@RequestMapping: This annotation is used to map HTTP requests to a specific method in a
controller. It can be applied at the class level to define a base URL for all methods in the class, or
at the method level to specify a specific URL mapping.