Java基础知识回顾-3 输入输出流

代码风格：http://svn.alibaba-inc.com/repos/ali_platform/spec/codestyle/

RandomAccessFile：支持随机读取，随意在文件内跳转，操作灵活但需要计算跳转的位置等

写入：

1. import java.io.File ; 
2. import java.io.RandomAccessFile ; 
3. public class RandomAccessFileDemo01{ 
4.     // 所有的异常直接抛出，程序中不再进行处理 
5.     public static void main(String args[]) throws Exception{ 
6.         File f = new File("d:" + File.separator + "test.txt") ; // 指定要操作的文件 
7.         RandomAccessFile rdf = null ;       // 声明RandomAccessFile类的对象 
8.         rdf = new RandomAccessFile(f,"rw") ;// 读写模式，如果文件不存在，会自动创建 
9.         String name = null ; 
10.         int age = 0 ; 
11.         name = "zhangsan" ;         // 字符串长度为8 
12.         age = 30 ;                  // 数字的长度为4 
13.         rdf.writeBytes(name) ;      // 将姓名写入文件之中 
14.         rdf.writeInt(age) ;         // 将年龄写入文件之中 
15.         name = "lisi    " ;         // 字符串长度为8 
16.         age = 31 ;                  // 数字的长度为4 
17.         rdf.writeBytes(name) ;      // 将姓名写入文件之中 
18.         rdf.writeInt(age) ;         // 将年龄写入文件之中 
19.         name = "wangwu  " ;         // 字符串长度为8 
20.         age = 32 ;                  // 数字的长度为4 
21.         rdf.writeBytes(name) ;      // 将姓名写入文件之中 
22.         rdf.writeInt(age) ;         // 将年龄写入文件之中 
23.         rdf.close() ;               // 关闭 
24.     } 
25. }; 

读取：

1. import java.io.File ; 
2. import java.io.RandomAccessFile ; 
3. public class RandomAccessFileDemo02{ 
4.     // 所有的异常直接抛出，程序中不再进行处理 
5.     public static void main(String args[]) throws Exception{ 
6.         File f = new File("d:" + File.separator + "test.txt") ; // 指定要操作的文件 
7.         RandomAccessFile rdf = null ;       // 声明RandomAccessFile类的对象 
8.         rdf = new RandomAccessFile(f,"r") ;// 以只读的方式打开文件 
9.         String name = null ; 
10.         int age = 0 ; 
11.         byte b[] = new byte[8] ;    // 开辟byte数组 
12.         // 读取第二个人的信息，意味着要空出第一个人的信息 
13.         rdf.skipBytes(12) ;     // 跳过第一个人的信息 
14.         for(int i=0;i<b.length;i++){ 
15.             b[i] = rdf.readByte() ; // 读取一个字节 
16.         } 
17.         name = new String(b) ;  // 将读取出来的byte数组变为字符串 
18.         age = rdf.readInt() ;   // 读取数字 
19.         System.out.println("第二个人的信息 --> 姓名：" + name + "；年龄：" + age) ; 
20.         // 读取第一个人的信息 
21.         rdf.seek(0) ;   // 指针回到文件的开头 
22.         for(int i=0;i<b.length;i++){ 
23.             b[i] = rdf.readByte() ; // 读取一个字节 
24.         } 
25.         name = new String(b) ;  // 将读取出来的byte数组变为字符串 
26.         age = rdf.readInt() ;   // 读取数字 
27.         System.out.println("第一个人的信息 --> 姓名：" + name + "；年龄：" + age) ; 
28.         rdf.skipBytes(12) ; // 空出第二个人的信息 
29.         for(int i=0;i<b.length;i++){ 
30.             b[i] = rdf.readByte() ; // 读取一个字节 
31.         } 
32.         name = new String(b) ;  // 将读取出来的byte数组变为字符串 
33.         age = rdf.readInt() ;   // 读取数字 
34.         System.out.println("第三个人的信息 --> 姓名：" + name + "；年龄：" + age) ; 
35.         rdf.close() ;               // 关闭 
36.     } 
37. }; 

