字节流和字符流

什么是流(Stream)，流就是一系列的数据

当不同的介质之间有数据交互的时候，JAVA就使用流来实现。 
数据源可以是文件，还可以是数据库，网络甚至是其他的程序 


比如读取文件的数据到程序中，站在程序的角度来看，就叫做输入流 
InputStream字节输入流 
OutputStream字节输出流 
用于以字节的形式读取和写入数据

文件输入流

如下代码，就建立了一个文件输入流，这个流可以用来把数据从硬盘的文件，读取到JVM(内存)。

package stream;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
 
public class TestStream {
 
    public static void main(String[] args) {
        try {
            File f = new File("d:/lol.txt");
            // 创建基于文件的输入流
            FileInputStream fis = new FileInputStream(f);
            // 通过这个输入流，就可以把数据从硬盘，读取到Java的虚拟中来，也就是读取到内存中
 
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
 
    }
}

以字节流的形式读取文件内容

InputStream是字节输入流，同时也是抽象类，只提供方法声明，不提供方法的具体实现。
FileInputStream 是InputStream子类，以FileInputStream 为例进行文件读取

package stream;
  
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
  
public class TestStream {
  
    public static void main(String[] args) {
        try {
            //准备文件lol.txt其中的内容是AB，对应的ASCII分别是65 66
            File f =new File("d:/lol.txt");
            //创建基于文件的输入流
            FileInputStream fis =new FileInputStream(f);
            //创建字节数组，其长度就是文件的长度
            byte[] all =new byte[(int) f.length()];
            //以字节流的形式读取文件所有内容
            fis.read(all);
            for (byte b : all) {
                //打印出来是65 66
                System.out.println(b);
            }
             
            //每次使用完流，都应该进行关闭
            fis.close();
              
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
          
    }
}

以字节流的形式向文件写入数据

OutputStream是字节输出流，同时也是抽象类，只提供方法声明，不提供方法的具体实现。
FileOutputStream 是OutputStream子类，以FileOutputStream 为例向文件写出数据


注: 如果文件d:/lol2.txt不存在，写出操作会自动创建该文件。 
但是如果是文件 d:/xyz/lol2.txt，而目录xyz又不存在，会抛出异常

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
 
public class TestStream {
 
    public static void main(String[] args) {
        try {
            // 准备文件lol2.txt其中的内容是空的
            File f = new File("d:/lol2.txt");
            // 准备长度是2的字节数组，用88,89初始化，其对应的字符分别是X,Y
            byte data[] = { 88, 89 };
 
            // 创建基于文件的输出流
            FileOutputStream fos = new FileOutputStream(f);
            // 把数据写入到输出流
            fos.write(data);
            // 关闭输出流
            fos.close();
             
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
 
    }
}

所有的流，无论是输入流还是输出流，使用完毕之后，都应该关闭。 如果不关闭，会产生对资源占用的浪费。 当量比较大的时候，会影响到业务的正常开展。

• 在try中关闭
  在try的作用域里关闭文件输入流，在前面的示例中都是使用这种方式，这样做有一个弊端；
  如果文件不存在，或者读取的时候出现问题而抛出异常，那么就不会执行这一行关闭流的代码，存在巨大的资源占用隐患。 不推荐使用
  

  package stream;
   
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.IOException;
   
  public class TestStream {
   
      public static void main(String[] args) {
          try {
              File f = new File("d:/lol.txt");
              FileInputStream fis = new FileInputStream(f);
              byte[] all = new byte[(int) f.length()];
              fis.read(all);
              for (byte b : all) {
                  System.out.println(b);
              }
              // 在try 里关闭流
              fis.close();
          } catch (IOException e) {
              e.printStackTrace();
          }
   
      }
  }

• 在finally中关闭
  这是标准的关闭流的方式
  1. 首先把流的引用声明在try的外面，如果声明在try里面，其作用域无法抵达finally.
  2. 在finally关闭之前，要先判断该引用是否为空
  3. 关闭的时候，需要再一次进行try catch处理
  
  
  这是标准的严谨的关闭流的方式，但是看上去很繁琐，所以写不重要的或者测试代码的时候，都会采用上面的有隐患try的方式，因为不麻烦~
  

   
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.IOException;
   
  public class TestStream {
   
      public static void main(String[] args) {
          File f = new File("d:/lol.txt");
          FileInputStream fis = null;
          try {
              fis = new FileInputStream(f);
              byte[] all = new byte[(int) f.length()];
              fis.read(all);
              for (byte b : all) {
                  System.out.println(b);
              }
   
          } catch (IOException e) {
              e.printStackTrace();
          } finally {
              // 在finally 里关闭流
              if (null != fis)
                  try {
   
                      fis.close();
                  } catch (IOException e) {
                      // TODO Auto-generated catch block
                      e.printStackTrace();
                  }
          }
   
      }
  }

• 使用try()的方式
  把流定义在try()里,try,catch或者finally结束的时候，会自动关闭
  这种编写代码的方式叫做 try-with-resources， 这是从JDK7开始支持的技术
  
  
  所有的流，都实现了一个接口叫做 AutoCloseable，任何类实现了这个接口，都可以在try()中进行实例化。 并且在try, catch, finally结束的时候自动关闭，回收相关资源。
  

  package stream;
    
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.IOException;
    
  public class TestStream {
    
      public static void main(String[] args) {
          File f = new File("d:/lol.txt");
    
          //把流定义在try()里,try,catch或者finally结束的时候，会自动关闭
          try (FileInputStream fis = new FileInputStream(f)) {
              byte[] all = new byte[(int) f.length()];
              fis.read(all);
              for (byte b : all) {
                  System.out.println(b);
              }
          } catch (IOException e) {
              e.printStackTrace();
          }
    
      }
  }

  
  

Reader字符输入流 
Writer字符输出流 
专门用于字符的形式读取和写入数据

使用字符流读取文件

FileReader 是Reader子类，以FileReader 为例进行文件读取

package stream;
 
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
 
public class TestStream {
 
    public static void main(String[] args) {
        // 准备文件lol.txt其中的内容是AB
        File f = new File("d:/lol.txt");
        // 创建基于文件的Reader
        try (FileReader fr = new FileReader(f)) {
            // 创建字符数组，其长度就是文件的长度
            char[] all = new char[(int) f.length()];
            // 以字符流的形式读取文件所有内容
            fr.read(all);
            for (char b : all) {
                // 打印出来是A B
                System.out.println(b);
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
 
    }
}

使用字符流把字符串写入到文件
FileWriter 是Writer的子类，以FileWriter 为例把字符串写入到文件

package stream;
  
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
  
public class TestStream {
  
    public static void main(String[] args) {
        // 准备文件lol2.txt
        File f = new File("d:/lol2.txt");
        // 创建基于文件的Writer
        try (FileWriter fr = new FileWriter(f)) {
            // 以字符流的形式把数据写入到文件中
            String data="abcdefg1234567890";
            char[] cs = data.toCharArray();
            fr.write(cs);
  
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
  
    }
}