JAVA从入门到精通-Java IO流总结
龚威 2018-03-10 来源 : 阅读 93 评论 0

摘要:JAVA从入门到精通,需要了解IO流,本文主要对Java基础中BIO文件输入输出流做一个总结,让大家在JAVA从入门到精通的学习道路上中走得更远。

本篇主要对Java基础中BIO文件输入输出流做一个总结。

首先来看一下IO流的分类,图片来自网络:

 JAVA从入门到精通-Java IO流总结

直接上代码吧:

 

1.字节输入流FileInputStream,字节输出流FileOutputStream:

Java代码  

1. /** 
2.  * FileInputStream 读取原始字节流 
3.  **/  
4. public class TestFileInputStream{  
5.     public static void main(String []args){  
6.         FileInputStream fis = null;  
7.         try{  
8.             fis = new FileInputStream("d:\\java\\io\\TestFileInputStream.java");//"d:/java/io/TestFileInputStream.java"  
9.             //read()  
10.             int num=0;  
11.             int b;  
12.             while((b=fis.read())!=-1){  
13.                     System.out.print((char)b);  
14.                     num++;  
15.                 }  
16.             System.out.println("共有字节数:"+num);  
17.             //read(byte []b)  
18.             /*byte []buffer = new byte[1024]; 
19.             int n; 
20.             int num=0; 
21.             int count=0; 
22.             while((n=fis.read(buffer))!=-1){ 
23.                 for(int i=0;i<buffer.length;i++){ 
24.                         System.out.print((char)buffer[i]); 
25.                         num++; 
26.                     } 
27.                     count++; 
28.             } 
29.             System.out.println("共有字节数:"+num+",共读了"+count+"次");*/  
30.             //read(byte []b,int off,int len)  
31.             /*byte []buffer = new byte[200]; 
32.             int n=0; 
33.             int num=0; 
34.             int count=0; 
35.             while((n=fis.read(buffer,0,buffer.length))!=-1){ 
36.                     for(int i=0;i<buffer.length;i++){ 
37.                         System.out.print((char)buffer[i]); 
38.                         num++; 
39.                     } 
40.                     count++; 
41.                 } 
42.             System.out.println("共有字节数:"+num+",共读了"+count+"次");*/  
43.             fis.close();  
44.         }catch(Exception e){  
45.             System.out.println("读取原始字节流失败!");     
46.         }  
47.     }  
48. }

Java代码  

1. /** 
2.  * FileOutputStream 写入原始字节流 
3.  **/  
4. public class TestFileOutputStream{  
5.     public static void main(String []args){  
6.         FileInputStream fis=null;  
7.         FileOutputStream fos=null;  
8.         int b;  
9.         try{  
10.             fis = new FileInputStream("d:/java.jpg");  
11.             fos = new FileOutputStream("e:/java.jpg");  
12.             //read(),write()  
13.             while((b=fis.read())!=-1){  
14.                 System.out.print((char)b);  
15.                 fos.write(b);     
16.             }  
17.             //read(byte []b),write(byte []b)  
18.             /*byte []buffer = new byte[1024]; 
19.             while((b=fis.read(buffer))!=-1){ 
20.                     fos.write(buffer); 
21.                 }*/  
22.             fos.flush();  
23.             fos.close();  
24.             fis.close();  
25.             System.out.println("文件复制成功!");  
26.         }catch(Exception e){  
27.             System.out.println("写入原始字节流失败!");     
28.         }     
29.     }  
30. }

 

2.字符输入流FileReader,字符输出流FileWriter:

Java代码  

1. /** 
2.  * FileReader 读取字符流 
3.  **/  
4. public class TestFileReader{  
5.     public static void main(String []args){  
6.         FileReader fr=null;  
7.         int b=0;  
8.         try{  
9.             fr = new FileReader("d:/java/io/TestFileReader.java");  
10.             while((b=fr.read())!=-1){  
11.                 System.out.print((char)b);    
12.             }  
13.             fr.close();  
14.         }catch(Exception e){  
15.             System.out.println("读取字符流失败!"+e);     
16.         }     
17.     }  
18. }

Java代码  

1. /** 
2.  * FileWriter 写入字符流 
3.  **/  
4. public class TestFileWriter{  
5.     public static void main(String []args){  
6.         FileReader fr = null;  
7.         FileWriter fw = null;  
8.         int b=0;  
9.         try{  
10.             fr = new FileReader("d:/java/io/TestFileWriter.java");  
11.             fw = new FileWriter("d:/java/io/TestFileWriter1.java");  
12.             while((b=fr.read())!=-1){  
13.                 fw.write(b);      
14.             }  
15.             fw.flush();  
16.             fw.close();  
17.             fr.close();  
18.             System.out.println("文件复制成功!");  
19.         }catch(Exception e){  
20.             System.out.println("写入字符流失败!"+e);     
21.         }     
22.     }     
23. }

 

