Java基础知识笔记九（详细）

IO流概述和分类

1,IO流用来处理设备之间的数据传输
(1)上传文件(上传头像)和下载文件(迅雷)
(2)文件复制(U盘拷贝)
2,IO流分类
(1)输出流
FileWriter(全称字符输出流)
(2)输入流
FileReader(全称字符输入流)
3,注意:
流的种类有很多种，目前先学习一些基本的和高效的输入输出流。
Java中的IO模型设计非常的优秀，它使用了设计模式中的装饰者模式。

FileWriter写数据

1,构造方法
传递一个文件的名称，根据文件名称创建输出流对象
public FileWriter(String fileName){} ;

//创建输出流对象
FileWriter fw = new FileWriter("d://a.txt");

传递一个文件的名称以及是否追加，根据文件名称创建输出流对象
public FileWriter(String filename,boolean append){};
2,成员方法
写一个字符串到指定的文件中
public void write(String str){};

//使用输出流中的方法完成数据的输出
fw.write("你好呀！");

将缓冲区的数据刷新到文件中
public void flush(){}:

//把数据写到了缓冲区
fw.flush();

将程序与硬盘之间打开的资源进行释放
public void close(){}:

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

一定注意需要释放资源
3,注意事项
(1)flush() 刷新缓冲区，只要没有close，那么就可以一直写出数据。
(2)close() 会先检查缓冲区是否需要刷新，然后在释放资源，只要close了，那么是不可以在写出数据了。
(3)相对路径:相当于你当前项目而言
(4)绝对路径:明确指定了盘符对应的具体位置

FileWriter写数据的方法

写一个字符串到指定的文件中
public void write(String str){};
写一个字符串的一部分到指定的文件中
public void write(String str,int index,int len){};
写一个字符到指定的文件中
public void write(int ch){}:;
写一个字符数组到指定的文件中
public void write(char[] chs){};
写一个字符数组的一部分到指定的文件中
public void write(char[] chs,int index,int len){};

