# java.io

***

**1. Reading Text from a File**

```java
try {
    BufferedReader reader = new BufferedReader(new FileReader("file.txt"));
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
    reader.close();
} catch (IOException e) {
    e.printStackTrace();
}
```

**2. Writing Text to a File**

```java
try {
    BufferedWriter writer = new BufferedWriter(new FileWriter("file.txt"));
    writer.write("Hello world!");
    writer.close();
} catch (IOException e) {
    e.printStackTrace();
}
```

**3. Reading Binary Data from a File**

```java
try {
    DataInputStream input = new DataInputStream(new FileInputStream("file.bin"));
    int value = input.readInt();
    input.close();
} catch (IOException e) {
    e.printStackTrace();
}
```

**4. Writing Binary Data to a File**

```java
try {
    DataOutputStream output = new DataOutputStream(new FileOutputStream("file.bin"));
    output.writeInt(1234);
    output.close();
} catch (IOException e) {
    e.printStackTrace();
}
```

**5. Serializing an Object**

```java
try {
    FileOutputStream fileOut = new FileOutputStream("object.ser");
    ObjectOutputStream out = new ObjectOutputStream(fileOut);
    out.writeObject(new Object());
    out.close();
    fileOut.close();
} catch (IOException | NotSerializableException e) {
    e.printStackTrace();
}
```

**6. Deserializing an Object**

```java
try {
    FileInputStream fileIn = new FileInputStream("object.ser");
    ObjectInputStream in = new ObjectInputStream(fileIn);
    Object object = in.readObject();
    in.close();
    fileIn.close();
} catch (IOException | ClassNotFoundException e) {
    e.printStackTrace();
}
```

**7. Reading from a URL**

```java
try {
    URL url = new URL("http://example.com");
    BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream()));
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
    reader.close();
} catch (IOException e) {
    e.printStackTrace();
}
```

**8. Writing to a URL**

```java
try {
    URL url = new URL("http://example.com");
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.setRequestMethod("POST");
    connection.setDoOutput(true);
    OutputStreamWriter writer = new OutputStreamWriter(connection.getOutputStream());
    writer.write("Hello world!");
    writer.close();
    connection.getResponseCode();
} catch (IOException e) {
    e.printStackTrace();
}
```

**9. Reading from a String**

```java
BufferedReader reader = new BufferedReader(new StringReader("Hello world!"));
String line;
while ((line = reader.readLine()) != null) {
    System.out.println(line);
}
reader.close();
```

**10. Writing to a String**

```java
StringWriter writer = new StringWriter();
writer.write("Hello world!");
String result = writer.toString();
writer.close();
```

**11. Reading from a ByteArrayInputStream**

```java
byte[] data = "Hello world!".getBytes();
ByteArrayInputStream input = new ByteArrayInputStream(data);
DataInputStream reader = new DataInputStream(input);
int value = reader.readInt();
reader.close();
input.close();
```

**12. Writing to a ByteArrayOutputStream**

```java
ByteArrayOutputStream output = new ByteArrayOutputStream();
DataOutputStream writer = new DataOutputStream(output);
writer.writeInt(1234);
writer.close();
byte[] data = output.toByteArray();
output.close();
```

**13. Reading from a PipedInputStream**

```java
PipedInputStream input = new PipedInputStream();
PipedOutputStream output = new PipedOutputStream();
output.connect(input);
output.write("Hello world!".getBytes());
output.close();
DataInputStream reader = new DataInputStream(input);
int value = reader.readInt();
reader.close();
input.close();
```

**14. Writing to a PipedOutputStream**

```java
PipedInputStream input = new PipedInputStream();
PipedOutputStream output = new PipedOutputStream();
input.connect(output);
DataInputStream reader = new DataInputStream(input);
output.write("Hello world!".getBytes());
output.close();
int value = reader.readInt();
reader.close();
input.close();
```

**15. Reading from a FilterInputStream**