3.带缓冲Buffered的输入输出流:

Java代码  

1. /** 
2.  * 缓冲流 
3.  * BufferedInputStream 带缓冲区地读取原始字节流 
4.  * BufferedOutputStream 带缓冲区地写入原始字节流  
5.  **/  
6. public class TestBufferedStream1{  
7.     public static void main(String []args){  
8.         BufferedInputStream bis = null;  
9.         BufferedOutputStream bos = null;  
10.         int c=0;  
11.         try{  
12.             bis = new BufferedInputStream(new FileInputStream("d:/java/io/TestBufferedStream1.java"));  
13.             bos = new BufferedOutputStream(new FileOutputStream("d:/Test1.java"));  
14.             System.out.println((char)bis.read());  
15.             System.out.println((char)bis.read());  
16.             bis.mark(100);  
17.             for(int i=0;i<10 && (c=bis.read())!=-1;i++){  
18.                 System.out.print((char)c);    
19.             }  
20.             System.out.println();     
21.             bis.reset();  
22.             for(int i=0;i<10 && (c=bis.read())!=-1;i++){  
23.                 System.out.print((char)c);    
24.             }  
25.             while((c=bis.read())!=-1){  
26.                 bos.write(c);     
27.             }  
28.             System.out.println("文件复制成功!");    
29.             bos.flush();  
30.             bos.close();  
31.             bis.close();  
32.         }catch(Exception e){  
33.             System.out.println("带缓冲区地读取、写入原始字节流失败!"+e);   
34.         }  
35.     }     
36. }

Java代码  

1. /** 
2.  * 缓冲流 
3.  * BufferedReader 带缓冲区地读取字符流 
4.  * BufferedWriter 带缓冲区地写入字符流  
5.  **/  
6. public class TestBufferedStream2{  
7.     public static void main(String []args){  
8.         BufferedReader br = null;  
9.         BufferedWriter bw = null;  
10.         String s=null;  
11.         try{  
12.             bw = new BufferedWriter(new FileWriter("d:/dbk.txt"));  
13.             br = new BufferedReader(new FileReader("d:/dbk.txt"));  
14.             for(int i=0;i<100;i++){  
15.                 bw.write(String.valueOf(Math.random()));      
16.                 bw.newLine();  
17.             }  
18.             bw.flush();  
19.             while((s=br.readLine())!=null){  
20.                 System.out.println(s);    
21.             }  
22.             bw.close();  
23.             br.close();  
24.         }catch(Exception e){  
25.             System.out.println("带缓冲区地读取、写入原始字符流失败!"+e);   
26.         }  
27.     }     
28. }

   

4.数据流DataStream:

Java代码  

1. /** 
2.  * 数据流 
3.  * ByteArrayOutputStream byte数组输出流 
4.  * ByteArrayInputStream byte数组输入流 
5.  * DataOutputStream 数据输出流 
6.  * DataInputStream 数据输入流 
7.  **/  
8. public class TestDataStream{  
9.     public static void main(String []args){  
10.         ByteArrayOutputStream baos = null;  
11.         DataOutputStream dos = null;  
12.         ByteArrayInputStream bais = null;  
13.         DataInputStream dis = null;  
14.         try{  
15.             baos = new ByteArrayOutputStream();  
16.             dos = new DataOutputStream(baos);  
17.             dos.writeDouble(Math.random());  
18.             dos.writeBoolean(true);  
19.             dos.flush();  
20.             bais = new ByteArrayInputStream(baos.toByteArray());  
21.             System.out.println(bais.available());  
22.             dis = new DataInputStream(bais);  
23.             System.out.println(dis.readDouble());  
24.             System.out.println(dis.readBoolean());  
25.             dos.close();  
26.             dis.close();  
27.         }catch(Exception e){  
28.             System.out.println("数据流失败!"+e);   
29.         }  
30.     }     
31. }

 

5.打印流PrintStream:

Java代码  

1. /* 
2.  * 打印流 
3.  * PrintStream 打印字节流 
4.  **/  
5. public class TestPrintStream1{  
6.     public static void main(String []args){  
7.         PrintStream ps = null;  
8.         try{  
9.             FileOutputStream fos = new FileOutputStream("d:/bak.dat");  
10.             ps = new PrintStream(fos);  
11.             if(ps != null){  
12.                 System.setOut(ps);    
13.             }             
14.             int n=0;  
15.             for(int i=0;i<60000;i++){  
16.                 System.out.print((char)i);    
17.                 if(n++==100){  
18.                     System.out.println();  
19.                     n=0;      
20.                 }  
21.             }  
22.         }catch(Exception e){  
23.             System.out.println("打印字节流失败!"+e);     
24.         }     
25.     }     
26. }

Java代码  

