IO知识点整理（四种基类的使用）

转载

mb5fe18f0f5c8c6 2017-04-12 21:56:00

文章标签 java 字节流字符流数组转换流 文章分类 代码人生

一：介绍

1.两种基类

　　字节流

　　　　InputStream，OutputStream

　　字符流

　　　　Reader，Writer

二：字符流的基本方法（文字的处理比较常见）

1.Writer的API

　　 IO知识点整理（四种基类的使用）_字符流

2.FileWriter

　　 IO知识点整理（四种基类的使用）_字符流_02

　　 IO知识点整理（四种基类的使用）_java_03

3.程序

1 import java.io.FileWriter;
2 public class Test82 {
3     public static void main(String[] args)throws Exception {
4         FileWriter fw=new FileWriter("Demo1.txt");
5         fw.write("\r\nqqqqqqqqqqqqqq\r\nbbbb");
6         fw.flush();
7         fw.close();
8     }
9 }

4.效果现象

　　 IO知识点整理（四种基类的使用）_字符流_04

5.IO的专业处理方式

　　注意点：FileWriter中的类放在外部定义。

finall中需要判读FileWriter是否为空，因为可能创建失败，就不存在流，也不需要关。

 1 import java.io.FileWriter;
 2 public class Test83 {
 3     public static void main(String[] args) {
 4         FileWriter fw=null;
 5         try{
 6             fw=new FileWriter("Demo2.txt");
 7             fw.write("hhhhh");
 8         }catch(Exception e){
 9             System.out.println(e.getMessage());
10         }finally{
11             try{
12                 if(fw!=null)
13                     fw.close();
14             }catch(Exception e){
15                 System.out.println(e.getMessage());
16             }
17         }
18     }
19 }

6.文件续写

　　注意：传递一个true参数，代表对已有的文件不进行覆盖，而是在文件的末尾处进行续写。

　　　　　如果没有文件，则新建文件。

1 import java.io.FileWriter;
2 public class Test82 {
3     public static void main(String[] args)throws Exception {
4         FileWriter fw=new FileWriter("Demo1.txt",true);//boolean为true
5         fw.write("\r\nqqqqqqqqqqqqqq\r\nbbbb");
6         fw.flush();
7         fw.close();
8     }
9 }

7.效果

　　 IO知识点整理（四种基类的使用）_数组_05

8.Reader的API

　　 IO知识点整理（四种基类的使用）_java_06

9.FileReader

　　 IO知识点整理（四种基类的使用）_字符流_07

　　 IO知识点整理（四种基类的使用）_字节流_08

10.读取单个字符（判读条件是读入的字符）

 1 import java.io.FileNotFoundException;
 2 import java.io.FileReader;
 3 public class Test84 {
 4     public static void main(String[] args) throws Exception {
 5         FileReader fr=new FileReader("Demo1.txt");
 6         int num=0;
 7         while((num=fr.read())!=-1){
 8             System.out.print((char)num);
 9         }
10     }
11 }

11.效果

　　 IO知识点整理（四种基类的使用）_转换流_09

12.读取数组（判断条件是字符个数）

　　注意点：print不要带ln，因为数据查过1024时，数据对从下一行开始打印。

 1 import java.io.FileReader;
 2 public class Test85 {
 3     public static void main(String[] args)throws Exception {
 4         FileReader fr=new FileReader("Demo1.txt");
 5         char[] buf=new char[1024];
 6         int len=0;
 7         while((len=fr.read(buf))!=-1){
 8             System.out.print(new String(buf,0,len));
 9         }
10         fr.close();
11     }
12 }

13.效果

　　 IO知识点整理（四种基类的使用）_数组_10

14.复制（文本的复制）

　　注意点：写入的方法是数组写入。

 1 import java.io.FileReader;
 2 import java.io.FileWriter;
 3 public class Test86 {
 4     public static void main(String[] args) {
 5         copy();
 6     }
 7     private static void copy(){
 8         FileWriter fw=null;
 9         FileReader fr=null;
10         try{
11             fw=new FileWriter("Demo1_copy.txt");
12             fr=new FileReader("Demo1.txt");
13             char[] buf=new char[1024];
14             int len=0;
15             while((len=fr.read(buf))!=-1){
16                 fw.write(buf,0,len);
17             }    
18         }catch(Exception e){
19             System.out.println("error"+e.toString());
20         }finally{
21             if(fr!=null)
22                 try{
23                     fr.close();
24                 }catch(Exception e){
25                     System.out.println("error fr close");
26                 }
27             if(fw!=null)
28                 try{
29                     fw.close();
30                 }catch(Exception e){
31                     System.out.println("error fw close");
32                 }
33         }
34     }
35 }

