Java基础之IO技术（一）

---恢复内容开始---

　　Java基础中的IO技术可谓是很是重要，俗话说的好，万丈高楼起于垒土之间。因此学习Java必定要把基础学好，今天咱们来学习IO技术的基础。

　　IO无非就是输入与输出，而其中处理的数据无非是字符与字节。字符最简单的定义就是这个数据是不是纯文本组成，除此以外全部的都是字节。Java给咱们提供了字符和字节的处理，其中字符的处理有Writer和Reader两个抽象父类（分别对应的是写和读），字节的处理有OutputStream和InputStream两个抽象类（分别对应的是写和读）。今天咱们就看看字符的处理。

　　字符的处理

　　1.字符的读（FileReader）

　　首先请看一段代码：

 1 import java.io.*;  2 
 3 public class FileReader1 {  4     public static void main(String[] args){  5         FileReader fr = null;  6         try{  7             fr = new FileReader("1.txt");  8             int ch = 0;  9             //read():字符读取，若是已经达到流的结尾，则为-1 10             //这个能够做为读取文件结束的条件
11             while((ch = fr.read()) != -1){ 12                 //进行强制转换
13                 System.out.print((char)ch); 14  } 15             sop("读取结束"); 16 
17         }catch(FileNotFoundException e){ 18  sop(e.toString()); 19         }catch(IOException e){ 20  sop(e.toString()); 21         }finally{ 22             try { 23                 if(fr != null) { 24  fr.close(); 25  } 26             }catch(IOException e){ 27  sop(e.toString()); 28  } 29  } 30  } 31     public static void sop(Object obj){ 32  System.out.println(obj); 33  } 34 }

 

　　这是文件读取的第一种方法，这种方法是将文件中的数据一个一个的读出来，这样操做比较耗资源，所以有了第二种读取方法，请看下面这段代码。

 1 import java.io.*;  2 
 3 public class FileReader2 {  4     public static void main(String[] args){  5         FileReader fr = null;  6         try{  7             fr = new FileReader("1.txt");  8             //read(char[] cbuf):将字符读取到数组中  9             //这个数组大小1024整数倍
10             char[] buff = new char[1024]; 11             int num = 0; 12             while((num = fr.read(buff)) != -1){ 13                 sop(new String(buff, 0, num)); 14  } 15 
16         }catch(FileNotFoundException e){ 17  sop(e.toString()); 18         }catch(IOException e){ 19  sop(e.toString()); 20         }finally{ 21             try{ 22                 if(fr != null) { 23  fr.close(); 24  } 25             }catch(IOException e){ 26  sop(e.toString()); 27  } 28  } 29 
30  } 31     public static void sop(Object obj){ 32  System.out.println(obj); 33  } 34 }

 

　　这种方法是利用一个数组（这个数组大小通常定义为1024的整数倍），将文件中的数据传入到一个数组中，而后将数组中的数据一次性的处理。显而易见这种方法更好。

　　文件打开是须要关闭的，经过close方法。

 

　　2.字符的写（FileWriter）

　　首先请看下面一段代码

 1 import java.io.*;  2 
 3 public class FileWriterDemo {  4     public static void main(String[] args){  5  fileWriter();  6 
 7  }  8     public static void fileWriter(){  9         FileWriter fw = null; 10         try { 11             fw = new FileWriter("1.txt"); 12 
13             fw.write("asdsadasdafd"); 14  fw.flush(); 15 
16             fw.append("\n"+123); 17  fw.flush(); 18 
19         }catch(IOException e){ 20  sop(e.toString()); 21         }finally{ 22             try{ 23                 if(fw != null) { 24  fw.close(); 25  } 26             }catch(IOException e){ 27  sop(e.toString()); 28  } 29  } 30  } 31     public static void sop(Object obj){ 32  System.out.println(obj); 33  } 34 }

 

　　首先对象的创立，有多个构造函数。这里我介绍两种，FileWriter(String fileName)和FileWriter(String fileName, boolean append)。在第二个构造函数中有一个布尔型参数，为false就和第一个构造函数同样，每次向目的地中写入数据时都会覆盖原来的数据，若不想覆盖原来的数据，可使用append方法；为true时，就不会覆盖原来的数据，而是在原数据后面追加数据。