1. /* 
2.  * 打印流 
3.  * PrintWriter 打印字符流 
4.  **/  
5. public class TestPrintStream3{  
6.     public static void main(String []args){  
7.         PrintWriter pw = null;  
8.         try{  
9.             BufferedReader br = new BufferedReader(new InputStreamReader(System.in));  
10.             pw = new PrintWriter(new FileWriter("d:/bak.log",true));  
11.             String s = null;  
12.             while((s=br.readLine())!=null){  
13.                 if(s.equalsIgnoreCase("exit"))break;      
14.                 System.out.println(s.toUpperCase());  
15.                 pw.println(s);  
16.                 pw.flush();  
17.             }  
18.             pw.println("------------");  
19.             pw.println("===="+new Date()+"====");  
20.             pw.flush();  
21.             pw.close();  
22.             br.close();  
23.         }catch(Exception e){  
24.             System.out.println("打印字符流失败!"+e);     
25.         }  
26.     }     
27. }

 

6.转换流:

Java代码  

1. /** 
2.  * 转换流 
3.  * InputStreamReader 将InputStream转换为Reader 
4.  * 可以读一行 
5.  **/  
6. public class TestTransform2{  
7.     public static void main(String []args){  
8.         InputStreamReader isr = null;  
9.         try{  
10.             isr = new InputStreamReader(System.in);  
11.             BufferedReader br = new BufferedReader(isr);  
12.             String s = null;  
13.             while((s=br.readLine())!=null){  
14.                 if(s.equalsIgnoreCase("exit")){  
15.                     System.exit(1);   
16.                 }  
17.                 System.out.println(s.toUpperCase());      
18.             }  
19.             br.close();  
20.             isr.close();  
21.         }catch(Exception e){  
22.             System.out.println("转换输出流失败!"+e);     
23.         }  
24.     }     
25. }

Java代码  

1. /** 
2.  * 转换流 
3.  * OutputStreamWriter 将OutputStream转换为Writer 
4.  * 可以写一个字符串 
5.  **/  
6. public class TestTransform1{  
7.     public static void main(String []args){  
8.         OutputStreamWriter osw = null;  
9.         try{  
10.             osw = new OutputStreamWriter(new FileOutputStream("d:/bak.txt"));  
11.             osw.write("microsoftibmgoogle");  
12.             System.out.println(osw.getEncoding());  
13.             osw.close();  
14.             osw = new OutputStreamWriter(new FileOutputStream("d:/bak.txt",true),"ISO-8859-1");  
15.             osw.write("microsoftibmgoogle");  
16.             System.out.println(osw.getEncoding());  
17.             osw.close();  
18.         }catch(Exception e){  
19.             System.out.println("转换输出流失败!"+e);     
20.         }  
21.     }     
22. }

 

7.Object流,Java对象序列化和反序列化,transient关键字:

Java代码  

1. /* 
2.  * Object流 
3.  * Serializable 标记类可被系列化 
4.  * ObjectInputStream 
5.  * ObjectOutputSteam 
6.  **/  
7. public class TestObjectIo{  
8.     public static void main(String []args){  
9.         T t = new T();  
10.         t.n=15;  
11.         try{  
12.             FileOutputStream fos = new FileOutputStream("d:/objectio.dat");  
13.             ObjectOutputStream oos = new ObjectOutputStream(fos);  
14.             oos.writeObject(t);  
15.             oos.flush();  
16.             oos.close();  
17.             FileInputStream fis = new FileInputStream("d:/objectio.dat");  
18.             ObjectInputStream ois = new ObjectInputStream(fis);  
19.             T oist = (T)ois.readObject();  
20.             System.out.println(oist.i+" "+oist.j+" "+oist.k+" "+oist.n);  
21.             ois.close();  
22.         }catch(Exception e){  
23.             System.out.println("Object流失败!"+e);   
24.         }     
25.     }     
26. }  
27.   
28. class T implements Serializable{  
29.     int i=1;  
30.     int j=10;  
31.     double k=2.231;  
32.     transient int n=12;//transient 透明的,在系列化时不予考滤  
33. }

     

先总结如上,后续持续更新。。。

本文由职坐标整理并发布,希望对同学们有所帮助。了解更多详情请关注职坐标编程语言JAVA频道!

本文由 @职坐标 发布于职坐标。未经许可,禁止转载。
喜欢 | 1 不喜欢 | 0
看完这篇文章有何感觉?已经有1人表态,100%的人喜欢 快给朋友分享吧~
评论(0)
后参与评论
X
免费获取海同IT培训资料
验证码手机号,获得海同独家IT培训资料
获取验证码
提交

版权所有 职坐标-一站式IT培训就业服务领导者 沪ICP备13042190号-4
上海海同信息科技有限公司 Copyright ©2015 www.zhizuobiao.com,All Rights Reserved.
沪公网安备 31011502005948号