Java笔记 - 黑马程序员

1.字节流 1.1 IO流概述和分类

IO流概述：

• IO:输入/输出(Input/Output)
• 流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输
• IO流就是用来处理设备间数据传输问题的
  常见的应用：文件复制；文件上传；文件下载
  

IO流分类：

• 按照数据的流向
  输入流：读数据
  输出流：写数据
• 按照数据类型来分

1. 字节流
   字节输入流；字节输出流
2. 字符流
   字符输入流；字符输出流

一般来说，我们说IO流的分类是按照数据类型来分的

那么这两种流都在什么情况下使用呢？

• 如果数据通过Window自带的记事本软件打开，我们还可以读懂里面的内容，就使用字符流，
  否则使用字节流。如果你不知道该使用哪种类型的流，就使用字节流

1.2 字节流写数据

字节流抽象基类：

• InputStream:这个抽像类是表示字节输入流的所有类的超类
• OutputStream:这个抽象类是表示字节输出流的所有类的超类
• 子类名特点：子类名称都是以其父类名作为子类名的后缀

FileOutputStream:：文件输出流用于将数据写入File

• FileOutputStream(String name):创建文件输出流以指定的名称写入文件

使用字节输出流写数据的步骤：

1. 创建字节输出流对象（调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件）
2. 调用字节输出流对象的写数据方法
3. 释放资源（关闭此文件输出流并释放与此流相关联的任何系统资源）

package demo_01;



import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        //FileOutputStream(String name):创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("myByteStream\java.txt");

        //write(int b)将指定的字节写入此输出流。。
        fos.write(97);

        //释放资源
        //close()关闭此文件输出流并释放与此流相关联的任何系统资源。
        fos.close();
    }
}

1.3 字节流写数据的3种方式

方法名	说明
void write(int b)	将指定的字节写入此文件输出流 一次写一个字节数据
void write(byte[] b)	将b.length字节从指定的字节数组写入此文件输出流 一次写一个字节数组数据
void write(byte[] b, int off, int len)	将Ien字节从指定的字节数组开始，从偏移量off开始写入此文件输出流 一次写一个字节数组的部分数据

package demo_01;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //FileOutputStream(String name):创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("myByteStream\java.txt",true);
        //new File(name) 底层代码
//        FileOutputStream fos = new FileOutputStream(new File("myByteStream\java.txt"));

    //FileOutputStream(File file)创建文件输出流以写入由指定的 File对象表示的文件

//        FileOutputStream fos2 = new FileOutputStream(new File("myByteStream\\java.txt"));

        //write(int b)将指定的字节写入此输出流
        fos.write(97);
        fos.write(98);

        //write(byte[] b)将 b.length字节从指定的字节数组写入此输出流。
        byte[] bys = {97,98,99};
        //byte[] getBytes():返回字符串对应的字节数组
        fos.write(bys);

        //write(byte[] b, int off, int len)从指定的字节数组写入 len个字节，从偏移 off开始输出到此输出流
        byte[] bys1 = {97,98,99};
        int len = bys1.length;
        fos.write(bys1,0,len);
        
         //释放资源
        fos.close();
    }
}

byte[]  getBytes():使用平台的默认字符集将此String编码为字节序列（返回字符串对应的字节数组）		//String中的方法

1.4 字节流写数据的两个小问题

字节流写数据如何实现换行呢？

• 写完数据后，加换行符

1. windows: rn
2. linux: n
3. mac: r

字节流写数据如何实现追加写入呢？

• public FileOutputStream(String name, boolean append)
• 创建文件输出流以指定的名称写入文件。如果第二个参数为true,则字节将写入文件的未尾而不是开头

package demo_01;

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo03 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
//        FileOutputStream fos = new FileOutputStream("myByteStream\java.txt");
        //创建文件输出流以指定的名称写入文件。如果第二个参数为true,则字节将写入文件的未尾而不是开头
        FileOutputStream fos = new FileOutputStream("myByteStream\java.txt", true);

        //写入数据
        for (int i = 0; i < 10; i++) {
            //byte[]  getBytes():使用平台的默认字符集将此String编码为字节序列（返回字符串对应的字节数组）
            fos.write("hello".getBytes());
            fos.write("rn".getBytes());
        }

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

