Java学习笔记八

IO流:就是input/output输入/输出流。

一、字节流操作文件的便捷类:FileWriter和FileReader

 import java.io.FileWriter;
 import java.io.IOException;

 public class FileWriterDemo {
     private static final String LINE_SEPARATOR=System.getProperty("line.separator");
     public static void main(String[] args) throws IOException{
         /*FileWriter类是Writer类的一个实现,用于向文件中写入字符
          * io操作可能会触发IOException.
          */
         demo();
     }

     //1、io操作应该处理IOException
     public static void demo() throws IOException {
         /*2、FileWriter类有多个构造函数,但是必须指定一个预期写入的目标文件,
          * 下面是字符串指定的文件,如果文件不存在则创建并写入内容;如果存在则先删除在创建并写入
          */
         FileWriter fw=new FileWriter("demo.txt");
         //3、write()是将内容写入到缓冲区中,而非硬盘中
         fw.write("asd"+LINE_SEPARATOR+"fgh"+LINE_SEPARATOR);
         //4、flush()是将缓冲区内容刷新到硬盘中
         fw.flush();
         //5、close()是两步操作:先刷新,在关闭
         fw.close();
         //如果想要在其后追加内容而非覆盖,则可以使用第二个boolean参数的构造方法
         FileWriter fw2=new FileWriter("demo.txt",true);
         fw2.write("这是追加的内容,使用了第二个boolean参数,没有将前面内容覆盖");
         fw2.close();
     }
 }

FileWriter示例

 import java.io.FileReader;
 import java.io.IOException;

 public class FileReaderDemo {

     public static void main(String[] args){
         readDemo();
         readDemo2();
     }

     public static void readDemo(){
         /*FileReader类是读取文件内容的Reader类的实现,特点
          * 1、继承了read(),但是每次只能读取一个字符,！！！范围在 0 到 65535 之间 (0x00-0xffff)
          * 2、读到结尾处,返回-1
          * 3、独处的数据是int类型而非char类型,可以进行强转
          */
         FileReader fr = null;
         try {
             fr = new FileReader("demo.txt");
             while (fr.read() != -1) {
                 System.out.println((char)(fr.read()));
             }
         } catch (IOException e) {
             System.out.println(e.toString());
         }finally{
             if(fr!=null){
                 try {
                     fr.close();
                 } catch (IOException e2) {
                     throw new RuntimeException("关闭失败");
                 }
             }
         }
     }

     public static void readDemo2() {
         /*第二种方式是先创建一个数组,然后将读取的字符存入其中,然后可以将字符数组转为字符串然后读取
          * 优点是一次可以读取多个,减少循环的次数
          * ！！！注意:每次都会读取数组长度的字符,并从0位开始存储,如果最后一次读取的字符<数组长度,
          * ！！！则只会覆盖前面的位置,之后的还是上一次读取的字符
          * 数组长度最好是1024的整数倍
          */
         FileReader fr = null;
         char[] buff=new char[1024];
         int len=0;
         try {
             fr = new FileReader("demo.txt");
             while ((len=fr.read(buff)) != -1) {
                 System.out.println(new String(buff,0,len));
             }
         } catch (IOException e) {
             System.out.println(e.toString());
         }finally{
             if(fr!=null){
                 try {
                     fr.close();
                 } catch (Exception e2) {
                     throw new RuntimeException("关闭失败");
                 }
             }
         }
     }
 }

