android 基本I/O操作

Java中换行  \r\n

在整个IO包中，流的操作就分为两种：

字节流：

字节输出流 OutputStream、字节输入流 InputStream

字符流：

字符输出流 Writer、字符输入流 Reader

IO操作的基本步骤：

在JAVA中使用IO操作必须按照以下的步骤完成：

1、使用File找到一个文件

2、使用字节流或字符流的子类为OutputSteam、InputStream、Writer、Reader进行实例化操作

3、进行读或写的操作

4、关闭：close()，在流的操作中必须进行关闭。

字节输出流：

在java.io包中 OutputStream是字节输出流的最大父类。

public abstract class OutputStream extends Object implements Closeable,Flushable

此类是一个抽象类，所以使用的时候需要依靠子类进行实例化操作

如果此时要完成文件的输出操作，则使用FileOutputStream为OutputStream进行实例化操作。

OutputStream提供了以下的写入数据方法：

*写入全部字节数组：public void write(byte[] b)throws IOException

*写入部分字节数组：public void write(byte[] b,int off,int len)throw IOException

*写入一个数据： public void write(int b)throw IOException

将字符串“"this is a OutputStream demo "写到g盘下的outputstremdemo.txt文件中并且换行

1、将全部的字节数组内容输出：

[html]  view plain  copy

1. package com.demo;  
2.   
3. import java.io.File;  
4. import java.io.FileInputStream;  
5. import java.io.FileNotFoundException;  
6. import java.io.FileOutputStream;  
7. import java.io.IOException;  
8. import java.io.InputStream;  
9. import java.io.OutputStream;  
10.   
11. public class FileOutputSteamDemo {  
12.     public static void main(String args[]){  
13.         //要操作的文件  
14.         File file = new File("g:"+File.separator+"outputstremdemo.txt");  
15.         //声明字节输出流  
16.         OutputStream outputStream = null;  
17.         try {  
18.             //通过子类实例化  
19. //          outputStream = new FileOutputStream(file);  
20.             //当为true表示可以追加  
21.             outputStream = new FileOutputStream(file,true);  
22.             //要输出的信息  
23.             String str = "this is a OutputStream demo "+"\r\n";  
24.             //将String变为byte数组  
25.             byte b[] = str.getBytes();  
26.             //写入数据  
27.             outputStream.write(b);  
28.             //关闭  
29.             outputStream.close();  
30.               
31.         } catch (FileNotFoundException e) {  
32.             // TODO Auto-generated catch block  
33.             e.printStackTrace();  
34.         } catch (IOException e) {  
35.             // TODO Auto-generated catch block  
36.             e.printStackTrace();  
37.         }  
38.       
39.     }  
40. }  

2、通过循环一个个输出：(通常采用此种方法)

[html]  view plain  copy

1. package com.demo;  
2.   
3. import java.io.File;  
4. import java.io.FileInputStream;  
5. import java.io.FileNotFoundException;  
6. import java.io.FileOutputStream;  
7. import java.io.IOException;  
8. import java.io.InputStream;  
9. import java.io.OutputStream;  
10.   
11. public class FileOutputSteamDemo {  
12.     public static void main(String args[]){  
13.         //要操作的文件  
14.         File file = new File("g:"+File.separator+"outputstremdemo.txt");  
15.         //声明字节输出流  
16.         OutputStream outputStream = null;  
17.         try {  
18.             //通过子类实例化  
19. //          outputStream = new FileOutputStream(file);  
20.             //当为true表示可以追加  
21.             outputStream = new FileOutputStream(file,true);  
22.             //要输出的信息  
23.             String str = "this is a OutputStream demo "+"\r\n";  
24.             //将String变为byte数组  
25.             byte b[] = str.getBytes();  
26.             for(int i=0;i<b.length;i++){  
27.                 //通过循环一个个写入数据  
28.                 outputStream.write(b[i]);  
29.             }  
30.             //关闭  
31.             outputStream.close();  
32.               
33.         } catch (FileNotFoundException e) {  
34.             // TODO Auto-generated catch block  
35.             e.printStackTrace();  
36.         } catch (IOException e) {  
37.             // TODO Auto-generated catch block  
38.             e.printStackTrace();  
39.         }  
40.       
41.     }  
42. }  

字节输入流：InputStream

使用InputStream可以读取输入流的内容，那么此类的定义如下：

public abstract classInputStreamextends Object implements Closeable

此类也属于一个抽象类。

如果要想使用的话，依靠其子类，如果现在是文件操作则使用的是FileInputStream。

FileInputStream类的构造方法：

public FileInputStream(File file)throw FileNotFoundException

实例化之后就可以通过如下的方法取得数据：

*将内容读到字节数组之中 public int read(byte[] b) throw IOException

*每次读一个数据：public abstract int read() throw IOException

将文件的内容读取进来：

[html]  view plain  copy

