java大数据学习第十三天----IO流 字节.字符输入输出流的普通和高效输入输出

IO流图示:

流的分类

• 流的方向:输入流 输出流
• 按照传输的单位:字节流 字符流

组合情况

• 字节输入流:InputStream------抽象父级,不可实例化

  • 此抽象类是表示字节输入流的所有类的超类。

  • 需要定义 InputStream 子类的应用程序必须总是提供返回下一个输入字节的方法。

  • FileInputStream-----普通字节输入流-----用于 *** 作文件 —构造函数:File/String------- 一次1字节

    构造方法一:
    		InputStream in =new FileInputStream(new File("D:\ready.txt"));//多态
    		或者
    		FileInputStream in =new FileInputStream(new File("D:\ready.txt"));
    
    构造方法二:
    		InputStream in =new FileInputStream("D:\ready.txt");//多态
    		或者
    		FileInputStream in =new FileInputStream("D:\ready.txt");    
    

  • BufferedInputStream----高效字节输入流—构造函数:InputStream ----- 一次8192字节

    构造方法一:
    		InputStream in = new BufferedInputStream(new FileInputStream(new File("D:\ready.txt")));//多态
    		或者
    		FileInputStream in = new BufferedInputStream(new FileInputStream(new File("D:\ready.txt")));
    
    构造方法二:
     		InputStream in=new BufferedInputStream(new FileInputStream("D:\ready.txt"));//多态
    		或者
    		FileInputStream in=new BufferedInputStream(new FileInputStream("D:\ready.txt"));
    

• 字节输出流:OutputStream—抽象父级 不可实例化

  • FileOutputStream— 普通字节输出流 -----用于 *** 作文件----- 构造函数:File/String

    构造方法一:
    	1>覆盖输出:
             OutputStream fos = new FileOutputStream(new File("D:\ready\1.txt"));//多态
    		 或者
            FileOutputStream  fos = new FileOutputStream(new File("D:\ready\1.txt"));  
    	2>追加输出:
    		 OutputStream fos = new FileOutputStream(new File("D:\ready\1.txt"),true);//多态
    		或者
              FileOutputStream  fos = new FileOutputStream(new File("D:\ready\1.txt"),true);   
    构造方法二:
    	1>覆盖输出:
             OutputStream fos = new FileOutputStream("D:\ready\1.txt");//多态
    		 或者
            FileOutputStream  fos = new FileOutputStream("D:\ready\1.txt");  
    	2>追加输出:
    		 OutputStream fos = new FileOutputStream("D:\ready\1.txt",true);//多态
    		或者
              FileOutputStream  fos = new FileOutputStream("D:\ready\1.txt",true);  
    

  • BufferedOutputStream-----高效的字节输出流 ----构造函数:OutputStream

  构造方法一:
  	1>覆盖输出:
           OutputStream fos = new BufferedOutputStream(new FileOutputStream(new File("D:\ready\1.txt")));//多态
  		 或者
          BufferedOutputStream  fos = new BufferedOutputStream(new FileOutputStream(new File("D:\ready\1.txt")));
  	2>追加输出:----高效的实现追加输出 实际上还是 FileOutputStream 实现的追加输出 true写在 FileOutputStream的括号里
  		 OutputStream fos = new BufferedOutputStream(new FileOutputStream(new File("D:\ready\1.txt"),true));//多态
  		 或者
          BufferedOutputStream  fos = new BufferedOutputStream(new FileOutputStream(new File("D:\ready\1.txt"),true));
  		
  构造方法二:
  	1>覆盖输出:
            OutputStream fos = new BufferedOutputStream(new FileOutputStream("D:\ready\1.txt"));//多态
  		 或者
          BufferedOutputStream  fos = new BufferedOutputStream(new FileOutputStream("D:\ready\1.txt"));
  	2>追加输出:----高效的实现追加输出 实际上还是 FileOutputStream 实现的追加输出 true写在 FileOutputStream的括号里
  		 OutputStream fos = new BufferedOutputStream(new FileOutputStream("D:\ready\1.txt",true));//多态
  		 或者
          BufferedOutputStream  fos = new BufferedOutputStream(new FileOutputStream("D:\ready\1.txt",true));
  