1.5 字节流写数据加异常处理

finally:在异常处理时提供finally块来执行所有清除操作。比如说IO流中的释放资源
特点：被finally控制的语句一定会执行，除非JVM退出

//格式
try{
    //可能出现的异常代码
}catch (异常类名 变量名){
    //异常处理代码
}finally {
    //执行所有清楚操作
}

package demo_01;

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo04 {
    public static void main(String[] args) {
        //加入finally来实现资源释放
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("myByteStream\java.txt");
            fos.write("hello".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

1.6 字节流读数据（一次读一个字节数据）

需求：把文件java.txt中的内容读取出来在控制台输出

FilelnputStream:从文件系统中的文件获取输入字节

• FilelnputStream(String name):通过打开与实际文件的连接来创建一个FilelnputStream,该文件由文件系统中的路径名name命名

使用字节输入流读数据的步骤：
①创建字节输入流对象
②调用字节输入流对象的读数据方法
③释放资源

package demo_02;

import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("myByteStream\java.txt");

        //int read():从该输入流读取一个字节数据
        //读取数据
        

        //优化
        int by;
        while ((by = fis.read()) != -1) {
            System.out.print((char) by);
        }

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

案例：复制文本文件

需求：把“D:\.File\java.txt”复制到模块目录下的“java.txt”

分析：

①复制文本文件，其实就把文本文件的内容从一个文件中读取出来（数据源），然后写入到另一个文件中（目的地）

②数据源：
D:\.File\java.txt—读数据—InputStream—FilelnputStream

③目的地：
myByteStream\java.txt—写数据—OutputStream–FileOutputStream

思路：

①根据数据源创建字节输入流对象
②根据目的地创建字节输出流对象
③读写数据，复制文本文件（一次读取一个字节，一次写入一个字节）
④释放资源

package demo_02;

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


public class CopyTxtDemo {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("D:\File\java.txt");

        //根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("myByteStream\java.txt");

        //读写数据，复制文本文件（一次读取一个字节，一次写入一个字节）
        int by;
        while ((by=fis.read())!=-1){
            fos.write(by);
        }

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

1.7 字节流读数据（一次读一个字节数组数据）

需求：把文件java.txt中的内容读取出来在控制台输出

使用字节输入流读数据的步骤：

1. 创建字节输入流对象
2. 调用字节输入流对象的读数据方法
3. 释放资源

package demo_02;

import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("myByteStream\java.txt");

        //调用字节输入流对象的读数据的方法
        byte[] bys = new byte[1024];
        int len;
        while ((len = fis.read(bys)) != -1) {
            //String(byte[] bytes, int offset, int length)通过使用平台的默认字符集解码指定的字节子阵列来构造新的 String
            System.out.println(new String(bys,0,len));
            System.out.println();
        }

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

String(byte[] bytes, int offset, int length)通过使用平台的默认字符集解码指定的字节子阵列来构造新的 String		(String的构造方法)

案例：复制图片

需求：把“D:\File\mn.jpg”复制到模块目录下的“mn.jpg”

思路：
①根据数据源创建字节输入流对像
②根据目的地创建字节输出流对象
③读写数据，复制图片（一次读取一个字节数组，一次写入一个字节数组)
④释放资源

package demo_02;

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

public class CopyImgDome {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("D:\File\mn.jpg");

        //创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("myByteStream\mn.jpg");

        //读写数据，复制图片（一次读取一个字节数组，一次写入一个字节数组
        byte[] bys = new byte[1024];
        int len;
        while ((len=fis.read())!=-1){
            fos.write(bys,0,len);
        }

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

1.8 字节缓冲流

字节缓冲流：

• BufferOutputStream:该类实现缓冲输出流。通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用
• BufferedInputStream:创建BufferedInputStream将创建一个内部缓冲区数组。当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节

构造方法：

• 字节缓冲输出流：BufferedOutputStream(OutputStream out)
• 字节缓冲输入流：BufferedInputStream(InputStream in）

为什么构造方法需要的是字节流，而不是具体的文件或者路径呢？

• 字节缓冲流仅仅提供缓冲区，而真正的读写数据还得依靠基本的字节流对象进行操作

package demo_03;



import java.io.*;

public class BufferStreamDemo {
    public static void main(String[] args) throws IOException{
        //字节缓冲输出流：BufferedOutputStream(OutputStream  out)
        

        

        //字节缓冲输入流：BufferedInputStream(InputStream  in）
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("myByteStream\java.txt"));
        
        //读取数据（一次读一个字节数组数据）
       
        
        //一次读取一个字节数据
        int by;
        while ((by=bis.read())!=-1){
            System.out.print((char)by);
        }

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

案例：复制视频

需求：把"D:\File\mv.avi"复制到模块目录下的"mv.avi”

思路：
①根据数据源创建字节输入流对像
②根据目的地创建字节输出流对象
③读写数据，复制视频
④释放资源

package demo_03;



import java.io.*;

public class CopyAviDemo {
    public static void main(String[] args) throws IOException {
        //记录开始事件
        long startTime = System.currentTimeMillis();

        //调用复制视频方法
//        method1();
//        method2();
//        method3();
        method4();
        
        //记录结束事件
        long endTime = System.currentTimeMillis();
        System.out.println("共耗时：" + (endTime - startTime) + "毫秒");
    }

    //1.基本字节流一次读写一个字节
    public static void method1() throws IOException {
        FileInputStream fis = new FileInputStream("D:\File\mv.avi");
        FileOutputStream fos = new FileOutputStream("myByteStream\mv.avi");

        int by;
        while ((by = fis.read()) != -1) {
            fos.write(by);
        }
        //释放资源
        fis.close();
        fos.close();
    }

    //2.基本字节流一次读写一个字节数组
    public static void method2() throws IOException {
        FileInputStream fis = new FileInputStream("D:\File\mv.avi");
        FileOutputStream fos = new FileOutputStream("myByteStream\mv.avi");

        byte[] bys = new byte[1024];
        int len;
        while ((len = fis.read(bys)) != -1) {
            fos.write(bys, 0, len);
        }
        //释放资源
        fis.close();
        fos.close();
    }

    //3.字节缓冲流一次读写一个字节
    public static void method3() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\File\mv.avi"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\mv.avi"));

        int by;
        while ((by = bis.read()) != -1) {
            bos.write(by);
        }
        //释放资源
        bis.close();
        bos.close();
    }

    //4.字节缓冲流一次读写一个字节数组
    public static void method4() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\File\mv.avi"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\mv.avi"));

        byte[] bys = new byte[1024];
        int len;
        while ((len = bis.read(bys)) != -1) {
            bos.write(bys,0,len);
        }
        //释放资源
        bis.close();
        bos.close();
    }
}

