java+++IO流操作

序：IO流的操作主要分为两种读和写。一方面：我们可以通过不加缓冲类字符流BufferedReader/Writer和字节流BufferedInputStream/OutputStream来进行简单的读写，当然加了缓冲类其效率更高。另一方面：当我们需要进行流转换时，主要为了解决读取乱码问题，且字节流能够进行编码指定，因此需要字节流到字符流的转换。

1.字符流的读写+不加BufferedReader/Writer

public class CharIOTest {

 	/**
      * 流转换读取数据.
 	 * @throws FileNotFoundException
 	 * @throws IOException
      * @throws IOException
      */
 	@Test
     public void readChangeTest() throws IOException  {
         File file = new File("C:\\Documents and Settings\\Administrator\\桌面\\1.txt");// 指定要读取的文件
         FileInputStream fis = new FileInputStream(file);// 获取该文件的输入流
         InputStreamReader isr=new InputStreamReader(fis, "gbk");
         char[] bb = new char[1024];// 用来保存每次读取到的字符
         StringBuffer sb = new StringBuffer();// 用来将每次读取到的字符拼接，当然使用StringBuffer类更好
         int n;// 每次读取到的字符长度
         while ((n = isr.read(bb)) != -1) {
             sb.append(new String(bb, 0, n));
         }
         isr.close();// 关闭输入流，释放连接
         System.out.println(sb);
     }  

 	/**
 	 * 没有进行字符编码的指定，因此只适合程序生成的文本文件的读取。
 	 * 好处：代码少写几行，但不通用。
 	 * @throws IOException
 	 */
 	@Test
     public void readTest() throws IOException  {
         File file = new File("C:\\Documents and Settings\\Administrator\\桌面\\2.txt");// 指定要读取的文件

         FileReader fr=new FileReader(file);
 //        System.out.println(fr.getEncoding());
         char[] bb = new char[1024];// 用来保存每次读取到的字符
         StringBuffer sb = new StringBuffer();// 用来将每次读取到的字符拼接，当然使用StringBuffer类更好
         int n;// 每次读取到的字符长度
         while ((n = fr.read(bb)) != -1) {
             sb.append(new String(bb, 0, n));
         }
         fr.close();// 关闭输入流，释放连接
         System.out.println(sb);
     }

 	 /**
      * 往文件里写入数据.
      * @throws IOException
      */
 	@Test
     public void writeTest() throws IOException {
         String writerContent = "hello world,你好世界";// 要写入的文本
         File file = new File("C:\\Documents and Settings\\Administrator\\桌面\\2.txt");// 要写入的文本文件
         if (!file.exists()) {// 如果文件不存在，则创建该文件
             file.createNewFile();
         }  

         FileWriter writer = new FileWriter(file);// 获取该文件的输出流
         System.out.println(writer.getEncoding());
         // 写内容  ,默认使用writer.getEncoding()进行写入，不会出现乱码，因为得到的文件的编码便是写入的编码
         writer.write(writerContent);
         writer.flush();// 清空缓冲区，立即将输出流里的内容写到文件里
         writer.close();// 关闭输出流，施放资源
     }
 }

2.字节流的读写+不加BufferedInputStream/OutputStream

public class ByteIOTest {
 	/**
      *
      * 将D盘下的D:\\xxx.ico文件，读取后，再存到E盘下面.
      *
      * @param args
      * @throws Exception
      */
 	@Test
     public void imageIOTest(String[] args) throws Exception {
         FileInputStream in = new FileInputStream(new File("D:\\xxx.ico"));// 指定要读取的图片
         File file = new File("E:\\test.jpg");
         if (!file.exists()) {// 如果文件不存在，则创建该文件
             file.createNewFile();
         }
         FileOutputStream out = new FileOutputStream(new File("E:\\yuanwang.ico"));// 指定要写入的图片
         int n = 0;// 每次读取的字节长度
         byte[] bb = new byte[1024];// 存储每次读取的内容
         while ((n = in.read(bb)) != -1) {
             out.write(bb, 0, n);// 将读取的内容，写入到输出流当中
         }
         out.close();// 关闭输入输出流
         in.close();
     }
 }