1. package com.demo;  
2.   
3. import java.io.File;  
4. import java.io.FileInputStream;  
5. import java.io.IOException;  
6. import java.io.InputStream;  
7.   
8.   
9. public class InputStreamDemo {  
10.     public static void main(String[] args) throws IOException{  
11.         //要操作的文件  
12.         File file = new File("g:"+File.separator+"outputstremdemo.txt");  
13.         //字节输入流 通过其子类进行实例化操作  
14.         InputStream inputStream = new FileInputStream(file);  
15.         //开辟空间接收要读取的内容  
16.         byte[] b = new byte[1024];  
17.         //将内容读入到byte数组中  
18.         int len =inputStream.read(b);  
19.         //输出内容  
20.         System.out.println(new String(b,0,len));  
21.         System.out.println("结束");  
22.         //关闭  
23.         inputStream.close();  
24.     }  
25. }  

以上是一种比较常见的读取形式，但是以上代码会受到开辟空间的限制。

如果现在想动态开辟数组的空间，则可以根据文件的大小来决定，采用read()方法一个个的读取数据。

[html]  view plain  copy

1. public class InputStreamDemo {  
2.     public static void main(String[] args) throws IOException{  
3.         //要操作的文件  
4.         File file = new File("g:"+File.separator+"outputstremdemo.txt");  
5.         //字节输入流 通过其子类进行实例化操作  
6.         InputStream inputStream = new FileInputStream(file);  
7.         //开辟空间接收要读取的内容  
8.         byte[] b = new byte[(int) file.length()];  
9.         for(int i=0;i<b.length ;i++){  
10.             b[i] =(byte) inputStream.read();  
11.         }  
12.         //输出内容  
13.         System.out.println(new String(b));  
14.         System.out.println("结束");  
15.         //关闭  
16.         inputStream.close();  
17.     }  
18. }  

字符输出流：Writer

Writer类是在io包中操作字符的最大父类，主要功能是完成字符流的输出。

Writer的定义格式：

public abstract class Writer extends Object implements Appendable,Closeable,Flushable

此类也是一个抽象类。

如果进行文件中的保存，则使用FileWriter。

写入操作：public void writer(String str) throw IOException.不用再转换

[html]  view plain  copy

1. package com.demo;  
2.   
3. import java.io.File;  
4. import java.io.FileWriter;  
5. import java.io.IOException;  
6. import java.io.Writer;  
7.   
8. public class WriterDemo {  
9.     public static void main(String[] args) throws IOException {  
10.         //要操作的文件  
11.         File file = new File("g:"+File.separator+"writedemo.txt");  
12.         //Writer writer = new FileWriter(file);  
13.         //通过子类实例化字符输出流，true表示可以追加  
14.         Writer writer = new FileWriter(file,true);  
15.         //写入数据  
16.         writer.write("this is a writer demo  \r\n");  
17.         //关闭  
18.         writer.close();  
19.     }  
20. }  

字符输入流：Reader

字符输入流与字节输入流不同的地方在于，使用的是char数组。Reader类的定义：

public abstract class Reader extends Object implements Readable,Closeable

是一个抽象类，要是现在进行文件的读取使用FileReader。

读取的方法：

*读取一组字符：public int read(char[] cbuf) throw IOException

*读取一个字符：public int read() throw IOException

[html]  view plain  copy

1. package com.demo;  
2.   
3. import java.io.File;  
4. import java.io.FileReader;  
5. import java.io.IOException;  
6. import java.io.Reader;  
7.   
8. public class ReaderDemo {  
9.     public static void main(String[] args) throws IOException {  
10.         //要操作的文件  
11.         File file = new File("g:"+File.separator+"writedemo.txt");  
12.         //通过子类进行实例化操作 实例化字符输入流  
13.         Reader reader = new FileReader(file);  
14.         //开辟空间接收读取的内容  
15.         char b[] = new char[(int)file.length()];  
16. //      reader.read(b);  
17.           
18.         for(int i=0;i<b.length;i++){  
19.             b[i] = (char)reader.read();  
20.         }  
21.         System.out.println(new String(b));  
22.         reader.close();  
23.       
24.     }  
25. }  

字节流与字符流的区别：

字符流不 关闭writer.close 或者 writer.flush就无法输出内容

*字节流在操作的时候是直接与文件本身关联，不使用缓冲区

字节——>文件

*字符流在操作的时候是通过缓冲区与文件操作

字符——>缓冲——>文件

综合比较来讲，在传输或者在硬盘上保存的内容都是以字节的形式存在的所以字节流较多，但是在操作中文的时候字符流比较好使。

总结：

1、在JAVA中所有的IO操作都定义在java.io包中。

2、File类表示与平台无关的文件操作，只负责文件的本身，而不负责文件的内容。

3、OutputStream和InputStream是字节输出、输入流，通过FileXx实例化。

4、Writer和Reader是字符的输出、输入流，通过FileXx实例化

5、字节流是直接操作文件本身的，而字符流是需要通过缓存操作文件本身