public static void main(String[] args) throws IOException {
    //创建输出流
    FileWriter fw = new FileWriter("a.txt");
    //write(String str)
    fw.write("hello china");

    //write(String str,int index,int len)
    String str = "hello china";
    fw.write(str,2,3);

    //write(int ch)
    fw.write(97);

    //write(char[] chs)
    char[] chs = {'a','b','c','d','e'};
    fw.write(chs);

    //write(char[] chs,int index,int len)
    fw.write(chs,1,3);

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

FileWriter写数据常见问题

1,如何实现数据的换行?
(1)假如我现在要写一个main函数到文件，期望有换行效果。

int main()
{return 0;}

2,如何实现数据的追加写入?
(1) 使用输出流对象去写数据，每次执行程序，都会帮我们删除之前的文件，然后创建新文件，如果期望把之前文件里面的数据保留，继续添加新的数据进去，不覆盖，这个时候就可以使用FileWriter(String filename，boolean append)的这个构造完成数据的追加。

public static void main(String[] args) throws IOException {
    //创建输出流对象
    FileWriter fw = new FileWriter("b.txt",true);
    //写数据
    fw.write("int main()\r\n");
    fw.write("{return 0;}\r\n");
    //释放资源
    fw.close();
}

FileReader读数据

1,构造方法
根据文件名称创建输入流对象
public FileReader(String fileName){}:

//创建输入流对象
FileReader fr = new FileReader("b.txt");

2,成员方法
一次读取一个字符
public int read(){}

//读取数据public int read() 一次读取一个字符
int read1 = fr.read();
System.out.println((char)read1);
public int read(char[] cbuf) {}:一次读取一个字符数组
char[] chs = new char[1024];//建议写1024或者倍数
int len = fr.read(chs);//返回的len是读取到的字符个数
public void close(){}:将程序与硬盘之间打开的资源进行释放
//释放资源
fr.close();

IO流案例

1,复制文本文件
(1)一次读写一个字符

//创建输入流对象
FileReader fr = new FileReader("1.txt");
int ch;
while((ch=fr.read()) != -1){
    System.out.print((char)ch);
}
//释放资源
fr.close();

(2) 一次读写一个字符数组

//创建输入流对象
FileReader fr = new FileReader("1.txt");
//创建输出流对象
FileWriter fw = new FileWriter("copy.txt");
//public int read(char[] cbuf) {}:一次读取一个字符数组
char[] chs = new char[1024];//建议写1024或者倍数
 while((fr.read(chs) != -1)){
            fw.write(chs);
        }
//释放资源
fw.close();
fr.close();

字符缓冲流

1,BufferedWriter基本用法
根据基本的输出流创建缓冲输出流对象
public BufferedWriter(Writer out) {}

//创建缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("c.txt"));
bw.write("hello China");
//bw.flush();
bw.close();

2,BufferedReader基本用法
根据基本的输入流创建缓冲输入流对象
public BufferedReader(Reader in) {}

//创建缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("c.txt"));
//一次读取一个字符
int ch;
while((ch = br.read()) != -1){
    System.out.print((char)ch);
}
br.close();

3,字符缓冲流复制文本文件

public static void main(String[] args) throws IOException {
    //method1();
    method2();//调用方法
}

(1)使用缓冲流一次读取一个字符的方式复制文件

public static void method1() throws IOException {
    //创建缓冲输入流
    BufferedReader br = new BufferedReader(new FileReader("1.txt"));
    //创建缓冲输出流
    BufferedWriter bw = new BufferedWriter(new FileWriter("copy.txt"));
    //读取数据到内存  一次读取一个字符
    int ch;
    while((ch = br.read()) != -1){
        //写出数据到硬盘
        bw.write(ch);
    }
    //释放资源
    bw.close();
    br.close();
}

(2)使用缓冲流一次读取一个字符数组的方式复制文件

public static void method2() throws IOException {
    //创建缓冲输入流
    BufferedReader br = new BufferedReader(new FileReader("1.txt"));
    //创建缓冲输出流
    BufferedWriter bw = new BufferedWriter(new FileWriter("copy.txt"));
    //读取数据到内存  一次读取一个字符数组
    char[] chars = new char[1024];
    int len;
    while((len = br.read(chars)) != -1){
        //写出数据到硬盘，建议读取到多少个，就写多少个
        bw.write(chars,0,len);
    }
    //释放资源
    bw.close();
    br.close();
}

4.特殊功能

//BufferedWriter
public void newLine(){}:一次读取一行数据
//创建缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("e.txt"));
//写数据
bw.write("int main()");
bw.newLine();
bw.write("{return 0;}");
//释放资源
bw.close();
//BufferedReader
//public String readLine(){}:写一个换行
//创建缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("e.txt"));
//读数据
String str;
while((str = br.readLine()) != null){
    System.out.println(str);
}
//释放资源
br.close();

5.字符缓冲流特殊功能复制文本文件

public static void main(String[] args) throws IOException {
    //创建缓冲输入流
    BufferedReader br = new BufferedReader(new FileReader("1.txt"));
    //创建缓冲输出流
    BufferedWriter bw = new BufferedWriter(new FileWriter("copy2.txt"));
    //使用缓冲流的特殊功能
    String str;
    while((str = br.readLine()) != null){
        bw.write(str);
        bw.newLine();
    }
    //释放资源
    bw.close();
    br.close();
}

IO流练习

1,复制文本文件(5种方式)

public static void main(String[] args) throws IOException {
    String  srcFileName = "1.txt";
    String  descFileName = "copy3.txt";
    method01(srcFileName,descFileName);
    method02(srcFileName,descFileName);
    method03(srcFileName,descFileName);
    method04(srcFileName,descFileName);
    method05(srcFileName,descFileName);
}

(1)使用基本流一次读取一个字符

public static void method01(String srcFileName, String descFileName) throws IOException {
    //创建基本的输入流
    FileWriter fw = new FileWriter(descFileName);
    //创建基本的输出流
    FileReader fr = new FileReader(srcFileName);
    //一次读取一个字符
    int ch;
    while((ch = fr.read()) != -1){
        System.out.println(ch);
        fw.write(ch);
    }
    //释放资源
    fr.close();
    fw.close();
}

(2)使用基本流一次读取一个字符数组

public static void method02(String srcFileName, String descFileName) throws IOException {
    //创建基本的输入流
    FileWriter fw = new FileWriter(descFileName);
    //创建基本的输出流
    FileReader fr = new FileReader(srcFileName);
    //一次读取一个字符数组
    char[] chs = new char[1024];
    int len;
    while((len = fr.read(chs)) != -1){
        fw.write(chs,0,len);
    }
    //释放资源
    fr.close();
    fw.close();
}

(3)使用缓冲流一次读取一个字符

public static void method03(String srcFileName, String descFileName) throws IOException {
    //创建基本的输出流
    FileWriter fw = new FileWriter(descFileName);
    //创建高效的输出流
    BufferedWriter bw = new BufferedWriter(fw);
    //创建基本的输入流
    FileReader fr = new FileReader(srcFileName);
    //创建高效的输入流
    BufferedReader br = new BufferedReader(fr);
    //一次读取一个字符
    int ch;
    while((ch = br.read()) != -1){
        System.out.println(ch);
        bw.write(ch);
    }
    //释放资源
    br.close();
    fr.close();
    bw.close();
    fw.close();
}

(4)使用缓冲流一次读取一个字符数组

public static void method04(String srcFileName, String descFileName) throws IOException {
    //创建基本的输出流
    FileWriter fw = new FileWriter(descFileName);
    //创建高效的输出流
    BufferedWriter bw = new BufferedWriter(fw);
    //创建基本的输入流
    FileReader fr = new FileReader(srcFileName);
    //创建高效的输入流
    BufferedReader br = new BufferedReader(fr);
    //一次读取一个字符数组
    char[] chs = new char[1024];
    int len;
    while((len = br.read(chs)) != -1){
        bw.write(chs,0,len);
    }
    //释放资源
    br.close();
    fr.close();
    bw.close();
    fw.close();
}

(5)使用缓冲流的特殊功能

public static void method05(String srcFileName, String descFileName) throws IOException {
    //创建基本的输出流
    FileWriter fw = new FileWriter(descFileName);
    //创建高效的输出流
    BufferedWriter bw = new BufferedWriter(fw);
    //创建基本的输入流
    FileReader fr = new FileReader(srcFileName);
    //创建高效的输入流
    BufferedReader br = new BufferedReader(fr);
    //使用缓冲流的特殊功能
    String str;
    while((str = br.readLine()) != null){
        bw.write(str);
        bw.newLine();
    }
    //释放资源
    br.close();
    fr.close();
    bw.close();
    fw.close();
}