day20

最新推荐文章于 2024-09-06 20:43:28 发布

婷婷学java

最新推荐文章于 2024-09-06 20:43:28 发布

阅读量126

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/weixin_46046848/article/details/116477910

版权

java基础专栏收录该内容

24 篇文章 1 订阅

订阅专栏

day20

一、字节缓冲流

通过测试，我们发现一次读写一个字节数组明显比一次读写一个字节要快很多。是因为一次读写一个字节数组这种方式，使用了数组作为一个缓冲的效果。Java官方也提供了类似的实现，就是字节缓冲流。

字节缓冲流中维持了一个长度（8192）足够的数组，并且这个效率会更高（因为这个数组是直接对接到内存的）

1.1 字节缓冲输出流 BufferedOutputStream

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cr8tPO3U-1620345038756)(img/image-20210430112333254.png)]

构造方法

BufferedOutputStream(OutputStream out)

public class Demo {

    public static void main(String[] args) throws IOException {

        //BufferedOutputStream(OutputStream out)
//        FileOutputStream fos = new FileOutputStream("day20//b.txt");
//        BufferedOutputStream bos = new BufferedOutputStream(fos);

        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("day20//b.txt"));

    }
}

常见方法

void flush() 	刷新此缓冲的输出流 
          
void write(int b)  
void write(byte[] b)  
void write(byte[] b, int off, int len)

public class Demo2 {

    public static void main(String[] args) throws IOException {

        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("day20//b.txt"));

        //void write(int b)   一次写一个字节
        bos.write(97);
        bos.write(98);
        bos.write(99);

        //void write(byte[] b)      一次写一个字节数组
        bos.write("中华人民共和国".getBytes());

        //void write(byte[] b, int off, int len)  一次写一个字节数组的一部分
        bos.write("中华人民共和国".getBytes(), 0, 3);

//        bos.flush();
        bos.close();
    }
}

1.2 字节缓冲输入流 BufferedInputStream

构造方法

BufferedInputStream(InputStream out)

常见方法

int read()  
int read(byte[] b)

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Demo3 {

    public static void main(String[] args) throws IOException {

        BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream("day20//a.txt"));

        //int read()     一次读取一个字节
//        int read = 0;
//        while((read = bis.read()) != -1){
//
//            System.out.println((char)read);
//        }

        //int read(byte[] b)   一次读取一个字节数组
        byte[] b = new byte[1024];
        int len = 0;
        while((len = bis.read(b)) != -1){

            System.out.println(new String(b, 0, len));
        }

        bis.close();

    }
}

1.3 flush和close的区别

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lxwnXr7a-1620345038758)(img/image-20210430112712781.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-at96TBOY-1620345038759)(img/image-20210430113034144.png)]

二、一个IO流的标准写法

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

public class Demo4 {

