文件流的实战应用

r囧r小猫 2022-11-15 11:46 175阅读 0赞

关于文件流：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMwNjMxMDYz_size_16_color_FFFFFF_t_70][]

### 文件字节输入流： FileInputStream类 ###

文件字节输入流可以从指定路径的文件中读取字节数据，文件字节输入流继承InputStream类，并且实现了读取输入流的各种方法

创建文件字节输入流的构造方法：

1.以File对象为参数创建FileInputStream

new FileInputStream(File file)

1.  以文件对象的绝对路径为参数创建FileInputStream实例

new FileInputStream(String filePath)

### 文件字节输出流：  FileOutPutSteam ###

文件字节输出流关联指定文件路径的文件，数据通过文件字节输出流以字节为单位输出并保存到文件中。文件字节输出流继承自OutputStream类，并实现OutputStream类的各种方法。

创建文件字节输出流的构造方法语法如下：

1.new FileOutPutStream(File file)

2.new FileOutPutStream(String filepath)

### 字符输入流：Reader类 ###

字符输入输出流 与 字节输入输出流有相同的功能，但传送数据的方式不一样，字节流以字节为单位传送数据，可以使任何类型的数据，例如文本、音频、视频、图片等。字符流以字符为单位传送数据，只能传送文本类型的数据。使用字符输入输出流的好处是，当读取中文时不会出现乱码问题，而使用字节输入输出流时，却不能保证这一点。

### 字符输出流类：writer类 ###

### 文件字符输入流：FileReader 继承 Reader类 ###

new FileReader(File file)
       
    new FileReader(String path)