FileReader示例

 import java.io.FileWriter;
 import java.io.IOException;

 public class IOExceptionDemo {
     private static final String LINE_SEPARATOR=System.getProperty("line.separator");

     public static void main(String[] args){
         demo();
     }

     public static void demo() {
         /*流类异常的处理:指的是那些需要打开/关闭资源的类,如IO流和数据库操作,
          * 1、就算出现异常,也要关闭资源,所以需要使用finally语句将关闭操作包含
          * 2、由于{}是一个单独的作用域,而这个资源需要在try和finally中分别操作,
          *         ！！！所以需要将资源定义在try结构之前
          * 3、关闭操作在finally中也可能出错,所以也需要单独进行try操作
          * ！！！4、在关闭资源之前应该先判断是否打开该资源,因为可能打开时就失败了
          */
         FileWriter fw =null;
         try {
             fw = new FileWriter("demo.txt");

             fw.write("asd" + LINE_SEPARATOR + "fgh" + LINE_SEPARATOR);
         } catch (IOException e) {
             System.out.println(e.toString());
         }finally{
             if(fw!=null){
                 try {
                     fw.close();
                 } catch (Exception e2) {
                     throw new RuntimeException("关闭失败");
                 }
             }
         }
     }
 }

IO异常处理

缓冲区BufferedWriter/BufferedReader是用来提高流操作的效率,将要读写的内如存放在内存中统一读取,减少IO操作次数

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;

 public class BufferDemo {
     public static void main(String[] args) throws IOException{
         //BufferedWriterDemo();
         BufferedReaderDemo();
     }

     public static void BufferedWriterDemo() throws IOException {
         //缓冲区必须封装一个字符流对象,其实内部就是用数组将字符流读取的内容先保存之后统一输出
         FileWriter fw=new FileWriter("bufferdemo.txt");
         BufferedWriter bw=new BufferedWriter(fw);
         bw.write("asdsf");
         bw.newLine();
         bw.write("这是新一行,使用缓冲区对象的方法换行");
         //这里使用缓冲区对象的close()其实就是使用字符流对象的该方法
         bw.close();
     }

     public static void BufferedReaderDemo() throws IOException {
         FileReader fr=new FileReader("bufferdemo.txt");
         //缓冲区内部其实就是一个数组,在这里体现的更明显
         BufferedReader br=new BufferedReader(fr);
         String line="";
         //BufferedReader类有一个特殊方法:就是读取一行内容,！！！读到最后返回null不是-1
         while((line=br.readLine())!=null){
             System.out.println(line);
         }
         br.close();
     }
 }

Buffered缓冲区示例

下图是缓冲区实现的原理图

缓冲区对象还有一个子类LineNumberReader可以读取行号,原理类似

二、字节流操作文件的便捷类:FileOutputStream和FileInputStream,和字符流对象类似

 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;

 public class ByteStreamDemo {

     public static void main(String[] args) {
         /*字节流演示:直接操作底层2进制,不管编码。和字符流的区别是
          * 1、使用的是字节数组,每次读取1个字节,如果字符超出1字节会被剪切
          * 2、不用刷新flush(),因为会直接输出,但是需要close()
          */
         FileOutputStreamDemo();
         FileInputStreamDemo();
     }

     public static void FileOutputStreamDemo() {
         FileOutputStream fos=null;
         try {
             fos = new FileOutputStream("ByteStream.txt");
             fos.write("abcdefg".getBytes());
         } catch (IOException e) {
             e.printStackTrace();
         }finally{
             if(fos!=null){
                 try {
                     fos.close();
                 } catch (IOException e) {
                     throw new RuntimeException("关闭失败");
                 }
             }
         }
     }

     public static void FileInputStreamDemo() {
         FileInputStream fis=null;
         try {
             fis = new FileInputStream("Bytestream.txt");
             /*FileInputStream对象available()可以直接访问文件的字节长度,所以比较简便的读取
              * ！！！注意:如果文件内容过程,例如一部电影,就不能使用这种方法,因为创建的数组过长
              * 但是该方法可以用在对文件的分段读取上
              */
             byte[] b=new byte[fis.available()];
             fis.read(b);
             System.out.println(new String(b));
         } catch (IOException e) {
             e.printStackTrace();
         }finally{
             try {

                 fis.close();
             } catch (IOException e) {
                 throw new RuntimeException("关闭失败");
             }
         }
     }

 }

字节流对象演示

字节流对象也有对应的缓冲区对象:BufferedOutputStream和BufferedInputStream