一、输入流

1、输入流， 从文件中读取内容到byte数组之中， 再截取byte数组中内容， 到结束字符为止

1. import java.io.File ; 
2. import java.io.InputStream ; 
3. import java.io.FileInputStream ; 
4. public class InputStreamDemo02{ 
5.     public static void main(String args[]) throws Exception{    // 异常抛出，不处理 
6.         // 第1步、使用File类找到一个文件 
7.         File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象 
8.         // 第2步、通过子类实例化父类对象 
9.         InputStream input = null ;  // 准备好一个输入的对象 
10.         input = new FileInputStream(f)  ;   // 通过对象多态性，进行实例化 
11.         // 第3步、进行读操作 
12.         byte b[] = new byte[1024] ;     // 所有的内容都读到此数组之中 
13.         int len = input.read(b) ;       // 读取内容 
14.         // 第4步、关闭输出流 
15.         input.close() ;                     // 关闭输出流\ 
16.         System.out.println("读入数据的长度：" + len) ; 
17.         System.out.println("内容为：" + new String(b,0,len)) ;  // 把byte数组变为字符串输出 
18.     } 
19. }; 

2、数组流， 开辟文件内容大小的空间以便读入：byte b[] = new byte[(int)f.length()] ;

1. import java.io.File ; 
2. import java.io.InputStream ; 
3. import java.io.FileInputStream ; 
4. public class InputStreamDemo03{ 
5.     public static void main(String args[]) throws Exception{    // 异常抛出，不处理 
6.         // 第1步、使用File类找到一个文件 
7.         File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象 
8.         // 第2步、通过子类实例化父类对象 
9.         InputStream input = null ;  // 准备好一个输入的对象 
10.         input = new FileInputStream(f)  ;   // 通过对象多态性，进行实例化 
11.         // 第3步、进行读操作 
12.         byte b[] = new byte[(int)f.length()] ;      // 数组大小由文件决定 
13.         int len = input.read(b) ;       // 读取内容 
14.         // 第4步、关闭输出流 
15.         input.close() ;                     // 关闭输出流\ 
16.         System.out.println("读入数据的长度：" + len) ; 
17.         System.out.println("内容为：" + new String(b)) ;    // 把byte数组变为字符串输出 
18.     } 
19. }; 

3、

1. import java.io.File ; 
2. import java.io.InputStream ; 
3. import java.io.FileInputStream ; 
4. public class InputStreamDemo04{ 
5.     public static void main(String args[]) throws Exception{    // 异常抛出，不处理 
6.         // 第1步、使用File类找到一个文件 
7.         File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象 
8.         // 第2步、通过子类实例化父类对象 
9.         InputStream input = null ;  // 准备好一个输入的对象 
10.         input = new FileInputStream(f)  ;   // 通过对象多态性，进行实例化 
11.         // 第3步、进行读操作 
12.         byte b[] = new byte[(int)f.length()] ;      // 数组大小由文件决定 
13.         for(int i=0;i<b.length;i++){ 
14.             b[i] = (byte)input.read() ;     // 读取内容 
15.         } 
16.         // 第4步、关闭输出流 
17.         input.close() ;                     // 关闭输出流\ 
18.         System.out.println("内容为：" + new String(b)) ;    // 把byte数组变为字符串输出 
19.     } 
20. }; 

4、