package com.zch.io;
    
    import java.io.File;
    import java.io.FileReader;
    
    public class FileInAndOut {
        public static void main(String[] args) {
            //定义指定磁盘的文件的File对象
            File file = new File("D://word.txt");
            
            if(! file.exists()){
                System.out.println("对不起，不包含指定路径的文件");
            }else{
                //根据指定路径的File对象创建FileReader对象
                try {
                    FileReader fr = new FileReader(file);
                    
                    char[] data = new char[23];         //定义char数组
                    
                    int length = 0;
                    
                    while((length = fr.read(data))>0){          //循环读取文件中的数据
                        String str = new String(data,0,length);         //根据读取文件的内容创建String 对象
                        System.out.println(str);                //输出读取内容
                    }
                    fr.close();                             //关闭流
                    
                    
                    
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
            }
        }
    }

### 文件字符输出流FileWriter ###

文件字符输出流继承自Writer类，提供了向文件输出的各种方法，数据通过文件字符输出流以字符为单位输出并保存到文件中

//创建指定文件
        File file=new File("path")
        
        try{
            if(!file.exists()){
                //如果指定的文件不存在，那么就新建文件
                file.createNewFile();   
            }
            FileReader fr=new FileReader("path")
            FileWriter fw=new FileWriter(file);//創建fileWriter對象
            while((length=fr.read()!=-1){//如果沒有读到文件末尾
                //向文件写入数据
                fw.write(length);
                
            }
                  fr.close
                  fw.close
        }

### **关于/和 \\\\ 的用法：** ###

具体使用中都可以达到访问路径的效果，只不过有一点小区别

正斜杠的话，一般在配置文件路径时，指向下一个路径只要使用一个

例如："c:/a/1.txt";

而反斜杠的话，在配置文件路径时，由于它本身在java中有特殊意义，作为转义符而存在，所以具体意义上的反斜杠要两个

例如："c\\\\a\\\\1.txt";这里的第一个反斜杠是作为转义符存在的，第二个才是真正意义上的反斜杠

**一般可以认为是"/"的作用等同于"\\\\"**

在java中路径一般用"/"

windows中的路径一般用"\\"

linux、unix中的路径一般用"/"

**最好用“/”  因为java是跨平台的。“\\”（在java代码里应该是\\\\）是windows环境下的路径分隔符，Linux和Unix下都是用“/”。而在windows下也能识别“/”。所以最好用“/”**

### File文件流常用方法： ###

/ 创建一个文件对象(可以是文件，可以是文件夹)
    		File file = new File("e:/java_text.txt");
    		// 基本属性
    		boolean canWriter = file.canWrite();
    		System.out.println("是否可写:" + canWriter);
    		boolean canRead = file.canRead();
    		System.out.println("是否可读:" + canRead);
    		long size = file.length(); // 常用
    		System.out.println("文件大小:" + size);
    		boolean isFile = file.isFile(); // 常用
    		System.out.println("是否是文件:" + isFile);
    		boolean isDirectory = file.isDirectory();
    		System.out.println("是否是文件夹:" + isDirectory);
    		String filename = file.getName(); // 常用
    		System.out.println("文件的名称:" + filename);
    		String absolutePath = file.getAbsolutePath(); // 常用
    		System.out.println("文件的绝对路径:" + absolutePath);
    		String filepath = file.getPath();
    		System.out.println("文件的绝对路径:" + filepath);
    		boolean isExists = file.exists(); // 常用
    		System.out.println("是否存在:" + isExists);
    		boolean isDelete = file.delete(); // 常用
    		System.out.println("是否已经被删除:" + isDelete);
    		boolean isCreate = file.createNewFile();
    		System.out.println("创建了没有:" + isCreate);

# File 文件流实战： #

### file流实现复制文件夹： ###

需求： 将一个文件夹复制一份新的文件夹，因为这个原文件夹中既有文件又有文件夹，所以需要进行分开复制

package com.example.File;/*
     * Copyright 2013- Smartdot Technologies Co., Ltd. All rights reserved.
     * SMARTDOT PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
     *
     */
    
    import java.io.*;
    import java.lang.reflect.Field;
    
    /**
     * 通过File流实现文件的复制，还可以复制文件夹
     * @author <a href="mailto:heyf@smartdot.com.cn">heyf</a>
     * @version 1.0,
     * @class
     * @date
     * @see
     */
    public class CopyFile {
        public static void main(String[] args) {
            File sourceFile =null;
            File desFile=null;
    
            String sourceFolder="D:/复制文件夹";
            String copyFolder="D:/cody";
    
            //实例化一个文件夹
            sourceFile =new File(sourceFolder);
            /**exists() 无论sourceFile是文件还是文件夹只要存在->true
             * isDirectory() 如果sourceFile是文件夹存在->true
             * isFile() sourceFile存在并且是一个文件的时候才会返回True
             */
            if(!sourceFile.exists()||!sourceFile.isDirectory()){
                System.out.println("源文件夹不存在");
            }else{
                desFile =new File(copyFolder);
                /**
                 * mkdir:只能创建一层目录,不能带多级目录
                 * mkdirs:可以创建完成的目录
                 * 在使用mkdir()的时候可以配合getFileDir（）来使用，如果知道完整路径，直接使用mkdirs比较好
                 */
                desFile.mkdir();
                copy(sourceFile.listFiles(),desFile);
            }
        }
    
        /**
         * 创建copy方法，该方法用来接收文件数组和目标文件夹，把文件数组复制到目标文件夹下，如果目标文件夹不存在，那么通过mkdir来创建文件夹
         */
         public static void copy(File[] fl,File file){
             //如果复制的目标文件夹不存在
             if(!file.isDirectory()){
                 //创建一个文件夹
                 file.mkdirs();
             }
             for(int i=0;i<fl.length;i++){
                 if(fl[i].isFile()){
                     try{
                         //将文件内容通过文件输入流的方式准备读取
                         FileInputStream fis=new FileInputStream(fl[i]);
                         
                         FileOutputStream fou=new FileOutputStream(new File(file.getPath()+File.separator+fl[i].getName()));
    
                         //在读写操作之前先知道数据流里面有多少个字节可以读取
                         int count=fis.available();
                         byte[] data=new byte[count];
                          //表示是否完整的读取整个文件或者读取完最后一个字符
                         if((fis.read(data))!=-1){
                             fou.write(data);
                         }
                     } catch (FileNotFoundException e) {
                         e.printStackTrace();
                     } catch (IOException e) {
                         e.printStackTrace();
                     }
                 }
                 if(fl[i].isDirectory()){
                     File des=new File(file.getPath()+File.separator+fl[i].getName());
                     des.mkdirs();
                     //然后递归去看看文件内部是否还有文件
                     copy(fl[i].listFiles(),des);
                 }
    
             }
         }
    }

### 字符流的读取和写入(只能读取字符文件的信息)： ###

//使用字符流读取文件
        public static void testReader() throws Exception{
            //创建文件对象
            File file = new File("e:/a/file.txt");
            //创建字符输入流对象
            Reader reader = new FileReader(file);
            //创建字符输出流对象
            File file2 = new File("e:/a/b/file_3.txt");
            Writer writer = new FileWriter(file2);
            char[] temp = new char[1000];
            int size =0;
            //通过循环边度编写
            do{
                size= reader.read(temp);  //读取字符内容
                if(size!=-1)
                {
                    writer.write(temp, 0, size);
                }
            }while(size!=-1);
            //关闭
            writer.flush();
            writer.close();
            reader.close();
        }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMwNjMxMDYz_size_16_color_FFFFFF_t_70]: /images/20221022/06238cd9ec484d2d8f788a1aeff243fb.png