　　文件的写入是经过一个缓冲区（为了解决cpu和硬盘速度并不匹配的问题），所以在写入一段数据后，要经过flush方法刷新缓冲区，将数据送到目的地中（文件）。最后经过close方法关闭资源，在关闭以前也会刷新缓冲区。每次向目的地写入数据时，都会检测是否有目的文件，若没有则建立一个。

　　为提升数据的读写效率，Java中提供了缓冲技术，对原来的FileWriter与FileReader进行修饰，其中涉及到了修饰设计模式，这里就不具体讲解。下面就对缓冲技术进行讲解。

 

　　3.修饰后的写（BufferedWriter）

　　咱们仍是来看看具体代码

 1 import java.io.*;  2 
 3 public class BufferedWriterDemo {  4     public static void main(String[] args){  5         //建立一个字符写入流对象
 6         FileWriter fw = null;  7         BufferedWriter bw = null;  8         try{  9             fw = new FileWriter("2.txt", true); 10             //为提升字符写入的流效率，加入了缓冲技术。 11             //只要将须要提升效率的流对象做为参数传递给缓冲区的构造函数
12             bw = new BufferedWriter(fw); 13             for(int i=0; i<5; i++) { 14                 bw.write("sdadadas"+i); 15  bw.newLine(); 16  } 17             //记住，只要用到缓冲区就要刷新
18  bw.flush(); 19 
20         }catch(IOException e){ 21  sop(e.toString()); 22 
23         }finally { 24             try{ 25                 //其实关闭缓冲区，就是在关闭与缓冲区关联的流对象
26  bw.close(); 27             }catch(IOException e){ 28  sop(e.toString()); 29  } 30  } 31 
32 
33  } 34     private static void sop(Object obj){ 35  System.out.println(obj); 36  } 37 }

 

　　这一段知识尽在代码与注释中。其中有一个newLine方法，让咱们看看1.8api中解释（写一行行分隔符。 行分隔符字符串由系统属性line.separator定义，并不必定是单个换行符（'\ n'）字符）。在不一样系统中，换行符都不一样。而使用了这个方法后，一样的代码不会在不一样的系统中出现乱码的问题。

　　最后的close方法，有一个疑问（究竟是使用流对象的close方法仍是使用缓冲技术的close方法呢），首先咱们回到一开始，缓冲技术是用来修饰流操做的，必然他们操做的是流。所以使用其中任何一个close方法都会关闭这个流资源。

 

　　4.修饰后的读（BufferedReader）

　　请看下一段代码

 

 1 import java.io.*;  2 
 3 public class BufferedReaderDemo {  4     public static void main(String[] args){  5         FileReader fr = null;  6         BufferedReader br = null;  7         try{  8             //建立一个读取流对象并与文件关联
 9             fr = new FileReader("2.txt"); 10             //为了提升效率，加入了缓冲区技术。将字符读取流对象做为参数传入到缓冲对象的构造函数
11             br = new BufferedReader(fr); 12 
13             String line = null; 14             while((line = br.readLine()) != null){ 15  sop(line); 16  } 17 
18         }catch(FileNotFoundException e){ 19  sop(e.toString()); 20         }catch(IOException e){ 21  sop(e.toString()); 22         }finally { 23             try{ 24                 if(br != null){ 25  br.close(); 26  } 27             }catch(IOException e){ 28  sop(e.toString()); 29  } 30  } 31  } 32 
33     private static void sop(Object obj){ 34  System.out.println(obj); 35  } 36 }

　　

　　这段知识的原理和上一段的知识相似，就不作具体的解释了。就说说其中的readLine方法，咱们来看看api文档，public String readLine()，（读一行文字。 一行被视为由换行符（'\ n'），回车符（'\ r'）中的任何一个或随后的换行符终止），也就是说把文件中的一行数据读取出来。

　　咱们总结一下字符的体系

 1 /**
 2  * 读：  3  * Reader  4  * |--FileReader（两种读的方法，资源的关闭）  5  * |--BufferedReader（修饰设计模式，高效的处理方式，readLine方法，close方法关闭资源）  6  *  7  * 写：  8  * Writer  9  * |--FileWriter（两种构造方法，write方法与append方法，） 10  * |--BufferedWriter（修饰设计模式，高效的处理方式，newLine方法，close方法关闭资源） 11  * 12  * 13  * */

 

 

 

　　今天只讲解了字符的操做，关于字节的操做和其余IO的基础知识，在后面会相应的推出。

 

 

 

 

---恢复内容结束---