1. import java.io.File ; 
2. import java.io.InputStream ; 
3. import java.io.FileInputStream ; 
4. public class InputStreamDemo05{ 
5.     public static void main(String args[]) throws Exception{    // 异常抛出，不处理 
6.         // 第1步、使用File类找到一个文件 
7.         File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象 
8.         // 第2步、通过子类实例化父类对象 
9.         InputStream input = null ;  // 准备好一个输入的对象 
10.         input = new FileInputStream(f)  ;   // 通过对象多态性，进行实例化 
11.         // 第3步、进行读操作 
12.         byte b[] = new byte[1024] ;     // 数组大小由文件决定 
13.         int len = 0 ;  
14.         int temp = 0 ;          // 接收每一个读取进来的数据 
15.         while((temp=input.read())!=-1){ 
16.             // 表示还有内容，文件没有读完 
17.             b[len] = (byte)temp ; 
18.             len++ ; 
19.         } 
20.         // 第4步、关闭输出流 
21.         input.close() ;                     // 关闭输出流\ 
22.         System.out.println("内容为：" + new String(b,0,len)) ;  // 把byte数组变为字符串输出 
23.     } 
24. }; 

二、输出流

1、

1. import java.io.File ; 
2. import java.io.OutputStream ; 
3. import java.io.FileOutputStream ; 
4. public class OutputStreamDemo01{ 
5.     public static void main(String args[]) throws Exception{    // 异常抛出，不处理 
6.         // 第1步、使用File类找到一个文件 
7.         File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象 
8.         // 第2步、通过子类实例化父类对象 
9.         OutputStream out = null ;   // 准备好一个输出的对象 
10.         out = new FileOutputStream(f)  ;    // 通过对象多态性，进行实例化 
11.         // 第3步、进行写操作 
12.         String str = "Hello World!!!" ;     // 准备一个字符串 
13.         byte b[] = str.getBytes() ;         // 只能输出byte数组，所以将字符串变为byte数组 
14.         out.write(b) ;                      // 将内容输出，保存文件 
15.         // 第4步、关闭输出流 
16.         out.close() ;                       // 关闭输出流 
17.     } 
18. }; 

2、

1. import java.io.File ; 
2. import java.io.OutputStream ; 
3. import java.io.FileOutputStream ; 
4. public class OutputStreamDemo02{ 
5.     public static void main(String args[]) throws Exception{    // 异常抛出，不处理 
6.         // 第1步、使用File类找到一个文件 
7.         File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象 
8.         // 第2步、通过子类实例化父类对象 
9.         OutputStream out = null ;   // 准备好一个输出的对象 
10.         out = new FileOutputStream(f)  ;    // 通过对象多态性，进行实例化 
11.         // 第3步、进行写操作 
12.         String str = "Hello World!!!" ;     // 准备一个字符串 
13.         byte b[] = str.getBytes() ;         // 只能输出byte数组，所以将字符串变为byte数组 
14.         for(int i=0;i<b.length;i++){        // 采用循环方式写入 
15.             out.write(b[i]) ;   // 每次只写入一个内容 
16.         } 
17.         // 第4步、关闭输出流 
18.         out.close() ;                       // 关闭输出流 
19.     } 
20. }; 

3、

1. import java.io.File ; 
2. import java.io.OutputStream ; 
3. import java.io.FileOutputStream ; 
4. public class OutputStreamDemo03{ 
5.     public static void main(String args[]) throws Exception{    // 异常抛出，不处理 
6.         // 第1步、使用File类找到一个文件 
7.         File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象 
8.         // 第2步、通过子类实例化父类对象 
9.         OutputStream out = null ;   // 准备好一个输出的对象 
10.         out = new FileOutputStream(f,true)  ;   // 此处表示在文件末尾追加内容 
11.         // 第3步、进行写操作 
12.         String str = "Hello World!!!" ;     // 准备一个字符串 
13.         byte b[] = str.getBytes() ;         // 只能输出byte数组，所以将字符串变为byte数组 
14.         for(int i=0;i<b.length;i++){        // 采用循环方式写入 
15.             out.write(b[i]) ;   // 每次只写入一个内容 
16.         } 
17.         // 第4步、关闭输出流 
18.         out.close() ;                       // 关闭输出流 
19.     } 
20. }; 

4、

