目录
- 1. Writer
- 1.1 写两行数据
- 1.2 换一种方式
- 1.3 追加数据
- 1.4 写很多数据，记得要清一下缓存
- 1.5 用数组、字符串写入
- 2. Reader
- 2.1 读个文件
- 2.2 读取字符
- 2.3 读取数据到数组
- 2.4 复制文件
- 3. InputStream
- 4. OutputStream
- 5. 参考链接
1. Writer
Writer类是Java.io包中的一个抽象类，用来将字符或字符串写入到输出流中。Writer类继承了Java.io.Writer类的一些方法，并添加了一些新的方法来实现字符和字符串的输出。Writer类是抽象类，不能直接使用，需要使用他的子类对象来操作输出流。
Writer类的常用子类有：
- FileWriter：用于将字符或字符串写入文件中。
- StringWriter：用于将字符或字符串写入到字符串缓冲区中。
- BufferedWriter：将文本数据写入到输出流中，比如文件或网络连接。它可以一次写入一个字符、字符数组或字符串，并将数据缓存到内存中，然后在适当的时候将缓冲区中的数据一次性写入输出流。
使用BufferedWriter的步骤如下：
- 创建一个BufferedWriter对象，可以通过传入一个Writer对象作为参数来实现。
- 使用BufferedWriter的write方法将数据写入缓冲区。
- 使用BufferedWriter的flush方法将缓冲区中的数据写入输出流，可以在写入完毕后调用该方法，也可以在需要时手动调用。
- 使用BufferedWriter的close方法关闭输出流，关闭之前会自动调用flush方法。
举几个例子：
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class BufferedWriterExample {
public static void main(String[] args) {
try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
String data = "Hello, World!";
writer.write(data);
writer.flush();
} catch (IOException e) {
e.printStackTrace();
}
}
}
1.1 写两行数据
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class BufferWriterDemo {
public static void main(String[] args) {
//创建高效缓冲字符输出流
BufferedWriter writer = null;
try {
writer = new BufferedWriter(new FileWriter("test.txt"));
//写一行数据
writer.write("helloworld");
//换行
writer.newLine();
writer.write("helloworld");
writer.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
//资源关闭
if(writer != null){
try {
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
test.txt
1.2 换一种方式
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class IODemo1{
public static void main(String[] args) {
//创建一个文件
File file = new File("test.txt");
Writer writer = null;
try {
//IO流是需要关闭的，如果不这样设计就会不能关闭资源
writer = new FileWriter(file);
writer.write("HelloWorld");
} catch (IOException e) {
e.printStackTrace();
}finally {
//判断writer不是空防止空指针异常
if(writer != null) {
try {
//关闭流
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
1.3 追加数据
import java.io.IOException;
import java.io.Writer;
import java.io.FileWriter;
import java.io.File;
public class IOTest4 {
public static void main(String[] args) {
Writer writer = null;
try {
//IO流是需要关闭的，如果不这样设计就会不能关闭资源
//writer = new FileWriter("test1.txt", true);
writer = new FileWriter(new File("test.txt"), true);
writer.write("liangliang");
} catch (IOException e) {
e.printStackTrace();
}finally {
//判断writer不是空防止空指针异常
if(writer != null) {
try {
//在关闭前会做flush的事情
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
1.4 写很多数据，记得要清一下缓存
import java.io.IOException;
import java.io.Writer;
import java.io.FileWriter;
import java.io.File;
public class IOTest5 {
public static void main(String[] args) {
//创建一个文件
File file = new File("test.txt");
Writer writer = null;
try {
//IO流是需要关闭的，如果不这样设计就会不能关闭资源
writer = new FileWriter(file);
for (int i = 0; i < 100; i++) {
writer.write("HelloWorld\r\n");
//每次写入10个helloworld的时候做一次flush
if(i % 10 == 0){
writer.flush();
}
}
} catch (IOException e) {
e.printStackTrace();
}finally {
//判断writer不是空防止空指针异常
if(writer != null) {
try {
//在关闭前会做flush的事情
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
1.5 用数组、字符串写入
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class IOTest6 {
public static void main(String[] args) {
//创建一个文件
File file = new File("test.txt");
Writer writer = null;
try {
writer = new FileWriter(file);
//定义一个数组
char[] c = {'a','b','p','b','p'};
/*writer.write(c);
//把数组中的一部分写入文件
writer.write(c, 2, 2);
writer.write(97);
*/
writer.write("helloworld", 2, 2);
} catch (IOException e) {
e.printStackTrace();
}finally {
if(writer != null) {
try {
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
2. Reader
Reader是所有字符输入流的父类，它是一个抽象类，用于读取字符数据。与InputStream不同，Reader操作的是字符，适用于文本文件的读取。
Java提供了多种Reader的实现类，例如：
- FileReader：用于从文件中读取字符数据。
- CharArrayReader：从字符数组中读取数据。
- BufferedReader：提供缓冲功能，提高读取效率。
- StringReader：从字符串中读取数据。
举几个例子：
2.1 读个文件
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
public class BufferReaderDemo {
public static void main(String[] args) {
BufferedReader reader = null;
try{
reader = new BufferedReader(new FileReader("IO操作/CopyDemo1.java"));
String line = null;
while((line = reader.readLine()) != null){
System.out.println(line);
}
}catch(Exception e){
e.printStackTrace();
}finally{
if(reader != null){
try{
reader.close();
}catch(IOException e){
e.printStackTrace();
}
}
}
}
}
2.2 读取字符
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class ReaderDemo {
public static void main(String[] args) {
Reader reader = null;
File file = new File("test.txt");
try{
//创建出入流对象FileReader
reader = new FileReader(file);
//读取数据, 读取的字符被转换成了ascii 单个字符读取
int c = reader.read();
System.out.println((char)c);
c = reader.read();
System.out.println((char)c);
//如果读取到的是-1后面就没有字符了
c = reader.read();
System.out.println(c);
}catch(Exception e){
e.printStackTrace();
}finally{
//关闭资源
if(reader != null){
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
2.3 读取数据到数组
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.util.Arrays;
public class ReaderDemo2 {
public static void main(String[] args) {
File file = new File("test.txt");
Reader reader = null;
try {
//创建出入流对象FileReader
reader = new FileReader(file);
//定义一个数组 字符 char
char[] cs = new char[5];
//向字符数组中填数据
int len = reader.read(cs);
System.out.println("读取的长度："+len+" 读取的内容："+ Arrays.toString(cs) + ",,,");
//本次读取的字符的长度，如果要是文件中没有数据了，读取到的是-1
len = reader.read(cs);
System.out.println("第二次读取的长度："+len+" 读取的内容："+ Arrays.toString(cs) + ",,,");
len = reader.read(cs);
System.out.println("第三次读取的长度："+len+" 读取的内容："+ Arrays.toString(cs) + ",,,");
} catch (Exception e) {
e.printStackTrace();
} finally {
//关闭资源
if(reader != null){
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
练习一下：
2.4 复制文件
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.Reader;
import java.io.Writer;
public class Test {
public static void main(String[] args) {
Reader reader = null;
Writer writer = null;
File file = new File("IO操作/ReaderDemo.java");
File fileX = new File("IO操作/ReaderDemoX.java");// 写入文件
try{
// 读取
reader = new FileReader(file);
writer = new FileWriter(fileX);
String str = "";
char[] chars = new char[1024];
int len = -1;
while((len = reader.read(chars)) != -1){
writer.write(chars, 0, len);
}
}catch(Exception e){
e.printStackTrace();
}finally{
try{
reader.close();
writer.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
}
3. InputStream
InputStream是Java IO库中的一个重要抽象类，它用于从字节输入流中读取数据。以下是关于InputStream的详细解释：
基本概念：
- InputStream是所有字节输入流的超类，用于读取诸如图像、视频、文本等各种类型的文件或其他数据源中的数据。
- 它是一个抽象类，定义了读取字节数据的方法，但具体的实现依赖于它的子类。
常见实现类：
- FileInputStream：从文件中读取数据。
- ByteArrayInputStream：从字节数组中读取数据。
- BufferedInputStream：提供缓冲功能，提高读取效率。
- DataInputStream：用于读取Java的基本数据类型。
基本方法：
- read()：从输入流中读取下一个字节的数据，并以整数形式返回。如果已经达到流的末尾，则返回-1。
- read(byte[] b)：从输入流中读取一些字节的数据，并将其存储到指定的字节数组b中。返回实际读取的字节数。
- read(byte[] b, int off, int len)：从输入流中读取最多len个字节的数据，并将其存储到指定的字节数组b中，从偏移量off开始。返回实际读取的字节数。
- skip(long n)：跳过并丢弃输入流中的n个字节数据。返回实际跳过的字节数。
- available()：返回从此输入流中可以读取（或跳过）而不会阻塞的字节数的估计值。此方法通常返回0。
- close()：关闭输入流并释放与该流关联的系统资源。
注意事项：
- 在使用完InputStream后，应该调用close()方法来关闭流并释放系统资源。可以使用try-with-resources语句来自动关闭流。
- 在处理字节流时，需要特别注意字符编码问题。如果需要处理文本数据，可能需要结合使用InputStreamReader来将字节流转换为字符流。
举例：
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class IOByteInputDemo {
public static void main(String[] args) {
InputStream in = null;
try {
//创建一个字节的数组
byte[] bs = new byte[1024];
//创建字符输入流的对象，如果有中文有可能出现乱码
in = new FileInputStream("test.txt");
//定义读取到的长度的标识
int len = -1;
while((len = in.read(bs)) != -1){
String s = new String(bs, 0 , len);
System.out.print(s);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if(in != null){
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
4. OutputStream
OutputStream 是 Java I/O 库中用于写入字节数据到目的地的抽象类。它定义了字节输出的基本方法，具体的实现细节则由它的子类来提供。以下是关于 OutputStream 的详细解释：
基本概念：
- OutputStream 是所有字节输出流的超类。当你需要将字节数据写入文件、网络连接或其他输出设备时，你可以使用 OutputStream 或其子类。
常见实现类：
- FileOutputStream：用于将数据写入文件。
- ByteArrayOutputStream：将数据写入内存中的字节数组。
- BufferedOutputStream：提供缓冲功能，以优化写入性能。
- DataOutputStream：允许写入 Java 基本数据类型到输出流中。
基本方法：
- write(int b)：将指定的字节写入此输出流。
- write(byte[] b)：将 b.length 个字节从指定的字节数组写入此输出流。
- write(byte[] b, int off, int len)：从指定的字节数组写入 len 个字节，从偏移量 off 开始。
- flush()：刷新此输出流并强制写出任何被缓冲的输出字节。
- close()：关闭此输出流并释放与此流相关联的任何系统资源。
注意事项：
- 在使用完 OutputStream 后，应该调用 close() 方法来关闭流并释放系统资源。可以使用 try-with-resources 语句来自动关闭流。
- 当你使用 BufferedOutputStream 或其他具有缓冲的 OutputStream 子类时，即使你不显式调用 flush() 方法，在关闭流时（例如通过 try-with-resources 语句）也会自动刷新缓冲区。但是，在某些情况下，你可能希望显式地刷新缓冲区以确保数据被立即写出。
- 在处理字节流时，如果源数据是文本，你可能需要考虑字符编码问题。如果需要将文本数据写入输出流，你可能需要结合使用 OutputStreamWriter 将字符流转换为字节流，并指定字符编码。
举例：
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class IOByteDemo {
public static void main(String[] args) {
//创建字节输出流
OutputStream out = null;
try {
out = new FileOutputStream(new File("test.txt"));
//字节流不需要flush
byte[] bs = {97, 99, 108, 111};
out.write(bs);
// out.write(97);
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if(out != null){
out.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
5. 参考链接
【java】IO流-1(OutputStream和Writer)