15.效果

　　 IO知识点整理（四种基类的使用）_字符流_11

三：字符流的缓冲（实际中的使用）

1.BufferedWriter API

　　 IO知识点整理（四种基类的使用）_数组_12

2.newLine的使用

 1 import java.io.BufferedWriter;
 2 import java.io.FileWriter;
 3 import java.io.IOException;
 4 
 5 public class Test87 {
 6     public static void main(String[] args) throws IOException{
 7         FileWriter fw=new FileWriter("Demo2.txt");
 8         BufferedWriter bufw=new BufferedWriter(fw);
 9         for(int i=0;i<7;i++){
10             bufw.write("abggf");
11             bufw.newLine();
12             bufw.flush();
13         }
14         bufw.close();
15     }
16 }

3.BufferedReader方法

　　多了一个方法

　　 IO知识点整理（四种基类的使用）_字节流_13

4.程序readLine的使用

　　注意点：读取的时候，不读取行终止符

　　　　所以打印的时候，要加上换行符

 1 import java.io.BufferedReader;
 2 import java.io.FileReader;
 3 import java.io.IOException;
 4 public class Test88 {
 5     public static void main(String[] args) throws IOException{
 6         FileReader fr=new FileReader("Demo2.txt");
 7         BufferedReader bufr=new BufferedReader(fr);
 8         String line=null;
 9         while((line=bufr.readLine())!=null){
10             System.out.println(line);
11         }
12     }
13 }

5.效果

　　 IO知识点整理（四种基类的使用）_转换流_14

6.复制

　　注意点：使用readLine的方法时，要加上换行newLine方法。

 1 import java.io.BufferedReader;
 2 import java.io.BufferedWriter;
 3 import java.io.FileReader;
 4 import java.io.FileWriter;
 5 import java.io.IOException;
 6 
 7 public class Test89 {
 8 
 9     public static void main(String[] args) {
10         BufferedReader bufr=null;
11         BufferedWriter bufw=null;
12         try{
13             bufr=new BufferedReader(new FileReader("Demo2.txt"));
14             bufw=new BufferedWriter(new FileWriter("BufferedDemo2.txt"));
15             String line=null;
16             while((line=bufr.readLine())!=null){
17                 bufw.write(line);  //写入的是String方法
18                 bufw.newLine();
19                 bufw.flush();
20             }
21         }catch(Exception e){
22             e.printStackTrace();
23         }finally{
24             if(bufw!=null){
25                 try{
26                     bufw.close();
27                 }catch(Exception e){
28                     e.toString();
29                 }
30             }
31             if(bufr!=null){
32                 try{
33                     bufr.close();
34                 }catch(Exception e){
35                     e.toString();
36                 }
37             }
38         }
39     }
40 
41 }

7.效果

　　 IO知识点整理（四种基类的使用）_字符流_15

8.LineNumberReader--其为BufferedReader的装饰修饰类

　　 IO知识点整理（四种基类的使用）_java_16

9.程序

 1 import java.io.FileNotFoundException;
 2 import java.io.FileReader;
 3 import java.io.IOException;
 4 import java.io.LineNumberReader;
 5 public class Test90 {
 6     public static void main(String[] args) throws IOException {
 7         FileReader fr=new FileReader("Demo2.txt");
 8         LineNumberReader lineReader=new LineNumberReader(fr);
 9         String line=null;
10         while((line=lineReader.readLine())!=null){
11             System.out.println(lineReader.getLineNumber()+":"+line);
12         }
13     }
14 }

10.效果

　　 IO知识点整理（四种基类的使用）_数组_17

四：字节流的基本方法

1.OutputStream的使用

 1 import java.io.FileNotFoundException;
 2 import java.io.FileOutputStream;
 3 import java.io.IOException;
 4 
 5 public class Test91 {
 6     public static void main(String[] args) throws IOException {
 7         outputS();
 8     }
 9     public static void outputS()throws IOException{
10         FileOutputStream fo=new FileOutputStream("Demo3.txt");
11         //将字符传转换为字节数组,进行写入
12         fo.write("yusbcjsbdcjksb".getBytes());
13         fo.close();
14     }
15 
16 }

2.效果

　　 IO知识点整理（四种基类的使用）_字符流_18

