IO流-基础

//创建输出流对象
FileWriter fw = new FileWriter("d:\a.txt");
/*
* 创建输出流对象做了哪些事情:
* A:调用系统资源创建了一个文件
* B:创建输出流对象
* C:把输出流对象指向文件
*/

//调用输出流对象的写数据的方法
//写一个字符串数据
fw.write("IO流你好");
//数据没有直接写到文件，其实是写到了内存缓冲区
fw.flush();

//释放资源
//通知系统释放和该文件相关的资源
fw.close();

* close()和flush()方法的区别：
* flush():刷新缓冲区。流对象还可以继续使用。
* close():先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

* 相对路径：相对当前项目而言的，在项目的根目录下(a.txt)

* void write(String str):写一个字符串数据

* void write(String str,int index,int len):写一个字符串中的一部分数据
* void write(int ch):写一个字符数据,这里写int类型的好处是既可以写char类型的数据，也可以写char对应的int类型的值。'a',97
* void write(char[] chs):写一个字符数组数据
* void write(char[] chs,int index,int len):写一个字符数组的一部分数据

* 如何实现数据的换行?
* 可以实现换行，但是windows系统自带的记事本打开并没有换行，这是为什么呢?因为windows识别的换行不是，而是
* windows:
* linux:
* mac:
* 如何实现数据的追加写入?
* FileWriter(String fileName, boolean append)

FileWriter fw = new FileWriter("c.txt",true); //表示追加写入，默认是false

文件读取:

 1   FileReader fr = new FileReader("FileWriterDemo.java");
 2  
 3   //调用输入流对象的读数据方法
 4   //int read():一次读取一个字符
 5   
 6   //通过测试，我们知道，如果读取数据的返回值是-1的时候，就说明没有数据了，这也是我们循环的结束条件
 7   
 8  int ch;
 9  while((ch=fr.read())!=-1) {
10  System.out.print((char)ch);
11  }
12  
13  //释放资源
14  fr.close();

复制文件:

 1         //创建输入流对象
 2         FileReader fr = new FileReader("FileWriterDemo.java");
 3         //创建输出流对象
 4         FileWriter fw = new FileWriter("Copy.java");
 5         
 6         //读写数据
 7         int ch;
 8         while((ch=fr.read())!=-1) {
 9             fw.write(ch);
10         }
11         
12         //释放资源
13         fw.close();
14         fr.close();

一次读取一个字符串:

 1 FileReader fr = new FileReader("FileWriterDemo.java");
 2 
 3 //int read(char[] cbuf)：一次读取一个字符数组的数据，返回的是实际读取的字符个数
 4 //通过测试，我们知道，如果实际读取长度是-1的时候，说明没有数据了
 5 char[] chs = new char[1024]; //这里可以是1024及其整数倍
 6 int len;
 7         
 8 while((len=fr.read(chs))!=-1) {
 9     //System.out.println(new String(chs,0,len));
10     System.out.print(new String(chs,0,len));
11 }
12         
13 //释放资源
14 fr.close();
15

FilreReader读取数据的两种方式图解:

一次读写一个字符数组复制文本文件:

 1         //创建输入流对象
 2         FileReader fr  = new FileReader("FileWriterDemo.java");
 3         //创建输出流对象
 4         FileWriter fw = new FileWriter("Copy.java");
 5         
 6         //读写数据
 7         char[] chs = new char[1024];
 8         int len;
 9         while((len=fr.read(chs))!=-1) {
10             fw.write(chs, 0, len);
11         }
12         
13         //释放资源
14         fw.close();
15         fr.close();

* BufferedWriter:将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
* BufferedReader:从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

 1         //创建输出缓冲流对象
 2         /*
 3         BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
 4         bw.write("hello");
 5         //bw.flush();
 6         bw.close();
 7         */
 8         
 9         //创建输入缓冲流对象
10         BufferedReader br = new BufferedReader(new FileReader("FileWriterDemo.java"));
11         
12         
13         //一次读写一个字符
14         int ch;
15         while((ch=br.read())!=-1){
16             System.out.print((char)ch);
17         }
18         
19         
20         //一次读写一个字符数组
21         char[] chs = new char[1024];
22         int len;
23         while((len=br.read(chs))!=-1) {
24             System.out.print(new String(chs,0,len));
25         }
26         
27         //释放资源
28         br.close();

缓冲流复制文本文件的两种方式:

 1         //创建输入缓冲流对象
 2         BufferedReader br = new BufferedReader(new FileReader("FileWriterDemo.java"));
 3         //创建输出缓冲流对象
 4         BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
 5         
 6         //读写数据
 7         /*
 8         //一次读写一个字符
 9         int ch;
10         while((ch=br.read())!=-1) {
11             bw.write(ch);
12         }
13         */
14         
15         //一次读写一个字符数组
16         char[] chs = new char[1024];
17         int len;
18         while((len=br.read(chs))!=-1) {
19             bw.write(chs,0,len);
20         }
21         
22         //释放资源
23         bw.close();
24         br.close();