2.字符流 2.1 为什么会出现字符流

由于字节流操作中文不是特别的方便，所以小ava就提供字符流

• 字符流=字节流+编码表

用字节流复制文本文件时，文本文件也会有中文，但是没有问题，原因是最终底层操作会自动进行字节拼接成
中文，如何识别是中文的呢？

• 汉字在存储的时候，无论选择哪种编码存储，第一个字节都是负数
• UTF-8编码，一个汉字占用3个字节
• GBK编码，一个汉字占用2个字节

package demo_01;

import java.io.IOException;
import java.util.Arrays;

public class FileInputStreamDemo {
    public static void main(String[] args) throws IOException{
//        String s = "abc";
        String s = "中国";
        byte[] bys = s.getBytes("UTF-8");
//        byte[] bys = s.getBytes("GBK");
        //toString(byte[] a)返回指定数组的内容的字符串表示形式
        System.out.println(Arrays.toString(bys));
    }
}
//运行结果
[-28, -72, -83, -27, -101, -67]

2.2 编码表

基础知识：

• 计算机中储存的信息都是用二进制数表示的：我们在屏幕上看到的英文、汉字等字符是二进制数转换之后
  的结果

• 按照某种规则，将字符存储到计算机中，称为编码。反之，将存储在计算机中的二进制数按照某种规则解
  析显示出来，称为解码。这里强调一下：按照A编码存储，必须按照A编码解析，这样才能显示正确的文本
  符号。否则就会导致乱码现象

• 字符编码：就是一套自然语言的字符与二进制数之间的对应规则(A , 65)

字符集：

• 是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等
• 计算机要准确的存储和识别各种字符集符号，就需要进行字符编码，一套字符集必然至少有一套字符编码。
  常见字符集有ASCII字符集、GBXXX字符集、Unicode:字符集等