```java
InputStream input = new FileInputStream("file.txt");
FilterInputStream filter = new BufferedInputStream(input);
DataInputStream reader = new DataInputStream(filter);
int value = reader.readInt();
reader.close();
filter.close();
input.close();
```

**16. Writing to a FilterOutputStream**

```java
OutputStream output = new FileOutputStream("file.txt");
FilterOutputStream filter = new BufferedOutputStream(output);
DataOutputStream writer = new DataOutputStream(filter);
writer.writeInt(1234);
writer.close();
filter.close();
output.close();
```

**17. Reading from a PushbackInputStream**

```java
InputStream input = new FileInputStream("file.txt");
PushbackInputStream buffer = new PushbackInputStream(input);
buffer.unread('a');
int value = buffer.read();
buffer.close();
input.close();
```

**18. Writing to a PushbackOutputStream**

```java
OutputStream output = new FileOutputStream("file.txt");
PushbackOutputStream buffer = new PushbackOutputStream(output);
buffer.write('a');
buffer.write("Hello world!".getBytes());
buffer.close();
output.close();
```

**19. Reading from a LineNumberInputStream**

```java
InputStream input = new FileInputStream("file.txt");
LineNumberInputStream reader = new LineNumberInputStream(input);
int lineNumber = reader.getLineNumber();
String line = reader.readLine();
reader.close();
input.close();
```

**20. Writing to a LineNumberOutputStream**

```java
OutputStream output = new FileOutputStream("file.txt");
LineNumberOutputStream writer = new LineNumberOutputStream(output);
writer.write("Hello world!".getBytes());
writer.close();
output.close();
```

**21. Reading from a SequenceInputStream**

```java
InputStream input1 = new FileInputStream("file1.txt");
InputStream input2 = new FileInputStream("file2.txt");
SequenceInputStream input = new SequenceInputStream(input1, input2);
DataInputStream reader = new DataInputStream(input);
int value = reader.readInt();
reader.close();
input.close();
input1.close();
input2.close();
```

**22. Writing to a PipedWriter**

```java
PipedReader input = new PipedReader();
PipedWriter output = new PipedWriter();
output.connect(input);
output.write("Hello world!");
output.close();
BufferedReader reader = new BufferedReader(input);
String line = reader.readLine();
reader.close();
input.close();
```

**23. Reading from a CharArrayReader**

```java
char[] data = "Hello world!".toCharArray();
CharArrayReader reader = new CharArrayReader(data);
int value = reader.read();
reader.close();
```

**24. Writing to a CharArrayWriter**

```java
CharArrayWriter writer = new CharArrayWriter();
writer.write("Hello world!");
char[] data = writer.toCharArray();
writer.close();
```

**25. Reading from a StringReader**

```java
String data = "Hello world!";
StringReader reader = new StringReader(data);
int value = reader.read();
reader.close();
```

**26. Writing to a FileWriter**

```java
FileWriter writer = new FileWriter("file.txt");
writer.write("Hello world!");
writer.close();
```

**27. Reading from a FileReader**

```java
FileReader reader = new FileReader("file.txt");
int value = reader.read();
reader.close();
```

**28. Creating a DataInputStream from a File**

```java
DataInputStream input = new DataInputStream(new FileInputStream("file.bin"));
int value = input.readInt();
input.close();
```

**29. Creating a DataOutputStream from a File**

```java
DataOutputStream output = new DataOutputStream(new FileOutputStream("file.bin"));
output.writeInt(1234);
output.close();
```

**30. Creating a BufferedReader from a String**

```java
BufferedReader reader = new BufferedReader(new StringReader("Hello world!"));
String line = reader.readLine();
reader.close();
```

**31. Creating a BufferedWriter from a String**

```java
BufferedWriter writer = new BufferedWriter(new StringWriter());
writer.write("Hello world!");
writer.close();
```

**32. Creating a FilterInputStream from a File**

```java
FilterInputStream input = new BufferedInputStream(new FileInputStream("file.txt"));
int value = input.read();
input.close();
```

**33. Creating a FilterOutputStream from a File**

