UNIT -3

1)What are Vectors?

Vector is a resizable array in Java, found in the [Link] package. It is part of
the Collection Framework and works like an ArrayList, but it is synchronized,
meaning it is safe to use in multi-threaded programs. However, this makes it
a bit slower than ArrayList.
Key Features of Vector
 It expands as elements are added.
 The Vector class is synchronized in nature means it is thread-safe by
default.
 Like an ArrayList, it maintains insertion order.
 It allows duplicates and nulls.
 It implements List, RandomAccess, Cloneable and Serializable.
Vector Class Declaration
public class Vector<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable
Here, E is the type of element.
Example: Java Program Implementing Vector
import [Link];
public class Geeks
{
public static void main(String[] args)
{
// Create a new vector
Vector<Integer> v = new Vector<>(3, 2);
// Add elements to the vector
[Link](1);
[Link](2);
[Link](3);
 // Insert an element at index 1
[Link](0, 1);
// Remove the element at index 2
[Link](2);
// Print the elements of the vector
for (int i : v) {
[Link](i);
}
}
}
Output
1
0
3

2) What is Mutlithreading?
Multithreading in Java is a feature that enables a program to run multiple
threads simultaneously, allowing tasks to execute in parallel and utilize the
CPU more efficiently. A thread is a lightweight, independent unit of execution
inside a program (process).
 A process can have multiple threads.
 Each thread runs independently but shares the same memory.
Example: Imagine a restaurant kitchen. Multiple chefs (threads) are
preparing different dishes at the same time. This speeds up service and
utilizes all available resources (CPU).

Advantages of Multithreading in Java

1. Improved Performance: Multiple tasks can run simultaneously, reducing
execution time.
2. Efficient CPU Utilization: Threads keep the CPU busy by running tasks
in parallel.
3. Responsiveness: Applications (like GUIs) remain responsive while
performing background tasks.
4. Resource Sharing: Threads within the same process share memory and
resources, avoiding duplication.
5. Better User Experience: Smooth execution of tasks like file downloads,
animations, and real-time updates.

3) What are Deadlocks in Java?

Deadlock occurs in Java when multiple threads block each other while
waiting for locks held by one another. To prevent deadlocks, we can use
the synchronized keyword to make methods or blocks thread-safe which
means only one thread can have the lock of the synchronized method and
use it, other threads have to wait till the lock releases other one acquires the
lock.
Preventing Deadlocks
We can avoid deadlock conditions by knowing its possibilities. It's a very
complex process and not easy to catch. Still, if we try, we can avoid this.
There are some methods by which we can avoid this condition. We can't
completely remove its possibility but we can reduce it.
  Avoid Nested Locks: This is the main reason for deadlock. Mainly
happens when we give locks to multiple threads. Avoid giving lock to
multiple threads if we already have given to one.
 Avoid Unnecessary Locks: We should have lock only those members
who are required. Having a lock on unnecessarily can lead to deadlock.
 Using thread join: Deadlock condition appears when one thread is
waiting for the other to finish. If this condition occurs we can use Thread.
Join the with the maximum time you think the execution will take.

3) How to manage errors and Exceptions in java?

Managing errors and exceptions in Java is crucial for building robust and reliable
applications. Java provides a structured mechanism for handling these events, primarily through
the use of try-catch-finally blocks and exception classes.

1. try-catch-finally Blocks:
 try block: Contains the code that might throw an exception.

 catch block: Follows a try block and handles specific types of exceptions. If an
exception of the specified type (or a subclass) is thrown in the try block,
the catch block's code executes.
 finally block: An optional block that always executes, regardless of whether an
exception was thrown or caught. It's commonly used for cleanup operations like closing
resources (files, database connections).
2. Exception Hierarchy:
 All exceptions in Java inherit from the Throwable class.

 Throwable has two main subclasses: Error and Exception.

 Error: Represents serious problems that applications should not typically try to catch
(e.g., OutOfMemoryError).

 Exception: Represents conditions that an application might want to catch and

handle. Exceptions are further divided into:
o Checked Exceptions: Must be explicitly handled using try-catch or declared in the
method signature using throws. Examples: IOException, SQLException.

o Unchecked Exceptions (Runtime Exceptions): Do not require explicit handling or

declaration. They usually indicate programming
errors. Examples: NullPointerException, ArrayIndexOutOfBoundsException.
3. Best Practices:
 Catch specific exceptions:

Catching Exception (the most general type) can hide specific issues. Catch the most
specific exception possible to handle it appropriately.
 Handle at the right level:

Catch exceptions where they can be effectively dealt with, either by recovering,
logging, or providing a user-friendly message.
 Avoid empty catch blocks:

At a minimum, log the exception to aid in debugging.

 Use try-with-resources:
For resources that implement AutoCloseable, try-with-resources automatically
closes them, simplifying resource management and preventing leaks.
 UNIT -4
1) Define Applet Programming?
Applet programming refers to the creation of small Java programs, known as applets, designed
to be embedded within HTML web pages and executed within a web browser or an applet
viewer. These programs run on the client side, meaning they are downloaded from a server and
executed on the user's computer.

Key characteristics of applets:

 Embedded in HTML:

Applets are embedded in HTML pages using the <applet> or <object> tag, which
specifies the applet's class file and its dimensions.
 Client-side execution:

They are executed by a Java-enabled web browser or an applet viewer on the user's
machine, providing dynamic and interactive content without requiring server-side
processing for every interaction.
 Subclass of Applet:

All Java applets are subclasses of the [Link] class, inheriting its
fundamental methods and functionalities.
 Lifecycle methods:

Applets typically override methods like init(), start(), stop(), and destroy() to
manage their lifecycle, from initialization to termination. The paint() method is used
for rendering graphics.
 Security restrictions:

Applets traditionally have security restrictions, limiting their access to local resources
like the file system and network to prevent malicious actions. Signed applets,
however, can gain more privileges after user approval.
 Lack of main() method:
Unlike standalone Java applications, applets do not require a main() method for
execution as they are managed by the browser or applet viewer.

Basic structure of an Applet:

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

public class MyFirstApplet extends Applet {

public void init() {
// Initialization code here
}

public void start() {

// Code to run when the applet starts or resumes
}

public void paint(Graphics g) {

// Drawing and rendering code here
[Link]("Hello, Applet!", 20, 20);
}

public void stop() {

// Code to run when the applet is paused
}

public void destroy() {

// Cleanup code here
}
}

2What are the Advantages and Disadvantages of An Applet?

Java Applets, while historically significant, present a mix of advantages and
disadvantages:

Advantages:
 Cross-Platform Compatibility:

Applets are platform-independent, meaning they can run on various operating systems
(Windows, macOS, Linux) as long as a compatible Java Runtime Environment (JRE)
is installed.
 Client-Side Execution:

Applets execute on the client's machine, reducing the load on the server and
potentially improving performance for interactive elements.
 Enhanced User Experience:

They can provide rich graphical user interfaces, animations, and interactive elements
within a web page, offering a more dynamic experience than static HTML.
 Security Sandbox:

Untrusted applets run within a security sandbox, limiting their access to local system
resources and protecting the user's machine.
 Caching:
Applets can be cached by the browser, leading to faster loading times on subsequent
visits.
Disadvantages:
 Java Plugin Requirement:

Applets require the Java plugin to be installed and enabled in the user's browser,
which has become less common and supported over time.
 Declining Browser Support:

Many modern web browsers, especially mobile browsers, no longer support Java
applets due to security concerns and the rise of alternative web technologies.
 Security Concerns:

Despite the sandbox, historical vulnerabilities in Java plugins led to security risks,
contributing to the decline in applet usage.
 Slow Startup Times:

Initial loading of applets can be slow as all necessary classes and resources need to
be downloaded over the network.
 Limited Access to Local Resources:

The security sandbox restricts applets from directly accessing local files, operating
system functionalities, or communicating with arbitrary servers, limiting their
capabilities compared to standalone applications.
 Maintenance and Development Challenges:
 With reduced support and the availability of more modern web development tools,
finding resources and maintaining applet-based solutions can be challenging.

4)What is Evnet handling in Applet?

Event handling in Java applets utilizes the Delegation Event Model to manage user
interactions and system events. This model involves two key components: event
sources and event listeners.

1. Event Sources:
Event sources are GUI components within the applet (e.g., buttons, text fields,
checkboxes, windows) that generate events in response to user actions or system
changes. For example, a button generates an ActionEvent when clicked, and a text
field can generate a KeyEvent when a character is typed.

2. Event Listeners:
Event listeners are objects designed to "listen" for specific types of events. They
implement specific interfaces (e.g., ActionListener, MouseListener, KeyListener) that
define methods for handling those events. When an event occurs, the corresponding
method in the registered listener is invoked.

Steps for Event Handling in an Applet:

 Identify the Event Type:

Determine the type of event you want to handle (e.g., button clicks, mouse
movements, key presses).
 Implement the Appropriate Listener Interface:

Your applet class (or a separate class) must implement the relevant event listener
interface for the event type. For example, to handle button clicks,
implement ActionListener.

 Register the Listener with the Source:

The event listener must be registered with the component that generates the
event. This is typically done using an add<EventType>Listener() method on the event
source (e.g., [Link](this) if the applet itself is the listener).

 Provide Event Handling Code:

 Implement the abstract methods defined in the listener interface. These methods
contain the code that will be executed when the event occurs. For example,
the actionPerformed(ActionEvent e) method in ActionListener handles button
clicks.

4) What are Applet parameters ad communications?

Applet parameters provide a mechanism to customize an applet's behavior and
appearance without modifying and recompiling its source code. They function similarly
to command-line arguments for standalone applications.

1. Applet Parameters:
 Definition:

Parameters are key-value pairs passed to an applet during its deployment. The applet
can then retrieve and utilize these values to configure its operation.
 Specification:

 <param> tag within <applet>: This is the traditional method, where parameters are
defined directly within the HTML <applet> tag using <param name="parameterName"
value="parameterValue">.

 Java Network Launch Protocol (JNLP) file: For more robust deployment,
particularly when an applet is used across multiple web pages, parameters can be
specified in the JNLP file associated with the applet.
 Retrieval:

Inside the applet's Java code, the getParameter(String name) method of

the Applet class is used to retrieve the value associated with a given parameter
name. The returned value is always a String, which the applet can then parse into
other data types (e.g., integers, booleans, URLs) as needed.
 Purpose:
Parameters enhance applet flexibility, allowing for dynamic configuration of elements
like window titles, dimensions, button labels, initial values, or network settings.
2. Applet Communications:
Applets can engage in various forms of communication:
 Communication with the Browser/JavaScript:
 Applets can interact with the surrounding HTML page and JavaScript code. JavaScript
can call public methods of an applet, and an applet can invoke JavaScript functions in
the browser. This enables dynamic updates of the webpage based on applet actions
or vice-versa.
 Communication with Other Applets:

 Applets on the same web page can communicate with each other by obtaining
references to other applets and calling their public methods. This facilitates
collaborative behavior between different applet components.
 Communication with a Server-Side Application:
 Applets can act as network clients, communicating with server-side applications (e.g.,
servlets, web services) using standard networking protocols like HTTP or
sockets. This allows applets to retrieve data from a server, submit user input, or
interact with backend systems.

 Security restrictions, often imposed by browsers or firewalls, can limit an applet's

ability to communicate with hosts other than its originating
server. The getCodeBase() and getHost() methods can help determine the applet's
origin for secure communication

5)Explain about Graphics programming?

Graphics is one of the most important features of Java. Java applets can be written to
draw lines, arcs, figures, images and text in different fonts and styles. Different colors
can also be incorporated in display.
The Graphics Class
The graphics class defines a number of drawing functions, Each shape can be drawn edge-only
or filled. To draw shapes on the screen, we may call one of the methods available in the graphics
class. The most commonly used drawing methods included in the graphics class are listed below.
To draw a shape, we only need to use the appropriate method with the required arguments.

Drawing Methods of the Graphics Class

[Link] Method Description

1. clearRect() Erase a rectangular area of the canvas.

2. copyAre() Copies a rectangular area of the canvas to another area

 3. drawArc() Draws a hollow arc

4. drawLine() Draws a straight line

5 drawOval() Draws a hollow oval

6 drawPolygon() Draws a hollow polygon

7 drawRect() Draws a hollow rectangle

8. drawRoundRect() Draws a hollow rectangle with rounded corners

9. drawString() Display a text string

10. FillArc() Draws a filled arc

11. fillOval() Draws a filled Oval

12. fillPolygon() Draws a filled Polygon

13. fillRect() Draws a filled rectangle

14. fillRoundRect() Draws a filled rectangle with rounded corners

15. getColor() Retrieves the current drawing color

16. getFont() Retrieves the currently used font

17. getFontMetrics() Retrieves the information about the current font

18. setColor() Sets the drawing color

19. setFont() Sets the font

Lines and Rectangles

Lines are drawn by means of the drawLine() method.

Syntax
void drawLine(int startX, int startY, int endX, int endY)

drawLine() displays a line in the current drawing color that begins at (start X, start Y) and ends
at (endX, end Y).

