(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();
}
}