• 字符输入流:Reader----抽象父级,不可实例化

  • FileReader----普通字符输入流-----用于 *** 作文件—构造函数:File/String

    构造方法一:
    		Reader in =new FileReader(new File("D:\ready.txt"));//多态
    		或者
    		FileReader in = new  FileReader(new File("D:\ready.txt"));   
    
    构造方法二:
    		Reader in =new FileReader("D:\ready.txt");//多态
    		或者
    		FileReader in = new  FileReader("D:\ready.txt");     
    

  • BufferedReader----高效字符输入流----构造函数:Reader

    构造方法一:
    		Reader in = new BufferedReader(new FileReader(new File("D:\ready.txt")));//多态
    		或者
    		BufferedReader in = new BufferedReader(new FileReader(new File("D:\ready.txt")));    
    
    构造方法二:
    		Reader in=new BufferedReader(new FileReader("D:\ready.txt"));//多态
    		或者
    		BufferedReader in = new BufferedReader(new FileReader("D:\ready.txt"));    
    
    

• 字符输出流:Writer----抽象父级,不可实例化

  • FileWriter—普通字符输出流-----用于 *** 作文件—构造函数:File/String

  构造方法一:
  	1>覆盖输出
  		 Writer out = new FileWriter(new file("D:\ready\1.txt"));//多态
  		 或者
  		 FileWriter out = new FileWriter(new file("D:\ready\1.txt"));   
  	2>追加输出
           Writer out = new FileWriter(new file("D:\ready\1.txt"),true);//多态
  		或者
            FileWriter out = new FileWriter(new file("D:\ready\1.txt"),true);
  构造方法二:
  	1>覆盖输出
  		 Writer out = new FileWriter("D:\ready\1.txt");//多态
  		 或者
  		 FileWriter out = new FileWriter("D:\ready\1.txt");   
  	2>追加输出
           Writer out = new FileWriter("D:\ready\1.txt",true);//多态
  		或者
            FileWriter out = new FileWriter("D:\ready\1.txt",true);
  

  • BufferedWriter-----高效字符输出流—构造函数:Writer

    构造方法一:
    	1>覆盖输出:
    		     Writer out = new BufferedWriter(new FileWriter(new File("D:\ready\1.txt")));//多态
    			或者
                 BufferedWriter out = new BufferedWriter(new FileWriter(new File("D:\ready\1.txt")));
    	2>追加输出:
    			 Writer out = new BufferedWriter(new FileWriter(new File("D:\ready\1.txt"),true));//多态
    			或者
                 BufferedWriter out = new BufferedWriter(new FileWriter(new File("D:\ready\1.txt"),true));
    构造方法二:
    	1>覆盖输出:
    		     Writer out = new BufferedWriter(new FileWriter("D:\ready\1.txt"));//多态
    			或者
                 BufferedWriter out = new BufferedWriter(new FileWriter("D:\ready\1.txt"));
    	2>追加输出:
    			 Writer out = new BufferedWriter(new FileWriter("D:\ready\1.txt",true));//多态
    			或者
                 BufferedWriter out = new BufferedWriter(new FileWriter("D:\ready\1.txt",true));
    
    

综合案例:文件复制

public class TestCopyFile {
    public static void main(String[] args) {
    	  //1.提示用户输入需要复制的文件路径 并进行接收
        System.out.println("请输入需要复制的文件路径:");
        String f = new Scanner(System.in).nextLine();
        //2.提示用户输入想要复制到的文件路径 并进行接收
        System.out.println("请输入想要复制到的文件路径");
        String t = new Scanner(System.in).nextLine();
        //3.调用两个方法
        //3.1 使用字节流复制,因为复制需要输入路径 所以有参数 参数就是路径 f t
        ZJCopy(f,t);
        //3.2 使用字符流复制
        ZFCopy(f,t);
    }
    
    
    