//Drawing Lines
import [Link].*;
import [Link].*;
/*
<applet code="Lines" width=300 Height=250>
</applet>
*/
public class Lines extends Applet
{
public void paint(Graphics g)
{
[Link](0,0,100,100);
[Link](0,100,100,0);
[Link](40,25,250,180);
[Link](5,290,80,19);
}
}

After this you can comiple your java applet program as shown below:
Rectangle

The drawRect() and fillRect() methods display an outlined and filled rectangle, respectively.

Syntax
void drawRect(int top, int left, int width, int height)
void fillRect(int top, int left, int width, int height)

The upper-left corner of the rectangle is at(top,left). The dimensions of the rectangle are specified
by width and height.

Use drawRoundRect() or fillRoundRect() to draw a rounded rectangle. A rounded rectangle has

rounded corners.

Syntax
void drawRoundRect(int top, int left, int width, int height int Xdiam, int YDiam)
void fillRoundRect(int top, int left, int width, int height int Xdiam, int YDiam)

The upper-left corner of the rounded rectangle is at (top,left). The dimensions of the rectangle are
specified by width and height. The diameter of the ribdubg are along the X axis are specified by x
Diam. The diameter of the rounding are along the Y axis is specified by Y Diam.

/*
===========================================================
File Name : [Link]
WebSite : [Link]
Facebook : [Link]
Created By : Bintu Chaudhary
===========================================================
*/
import [Link].*;
import [Link].*;
/*
<applet code="Rectanlge" width=300 Height=300>
</applet>
*/
public class Rectanlge extends Applet
{
public void paint(Graphics g)
{
[Link](10,10,60,50);
 [Link](100,100,100,0);
[Link](190,10,60,50,15,15);
[Link](70,90,140,100,30,40);
}
}

After this you can comiple your java applet program as shown below:

c:\jdk1.4\bin\javac [Link]
c:\jdk1.4\bin\appletviewer [Link]

"Output of [Link]"

Circles and Ellipses

The Graphics class does not contain any method for circles or ellipses. To draw an ellipse, use
drawOval(). To fill an ellipse, use fillOval().

Syntax
void drawOval(int top, int left, int width, int height)
void fillOval(int top, int left, int width, int height)

The ellipse is drawn within a bounding rectangle whose upper-left corner is specified by
(top,left) and whose width and height are specified by width and height. To draw a circle, specify
a square as the bounding rectangle i.e get height = width.

The following program draws serveral ellipses:

/*
===========================================================
File Name : [Link]
WebSite : [Link]
Facebook : [Link]
Created By : Bintu Chaudhary
===========================================================
*/
import [Link].*;
import [Link].*;
/*
<applet code="Ellipses" width=300 Height=300>
</applet>
*/
public class Ellipses extends Applet
{
public void paint(Graphics g)
{
[Link](10,10,60,50);
[Link](100,10,75,50);
[Link](190,10,90,30);
[Link](70,90,140,100);
}
}

After this you can comiple your java applet program as shown below:

c:\jdk1.4\bin\javac [Link]
c:\jdk1.4\bin\appletviewer [Link]
 "Output of [Link]"

Drawing Arcs
An arc is a part of oval. Arcs can be drawn with draw Arc() and fillArc() methods.

Syntax
void drawArc(int top, int left, int width, int height, int startAngle, int sweetAngle)
void fillArc(int top, int left, int width, int height, int startAngle, int sweetAngle)

The arc is bounded by the rectangle whose upper-left corner is specified by (top,left) and whose
width and height are specified by width and height. The arc is drawn from startAngle through the
angular distance specified by sweepAngle. Angles are specified in degree. '0 o' is on the
horzontal, at the 30' clock's position. The arc is drawn conterclockwise if sweepAngle is positive,
and clockwise if sweetAngle is negative.

The following applet draws several arcs:

/*
===========================================================
File Name : [Link]
WebSite : [Link]
Facebook : [Link]
Created By : Bintu Chaudhary
===========================================================
*/
import [Link].*;
import [Link].*;
/*
<applet code="Arcs" width=300 Height=300>
</applet>
*/
public class Arcs extends Applet
{
public void paint(Graphics g)
{
[Link](10,40,70,70,0,75);
[Link](100,40,70,70,0,75);
[Link](10,100,70,80,0,175);
[Link](100,100,70,90,0,270);
[Link](200,80,80,80,0,180);
}
}

After this you can comiple your java applet program as shown below:

c:\jdk1.4\bin\javac [Link]
c:\jdk1.4\bin\appletviewer [Link]
 "Output of [Link]"

6) Explain about Line Graph?