```java
FilterOutputStream output = new BufferedOutputStream(new FileOutputStream("file.txt"));
output.write(1234);
output.close();
```

**34. Creating a PushbackInputStream from a File**

```java
PushbackInputStream input = new PushbackInputStream(new FileInputStream("file.txt"));
input.unread('a');
int value = input.read();
input.close();
```

**35. Creating a PushbackOutputStream from a File**

```java
PushbackOutputStream output = new PushbackOutputStream(new FileOutputStream("file.txt"));
output.write('a');
output.write(1234);
output.close();
```

**36. Creating a LineNumberInputStream from a File**

```java
LineNumberInputStream input = new LineNumberInputStream(new FileInputStream("file.txt"));
int lineNumber = input.getLineNumber();
String line = input.readLine();
input.close();
```

**37. Creating a LineNumberOutputStream from a File**

```java
LineNumberOutputStream output = new LineNumberOutputStream(new FileOutputStream("file.txt"));
output.write(1234);
output.close();
```

**38. Creating a SequenceInputStream from multiple Files**

```java
InputStream input1 = new FileInputStream("file1.txt");
InputStream input2 = new FileInputStream("file2.txt");
SequenceInputStream input = new SequenceInputStream(input1, input2);
int value = input.read();
input.close();
input1.close();
input2.close();
```

**39. Creating a PipedInputStream and PipedOutputStream**

```java
PipedInputStream input = new PipedInputStream();
PipedOutputStream output = new PipedOutputStream();
output.connect(input);
```

**40. Creating a CharArrayReader from a char array**

```java
char[] data = "Hello world!".toCharArray();
CharArrayReader reader = new CharArrayReader(data);
int value = reader.read();
reader.close();
```

**41. Creating a CharArrayWriter**

```java
CharArrayWriter writer = new CharArrayWriter();
writer.write("Hello world!");
char[] data = writer.toCharArray();
writer.close();
```

**42. Creating a StringReader from a String**

```java
String data = "Hello world!";
StringReader reader = new StringReader(data);
int value = reader.read();
reader.close();
```

**43. Creating a FileWriter**

```java
FileWriter writer = new FileWriter("file.txt");
writer.write("Hello world!");
writer.close();
```

**44. Creating a FileReader**

```java
FileReader reader = new FileReader("file.txt");
int value = reader.read();
reader.close();
```

**45. Using a FileInputStream to read a file into a byte array**

```java
byte[] data = new byte[1024];
FileInputStream input = new FileInputStream("file.txt");
input.read(data);
input.close();
```

**46. Using a FileOutputStream to write a byte array to a file**

```java
byte[] data = "Hello world!".getBytes();
FileOutputStream output = new FileOutputStream("file.txt");
output.write(data);
output.close();
```

**47. Using a StringReader to read a string into a character array**

```java
char[] data = new char[1024];
StringReader reader = new StringReader("Hello world!");
reader.read(data);
reader.close();
```

**48. Using a StringWriter to write a character array to a string**

```java
char[] data = "Hello world!".toCharArray();
StringWriter writer = new StringWriter();
writer.write(data);
String result = writer.toString();
writer.close();
```

**49. Using a PipedInputStream and PipedOutputStream to communicate between threads**

```java
PipedInputStream input = new PipedInputStream();
PipedOutputStream output = new PipedOutputStream();
output.connect(input);

Thread thread1 = new Thread(() -> {
    try {
        output.write("Hello world!".getBytes());
        output.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
});

Thread thread2 = new Thread(() -> {
    try {
        byte[] data = new byte[1024];
        input.read(data);
        System.out.println(new String(data));
        input.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
});

thread1.start();
thread2.start();

thread1.join();
thread2.join();
```

**50. Using a FileChannel to read and write data to a file**

```java
FileChannel channel = FileChannel.open(Paths.get("file.txt"), StandardOpenOption.READ, StandardOpenOption.WRITE);

ByteBuffer buffer = ByteBuffer.allocate(1024);

channel.read(buffer);
buffer.flip();

channel.write(buffer);
channel.close();
```