1. ASCII字符集：

• ASCIi(American Standard Code for Information Interchange,美国信息交换标准代码)：是基于拉丁字母的一套电脑编码系统，用于显示现代英语，主要包括控制字符（回车键、退格、换行键等）和可显示字符英文大小写字符、阿拉伯数字和西文符号)
• 基本的ASCII字符集，使用7位表示一个字符，共128字符。ASC的扩展字符集使用8位表示一个字符，共26字符，方便支持欧洲常用字符。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号，数字等

2. GBXXX:字符集：

• GB2312：简体中文码表。一个小于127的字符的意义与原来相同，但两个大于127的字符连在一起时，就表示一个汉字，这样大约可以组合了包含7000多个简体汉字，此外数学符号、罗马希腊的字母、日文的假名等都编进去了，连在ASC里本来就有的数字、标点、字母都统统重新编了两个字节长的编码，这就是常说的“全角“字符，而原来在127号以下的那些就叫"半角“字符了
• GBK：最常用的中文码表。是在GB2312标准基础上的扩展规范，使用了双字节编码方案，共收录了21003个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩汉字等
• GB18030：最新的中文码表。收录汉字70244个，采用多字节编码，每个字可以由1个、2个或4个字节组成。支持中国国内少数民族的文字，同时支持繁体汉字以及日韩汉字等

3. Unicode字符集：

• 为表达任意语言的任意字符而设计，是业界的一种标准，也称为统一码、标准万国码。它最多使用4个字节的数字来表达每个字母、符号，或者文字。有三种编码方案，UTF-8、UTF-16和UTF32。最为常用的UTF-8编码
• UTF-8编码：可以用来表示Jnicode标准中任意字符，它是电子邮件、网页及其他存储或传送文字的应用中，优先采用的编码。互联网工程工作小组(ETF)要求所有互联网协议都必须支持UTF-8编码。它使用一至四个字节为每个字符编码

编码规则：

1. 128个US-ASCI字符，只需一个字节编码
2. 拉丁文等字符，需要二个字节编码
3. 大部分常用字（含中文)，使用三个字节编码
4. 其他极少使用的Unicode?辅助字符，使用四字节编码

小结：采用何种规则编码，就要采用对应规则解码，否则就会出现乱码

2.3 字符串中的编码解码问题

编码：

• byte[] getBytes()：使用平台的默认字符集将该String编码为一系列字节，将结果存储到新的字节数组中
• byte[] getBytes(String charsetName))：使用指定的字符集将该String编码为一系列字节，将结果存储
  到新的字节数组中

解码：

• String(byte[] bytes)：通过使用平台的默认字符集解码指定的字节数组来构造新的String
• String(byte[]bytes,String charsetName)：通过指定的字符集解码指定的字节数组来构造新的String

package demo_01;

import java.io.IOException;
import java.util.Arrays;

public class StringDemo {
    public static void main(String[] args) throws IOException {
        //定义字符串
        String s = "中国";

        //byte[]  getBytes()：使用平台的默认字符集将该String编码为一系列字节，将结果存储到新的字节数组中
//        byte[] bys = s.getBytes();        //[-28, -72, -83, -27, -101, -67]
        //byte[]  getBytes(String  charsetName))：使用指定的字符集将该String编码为一系列字节，将结果存储 到新的字节数组中
//        byte[] bys = s.getBytes("UTF-8");
        byte[] bys = s.getBytes("GBK");     //[-42, -48, -71, -6]
        System.out.println(Arrays.toString(bys));

        //String(byte[]  bytes)：通过使用平台的默认字符集解码指定的字节数组来构造新的String
//        String ss = new String(bys);
        //String(byte[]bytes,String charsetName)：通过指定的字符集解码指定的字节数组来构造新的String
        String ss = new String(bys,"GBK");	//中国
        System.out.println(ss);
    }
}

2.4 字符流中编码解码问题

• InputStreamReader：是从字节流到字符流的桥梁：它读取字节，并使用指定的charset将其解码为字符， 它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。

构造方法：

1. InputStreamReader(InputStream in) 创建一个使用默认字符集的InputStreamReader
2. InputStreamReader(InputStream in, String charsetName) 创建一个使用命名字符集的InputStreamReader