3.读取InputStream方法（一个一个的读取）

 1 import java.io.FileInputStream;
 2 import java.io.FileNotFoundException;
 3 import java.io.IOException;
 4 public class Test92 {
 5     public static void main(String[] args) throws IOException{
 6         inputS();        
 7     }
 8     public static void inputS() throws IOException{
 9         FileInputStream fi=new FileInputStream("Demo2.txt");
10         int num=0;
11         while((num=fi.read())!=-1){
12             System.out.print((char)num);
13         }
14     }
15 }

4.效果

　　 IO知识点整理（四种基类的使用）_java_19

5.读取InputStream方法（数组的读取）

 1 import java.io.FileInputStream;
 2 import java.io.IOException;
 3 
 4 public class Test93 {
 5     public static void main(String[] args) throws IOException{
 6         inputS();        
 7     }
 8     public static void inputS() throws IOException{
 9         FileInputStream fi=new FileInputStream("Demo2.txt");
10         byte[] fb=new byte[1024];
11         int len=0;
12         while((len=fi.read(fb))!=-1){
13             System.out.println(new String(fb,0,len));
14         }
15     }
16 }

6.效果

　　 IO知识点整理（四种基类的使用）_转换流_20

7.复制图片

 1 import java.io.FileInputStream;
 2 import java.io.FileOutputStream;
 3 
 4 public class Test94 {
 5 /**
 6  * copy picture
 7  * @param args
 8  */
 9     public static void main(String[] args) {
10         copyPicture();
11     }
12     public static void copyPicture(){
13         FileInputStream fi=null;
14         FileOutputStream fo=null;
15         try{
16             fi=new FileInputStream("me1.jpg");
17             fo=new FileOutputStream("me1_copy.jpg");
18             byte[] fb=new byte[1024];
19             int len=0;
20             while((len=fi.read(fb))!=-1){
21                 fo.write(fb, 0, len);
22             }
23             
24         }catch(Exception e){
25             e.toString();
26         }finally{
27             if(fi!=null){
28                 try{
29                     fi.close();
30                 }catch(Exception e){
31                     e.toString();
32                 }
33             }
34             if(fo!=null){
35                 try{
36                     fo.close();
37                 }catch(Exception e){
38                     e.toString();
39                 }
40             }
41         }
42     }
43 
44 }

五：字节流的缓存

1.复制图片

 1 import java.io.BufferedInputStream;
 2 import java.io.BufferedOutputStream;
 3 import java.io.FileInputStream;
 4 import java.io.FileNotFoundException;
 5 import java.io.FileOutputStream;
 6 import java.io.IOException;
 7 public class Test95 {
 8 /**
 9  * copy picture with cache
10  * @param args
11  * @throws IOException
12  */
13     public static void main(String[] args) throws IOException {
14         BufferedInputStream bufi=new BufferedInputStream(new FileInputStream("me1.jpg"));
15         BufferedOutputStream bufo=new BufferedOutputStream(new FileOutputStream("me1_copy2.jpg"));
16         int num=0;
17         while((num=bufi.read())!=-1){
18             bufo.write(num);
19             bufo.flush();
20         }
21         bufi.close();
22         bufo.close();
23     }
24 }

2.键盘录入

 1 import java.io.IOException;
 2 import java.io.InputStream;
 3 public class Test96 {
 4     public static void main(String[] args) throws IOException {
 5         InputStream ins=System.in;
 6         StringBuilder sb=new StringBuilder();
 7         while(true){
 8             int ch=ins.read();
 9             if(ch=='\r'){
10                 continue;
11             }
12             if(ch=='\n'){
13                 String s=sb.toString();
14                 if(s.equals("over"))
15                     break;
16                 System.out.println(s.toUpperCase());
17                 sb.delete(0, sb.length());
18             }else{
19                 sb.append((char)ch);  //将字母存入
20             }
21         }
22 
23     }
24 
25 }

3.结果

　　 IO知识点整理（四种基类的使用）_数组_21

六：转换流

1.需求一（字节流转换成字符流）

　　键盘的录入时，是一行一行的录入，但是键盘录入时InputStream，读取一行的方法是BufferedReader中的readLine方式。

因此，需要一个转换流，将字节流转换成字符流。

　　 IO知识点整理（四种基类的使用）_字节流_22

　　 IO知识点整理（四种基类的使用）_字符流_23

