第32天学习打卡（字符流读写文件，字节流读写文件）

字符流读写文件

创建字符流读文件对象：

BufferedReader br = new BufferedReader(new FileReader("readme.txt"));

创建字符流写文件对象:

BufferedWriter bw = now BufferedWriter(new FileWriter("dext.txt"));
 

异常处理：

throws IOException

使用while循环读写数据：

int len;
while((len = br.read())!= -1){
    
    
bw.write(len);
}

关闭资源:

br.close();
bw.close();

package cn.itcast.demo25;
/*
字符缓冲流用法：
        分类：
           BufferedReader:字符缓冲输入流（也叫高效字符输入流）
                   构造方法：
                          public BufferedReader(Reader reader);
           BufferedWriter:字符缓冲输出流（也叫高效字符输出流）
                   构造方法：
                           public BufferedWriter(Writer writer);
           特点：
              字符缓冲流自带有缓冲区，大小为8192字符(一个字符等于两个字节)，也就是16KB
 */

import java.io.*;

public class CopyFile1 {
    
    
    public static void main(String[] args) throws IOException {
    
    
        //需求：通过字符缓冲流，将1.txt文件中的内容拷贝到2.txt文件中
        //1.创建字符缓冲输入流对象，关联数据源文件
        //1.1创建普通的字符输入流对象
        FileReader fr = new FileReader("lib/1.txt");//fr 是reader类的对象
        //1.2创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(fr);
        //优化上述两行代码
        // BufferedReader br2 = new BufferedReader(new FileReader("lib/1.txt"));


        //2.创建字符缓冲输出流对象，关联目的地文件
        //2.1创建普通的字符输出流对象
        FileWriter fw = new FileWriter("lib/2.txt");
        //2.2创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(fw);


        // 3.定义变量，记录读取到的数据
        int len;
        //4.循环读取，只要条件满足就一直读，并将读取到的内容赋值给变量
        while( (len = br.read()) != -1) {
    
    
            //5.将读取到的数据写入到目的地文件中
            bw.write(len);
        }

        //6.释放数据
        br.close();
        bw.close();
    }
}

底层是按照字符数组读取的

package cn.itcast.demo25;
/*
   字符缓冲流用法:
           分类：
               BufferedReader:字符缓冲输入流（也叫高效字符输入流）
                       成员方法:
                               public String readLine():一次读取一行数据并返回读取到的内容，读不到返回null
                BufferedWriter:字符缓冲输出流（也叫高效字符输出流）
                         成员方法:
                                public void newLine():根据当前操作系统给出对应的换行符
                                window操作系统换行符: \r\n
                                mac操作系统: \r
                                unix操作系统:\n

                 特点:
                     字符缓冲流自带缓冲区，大小为8192个字符，也就是16KB
                  注意：
                      字符流只能拷贝文本文件
                      


 */

import java.io.*;

public class CopyFile2 {
    
    
    public static void main(String[] args) throws IOException {
    
    
        //需求：通过字符缓冲流“一次读写一行”的方式，将1.txt文中的内容拷贝到2.txt文件中
        //1.创建字符缓冲输入流对象，关联数据源文件
        //创建普通输入流对象
       // FileReader fr = new FileReader("lib/1.txt");
        //创建字符缓冲输入流对象
      //  BufferedReader br = new BufferedReader(new FileReader("lib/1.txt"));
        //合并上述两行代码
        BufferedReader br = new BufferedReader(new FileReader("lib/1.txt"));


        //2.创建字符缓冲输出流对象，关联目的地文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("lib/2.txt"));

        //3.定义变量，记录读取到的内容
        String str;
        //4.循环读取，只要条件满足就一直读，并将读取到的内容赋值给变量
        while ((str = br.readLine())!=null){
    
    
            //5.将读取到的内容写入到目的地文件中
            bw.write(str);
            //千万注意一个小细节，特别容易忽略
            //千万别忘记换行
          // bw.write("\r\n");
            bw.newLine();



        }

        //6.释放资源
        br.close();
        bw.close();


    }
}

字节流读写文件

字节流拷贝文件-按单个字节读写

创建字节流读文件对象：

InputStream is = new FileInputStream("Desktop.jpk");

创建字节流写文件对象：

OutputStream os = new FileOutputStream("D:\\随便什么图片.jpg");

使用while循环读写数据：

int b;
while(b = is.read()!= -1){
    
    
os.write(b);
}

关闭资源：

is.close();
os.close();

package cn.itcast.demo26;
/*
   字节流的用法：
           FileInputStream:普通的字节输入流，用来读取数据的。
           构造方法：
                  public FileInputStream(String pathname);
           成员方法：
                  public int read();一次读取一个字节，并返回读取到的内容，读不到返回-1

            FileOutputStream:普通的字节输出流，用来写数据的
            构造方法：
                   public FileOutputStream(String pathname);
            成员方法：
                    public void write(int len):一次写入一个字节

 */

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