3.字符流的读写+加BufferedReader/Writer

public class BufferCharIOTest {
 	/**
      * 考虑到编码问题-转换流读取，即字节流->字符流
     	  windows系统下默认编码为gbk，即所读取文本为gbk编码。
                            因此如果myeclipse的默认是utf-8编码的话则读取中文时会出现乱码
                            情况，utf8 中文会默认3个字节，而gbk 中文默认2个字节。
                          一个字符在不同编码的情况下，其所对应的字节数是不相同，字符有中文字符，英文字符，数字字符等等
      * @throws FileNotFoundException
      * @throws IOException
      */
 	@Test
     public void readChangeTest() throws FileNotFoundException, IOException {
         File file = new File("C:\\Documents and Settings\\Administrator\\桌面\\1.txt");// 指定要读取的文件
         // 获得该文件的缓冲输入流
         //BufferedReader bufferedReader = new BufferedReader(new FileReader(file));  

         BufferedInputStream bis=new BufferedInputStream(new FileInputStream(file));
         InputStreamReader isr=new InputStreamReader(bis, "gbk");

         char[] bb = new char[1024];// 用来保存每次读取到的字符
         StringBuffer sb = new StringBuffer();// 用来将每次读取到的字符拼接，当然使用StringBuffer类更好
         int n;// 每次读取到的字符长度
         while ((n = isr.read(bb)) != -1) {
             sb.append(new String(bb, 0, n));
         }
         isr.close();// 关闭输入流，释放连接
         System.out.println(sb);
     }  

 	/**
 	 * 没有进行字符编码的指定，因此只适合程序生成的文本文件的读取。
 	 * 好处：代码少写几行，但不通用。
 	 * @throws IOException
 	 */
 	@Test
     public void readTest() throws FileNotFoundException, IOException {
 		File file = new File("C:\\Documents and Settings\\Administrator\\桌面\\1.txt");// 指定要读取的文件
         // 获得该文件的缓冲输入流
         BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
         String line = "";// 用来保存每次读取一行的内容
         while ((line = bufferedReader.readLine()) != null) {
             System.out.println(line);
         }
         bufferedReader.close();// 关闭输入流
     }  

     /**
      * 在写入过程中，不需要考虑编码问题，
      * 因为生成的文件文本的编码会与写入编码一致。因此不会出现乱码情况
      *
      * @throws IOException
      */
 	@Test
     public void writeTest() throws IOException {
         File file = new File("C:\\Documents and Settings\\Administrator\\桌面\\2.txt");// 指定要写入的文件
         if (!file.exists()) {// 如果文件不存在则创建
             file.createNewFile();
         }
         // 获取该文件的缓冲输出流
         BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file));
         // 写入信息
         bufferedWriter.write("你好世界");
         bufferedWriter.newLine();// 表示换行
         bufferedWriter.write("hello world");
         bufferedWriter.flush();// 清空缓冲区
         bufferedWriter.close();// 关闭输出流
     }
 }

4.字节流的读写+加BufferedInputStream/OutputStream

public class BufferByteIOTest {
 	public void imageIOTest(String[] args) throws Exception {
         // 指定要读取文件的缓冲输入字节流
         BufferedInputStream in = new BufferedInputStream(new FileInputStream("F:\\xx.jpg"));
         File file = new File("E:\\xx.jpg");
         if (file != null) {
             file.createNewFile();
         }
         // 指定要写入文件的缓冲输出字节流
         BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(file));
         byte[] bb = new byte[1024];// 用来存储每次读取到的字节数组
         int n;// 每次读取到的字节数组的长度
         while ((n = in.read(bb)) != -1) {
             out.write(bb, 0, n);// 写入到输出流
         }
         out.close();// 关闭流
         in.close();
     }
 }