2.程序

 1 import java.io.BufferedReader;
 2 import java.io.IOException;
 3 import java.io.InputStream;
 4 import java.io.InputStreamReader;
 5 
 6 public class Test97 {
 7 
 8     public static void main(String[] args) throws IOException {
 9         InputStream in=System.in;
10         InputStreamReader insr=new InputStreamReader(in);
11         //use buffer
12         BufferedReader bufr=new BufferedReader(insr);
13         String line=null;
14         while((line=bufr.readLine())!=null){
15             if(line.equals("over")){
16                 break;
17             }
18             System.out.println(line.toUpperCase());
19         }
20     }
21 }

3.结果

　　 IO知识点整理（四种基类的使用）_字符流_24

4.需求二（字符流转换成字节流）

　　当字符想保存到硬盘上时，就是字符转换成字节流。

　　 IO知识点整理（四种基类的使用）_java_25

　　 IO知识点整理（四种基类的使用）_数组_26

5.程序

 1 import java.io.BufferedReader;
 2 import java.io.BufferedWriter;
 3 import java.io.IOException;
 4 import java.io.InputStream;
 5 import java.io.InputStreamReader;
 6 import java.io.OutputStream;
 7 import java.io.OutputStreamWriter;
 8 public class Test98 {
 9     public static void main(String[] args) throws Exception {
10         //in
11         InputStream in=System.in;
12         InputStreamReader insr=new InputStreamReader(in);
13         BufferedReader bufr=new BufferedReader(insr);
14         //out
15         OutputStream out=System.out;
16         OutputStreamWriter outs=new OutputStreamWriter(out);
17         BufferedWriter bufw=new BufferedWriter(outs);
18         //
19         String line=null;
20         while((line=bufr.readLine())!=null){
21             if(line.equals("over"))
22                 break;
23             bufw.write(line.toUpperCase());
24             bufw.newLine();
25             bufw.flush();
26         }
27     }
28 }

七：其他知识点

1.改变标准输入输出设备（其中输入的一种改变被注释了）

 1 import java.io.BufferedReader;
 2 import java.io.BufferedWriter;
 3 import java.io.FileInputStream;
 4 import java.io.InputStream;
 5 import java.io.InputStreamReader;
 6 import java.io.OutputStream;
 7 import java.io.OutputStreamWriter;
 8 import java.io.PrintStream;
 9 
10 public class Test99 {
11     public static void main(String[] args) throws Exception {
12         //change
13         //System.setIn(new FileInputStream("Demo2.txt"));
14         System.setOut(new PrintStream("change.txt"));
15         //in
16         InputStream in=System.in;
17         InputStreamReader insr=new InputStreamReader(in);
18         BufferedReader bufr=new BufferedReader(insr);
19         //out
20         OutputStream out=System.out;
21         OutputStreamWriter outs=new OutputStreamWriter(out);
22         BufferedWriter bufw=new BufferedWriter(outs);
23         //
24         String line=null;
25         while((line=bufr.readLine())!=null){
26             if(line.equals("over"))
27                 break;
28             bufw.write(line.toUpperCase());
29             bufw.newLine();
30             bufw.flush();
31         }
32     }
33 }

2.效果

　　 IO知识点整理（四种基类的使用）_字节流_27

　　 IO知识点整理（四种基类的使用）_字符流_28

3.将日志由控制台的打印转到文件中

 1 import java.io.IOException;
 2 import java.io.PrintStream;
 3 import java.text.SimpleDateFormat;
 4 import java.util.Date;
 5 
 6 public class Test100 {
 7     public static void main(String[] args) {
 8         try
 9         {
10             int[] arr = new int[2];
11             System.out.println(arr[3]);
12         }
13         catch (Exception e)
14         {
15             try
16             {
17                 Date d = new Date();
18                 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
19                 String s = sdf.format(d);
20                 PrintStream ps = new PrintStream("exception.log");
21                 ps.println(s);
22                 System.setOut(ps);    
23             }
24             catch (IOException ex)
25             {
26                 throw new RuntimeException("日志文件创建失败");
27             }
28             e.printStackTrace(System.out);
29         }
30     }
31 }

4.效果

　　 IO知识点整理（四种基类的使用）_数组_29

5.打印系统信息

 1 import java.io.FileNotFoundException;
 2 import java.io.PrintStream;
 3 import java.util.Properties;
 4 public class Test101 {
 5     public static void main(String[] args) throws Exception {
 6         Properties pro=System.getProperties();
 7         //
 8         pro.list(new PrintStream("hui.txt"));
 9     }
10 }