1. import java.io.File ; 
2. import java.io.OutputStream ; 
3. import java.io.FileOutputStream ; 
4. public class OutputStreamDemo04{ 
5.     public static void main(String args[]) throws Exception{    // 异常抛出，不处理 
6.         // 第1步、使用File类找到一个文件 
7.         File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象 
8.         // 第2步、通过子类实例化父类对象 
9.         OutputStream out = null ;   // 准备好一个输出的对象 
10.         out = new FileOutputStream(f,true)  ;   // 此处表示在文件末尾追加内容 
11.         // 第3步、进行写操作 
12.         String str = "\r\nHello World!!!" ;     // 准备一个字符串 
13.         byte b[] = str.getBytes() ;         // 只能输出byte数组，所以将字符串变为byte数组 
14.         for(int i=0;i<b.length;i++){        // 采用循环方式写入 
15.             out.write(b[i]) ;   // 每次只写入一个内容 
16.         } 
17.         // 第4步、关闭输出流 
18.         out.close() ;                       // 关闭输出流 
19.     } 
20. }; 

5、

1. import java.io.File ; 
2. import java.io.OutputStream ; 
3. import java.io.FileOutputStream ; 
4. public class OutputStreamDemo05{ 
5.     public static void main(String args[]) throws Exception{    // 异常抛出，不处理 
6.         // 第1步、使用File类找到一个文件 
7.         File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象 
8.         // 第2步、通过子类实例化父类对象 
9.         OutputStream out = null ;   // 准备好一个输出的对象 
10.         out = new FileOutputStream(f)  ;    // 实例化 
11.         // 第3步、进行写操作 
12.         String str = "Hello World!!!" ;     // 准备一个字符串 
13.         byte b[] = str.getBytes() ;         // 只能输出byte数组，所以将字符串变为byte数组 
14.         out.write(b) ;      // 写入数据 
15.         // 第4步、关闭输出流 
16.         // out.close() ;                        // 关闭输出流 
17.     } 
18. }; 

三、输入输出流转换

 （1）对象的输入输出流ObjectOutputStream、ObjectInputStream， 可以序列化对象或反序列化对象

【注意】（1）必须实现Serializable接口 （2）序列化的类不能是内部类

1. Student student = new Student(); 
2.     student.setName("zhangsan"); 
3.     student.setAge(10); 
4.      
5.     ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("d:" + File.separator + "test.txt"))); 
6.     oos.writeObject(student); 
7.     oos.close(); 
8.      
9.     ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("d:" + File.separator + "test.txt"))); 
10.     Student stu = (Student) ois.readObject(); 
11.     System.out.println(stu.getName() + "\t" + stu.getAge()); 
12.     ois.close(); 

 （2）序列化和反序列化一组对象

1. public class SerDemo{ 
2.     public static void main(String args[]) throws Exception{ 
3.         Person per[] = {new Person("张三",30),new Person("李四",31), 
4.             new Person("王五",32)} ; 
5.         ser(per) ; 
6.         Object o[] = (Object[])dser() ; 
7.         for(int i=0;i<o.length;i++){ 
8.             Person p = (Person)o[i] ; 
9.             System.out.println(p) ; 
10.         } 
11.     } 
12.     public static void ser(Object obj[]) throws Exception { 
13.         File f = new File("D:" + File.separator + "test.txt") ; // 定义保存路径 
14.         ObjectOutputStream oos = null ; // 声明对象输出流 
15.         OutputStream out = new FileOutputStream(f) ;    // 文件输出流 
16.         oos = new ObjectOutputStream(out) ; 
17.         oos.writeObject(obj) ;  // 保存对象 
18.         oos.close() ;   // 关闭 
19.     } 
20.     public static Object[] dser() throws Exception { 
21.         File f = new File("D:" + File.separator + "test.txt") ; // 定义保存路径 
22.         ObjectInputStream ois = null ;  // 声明对象输入流 
23.         InputStream input = new FileInputStream(f) ;    // 文件输入流 
24.         ois = new ObjectInputStream(input) ;    // 实例化对象输入流 
25.         Object obj[] = (Object[])ois.readObject() ; // 读取对象 
26.         ois.close() ;   // 关闭 
27.         return obj ; 
28.     } 
29. }; 