• OutputStreamWriter：是字符的桥梁流以字节流：向其写入的字符编码成使用指定的字节。 它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。

构造方法：

1. OutputStreamWriter(OutputStream out) 创建一个使用默认字符编码的OutputStreamWriter
2. OutputStreamWriter(OutputStream out, String charsetName) 创建一个使用命名字符集的OutputStreamWriter

package demo_01;

import java.io.*;

public class StreamReadAndWriterDemo {
    public static void main(String[] args) throws IOException {
        //1. OutputStreamWriter(OutputStream out) 创建一个使用默认字符编码的OutputStreamWriter
        //2. OutputStreamWriter(OutputStream out, String charsetName) 创建一个使用命名字符集的OutputStreamWriter
        
//        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\java.txt"));
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\java.txt"),"UTF-8");
        osw.write("中国");
        osw.close();

        //1. InputStreamReader(InputStream in)  创建一个使用默认字符集的InputStreamReader
        //2. InputStreamReader(InputStream in, String charsetName)  创建一个使用命名字符集的InputStreamReader
//        InputStreamReader isw = new InputStreamReader(new FileInputStream("myCharStream\java.txt"));
        InputStreamReader isw = new InputStreamReader(new FileInputStream("myCharStream\java.txt"),"UTF-8");
        //一次读取一个字符数据
        

        //一次读取一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len=isw.read(chs))!=-1){
            System.out.println(new String(chs,0,len));
        }
        //释放资源
        isw.close();
    }
}

2.5 字符流写数据的5种方式

方法名	说明
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)	写一个字符串的一部分

方法名	说明
fiush()	刷新流，还可以继续写数据
close()	关闭流，释放资源，但是在关闭之前会先刷新流。一旦关闭，就不能再写数据

package demo_01;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class WriterMethod5Demo {
    public static void main(String[] args) throws IOException {
        // OutputStreamWriter(OutputStream out) 创建一个使用默认字符编码的OutputStreamWriter
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\java.txt"));

        

        

       

        

        //void write(String str, int off, int len)写一个字符串的一部分
        String s = "abcd";
        osw.write(s,1,s.length()-1);
        osw.flush();



        osw.close();
    }
}

2.6 字符读取数据的2种方式

方法名	说明
int rea()	一次读一个字符数据
int read(char[] cbuf)	一次读一个字符数组数据

package demo_01;

import java.io.*;

public class StreamReadAndWriterDemo {
    public static void main(String[] args) throws IOException {
        //1. InputStreamReader(InputStream in)  创建一个使用默认字符集的InputStreamReader
//        InputStreamReader isw = new InputStreamReader(new FileInputStream("myCharStream\java.txt"));
        InputStreamReader isw = new InputStreamReader(new FileInputStream("myCharStream\java.txt"),"UTF-8");
        //一次读取一个字符数据
        

        //一次读取一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len=isw.read(chs))!=-1){
            System.out.println(new String(chs,0,len));
        }
        //释放资源
        isw.close();
    }
}

案例：复制Java文件

需求：把模块目录下的“Java.txt”复制到模块目录下的“Copy.txt"

思路：
①根据数据源创建字符输入流对象
②根据目的地创建字符输出流对象
③读写数据，复制文件
④释放资源

package demo_02;

import java.io.*;

public class CopyJavaDemo {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符输入流对像
        InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\java.txt"));
        //根据目的地创建字符输出流对像
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\copy.txt"));

        //读写数据，复制文件
        char[] chs = new char[1024];
        int len;
        while ((len=isr.read(chs))!=-1){
            osw.write(chs,0,len);
        }
        //释放资源
        isr.close();
        osw.close();
    }
}

案例：复制Java文件（改进版）

需求：把模块目录下的“java.txt”复制到模块目录下的"Copy.txt’

分析：
①转换流的名字比较长，而我们常见的操作都是按照本地默认编码实现的，所以，为了简化书写，转换流提供了对应的子类
②FileReader：用于读取字符文件的便捷类
FileReader(String fileName)
③FileWriter：用于写入字符文件的便捷类
FileWriter(String fileName)
④数据源和目的地的分析
数据源：myCharStreamjava.txt—读数据—Reader—InputStreamReader—FileReader
目的地：myCharStreamcopy.txt—写数据—Writer—OutputStreamWriter—FileWriter