Line graph also known as a line chart or line plot is a tool used for data
visualization . It is a type of graph that represents the data in a pictorial
form which makes the raw data more easily understandable. In a line graph
data points are connected with a straight-line and data points are
represented either with points or wedges. Some other examples of graphs
are bar graphs, histograms, pie charts, line graphs, etc.
Parts of Line Graph
Parts of the line graph include the following:
 Title: It is nothing but the title of the graph drawn.
 Axes: The line graph contains two axes i.e. X-axis and Y-axis.
 Labels: The name given to the x-axis and y-axis.
 Line: It is the line segment that is used to connect two or more data
points.
 Point: It is nothing but a point given at each segment.
How to Draw and Read a Line Graph?
Drawing a line Graph
To make a line graph we need to use the following steps:
1. Determine the variables: The first and foremost step is to identify the
variables you want to plot on the X-axis and Y-axis.
2. Choose appropriate scales: Based on your data, determine the
appropriate scale.
3. Plot the points: Plot the individual data points on the graph according to
the given data.
4. Connect the points: After plotting the points, you have to connect those
points with a line.
5. Label the axes: Add labels to the X-axis and Y-axis. You can also
include the unit of measurement.
6. Add Title: After completing the graph you should provide a suitable title.
Reading a Line Graph
To read a line graph you need to follow the below given steps:
1. Understand the axes: First, you need to understand the X-axis and Y-
axis of the graph.
2. Estimate the scale: Look at the values marked along each axis to
determine the scale.
3. Estimate the values of data points: Look at the data points on the graph
to estimate the values on the graph.
4. Analyze the pattern: Identify the pattern and analyze it.
5. Conclude: Based on the above step find conclusions.

Example: Draw a line graph for the given data

No. of Days 1 2 3 4

Absentees 5 10 15 10

Answer:

Types of Line Graph

Let us discuss the types of line graphs:
 Simple Line Graph
 Multiple Line Graph
 Compound Line Graph
Simple Line Graph
It is the most common type of line graph in which a single line represents the
relationship between two variables over time. The above diagram is an
example of a basic line graph.
Multiple Line Graph
It is the type of line graph in which we can represent two or more lines in a
single graph and they can either belong to the same categories or different
which makes it easy to make comparisons between them. Multiple line
graphs also include a double line graph or we can say that a double line
graph is also a multiple line graph.
An example of multiple graphs is shown below:

In the above graph sale of product A and B is shown in the same graph.
Compound Line Graph
It is a type of line graph in which multiple lines or data are combined into a
single graph showing different categories or variables. The main aim of a
compound line graph is to represent or display the relationship between
different variables on a single graph.
A Compound Line graph example is shown below:
 Advantages of Line Graph
Some of the advantages of using line graph are listed below:
 It helps to visualize the data.
 It provides a clear overview of the data.
 It becomes easy to make predictions using a line graph.
 It helps to compare the data more easily.

7) Explain about Bar charts?

Drawing bar charts in graphics programming involves several key steps to visualize
categorical data with corresponding numerical values. The process generally includes:

 Data Preparation:

Organize your data, ensuring you have clear categories and their associated
numerical values. This data will determine the number of bars, their labels, and their
heights or lengths.
 Setting up the Canvas/Window:

Initialize a graphics window or drawing surface where the bar chart will be
rendered. The specific method for this depends on the programming language and
graphics library being used (e.g., initgraph in C graphics, creating
a JFrame and JPanel in Java, or setting up a canvas in web development).
 Drawing Axes:

 X-axis (Categorical): This axis will typically display the categories. Determine the
spacing between bars and labels for each category.
 Y-axis (Numerical): This axis will represent the numerical values. Establish a suitable
scale and range for the values and mark increments along the axis. The y-axis should
ideally start from zero for accurate representation.
 Drawing the Bars:

 For each category in your data, draw a rectangular bar.

 The position of the bar on the x-axis corresponds to its category.

 The height (for vertical bar charts) or length (for horizontal bar charts) of the bar is
proportional to its numerical value on the y-axis.

 Ensure uniform width and consistent spacing between bars for readability.
 Adding Labels and Titles:

 Axis Labels: Label the x-axis with the categories and the y-axis with the numerical
values or units.
 Bar Labels: Optionally, add labels directly on or above each bar to display its precise
value.
 Chart Title: Provide a clear and descriptive title for the entire bar chart.

 Legend (Optional): If multiple data sets are being compared or different colors are
used to represent distinct meanings, include a legend to explain them.
 Customization and Enhancements:
 Color: Use colors strategically to differentiate categories or highlight specific data