    //  构造 字节流复制 方法
    private static void ZJCopy(f,t){
        //1.定义在整个方法中都可以使用的 输入流变量 和 输出流变量   因为是局部变量 所以需要手动赋值 默认值null
        //输入流变量
        InputStream in = null;//多态字节输入流
        FileInputStream in = null;//普通字节输入流--纯纯变量
        BufferedInputStream in = null ;//高效字节输入流---纯纯变量
        //输出流变量
        OutputStream out = null;
        FileOutputStream out = null;
        BufferedOutputStream out = null;
        
        //2.因为方法的主体代码可能会产生异常,所以需要try-catch-finally结构
        try{
            //3.1给输入变量赋值
            //普通输入--两种
            in = new FileInputStream(new File(f));
            in = new FileInputStream(f);
             //高效输入--两种
             in = new BufferedInputStream(new FileInputStream(new File(f))); 
             in = new BufferedInputStream(new FileInputStream(f));
            //3.2给输出变量赋值
            //普通输出--两种
            out = new FileOutputStream(new File(t));
            out = new FileOutputStream(t);
             //高效输出--两种
            out = new BufferedOutputStream(new FileOutputStream(new File(t)));
            out = new BufferedOutputStream(new FileOutputStream(t));
            
            //4.使用流对象
          	//定义一个变量 保存读取的数据
            int b;
            //因为文件需要循环读取和写出 所以需要循环语句
            while((b=in.read())!=-1){//当读取数据为-1 表示读取结束
                out.write(b);//写入数据
            }
           //此处可以提醒用户 复制完成
            System.out.println("恭喜您,复制完成");            
        }catch(Exception e){
            //如果没有复制成功 在这里提示用户
            System.out.println("对不起,复制失败");      
            e.printStackTrace();
        }finally{
            //5.关流 
            //关流有顺序,最后创建的流 要最先关闭
            //关流需要一个一个try-catch
            try{
                out.close();
            }catch(Exception e){
                e.printStackTrace();
            }
            
            try{
                in.close();
            }catch(Exception e){
                e.printStackTrace();
            }
        }
       
    }

    
    
    
    //构造字符流复制方法
    private static void ZFCopy(f,t){
        //1.定义在整个方法中都可以使用的局部变量
        //输入流变量
        Reader in = null;//多态字符输入流
        FileReader in = null;//普通字符输入流
        BufferedReader in = null;//高效字符输入流
        //输出流变量
        Writer out = null;
        FileWriter out = null;
        BufferedWriter out = null;
        //2.因为方法的主体代码可能会产生异常,所以需要try-catch-finally结构
        try{
              //3.1给输入变量赋值
            //普通输入--两种
            in = new FileReader(new File(f));
            in = new FileReader(f);
            //高效输入--两种
            in = new BufferedReader(new FileReader(new File(f)));
            in = new BufferedReader(new FileReader(f));
            //3.2给输出变量赋值
             //普通输出--两种
            out = new FileWriter(new File(t));
            out = new FileWriter(t);
            //高效输出--两种
            out = new BufferedWriter(new FileWriter(new File(t)));
            out = new BufferedWriter(new FileWriter(t));
            
            //4.使用流对象
          	//定义一个变量 保存读取的数据
            int b;
            //因为文件需要循环读取和写出 所以需要循环语句
            while((b=in.read()!=-1)){//当读取数据为-1 表示读取结束
                out.write(b);//写入数据
            }
            //此处可以提醒用户 复制完成
              System.out.println("恭喜您,复制完成");                  
        }catch(Exception e){
            //如果没有复制成功 在这里提示用户
            System.out.println("对不起,复制失败"); 
            e.printStackTrace();            
        }finally{
            //5.关流 
            //关流有顺序,最后创建的流 要最先关闭
            //关流需要一个一个try-catch
            try{
                out.close();
            }catch(Exception e){
                e.printStackTrace();
            }
            
            try{
                in.close();
            }catch(Exception e){
                e.printStackTrace();
            }            
        }      
    }
    
    
    
    
}