字节流和字符流的相关知识

最新推荐文章于 2024-07-25 11:59:12 发布

岳轩子

最新推荐文章于 2024-07-25 11:59:12 发布

阅读量842

点赞数 11

分类专栏： java类的使用文章标签： spring java 后端

本文链接：https://blog.csdn.net/weixin_51395608/article/details/139728828

版权

java类的使用专栏收录该内容

4 篇文章 0 订阅

订阅专栏

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