    public static void main(String[] args) {

        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("day20//a.txt");
            fos = new FileOutputStream("day20//aa.txt");

            //一次读写一个字节
            int read = 0;
            while((read = fis.read()) != -1){

                fos.write(read);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {

            if(fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

三、字符流

3.1 为什么使用字符流

使用字节流写数据

1. 需要先将字符串通过getBytes()方法转为字节数组之后，才可以写到流中

使用字节流读数据

1. 如果数据全是英文或者数字的话，那么直接读取即可正确读取
2. 如果数据全是中文的的话，并且使用的编码是UTF-8（UTF-8是三个字节表示一个中文），那么我们将数组设置为3的倍数即可正确读取
3. 如果数据是中文和英文混杂的话，那么具体设置多少长度的数组我们就不清楚了。因为随着数据的增多，肯定会有乱码出现。

以上使用字节流所出现的问题，完全是因为表示中文和英文的字节数不一样导致的。
所以针对这种情况，JDK提供了字符流。字符流操作的基本单位（从使用者角度来看是变成了字符）已经从字节变成了字符。（比如：一个中文"你"或者一个英文 H 都是一个字符）

3.2 文件字符输出流 FileWriter

用来写入字符文件的便捷类

构造方法

FileWriter(File file) 
FileWriter(File file, boolean append) 
FileWriter(String fileName) 
FileWriter(String fileName, boolean append)

常见方法

void write(int c)  
void write(char[] cbuf)  
void write(char[] cbuf, int off, int len)  
void write(String str)  
void write(String str, int off, int len)  
    
flush() 	刷新该流的缓冲

package com.ujiuye.demo02_字符输出流;

import java.io.FileWriter;
import java.io.IOException;

/*
    常见方法：
        void write(int c)
        void write(char[] cbuf)
        void write(char[] cbuf, int off, int len)
        void write(String str)
        void write(String str, int off, int len)

        flush() 	刷新该流的缓冲
 */
public class Demo3 {

    public static void main(String[] args) throws IOException {

        FileWriter fw = new FileWriter("day20//d.txt");

        //void write(int c)   一次写入一个字符
        fw.write('a');
        fw.write('b');
        fw.write('c');

        //void write(char[] cbuf)  一次写入一个字符数组
        char[] ch = {'你', '好', '啊'};
        fw.write(ch);

        /*
                void write(char[] cbuf, int off, int len) 一次写入一个字符数组的一部分。

                参数off：字符串的偏移量，这个地方可以当成字符串的索引来使用
                参数len：需要写入的字符的个数
         */
        fw.write(ch, 0, 2);

        //void write(String str)    一次写入一个字符串
        fw.write("中华人民共和国");

        /*
                void write(String str, int off, int len)  一次写入一个字符串的一部分

                参数off：字符串的偏移量，这个地方可以当成字符串的索引来使用
                参数len：需要写入的字符的个数
         */
        fw.write("中华人民共和国", 0, 2);

        fw.flush();
        fw.close();

    }
}

3.3 文件字符输入流 FileReader

用来读取字符文件的便捷类。

构造方法

FileReader(File file) 
FileReader(String fileName)

常见方法

int read()  
int read(char[] cbuf)

import java.io.FileReader;
import java.io.IOException;

public class Demo {

    public static void main(String[] args) throws IOException {

        FileReader fr = new FileReader("day20//a.txt");

        //int read()        一次读取一个字符。 返回值是读取到的字符，返回值为-1证明已经到了流的末尾
//        int read = 0;
//        while((read = fr.read()) != -1){
//
//            System.out.println((char)read);
//        }

        //int read(char[] cbuf)  一次读取一个字符数组，返回值为-1证明已经到了流的末尾
        char[] ch = new char[1024];
        int len = 0;
        while((len = fr.read(ch)) != -1){

            System.out.println(new String(ch, 0, len));
        }

        fr.close();

    }
}

3.4 文件的复制

使用字符流复制文本数据

完全可以的

使用字符流复制非文本数据（音乐、图片等）

不能使用字符流

建议使用

无论是文本数据，还是非文本数据，都建议使用字节流进行复制。因为字节流没有转换为字符的过程，所以效率更高。

如果想要读取一个文本的内容，这个时候只能使用字符流。

3.5 字符缓冲输出流 BufferedWriter

将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。

构造方法

BufferedWriter(Writer out)

特有方法

void newLine() 		写入一个行分隔符

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

public class Demo {

    public static void main(String[] args) throws IOException {

        BufferedWriter bw = new BufferedWriter(new FileWriter("day20//e.txt"));

        for(int i = 1; i <= 10; i++){

            bw.write("Hello" + i);
//            bw.write("\r\n");
            bw.newLine();
        }

        bw.close();

    }
}

3.6 字符缓冲输入流 BufferedReader

从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。

构造方法

BufferedReader(Reader in)

特有方法

String readLine() 		读取一个文本行。 返回该行内容的字符串。如果已经达到了流的末尾，就返回null

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

public class Demo2 {

    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new FileReader("day20//e.txt"));

        String s = null;
        while((s = br.readLine()) != null){

            System.out.println(s);
        }

        br.close();

    }
}

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

public class Demo2 {

public static void main(String[] args) throws IOException {

    BufferedReader br = new BufferedReader(new FileReader("day20//e.txt"));

    String s = null;
    while((s = br.readLine()) != null){

        System.out.println(s);
    }

    br.close();

}

}