三、标准输入:即通过键盘录入数据

 import java.io.IOException;
 import java.io.InputStream;

 public class ReadKey {

     public static void main(String[] args) throws IOException {
         readkeydemo();
         readkeytest();
     }

     public static void readkeydemo() throws IOException {
         //1、通过System.in获取标准输入流对象
         InputStream in=System.in;
         /*2、通过read()来读取标准输入设备的输入数据,特点:
          *     1、！！！注意在读取完之前/抛出异常之前总是阻塞
          *     2、内容输入完使用Enter回车键结束,即使输入多个字符,该方法一次只能读取一个
          * ！！！注意:实际的输入内容包括回车符\r(13),换行符\n(10)
          */
         int context=in.read();
         System.out.println(context);
         context=in.read();
         System.out.println(context);
         context=in.read();
         System.out.println(context);
         context=in.read();
         System.out.println(context);
         //3、！！！标准的输入/出对象在关闭之后就不能再打开了,所以不要手动关闭,会在程序结束时自动关闭
         //in.close();
     }

     public static void readkeytest() throws IOException {
         /*读取用户输入信息,以over结束而不是以回车符结束
          * 1、既然不使用回车符结束就要将其避免,
          *         当读到\r时跳过,下一个若是\n,表示一行的结束
          * 2、在一行结束时应该先判断是否是over,如果是则跳出循环,
          */
         InputStream in=System.in;
         StringBuffer sb=new StringBuffer();
         int ch=0;
         /*下面循环中的操作就是多次读取一行信息,和字符流BufferedReader中的readLine()相似,
          * 只是需要将字节流转换为字符流才能操作,见InputStreamReaderDemo.java
          */
         while((ch=in.read())!=-1){
             if(ch=='\r'){
                 continue;
             }
             if(ch=='\n'){
                 String str=sb.toString();
                 if(str.equals("over")){
                     break;
                 }
                 System.out.println(str);
                 sb.delete(0, sb.length());
             }else{
                 sb.append((char)(ch));
             }
         }
     }
 }

键盘录入示例

四、字节流到字符流的转换InputStreamReader和OutputStreamWriter

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;

 public class StreamtoReaderWriter {
     public static void main(String[] args) throws IOException{
         /*字符流=字节流+编码,在Java中有对象可以实现字节流和字符流之间的转换
          * 1、字节流--》字符流：解码,使用InputStreamReader
          * 2、字符流--》字节流：编码,使用OutputStreamWriter
          */
         //readKeyTest();
         OutputStreamWriterDemo();
     }

     public static void readKeyTest() throws IOException {
         InputStream in=System.in;
         InputStreamReader isr=new InputStreamReader(in);
         BufferedReader br=new BufferedReader(isr);
         String str=null;
         while((str=br.readLine())!=null){
             if(str.equals("over")){
                 break;
             }
             System.out.println(str);
         }
     }

     public static void OutputStreamWriterDemo() throws IOException {
         /*这个函数是将System.out用流的方式实现了,其实其本身就是一种流
          * 并且可以将一个输入流内容输出到指定位置,扩展了System.out只能输出到控制台的功能
          */
         BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
         BufferedWriter bw=new BufferedWriter(new FileWriter("a.txt"));
         String str=null;
         while((str=br.readLine())!=null){
             if(str.equals("over")){
                 bw.close();
                 break;
             }
             //System.out.println(str);
             bw.write(str);
             bw.newLine();
             bw.flush();
         }
     }
 }

转换流

！！！注意:System.out对象就是PrintStream的一个实例,用于方便的输出各种类型的数据;而System.in就是InputStream的一个实例

！！！PrintStream对象的println()会在写入byte[]之后自动添加换行符(意味着结束此行),并自动刷新,例如out对象的println()

五、流对象该如何选择

文件系统操作:IO流操作是对数据的操作,但是不能操作文件本身,Java中将对文件/文件夹的操作封装为File对象