思路：
①根据数据源创建字符输入流对像
②根据目的地创建字符输出流对象
③读写数据，复制文件
④释放资源

package demo_02;

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

public class CopyJavaDemo02 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符输入流对象
        FileReader fr = new FileReader("myCharStream\java.txt");
        //根据目的地创建字符输出流对象
        FileWriter fw = new FileWriter("myCharStream\copy.txt");

        //读写数据，复制文件
        

        char[] chs = new char[1024];
        int len;
        while ((len=fr.read(chs))!=-1){
            fw.write(chs,0,len);
        }

        //释放资源
        fr.close();
        fw.close();
    }
}

2.7 字符缓冲流

字符缓冲流：

• BufferedWriter:将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途
• BufferedReader:从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默认大小。默认值足够大，可用于大多数用途

构造方法：

• BufferedWriter(Writer out)
• BufferedReader(Reader in)

package demo_03;

import java.io.*;

public class BufferedStreamDemo {
    public static void main(String[] args) throws IOException {
        //BufferedWriter(Writer  in)
        
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\copy.txt"));
        bw.write("hellorn");
        bw.write("worldrn");
        bw.close();

        //BufferedReader(Reader  out)
        BufferedReader br = new BufferedReader(new FileReader("myCharStream\java.txt"));

        

        //一次读取一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len=br.read(chs))!=-1){
            System.out.print(new String(chs,0,len));
        }

        //释放资源
        br.close();
    }
}

案例：复制java文件（字符缓冲流改进版）

需求：把模块目录下的“java.txt”复制到模块目录下的"copy.txt’

思路：
①根据数据源创建字符缓冲输入流对象
②根据目的地创建字符缓冲输出流对象
③读写数据，复制文件
④释放资源

package demo_03;

import java.io.*;

public class BufferedStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("myCharStream\java.txt"));
        //根据目的地创建字数输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\copy.txt"));

        //读取数据，复制文件
        

        //一次读写一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len = br.read(chs)) != -1) {
            bw.write(chs, 0, len);
        }

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

2.8 字节缓冲流特有功能

BufferedWriter：

• void newLine()：写一行行分隔符，行分隔符字符串由系统属性定义

BufferedReader：

• public String readLine()：读一行文字。结果包含行的内容的字符串，不包括任何行终止字符，如果流的结尾已经到达，则为null

package demo_03;

import java.io.*;

public class NewMethodBufferdeDemo {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲输出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\copy.txt"));

        //写数据
        for (int i = 0; i < 10; i++) {
            bw.write("hello" + i);
//            bw.write("rn");
            bw.newLine();
            bw.flush();
        }

        //创建字符缓冲输入流
//        BufferedReader br= new BufferedReader(new FileReader("myCharStream\java.txt"));
        FileReader fr = new FileReader("myCharStream\java.txt");
        BufferedReader br= new BufferedReader(fr);

        //读数据
        String line;
        while ((line=br.readLine())!=null){
            System.out.println(line);
        }

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

案例：复制Java文件（字符缓冲流特有功能改进版）

需求：把模块目录下的“java.txt”复制到模块目录下的"copy.txt’

思路：
①根据数据源创建字符缓冲输入流对象
②根据目的地创建字符缓冲输出流对象
③读写数据，复制文件
使用字符缓冲流特有功能实现
④释放资源

package demo_03;

import java.io.*;

public class CopyJavaNewMethodDemo {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符缓冲输入流对象
        BufferedReader bis = new BufferedReader(new FileReader("myCharStream\java.txt"));
        //根据目的地创建字符缓冲输出流对象
        BufferedWriter bos = new BufferedWriter(new FileWriter("myCharStream\copy.txt"));

        //读写数据，复制文件
        //使用字符缓冲流特有功能实现
        String len;
        while ((len=bis.readLine())!=null){
            bos.write(len);
            bos.newLine();
            bos.flush();
        }

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

2.9 IO流小结

更多内容请访问博主博客：逸乐的博客 - 今晚一起吃火锅

文章如有纰漏请指出，整理不易多多包涵。

Java后续笔记将持续更新…