public class CopyFile1 {
    
    
    public static void main(String[] args) throws IOException {
    
    
        //需求：通过普通的字节流，一次读写一个字节的方式，将a.jpg复制到b.jpg中
        //1.创建字节输入流，关联数据源文件
        FileInputStream fis = new FileInputStream("lib/a.jpg");
        //2.创建字节输出流，关联目的地文件
        FileOutputStream fos = new FileOutputStream("lib/b.jpg");
        //3.定义变量，用来记录读取到的内容
        int len;
        //4.循环读取，只要条件满足就一直读，并将读取到的内容赋值给变量
        while ((len = fis.read())!=-1){
    
    
            //5.将读取到的内容写入到目的地文件中
            fos.write(len);
        }

        //6.释放数据
        fis.close();
        fos.close();


    }
}

把图片拷入到IDEA中

首先创建一个.jpg文件 然后复制一张图片在里面就可以了.

字节流拷贝文件-按字节数组读写

创建字节流读文件对象：

InputStream is = new FileInputStream("Desktop.jpg");

创建字节流写文件对象：

OutputStream os = new FileOutputStream("D:\\随便什么图片.jpg");

异常处理：

throws IOException

定义字节数组，每次读取2048个字节：(最好是1024的倍数)

byte[] b = new byte[2048];

使用while循环读写数据：

int len;
while((len = is read(b))!= -1){
    
    
os.write(b, 0, len);//b:表示要操作的字节数组，0：表示起始索引，len:表示具体要操作的字节个数
}

关闭资源：

is.close();
os.close();

package cn.itcast.demo26;

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

/*
    字节流的用法：
             FileInputStream:普通的字节输入流，用来读取数据的
                     成员方法：
                            public int read(byte[] bys):一次读取一个字节数组，将读取到的内容存入到数据中，并返回读取到的有效字节数，读不到返回-1
             FileOutputStream:普通的字节输出流，用来写数据的
                     成员方法：
                            public void write(byte[] bys,int index,int len);一次写入一个指定的字符数据


 */
public class CopyFile2 {
    
    
    public static void main(String[] args) throws IOException {
    
    
        //需求：通过普通字节流一次读写一个字节数组的方式，将a.jpg复制到b.jpg中
        //1.创建字节输入流对象，关联数据源文件
        FileInputStream fis = new FileInputStream("lib/a.jpg");
        //2.创建字节输出流对象，关联目的地文件
        FileOutputStream fos = new FileOutputStream("lib/c.jpg");
        //3.定义变量，用来接收读取到的内容
        byte[] bys = new byte[1024];
        //用来记录读取到的有效字节数
        int len;
        //4.循环读取，只要条件满足就一直读，并将读取到的内容（有效的字节数）赋值给变量
        while((len = fis.read(bys))!= -1){
    
    
            //5.将读取到的数据写入到目的地文件中
            fos.write(bys,0,len);

        }

        //6.释放资源
        fis.close();
        fos.close();
    }
}

字节缓冲流拷贝文件的标准代码

创建字节缓冲流读文件对象：

BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.jpg"));

创建字节缓冲流写文件对象：

BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b.jpg"));

异常处理：

throws IOException

使用while循环读写数据：

int len;
while((len = bis.read())!= -1){
    
    
bos.write(len);
}

关闭资源：

bis.close();
bos.close();

package cn.itcast.demo27;
/*
字节缓冲流的用法：
            BufferedInputStream:字节缓冲输入流（也叫：高效字节输入流）用来读取数据的
                     构造方法：
                           public BufferedInputStream(InputStream is);
                     成员方法：
                           public int read():一次读取一个字节，并返回读取到的内容，读取不到返回-1
           BufferedOutputStream:字节缓冲输出流（也叫：高效字节输出流），用来写数据的
                      构造方法：
                            public BufferedOutputStream(OutputStream os);
                      成员方法：
                            public void writer(int len);一次写入一个字节
                  特点：
                  字节缓冲流有自己的缓冲区，大小为8192个字节，也就是8KB
                  总结：
                  拷贝纯文本文件使用字符流，拷贝其它（图片、音频、视频等）使用字节流
 */

import java.io.*;

public class CopyFile1 {
    
    
    public static void main(String[] args) throws IOException {
    
    
        //需求：通过字节缓冲流，将a.jpg复制到e.jpg中
        //1.创建字节输入流对象，关联数据源文件
        //创建普通的字节输入流
       // FileInputStream fis = new FileInputStream("lib/a.jpg");
        //创建高效的字节输入流
        //BufferedInputStream bis = new BufferedInputStream(fis);
        //合并上面两行代码
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("lib/1.txt"));


        //2.创建字节输出流对象，关联目的地文件
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("lib/4.txt"));


        //3.定义变量，用来记录读取到的内容
        int len;
        //4.循环读取，只要条件满足就一直读，然后将读取到的内容赋值给变量
        while((len = bis.read())!=-1){
    
    
            //5.将读取到的内容写入到目的地文件中
            bos.write(len);

        }


        //6.释放资源
        bis.close();
        bos.close();
    }
}

总结：拷贝纯文本使用字符流，拷贝其它（图片、音频、视频等）用字节流。