Scribd
Upload
36 views6 pages

Java Exp 9 10

The document discusses reading from and writing to files in Java using FileInputStream, FileOutputStream, FileReader, BufferedReader, FileWriter, and BufferedWriter. It also covers multi-threading concepts like wait/notify and producer-consumer using a bounded buffer.

Uploaded by

smdazeem.net2022
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
36 views6 pages

Java Exp 9 10

The document discusses reading from and writing to files in Java using FileInputStream, FileOutputStream, FileReader, BufferedReader, FileWriter, and BufferedWriter. It also covers multi-threading concepts like wait/notify and producer-consumer using a bounded buffer.

Uploaded by

smdazeem.net2022
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 6

(i) Writing to a file and reading from a text file using FileInputStream and FileOutputStream:

```java
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileReadWrite {


public static void main(String[] args) {
String fileName = "test.txt";
String message = "Hello, world!";

// Writing to a file
try (FileOutputStream outputStream = new FileOutputStream(fileName)) {
outputStream.write(message.getBytes());
System.out.println("Data written to file successfully.");
} catch (IOException e) {
e.printStackTrace();
}

// Reading from a file


try (FileInputStream inputStream = new FileInputStream(fileName)) {
int data;
StringBuilder content = new StringBuilder();
while ((data = inputStream.read()) != -1) {
content.append((char) data);
}
System.out.println("Data read from file: " + content.toString());
} catch (IOException e) {
e.printStackTrace();
}
}
}
```

(ii) Reading from a text file using FileReader and BufferedReader:

```java
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class FileRead {


public static void main(String[] args) {
String fileName = "test.txt";

try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {


String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
```

(iii) Writing to a file using FileWriter and BufferedWriter:

```java
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class FileWrite {


public static void main(String[] args) {
String fileName = "test.txt";
String message = "Hello, world!";

try (BufferedWriter writer = new BufferedWriter(new FileWriter(fileName))) {


writer.write(message);
System.out.println("Data written to file successfully.");
} catch (IOException e) {
e.printStackTrace();
}
}
}

import java.util.Random;
import java.util.HashSet;
import java.util.Set;
class NumberGenerator implements Runnable
{
private Set<Integer> generatedNumbers = new HashSet<>();
public void run()
{
Random random = new Random();
try
{
while(true)
{
int number = random.nextInt(5);
if (!generatedNumbers.contains(number))
{
System.out.println("Generated number: " + number);
generatedNumbers.add(number);
if (number % 2 == 0)
{
synchronized (ThreadSquare.class)
{
ThreadSquare.number = number;
ThreadSquare.class.notify();
}
}
else
{
synchronized (ThreadCube.class)
{
ThreadCube.number = number;
ThreadCube.class.notify();
}
}
Thread.sleep(1000);
}
}
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}

class ThreadSquare implements Runnable


{
public static int number;

public void run()


{
try
{
while (true)
{
synchronized (ThreadSquare.class)
{
ThreadSquare.class.wait();
System.out.println("Square of " + number + ": " + (number
* number));
}
}
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
class ThreadCube implements Runnable
{
public static int number;

public void run()


{
try
{
while (true)
{
synchronized (ThreadCube.class)
{
ThreadCube.class.wait();
System.out.println("Cube of " + number + ": " + (number *
number * number));
}
}
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}

public class Main_multiThread


{
public static void main(String[] args)
{
Thread t1 = new Thread(new NumberGenerator());
Thread t2 = new Thread(new ThreadSquare());
Thread t3 = new Thread(new ThreadCube());

t1.start();
t2.start();
t3.start();
}
}

import java.util.LinkedList;
class ProducerConsumer {
LinkedList<Integer> buffer = new LinkedList<>();
int capacity = 5;
public void produce() throws InterruptedException {
int value = 0;
while (true) {
synchronized (this) {
while (buffer.size() == capacity) {
wait();
}
System.out.println("Producer produced: " + value);
buffer.add(value++);
notify();
Thread.sleep(1000);
}
}
}

public void consume() throws InterruptedException {


while (true) {
synchronized (this) {
while (buffer.size() == 0) {
wait();
}
int consumedValue = buffer.removeFirst();
System.out.println("Consumer consumed: " + consumedValue);
notify();
Thread.sleep(1000);
}
}
}
}

public class Main {


public static void main(String[] args) {
final ProducerConsumer pc = new ProducerConsumer();

Thread producerThread = new Thread(new Runnable() {


@Override
public void run() {
try {
pc.produce();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});

Thread consumerThread = new Thread(new Runnable() {


@Override
public void run() {
try {
pc.consume();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});

producerThread.start();
consumerThread.start();
}
}

You might also like