UNIT - 2

1) Byte Stream Classes:-

In Java, byte stream classes are used for handling input and output of raw bytes. These classes are typically used for
reading and writing binary data, such as image files, sound files, or any other data that does not contain textual
information.

There are two main types of byte stream classes in Java: InputStream and OutputStream. The InputStream class
provides methods for reading bytes from a source, while the OutputStream class provides methods for writing bytes
to a destination.

Some of the most commonly used byte stream classes in Java include:

1) FileInputStream and FileOutputStream: These classes are used for reading and writing data to and from a file.

2) ByteArrayInputStream and ByteArrayOutputStream: These classes are used for reading and writing data to and
from an in-memory byte array.

3) DataInputStream and DataOutputStream: These classes are used for reading and writing binary data types, such
as integers, floating point numbers, and strings.

4) BufferedInputStream and BufferedOutputStream: These classes provide a buffered layer on top of an input or
output stream, which can improve performance when reading or writing large amounts of data.

When working with byte stream classes in Java, it is important to remember to close the streams when you are
finished using them. This can be done using the close() method, or by using a try-with-resources block, which will
automatically close the stream when the block is exited.

Overall, byte stream classes are a fundamental part of Java's I/O system, and are essential for working with binary
data in a variety of applications.

import java.io.*;

public class ByteStreamExample {

public static void main(String[] args) throws IOException {

// write binary data to a file

FileOutputStream fos = new FileOutputStream("data.bin");

DataOutputStream dos = new DataOutputStream(fos);

dos.writeInt(42);

dos.writeDouble(3.14159);

dos.writeUTF("Hello, world!");

dos.close();

// read binary data from the file

FileInputStream fis = new FileInputStream("data.bin");

DataInputStream dis = new DataInputStream(fis);

int i = dis.readInt();
 double d = dis.readDouble();

String s = dis.readUTF();

dis.close();

// print the values that were read

System.out.println("i = " + i);

System.out.println("d = " + d);

System.out.println("s = " + s);

2) Thread Synchorinzation:-
Thread synchronization in Java is a mechanism that allows multiple threads to access a shared resource in a
controlled manner. It ensures that only one thread can access the shared resource at any given time, preventing race
conditions and other synchronization issues.

There are two ways to synchronize threads in Java:

Synchronized blocks: A synchronized block is a section of code that is executed by only one thread at a time. The
syntax for a synchronized block is:

Copy code

synchronized (object) {

// Code to be synchronized

The object in parentheses is the object that the thread must acquire a lock on before it can execute the synchronized
block. Only one thread can acquire the lock on the object at any given time.

Synchronized methods: A synchronized method is a method that is declared with the synchronized keyword. When a
thread calls a synchronized method, it automatically acquires a lock on the object that the method is called on. Only
one thread can execute a synchronized method at any given time.

public synchronized void method() {

// Code to be synchronized

In both cases, the synchronized code must be carefully designed to avoid deadlocks, where multiple threads are
waiting for each other to release locks.

Thread synchronization is important in multi-threaded applications to ensure data consistency and avoid race
conditions.
UNIT – 3
1) Bitset:-
In Java, a BitSet is a class that represents a set of bits or binary values. It is similar to an array of Boolean values but
uses much less memory.

A BitSet is created with a specific size, which determines the number of bits that can be stored in it. Each bit is
represented as a Boolean value, where "true" means the bit is set to 1 and "false" means it is set to 0.

BitSets are useful when you need to efficiently store and manipulate large sets of Boolean values. For example, they
can be used to represent flags or permissions in a system, where each bit corresponds to a specific permission.

BitSets provide methods for setting, clearing, flipping, and testing individual bits, as well as logical operations such as
AND, OR, and XOR. They also support operations for finding the next set or unset bit in the set.

import java.util.BitSet;

public class BitSetExample {

public static void main(String[] args) {

BitSet bs1 = new BitSet(8);

BitSet bs2 = new BitSet(8);

// set some bits in bs1

bs1.set(0);

bs1.set(2);

bs1.set(4);

bs1.set(6);

// set some bits in bs2

bs2.set(1);

bs2.set(3);

bs2.set(5);

bs2.set(7);

// print the contents of each BitSet

System.out.println("bs1: " + bs1);

System.out.println("bs2: " + bs2);

 // perform some bitwise operations

BitSet andResult = (BitSet) bs1.clone();

andResult.and(bs2);

System.out.println("bs1 AND bs2: " + andResult);

BitSet orResult = (BitSet) bs1.clone();

orResult.or(bs2);

System.out.println("bs1 OR bs2: " + orResult);

BitSet xorResult = (BitSet) bs1.clone();

xorResult.xor(bs2);

System.out.println("bs1 XOR bs2: " + xorResult);

2) Write a java pg to comparartor

import java.util.*;
import java.io.*;
class Simple{
public static void main(String args[]){

ArrayList<Student> al=new ArrayList<Student>();

al.add(new Student(101,"Vijay",23));
al.add(new Student(106,"Ajay",27));
al.add(new Student(105,"Jai",21));

System.out.println("Sorting by Name");

Collections.sort(al,new NameComparator());
for(Student st: al){
System.out.println(st.rollno+" "+st.name+" "+st.age);
}

System.out.println("Sorting by age");

Collections.sort(al,new AgeComparator());
for(Student st: al){
 System.out.println(st.rollno+" "+st.name+" "+st.age);
}
}
}
Sorting by Name
106 Ajay 27
105 Jai 21
101 Vijay 23

Sorting by age
105 Jai 21
101 Vijay 23
106 Ajay 27

3) Random access interface:-

In Java, a random access interface is provided by the RandomAccess interface. This interface is typically used to
indicate that a class provides fast random access to its elements.

The RandomAccess interface does not include any methods; it is simply a marker interface that allows algorithms to
take advantage of the fast random access offered by certain data structures such as arrays or ArrayLists. This interface
can be implemented by any class that provides fast random access to its elements.

When a class implements the RandomAccess interface, it can be used by algorithms that require fast random access,
such as the binary search algorithm. By using the RandomAccess interface, the algorithm can determine whether to
use a linear search or a binary search to find a particular element in the data structure. If the data structure
implements the RandomAccess interface, the algorithm will use a binary search, which is faster than a linear search.

Here is an example of how the RandomAccess interface can be used:

import java.util.*;

public class Example implements RandomAccess {

private List<String> list;

public Example() {

list = new ArrayList<String>();

public void add(String str) {

list.add(str);

public String get(int index) {

 return list.get(index);

public static void main(String[] args) {

Example ex = new Example();

ex.add("one");

ex.add("two");

ex.add("three");

// Using binary search on the Example object

int index = Collections.binarySearch(ex, "two");

System.out.println("Index of \"two\": " + index);

In the above example, the Example class implements the RandomAccess interface and provides fast random access
to its elements via the get method. The main method uses the binarySearch method from the Collections class to
find the index of the element "two" in the Example object. Since the Example class implements the RandomAccess
interface, the binary search algorithm will use a binary search to find the element, resulting in faster performance.

4) Explain how iteration class works?

In Java, the Iterator class is used to iterate over a collection of objects. It provides a way to access the elements of a
collection one at a time without exposing the underlying implementation of the collection. The Iterator class is part
of the Java Collections Framework and is implemented by all collection classes.

The Iterator class provides three main methods:

1. `hasNext()`: This method returns true if the iterator has more elements to iterate over, and false otherwise.

2. `next()`: This method returns the next element in the iteration. If there are no more elements, it throws a
NoSuchElementException.

3. `remove()`: This method removes the last element returned by the iterator. It can only be called once per call to
`next()`, and only if `next()` has been called at least once.

Here is an example of how to use the Iterator class in Java:

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

myList.add("apple");

myList.add("banana");

myList.add("orange");
Iterator<String> iterator = myList.iterator();

while (iterator.hasNext()) {

String element = iterator.next();

System.out.println(element);

In this example, we create an ArrayList of strings and add three elements to it. We then create an Iterator object for
the list and use a while loop to iterate over the elements. Inside the loop, we use the `next()` method to get the next
element in the list and print it to the console.

Note that the `remove()` method is not used in this example, but it can be used to remove elements from the list as
they are being iterated over. It is important to use the `remove()` method carefully, as calling it incorrectly can result
in unexpected behavior.

UNIT – 4 Introducing AWT Working with Graphics

1) Working with graphics in Java involves using the Java Graphics and Graphics2D classes,
which provide a powerful set of tools for creating and manipulating graphical elements. Here are
some basic steps to get started:

1. Import the necessary classes: To use the Java graphics classes, you will need to import the java.awt.*
and javax.swing.* packages.
2. Create a JFrame or JPanel: You can use a JFrame or JPanel as a container for your graphics elements.
A JFrame is a top-level window, while a JPanel can be embedded in a larger container.
3. Override the paintComponent() method: To draw graphics elements on your container, you will
need to override the paintComponent() method of your container. This method is called
automatically when the container needs to be repainted.
4. Create a Graphics2D object: Inside the paintComponent() method, create a Graphics2D object using
the getGraphics() method of your container.
5. Draw graphics elements: Use the methods of the Graphics2D class to draw lines, shapes, text, and
images. For example, you can use the drawLine() method to draw a line, or the fillRect() method to
fill a rectangle.
6. Repaint the container: After drawing your graphics elements, call the repaint() method of your
container to trigger a repaint of the container.This code creates a JPanel, overrides its
paintComponent() method to draw a line and a rectangle, and then adds the panel to a JFrame.
When you run this code, you should see a window with a line and a rectangle inside it.

Here's a simple example that draws a line and a rectangle on a JPanel:

import java.awt.*;
import javax.swing.*;

public class DrawRectangle {

public static void main(String[] arguments) {

MyPanel panel = new MyPanel();

 // create a basic JFrame
JFrame.setDefaultLookAndFeelDecorated(true);
JFrame frame = new JFrame("JFrame Color Example");
frame.setSize(300,200);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

// add panel to main frame

frame.add(panel);

frame.setVisible(true);

}
}

// create a panel that you can draw on.

class MyPanel extends JPanel {
public void paint(Graphics g) {
g.setColor(Color.red);
g.fillRect(10,10,100,100);
}
}

Output:
$ java DrawRectangle

2) Event Handling Mechanism:-

This code creates a JPanel, overrides its paintComponent() method to draw a line and a rectangle, and then adds the
panel to a JFrame. When you run this code, you should see a window with a line and a rectangle inside it.

In computer programming, an event handling mechanism is a system that allows programs to respond to
events or actions that occur outside the normal flow of the program's execution. Events can be triggered by
user actions, such as clicking a button or pressing a key, or by changes in the state of the system, such as a
timer expiring or a network connection being established.

The basic idea behind event handling is that the program sets up a set of event handlers, which are
functions or methods that are executed in response to specific events. When an event occurs, the system
notifies the appropriate event handler, which can then take some action based on the event.
Event handling mechanisms can vary depending on the programming language and framework being used.
In general, though, the basic steps involved in handling events are:

1. Registering event handlers: The program sets up one or more event handlers to handle specific
types of events. For example, a button click event might have a corresponding event handler that
executes when the button is clicked.
2. Waiting for events: The program enters a loop or other mechanism that waits for events to occur.
This might involve polling for events, or using a callback mechanism where the system notifies the
program when an event occurs.
3. Handling events: When an event occurs, the system identifies the appropriate event handler and
executes it. The event handler can then take some action based on the event. This might involve
updating the user interface, performing a computation, or triggering some other action.
4. Returning to waiting: After an event has been handled, the program returns to waiting for the next
event to occur.

Overall, event handling mechanisms provide a powerful way for programs to respond to user input and
other external events, making them an essential tool for building interactive and responsive software.

3) AWT Components : -
AWT (Abstract Window Toolkit) is a set of Java classes used for creating graphical user interfaces (GUIs) in
Java applications. AWT provides a collection of components, including:

1. Frame - A top-level container with a title bar and borders.

2. Panel - A container that can be used to group other components together.
3. Button - A clickable button that performs an action when pressed.
4. Label - A text label used to display information or instructions.
5. TextField - A single-line text field used to accept input from the user.
6. TextArea - A multi-line text field used to accept longer input from the user.
7. Checkbox - A checkbox used to select one or more options.
8. CheckboxGroup - A group of checkboxes that are mutually exclusive.
9. Choice - A drop-down list of options.
10. List - A scrollable list of items.
11. Scrollbar - A horizontal or vertical scrollbar used to navigate through content.
12. Canvas - A blank area that can be drawn on using graphics methods.
13. MenuBar - A bar containing menus that can be used to select actions or options.
14. Menu - A drop-down menu containing selectable options.
15. MenuItem - An item within a menu that performs an action when selected.
16. Dialog - A pop-up window used to display information or accept input from the user.
17. FileDialog - A dialog for selecting files or directories.
18. Font - A class representing a font used for drawing text.
19. Color - A class representing a color used for drawing graphics.

These components can be used to create a wide range of GUIs, from simple dialogs to complex applications
with multiple windows and menus.
UNIT – 5
Swing Components:-
Swing is a set of GUI (Graphical User Interface) components for Java programming language. Swing
provides a variety of components that can be used to create desktop applications with a rich user interface.
Some of the commonly used Swing components are:

1. JFrame - It is the main container for a Swing application, and provides the window frame for the
application.
2. JPanel - It is a container that can hold other components, and is often used as a container for
grouping related components.
3. JButton - It is a simple button component that can be used to trigger an action.
4. JLabel - It is a component that displays text or an image.
5. JCheckBox - It is a component that provides a checkbox, which can be used to select or deselect an
option.
6. JTextField - It is a component that allows the user to enter text.
7. JList - It is a component that displays a list of items, from which the user can select one or more
items.
8. JComboBox - It is a component that provides a drop-down list of items, from which the user can
select one item.
9. JRadioButton - It is a component that provides a radio button, which can be used to select one
option from a group of options.
10. JSlider - It is a component that provides a slider, which can be used to select a value from a range.

These are just a few examples of the many Swing components available for use in Java applications. Each
component has its own set of properties and methods, which can be used to customize its appearance and
behavior.

# About Swing Package:-

The Swing package is a part of the Java Foundation Classes (JFC) that provides a set of graphical user
interface (GUI) components for creating desktop applications in Java. It includes a wide range of
components such as buttons, text fields, labels, lists, tables, and many more that can be used to create
interactive and dynamic user interfaces.

Swing was introduced in Java 1.2 as a replacement for the earlier Abstract Window Toolkit (AWT). Unlike
AWT, Swing is implemented entirely in Java, which makes it platform-independent and provides a
consistent look and feel across different operating systems.

Some of the key features of Swing include:

 Customizable look and feel: Swing provides a pluggable look and feel architecture, which allows
developers to change the appearance of their applications easily. It includes several predefined look
and feels such as Metal, Windows, and Motif, and also allows developers to create their own custom
look and feel.
 Rich set of components: Swing provides a wide range of components that can be used to create
complex and sophisticated user interfaces. These components are highly customizable and provide a
lot of flexibility in terms of layout and behavior.
  Event-driven programming model: Swing follows an event-driven programming model, where
components generate events in response to user actions, and developers write event listeners to
handle those events. This allows for highly interactive and responsive user interfaces.

Overall, Swing is a powerful and versatile GUI toolkit that has been widely used for developing desktop
applications in Java. However, with the rise of web and mobile applications, its popularity has declined in
recent years in favor of other technologies such as JavaFX and web-based frameworks.

# J Button pg:-
import java.awt.*;

import javax.swing.*;

public class BorderLayoutExample

JFrame jframe;

// constructor

BorderLayoutExample()

// creating a Frame

jframe = new JFrame();

// create buttons

JButton btn1 = new JButton("NORTH");

JButton btn2 = new JButton("SOUTH");

JButton btn3 = new JButton("EAST");

JButton btn4 = new JButton("WEST");

JButton btn5 = new JButton("CENTER");

// creating an object of the BorderLayout class using

// the parameterized constructor where the horizontal gap is 20

// and vertical gap is 15. The gap will be evident when buttons are placed

// in the frame

jframe.setLayout(new BorderLayout(20, 15));

jframe.add(btn1, BorderLayout.NORTH);

jframe.add(btn2, BorderLayout.SOUTH);

jframe.add(btn3, BorderLayout.EAST);

jframe.add(btn4, BorderLayout.WEST);

jframe.add(btn5, BorderLayout.CENTER);

jframe.setSize(300,300);
 jframe.setVisible(true);

// main method

public static void main(String argvs[])

new BorderLayoutExample();

Output:

# Serialization :-
Serialization in Java is the process of converting an object into a byte stream so that it can be transmitted over a
network or stored in a file for later use. This byte stream can be used to recreate the object again in memory.

To make an object serializable, the class must implement the Serializable interface, which is a marker interface (an
interface with no methods). This indicates that the class can be serialized.

Once a class is marked as Serializable, we can serialize an instance of the class using an ObjectOutputStream. Here's
an example:

java

import java.io.*;

public class SerializationExample {

public static void main(String[] args) {

MyClass obj = new MyClass(42, "hello");

try {

FileOutputStream fileOut = new FileOutputStream("filename.ser");

ObjectOutputStream out = new ObjectOutputStream(fileOut);

out.writeObject(obj);

out.close();

fileOut.close();

System.out.println("Serialized data is saved in filename.ser");

} catch (IOException i) {

i.printStackTrace();

}
In this example, we create an instance of MyClass and write it to a file called "filename.ser". We first create a
FileOutputStream, which is used to write data to a file. We then create an ObjectOutputStream, which is used to
write objects to a stream. We write the object to the stream using the writeObject method, and then close the
stream and the file.

We can deserialize an object using an ObjectInputStream. Here's an example:

java

import java.io.*;

public class DeserializationExample {

public static void main(String[] args) {

MyClass obj = null;

try {

FileInputStream fileIn = new FileInputStream("filename.ser");

ObjectInputStream in = new ObjectInputStream(fileIn);

obj = (MyClass) in.readObject();

in.close();

fileIn.close();

} catch (IOException i) {

i.printStackTrace();

return;

} catch (ClassNotFoundException c) {

System.out.println("MyClass class not found");

c.printStackTrace();

return;

System.out.println("Deserialized MyClass...");

System.out.println("myInt = " + obj.getMyInt());

System.out.println("myString = " + obj.getMyString());

In this example, we read the serialized object from the file using a FileInputStream and an ObjectInputStream. We
then cast the object to the MyClass type and print out its properties. It's important to catch the
ClassNotFoundException, which can be thrown if the class being deserialized is not found in the classpath.
# Image Package:-
In Java, there are several libraries available for working with images. Some of the popular ones are:

Java 2D API: This is a built-in Java library that provides a comprehensive set of classes and interfaces for working with
2D graphics and images. It includes support for image manipulation, drawing, and text rendering.

Java Image I/O API: This API provides a set of classes for reading and writing images in different formats. It includes
support for popular image formats like JPEG, PNG, and GIF.

Java Advanced Imaging (JAI): This is a set of extensions to the Java 2D API that provides advanced image processing
capabilities like image scaling, rotation, and filtering.

Here's an example of how to read an image file using the Java Image I/O API:

import java.io.File;

import java.io.IOException;

import javax.imageio.ImageIO;

import java.awt.image.BufferedImage;

public class ImageReader {

public static void main(String[] args) {

try {

// Read image from file

BufferedImage image = ImageIO.read(new File("image.jpg"));

// Get image dimensions

int width = image.getWidth();

int height = image.getHeight();

// Print dimensions

System.out.println("Image dimensions: " + width + "x" + height);

} catch (IOException e) {

System.out.println("Error reading image file: " + e.getMessage());

This code reads an image file named "image.jpg" and prints its dimensions. You can modify this code to perform
other operations on the image, like resizing, cropping, or applying filters.

# Socket programming in Java allows applications to communicate with each other over a network
using sockets. Sockets are endpoints for sending and receiving data across a network, and Java provides a rich set of
APIs for socket programming.
To create a socket in Java, you need to create an instance of the Socket class. The Socket class provides methods for
connecting to a remote host and sending/receiving data over the network.