四、文件的拷贝

（1）本地文件的拷贝

JDK中没有提供文件拷贝的相关方法，apache的commons下面有关于File的扩展FileUtils可以做到。具体参考如下链接：http://commons.apache.org/io/api-release/index.html

 （2）远程文件拷贝（大致思路：InputStream -> HttpURLConnection -> OutputStream）

1. public class HttpDistributeFileReceiverImpl implements DistributeFileReceiver { 
2.      
3.     private static final Log logger = LogFactory.getLog(HttpDistributeFileReceiverImpl.class); 
4.      
5.     public void receive(String targetURL, String targetFileType, String targetDirPath, String targetFileNamePrefix) throws FileReceiveException { 
6.          
7.         if (!isParameterValid(targetDirPath) || !isParameterValid(targetFileNamePrefix) || !isParameterValid(targetURL) || !isParameterValid(targetFileType)) { 
8.             if (logger.isInfoEnabled()) { 
9.                 logger.info("parameter is invalid!"); 
10.             } 
11.             return; 
12.         } 
13.          
14.         if (logger.isDebugEnabled()) { 
15.             logger.debug("download from " + targetURL); 
16.         } 
17.          
18.         try { 
19.             prepare(targetDirPath); 
20.         } catch (PrepareDistributeEnvException e) { 
21.             throw new FileReceiveException(e); 
22.         } 
23.          
24.         String newTargetFileName = targetFileNamePrefix + ".tar"; 
25.         String targetFileFullPath = targetDirPath + File.separator + newTargetFileName; 
26.         File targetFile = null; 
27.         FileOutputStream outputStream = null;    
28.          
29.         try { 
30.             targetFile = new File(targetFileFullPath); 
31.             if (logger.isDebugEnabled()) { 
32.                 logger.debug("create file '" + targetFileFullPath + "' ......"); 
33.             } 
34.             outputStream = new FileOutputStream(targetFile); 
35.         } catch (FileNotFoundException e) { 
36.             throw new FileReceiveException(e); 
37.         } 
38.          
39.          
40.         URL url = null; 
41.         try { 
42.             url = new URL(targetURL); 
43.         } catch (MalformedURLException e) { 
44.             throw new FileReceiveException("download file '" + targetURL + "' failed!", e);          
45.         } 
46.          
47.         HttpURLConnection connection = null; 
48.         InputStream inputStream = null; 
49.          
50.         try { 
51.              
52.             connection = (HttpURLConnection)url.openConnection(); 
53.             inputStream = connection.getInputStream();       
54.          
55.             byte[] buffer = new byte[1024];          
56.             int len = 0;             
57.             while ((len = inputStream.read(buffer, 0, 1024)) != -1 ) {               
58.                 outputStream.write(buffer, 0, len);                                  
59.             }; 
60.              
61.             if (logger.isDebugEnabled()) { 
62.                 logger.debug("create file '" + targetFileFullPath + "' success!"); 
63.             } 
64.              
65.         } catch (IOException e) {            
66.              
67.             throw new FileReceiveException("download file '" + targetURL + "' failed!", e); 
68.              
69.         } finally { 
70.             if (outputStream != null) { 
71.                 try { 
72.                     outputStream.close(); 
73.                 } catch (IOException e) { 
74.                     if (logger.isWarnEnabled()) { 
75.                         logger.warn("close outputStream failed!\n"  
76.                                 + ExceptionUtil.getThrowableStackTrace(e)); 
77.                     } 
78.                 } 
79.             } 
80.             if (inputStream != null) { 
81.                 try { 
82.                     inputStream.close(); 
83.                 } catch (IOException e) {                    
84.                     if (logger.isWarnEnabled()) { 
85.                         logger.warn("close inputStream failed!\n"  
86.                                 + ExceptionUtil.getThrowableStackTrace(e)); 
87.                     } 
88.                 } 
89.             } 
90.             if (connection != null) { 
91.                 connection.disconnect(); 
92.             } 
93.         } 
94.          
95.         try { 
96.             if (MessageConstant.TARGET_PACKAGE_TYPE_FOR_ZIP.equals(targetFileType)) { 
97.                 FileUtil.unzip(targetFileFullPath, targetDirPath); 
98.             } else if (MessageConstant.TARGET_PACKAGE_TYPE_FOR_TAR.equals(targetFileType)) { 
99.                 FileUtil.untar(targetFileFullPath, targetDirPath); 
100.             } else {             
101.                 throw new FileReceiveException("unpackage failed, unknown package file type'" + targetFileType + "'"); 
102.             } 
103.              
104.         } catch(UnzipFileException e) { 
105.             throw new FileReceiveException(e); 
106.         } 
107.          
108.     } 
109.      
110.     /** 
111.      * 为预发布准备环境目录 
112.      * @param targetWorkingDir 
113.      * @throws PrepareDistributeEnvException 
114.      */ 
115.     private void prepare(String targetWorkingDir) throws PrepareDistributeEnvException{ 
116.          
117.         if (logger.isDebugEnabled()) { 
118.             logger.debug("try to locate target dir '" + targetWorkingDir + "'"); 
119.         } 
120.          
121.         File targetDir = new File(targetWorkingDir);  
122.          
123.         //if target dir exists 
124.         if (targetDir.exists()) { 
125.             //如果是目录 
126.             if (targetDir.isDirectory()) { 
127.                 if (logger.isDebugEnabled()) { 
128.                     logger.debug("target dir '" + targetWorkingDir + "' already exist!"); 
129.                 } 
130.                 //清除目标目录 
131.                 try { 
132.                     FileUtil.deleteDirs(targetDir); 
133.                 } catch (DeleteDirException e) {                     
134.                     throw new PrepareDistributeEnvException("delete target dir failed!", e);                     
135.                 }                
136.              
137.             } else { 
138.                 //如果是文件 
139.                 if (logger.isDebugEnabled()) { 
140.                     logger.debug("target dir '" + targetWorkingDir + "' alread exists, but is file type"); 
141.                 } 
142.                 //删除同名文件 
143.                 targetDir.delete(); 
144.             } 
145.              
146.             //创建目标文件夹 
147.             if (!targetDir.mkdirs()) { 
148.                 if (logger.isDebugEnabled()) { 
149.                     logger.debug("create dir '" + targetWorkingDir + "' failed!"); 
150.                 } 
151.                 throw new PrepareDistributeEnvException("create target dir failed!");    
152.             } 
153.              
154.             if (logger.isDebugEnabled()) { 
155.                 logger.debug("create target dir '" + targetWorkingDir + "' success!"); 
156.             } 
157.             return;          
158.              
159.         }    
160.          
161.         //if target dir doesn't exist 
162.         if (targetDir.mkdirs()) { 
163.             if (logger.isDebugEnabled()) { 
164.                 logger.debug("create target dir '" + targetWorkingDir + "' success!"); 
165.             } 
166.             return; 
167.         } else { 
168.             if (logger.isDebugEnabled()) { 
169.                 logger.debug("create target target dir '" + targetWorkingDir + "' failed!"); 
170.             } 
171.             throw new PrepareDistributeEnvException("create target dir failed!"); 
172.         } 
173.          
174.          
175.     } 
176.      
177.     /** 
178.      * 判断模型release包下载路径和参数是否有效 
179.      * @return 
180.      */ 
181.     private boolean isParameterValid(String parameter) { 
182.          
183.         if (StringUtil.isEmpty(parameter) || StringUtil.isBlank(parameter) ) { 
184.              
185.             return false; 
186.         } 
187.          
188.         return true; 
189.     }    
190.      
191. } 

本文转自 tianya23 51CTO博客，原文链接：http://blog.51cto.com/tianya23/427130，如需转载请自行联系原作者