* 缓冲流的特殊功能：
* BufferedWriter
* void newLine():写一个换行符，这个换行符由系统决定
* BufferedReader
* String readLine():一次读取一行数据，但是不读取换行符

 1         BufferedWriter bw = new BufferedWriter(new FileWriter("bw2.txt"));
 2         for(int x=0; x<10; x++) {
 3             bw.write("hello"+x);
 4             //bw.write("
");
 5             bw.newLine();
 6             bw.flush();
 7         }
 8         bw.close();
 9 
10         
11         BufferedReader br = new BufferedReader(new FileReader("br.txt"));
12     
13         String line;
14         //1:br.readLine()
15         //2:line=br.readLine()
16         //3:line != null
17         while((line=br.readLine())!=null) {
18             System.out.println(line);
19         }
20         
21         br.close();

缓冲流特殊功能复制文本文件:

 1         //创建输入缓冲流对象
 2         BufferedReader br = new BufferedReader(new FileReader("FileWriterDemo.java"));
 3         //创建输出缓冲流对象
 4         BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
 5         
 6         //读写数据
 7         String line;
 8         while((line=br.readLine())!=null) {
 9             bw.write(line);
10             bw.newLine();
11             bw.flush();
12         }
13         
14         //释放资源
15         bw.close();
16         br.close();

复制文本文件的5种方式

A:利用基本流一次读写一个字符

B:利用基本流一次读写一个字符数组

C:利用缓冲流一次读写一个字符

D:利用缓冲流一次读写一个字符数组

E:利用缓冲流的特有方法一次读写一个字符串

 1     //缓冲流一次读写一个字符串
 2     public static void method5(String srcFileName,String destFileName) throws IOException {
 3         //创建输入缓冲流对象
 4         BufferedReader br = new BufferedReader(new FileReader(srcFileName));
 5         //创建输出缓冲流对象
 6         BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));
 7         
 8         //一次读写一个字符串
 9         String line;
10         while((line=br.readLine())!=null){
11             bw.write(line);
12             bw.newLine();
13             bw.flush();
14         }
15         
16         //释放资源
17         bw.close();
18         br.close();
19     }
20     
21     //缓冲流一次读写一个字符数组
22     public static void method4(String srcFileName,String destFileName) throws IOException {
23         //创建输入缓冲流对象
24         BufferedReader br = new BufferedReader(new FileReader(srcFileName));
25         //创建输出缓冲流对象
26         BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));
27         
28         //一次读写一个字符数组
29         char[] chs = new char[1024];
30         int len;
31         while((len=br.read(chs))!=-1) {
32             bw.write(chs,0,len);
33         }
34         
35         //释放资源
36         bw.close();
37         br.close();
38     }
39     
40     //缓冲流一次读写一个字符
41     public static void method3(String srcFileName,String destFileName) throws IOException {
42         //创建输入缓冲流对象
43         BufferedReader br = new BufferedReader(new FileReader(srcFileName));
44         //创建输出缓冲流对象
45         BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));
46         
47         //一次读写一个字符
48         int ch;
49         while((ch=br.read())!=-1) {
50             bw.write(ch);
51         }
52         
53         //释放资源
54         bw.close();
55         br.close();
56     }
57     
58     //基本流一次读写一个字符数组
59     public static void method2(String srcFileName,String destFileName) throws IOException {
60         //创建输入流对象
61         FileReader fr = new FileReader(srcFileName);
62         //创建输出流对象
63         FileWriter fw = new FileWriter(destFileName);
64         
65         //一次读写一个字符数组
66         char[] chs = new char[1024];
67         int len;
68         while((len=fr.read(chs))!=-1) {
69             fw.write(chs,0,len);
70         }
71         
72         //释放资源
73         fw.close();
74         fr.close();
75     }
76     
77     //基本流一次读写一个字符
78     public static void method1(String srcFileName,String destFileName) throws IOException {
79         //创建输入流对象
80         FileReader fr = new FileReader(srcFileName);
81         //创建输出流对象
82         FileWriter fw = new FileWriter(destFileName);
83         
84         //一次读写一个字符
85         int ch;
86         while((ch=fr.read())!=-1) {
87             fw.write(ch);
88         }
89         
90         //释放资源
91         fw.close();
92         fr.close();
93     }
94 }

相关阅读:
B. Sorted Adjacent Differences(思维构造)
C. Yet Another Counting Problem(循环节规律)
B. Phoenix and Beauty(贪心构造)
Phoenix and Distribution(字典序贪心)
D. Almost All Divisors(数学分解因子)
Mongodb之简介
 web服务版智能语音对话
 图灵机器人
 人工智能之语音
 人工智能
原文地址：https://www.cnblogs.com/samuraihuang/p/9753276.html