HMR
INSTITUTE OF TECHNOLOGY AND MANAGEMENT
PRACTICAL FILE
Of JAVA
FOR
BACHELOR OF TECHNOLOGY, 2ND YEAR
DEPARTMENT-COMPUTER SCIENCE
ENGINEERING
Submitted To: Submitted by:
Dr.Veerendra Yadav PRATHAM MEHTA
00196502721
CSE 4rd Sem
Exp Aim of Experiment Date Remarks Teacher’s
No.
signature
Experiment- 1
AIM – write a program to show method overloading
public class methodoverloading_1 {
public int add(int a, int b) {
return a + b;
}
public int add(int a, int b, int c) {
return a + b + c;
}
public double add(double a, double b) {
return a + b;
}
public static void main(String[] args) {
methodoverloading_1 obj = new methodoverloading_1();
int result1 = obj.add(1, 2);
int result2 = obj.add(1, 2, 3);
double result3 = obj.add(1.5, 2.5);
System.out.println("Result 1: " + result1);
System.out.println("Result 2: " + result2);
System.out.println("Result 3: " + result3);
}
}
Output
Experiment-2
Aim-Write a java program to implement stack and queue concept.
import java.util.LinkedList;
public class StackAndQueue_2 {
// Implementing stack using LinkedList
private LinkedList<Integer> stack = new LinkedList<>();
// Push operation to add an element to the stack
public void push(int element) {
stack.addFirst(element);
}
// Pop operation to remove the top element from the stack
public int pop() {
return stack.removeFirst();
}
// Peek operation to return the top element from the stack without
removing it
public int peek() {
return stack.getFirst();
}
// Checking if stack is empty
public boolean isEmpty() {
return stack.isEmpty();
}
// Implementing queue using LinkedList
private LinkedList<Integer> queue = new LinkedList<>();
// Enqueue operation to add an element to the queue
public void enqueue(int element) {
queue.addLast(element);
}
// Dequeue operation to remove the front element from the queue
public int dequeue() {
return queue.removeFirst();
}
// Peek operation to return the front element from the queue without
removing it
public int front() {
return queue.getFirst();
}
// Checking if queue is empty
public boolean isQueueEmpty() {
return queue.isEmpty();
}
public static void main(String[] args) {
StackAndQueue_2 stackAndQueue = new StackAndQueue_2();
// Pushing elements to the stack
stackAndQueue.push(10);
stackAndQueue.push(20);
stackAndQueue.push(30);
// Printing the top element of the stack
System.out.println("Top element of stack: " + stackAndQueue.peek());
// Popping elements from the stack
System.out.println(stackAndQueue.pop() + " popped from stack");
System.out.println(stackAndQueue.pop() + " popped from stack");
// Checking if stack is empty
System.out.println("Is stack empty? " + stackAndQueue.isEmpty());
// Enqueuing elements to the queue
stackAndQueue.enqueue(40);
stackAndQueue.enqueue(50);
stackAndQueue.enqueue(60);
// Printing the front element of the queue
System.out.println("Front element of queue: " + stackAndQueue.front());
// Dequeuing elements from the queue
System.out.println(stackAndQueue.dequeue() + " dequeued from
queue");
System.out.println(stackAndQueue.dequeue() + " dequeued from
queue");
// Checking if queue is empty
System.out.println("Is queue empty? " +
stackAndQueue.isQueueEmpty());
}
}
Output
Experiment-3
Aim- write a program to produce the token from given long
string.
import java.util.StringTokenizer;
public class Tokenizer_3 {
public static void main(String[] args) {
String longString = "This is a long string with multiple words
and punctuations. It includes commas, periods, and question
marks.";
StringTokenizer tokenizer = new StringTokenizer(longString,
" ,.?!");
while (tokenizer.hasMoreTokens()) {
System.out.println(tokenizer.nextToken());
}
}
}
Output
Experiment-4
Aim- Write a java program to show multithreaded producer and
consumer application.
import java.util.LinkedList;
public class ProducerConsumer_4 {
public static void main(String[] args) {
LinkedList<Integer> buffer = new LinkedList<Integer>();
int bufferSize = 10;
int producerCount = 2;
int consumerCount = 3;
Thread[] producerThreads = new
Thread[producerCount];
Thread[] consumerThreads = new
Thread[consumerCount];
// Create and start producer threads
for (int i = 0; i < producerCount; i++) {
Producer producer = new Producer(buffer,
bufferSize);
producerThreads[i] = new Thread(producer,
"Producer " + (i + 1));
producerThreads[i].start();
}
// Create and start consumer threads
for (int i = 0; i < consumerCount; i++) {
Consumer consumer = new Consumer(buffer);
consumerThreads[i] = new Thread(consumer,
"Consumer " + (i + 1));
consumerThreads[i].start();
}
}
}
class Producer implements Runnable {
private LinkedList<Integer> buffer;
private int bufferSize;
public Producer(LinkedList<Integer> buffer, int bufferSize)
{
this.buffer = buffer;
this.bufferSize = bufferSize;
}
public void run() {
while (true) {
synchronized(buffer) {
// Wait if buffer is full
while (buffer.size() == bufferSize) {
try {
buffer.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// Produce item and add to buffer
int item = (int) (Math.random() * 100);
buffer.add(item);
System.out.println(Thread.currentThread().getName() + "
produced " + item);
// Notify waiting consumers
buffer.notifyAll();
}
// Sleep for some time before producing next item
try {
Thread.sleep((int) (Math.random() * 1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Consumer implements Runnable {
private LinkedList<Integer> buffer;
public Consumer(LinkedList<Integer> buffer) {
this.buffer = buffer;
}
public void run() {
while (true) {
synchronized(buffer) {
// Wait if buffer is empty
while (buffer.isEmpty()) {
try {
buffer.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// Consume item from buffer
int item = buffer.remove();
System.out.println(Thread.currentThread().getName() + "
consumed " + item);
// Notify waiting producers
buffer.notifyAll();
}
// Sleep for some time before consuming next item
try {
Thread.sleep((int) (Math.random() * 1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
Output