points. Avoid excessive or arbitrary coloring that might distract the viewer.
 Styling: Adjust bar colors, outlines, and text fonts for improved aesthetics and clarity.

 Interactivity (Advanced): In some programming environments, you can add

interactive elements like tooltips that display data details when hovering over a bar.
 UNIT 5
1) What are Files in java?

 File handling is an important part of any application.

 Java has several methods for creating, reading, updating, and deleting files.

Java File Handling

The File class from the [Link] package, allows us to work with files.

To use the File class, create an object of the class, and specify the filename or directory
name:

ExampleGet your own Java Server

import [Link]; // Import the File class

File myObj = new File("[Link]"); // Specify the filename

The File class has many useful methods for creating and getting information about files.
For example:

Method Type Description

canRead() Boolean Tests whether the file is readable or not

canWrite() Boolean Tests whether the file is writable or not

 createNewFile() Boolean Creates an empty file

delete() Boolean Deletes a file

exists() Boolean Tests whether the file exists

getName() String Returns the name of the file

getAbsolutePath() String Returns the absolute pathname of the file

length() Long Returns the size of the file in bytes

list() String[] Returns an array of the files in the directory

mkdir() Boolean Creates a directory

2) Explain about Streams in Java?

Java utilizes various stream classes within the [Link] package to handle input and
output operations. These classes are primarily categorized into two main types: Byte
Streams and Character Streams.

1. Byte Streams:
These streams process 8-bit bytes and are suitable for handling binary data like images,
audio, or compiled files.

 InputStream:
 The abstract superclass for all input byte streams.
 FileInputStream : Reads bytes from a file.

 ByteArrayInputStream : Reads bytes from an array in memory.

 BufferedInputStream: Adds buffering to another input stream for efficiency.

 DataInputStream : Reads primitive Java data types from an input stream.

 OutputStream:
The abstract superclass for all output byte streams.
 FileOutputStream: Writes bytes to a file.

 ByteArrayOutputStream: Writes bytes to an array in memory.

 BufferedOutputStream : Adds buffering to another output stream for efficiency.

 DataOutputStream: Writes primitive Java data types to an output stream.

2. Character Streams:
These streams process 16-bit Unicode characters and are primarily used for handling
text data. They automatically handle character encoding.

 Reader:

The abstract superclass for all input character streams.

 FileReader: Reads characters from a file.

 StringReader: Reads characters from a string.

 BufferedReader: Adds buffering to another reader for efficiency.

 InputStreamReader: Converts byte streams to character streams.

 Writer:
The abstract superclass for all output character streams.
 FileWriter: Writes characters to a file.

 StringWriter: Writes characters to a string.

 BufferedWriter: Adds buffering to another writer for efficiency.

 OutputStreamWriter: Converts character streams to byte streams.

Standard Streams:
Java also provides three standard streams that are automatically created:

 [Link]: A standard input stream, typically connected to the keyboard.

 [Link]: A standard output stream, typically connected to the console.

 [Link]: A standard error stream, typically connected to the console for error
messages.
Java 8 Stream API:
Separately from the [Link] package, Java 8 introduced the Stream API for processing
collections of objects in a functional style. This API provides a sequence of elements
that can be processed in parallel or sequentially, enabling operations like filtering,
mapping, and reducing data. These streams are not related to the I/O streams but offer
a powerful way to work with data collections.

3)What is File Class?

The [Link] class in Java provides an abstract representation of file and directory
pathnames. It is a fundamental class for interacting with the file system, allowing
programs to manage files and directories.

Key characteristics and functionalities of the File class:

 Abstract Pathname Representation:

The File class represents the name and location of a file or directory, not its
contents. It handles the differences in file naming conventions across various
operating systems.
 File System Interaction:

It provides methods for performing various operations on files and directories, such as:
 Creation and Deletion: createNewFile(), mkdir(), mkdirs(), delete()
 Inspection: exists(), isFile(), isDirectory(), isHidden(), canRead(), canWrite(),
canExecute()

 Information
Retrieval: getName(), getPath(), getAbsolutePath(), getParent(), length(), lastMod
ified()

 Manipulation: renameTo()
 Immutability:

Instances of the File class are immutable. Once a File object is created with a
specific abstract pathname, that pathname cannot be changed.
 Package:
 The File class is part of the [Link] package, which needs to be imported to use it.

 Constructors:
It offers various constructors to create File objects, including those accepting a
pathname string, a parent File object and a child pathname string, or a URI.