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

IO流

  1. IO流图示:在这里插入图片描述

  2. 流的分类

    • 流的方向:输入流 输出流
    • 按照传输的单位:字节流 字符流
  3. 组合情况

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

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

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

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

        构造方法一:
        		InputStream in =new FileInputStream(new File("D:\\ready\\1.txt"));//多态
        		或者
        		FileInputStream in =new FileInputStream(new File("D:\\ready\\1.txt"));
        
        构造方法二:
        		InputStream in =new FileInputStream("D:\\ready\\1.txt");//多态
        		或者
        		FileInputStream in =new FileInputStream("D:\\ready\\1.txt");    
        
      • BufferedInputStream----高效字节输入流—构造函数:InputStream ----- 一次8192字节

        构造方法一:
        		InputStream in = new BufferedInputStream(new FileInputStream(new File("D:\\ready\\1.txt")));//多态
        		或者
        		FileInputStream in = new BufferedInputStream(new FileInputStream(new File("D:\\ready\\1.txt")));
        
        构造方法二:
         		InputStream in=new BufferedInputStream(new FileInputStream("D:\\ready\\1.txt"));//多态
        		或者
        		FileInputStream in=new BufferedInputStream(new FileInputStream("D:\\ready\\1.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\\1.txt"));//多态
        		或者
        		FileReader in = new  FileReader(new File("D:\\ready\\1.txt"));   
        
        构造方法二:
        		Reader in =new FileReader("D:\\ready\\1.txt");//多态
        		或者
        		FileReader in = new  FileReader("D:\\ready\\1.txt");     
        
      • BufferedReader----高效字符输入流----构造函数:Reader

        构造方法一:
        		Reader in = new BufferedReader(new FileReader(new File("D:\\ready\\1.txt")));//多态
        		或者
        		BufferedReader in = new BufferedReader(new FileReader(new File("D:\\ready\\1.txt")));    
        
        构造方法二:
        		Reader in=new BufferedReader(new FileReader("D:\\ready\\1.txt"));//多态
        		或者
        		BufferedReader in = new BufferedReader(new FileReader("D:\\ready\\1.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));
        
        
  4. 综合案例:文件复制

    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();
                }            
            }      
        }
        
        
        
        
    }
    
  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 文件拆分是将一个大文件分成多个小文件的过程,这在处理大文件时非常有用。在Java中,可以使用文件字节IO来实现文件拆分。具体步骤如下: 1. 打开要拆分的文件,创建一个输入对象。 2. 创建一个输出对象,用于写入拆分后的文件。 3. 定义一个缓冲区,用于存储读取的数据。 4. 循环读取文件中的数据,每次读取一定大小的数据,将其写入输出中。 5. 当读取的数据量达到指定大小时,关闭当前输出,创建一个新的输出,继续写入数据。 6. 循环结束后,关闭输入输出。 需要注意的是,拆分后的文件名可以根据需要进行命名,可以使用数字、字母或其他符号来区分不同的文件。同时,拆分后的文件大小也需要根据实际需求进行设置,一般建议不要超过2GB。 ### 回答2: Java是一门广泛应用的编程语言,涵盖了众多领域,其中文件输入输出是其中之一。文件字节IO的文件拆分是文件处理中的一项重要功能,在Java中,常用的文件处理类库是java.io库,它包含了Java文件输入输出所需要的各种类,例如File类、FileReader类、FileWriter类、BufferedReader类、InputStream类、OutputStream类等。 Java文件字节IO的文件拆分主要实现通过读取一个大文件,然后将其分割成小的文件块,以便于更好的管理文件,便于数据传输和存储。这种操作依赖于Java的二进制位操作,它的程如下: 1. 指定待拆分的文件 通过File类下的File对象指定待拆分的文件。 2. 获取待拆分文件的长度 通过File对象的length()方法获取待拆分文件的长度,以便于下一步的拆分操作。 3. 打开输入 通过InputStream类中的FileInputStream对象打开待拆分文件的输入,以读取文件内容。 4. 拆分待处理文件 使用byte[]数组作为缓存区读取待处理文件中的内容,并将它分割成小的文件块。 5. 写入分割文件 通过OutputStream类中的FileOutputStream对象打开文件的输出,将分割的文件块写入新的文件中(例如:文件名末尾加以排序数字)。 6. 关闭输入输出 操作完成后,关闭输入输出释放文件资源,避免内存泄漏。 文件字节IO的文件拆分可以适用于很多场景,例如:大型多媒体文件的存储及快速传输、分散式文件处理场景等。在Java中,我们可以根据自己的需要,使用java.io库中的File类、InputStream类、OutputStream类等API进行相关操作。 ### 回答3: Java输入输出(I/O)是Java编程中重要的一个方面。I/O是程序与外部环境交互的重要方式,它允许程序从磁盘文件或其他设备中读取数据,并将计算结果写回磁盘或其他设备。在Java I/O中,文件字节IO是常用的操作之一。 文件字节IO是对文件进行字节级别操作的输入输出。它以字节为单位进行读取和写入文件,每次读取和写入的长度是固定的,一般为1个字节或多个字节。 文件拆分是文件字节IO操作中的一种常见应用。文件拆分是将文件按照一定的规则分解成多个文件的过程。例如,将一个大文件分成多个小文件,便于存储和传输。文件拆分在数据处理、数据传输等领域都有广泛的应用。 Java中实现文件拆分可以使用文件字节IO。具体实现可以采用以下伪代码: 1. 打开原文件,创建文件字节输入; 2. 创建多个文件字节输出,每个输出对应一个拆分后的文件; 3. 读取原文件,逐个字节分别写入每个输出; 4. 当一个拆分后的文件大小达到限制值时,关闭该输出,创建一个新的输出继续写入; 5. 当原文件读取完毕时,关闭所有输出,完成文件拆分。 这里需要考虑的一些问题是如何确定拆分后每个文件的大小,如何命名新的拆分文件等。 在编写文件拆分程序时,需要注意文件拆分的合法性。例如,在分解文件时需要根据文件格式和业务需求来确定分解规则,保证分解后的文件是合法的。同时还需要考虑拆分后的文件如何合并的问题。 综上所述,文件字节IO的文件拆分操作是Java I/O编程中常见的操作之一。实现文件拆分需要充分考虑拆分规则和文件合法性等问题。在实际开发中,我们可以根据具体需求,结合其他API来实现更多复杂的文件操作。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值