File I/O

偏执的太偏执、 2024-04-17 05:51 63阅读 0赞

## 一，操作文件或目录的属性 ##

File对象既可表示文件，也可表示目录。在程序中，一个File对象可以代表一个文件或目录。利用它可用来对文件或目录进行基本操作。它可以查出与文件相关的信息，如名称、最后修改日期，文件大小等。  
创建一个file对象的语法格式如下：

File file = new File(String pathName);

其中pathName表示所指向的文件路径名，例如：

//创建一个指向D盘根目录下test.txt文本文件的对象
    File file = new File("D:\\text.txt");

需要注意的是，在 Windows操作系统中，文件路径名中的分隔符可以使用正斜杠“/”，“C：/test.txt“也可以使用反斜杠“\\”，但必须写成“\\”，其中第一个表示转义符，如“C:\\test.txt"；

file类常用的方法

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>boolean exists()</td> 
   <td>判断文件或目录是否存在</td> 
  </tr> 
  <tr> 
   <td>boolean isFile()</td> 
   <td>判断是否是文件</td> 
  </tr> 
  <tr> 
   <td>boolean isDirectory()</td> 
   <td>判断是否是目录</td> 
  </tr> 
  <tr> 
   <td>String getPath()</td> 
   <td>返回此对象表示的文件的相对路径名</td> 
  </tr> 
  <tr> 
   <td>String getAbsolutePath()</td> 
   <td>返回此对象表示的文件的绝对路径名</td> 
  </tr> 
  <tr> 
   <td>String getName</td> 
   <td>返回此对象表示的文件或目录的名称</td> 
  </tr> 
  <tr> 
   <td>boolean delete</td> 
   <td>删除此对象指定的文件或目录</td> 
  </tr> 
  <tr> 
   <td>boolean createNewFile()</td> 
   <td>创建名称的空文件，不创建文件夹</td> 
  </tr> 
  <tr> 
   <td>long length</td> 
   <td>返回文件的长度，单位为字节，若文件不存在，则返回OL</td> 
  </tr> 
 </tbody> 
</table>

File类是如何获取文件属性的，案例：

import java.io.File;
    import java.io.IOException;
    
    public class DemoApplication {
        public static void main(String[] args)throws IOException {
            DemoApplication fm = new DemoApplication();
            File file=new File("D:\\hello.txt");
            fm.showFileInfo(file);
        }
        public void showFileInfo(File file){
            if (file.exists()){	//判断文件或目录是否存在
                if (file.isFile()){	//如果是文件
                    System.out.println("名称："+file.getName());
                    System.out.println("相对路径："+file.getPath());
                    System.out.println("绝对路径："+file.getAbsolutePath());
                    System.out.println("文件大小："+file.length()+"字节");
                }
                if (file.isDirectory()){
                    System.out.println("此文件是目录");
                }
            }else{
                System.out.println("文件不存在");
            }
        }
    }

运行结果：

创建文件

/**
         * 创建文件的方法
         * @param file
         */
        public void create(File file){
            if(!file.exists()){
                try{
                    file.createNewFile();
                    System.out.println("文件已经创建");
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }

删除文件

/**
         * 删除文件
         * @param file
         */
        public void delete(File file){
            if(file.exists()){
                file.delete();
                System.out.println("文件已删除");
            }
        }

## 二，Java的流 ##

读文件：指把文件中的数据读取到内存中；  
写文件：把内存中的数据写到文件中；

*  按照流的流向进行划分，可以分为输入流和输出流  
    (1).**输入流**：只能从中读取数据，而不能向其中写入数据；（数据从硬盘到内存）  
    InputStream和Reader作为基类；  
    (2).**输出流**：只能向其中写入数据，而不能从中读取数据；（数据从内存到硬盘）  
    OutputStream和Write作为基类
 *  按照所操作的数据单元的不同，流又可划分成字节流和字符流  
    字节流操作的最小数据单元为8位的字节；  
    字符流操作的最小数据单元为16位的字符；  
    **区分：**  
    字节流建议用于二进制数据（图片），而字符流用于文本，他们的用法几乎完全一样；  
    (1).**字节流：**  
    字节输入流InputStream基类  
    字节输出流OutputStream基类  
    (2).**字符流：**  
    字符输入流Reader基类  
    字符输出流Writer基类

## 三，读写文本文件 ##

*  **使用字节流读取文本文件**  
    1.字节输入流InputStream类（把文件中的数据输入到内存中）

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>int read()</td> 
   <td>读取一个字节数据</td> 
  </tr> 
  <tr> 
   <td>int read(byte[] b)</td> 
   <td>将数据读取到字节数组中</td> 
  </tr> 
  <tr> 
   <td>int read(byte[] b,int off,int len)</td> 
   <td>从输入流中读取最多len长度的字节，保存到字节数组b中，保存的位置从off开始</td> 
  </tr> 
  <tr> 
   <td>void close()</td> 
   <td>关闭输入流</td> 
  </tr> 
  <tr> 
   <td>int available()</td> 
   <td>返回输入流读取的估计字节数</td> 
  </tr> 
 </tbody> 
</table>

2.字节输入流FileInputStream类  
我们通常使用InputStream的子类FileInputStream类来实现文本文件内容的读取；以下是常用的两个构造方法：

(1).FileInputStream(File file)，其中file是指定文件数据源;案例如下：

File file = new File("C:/hello.txt");
    FileInputStream fis= new FileInputStream(file);

(2).FileInputStream(String name)，其中name是指定文件数据源，可以是路径;案例如下：

FileInputStream fis= new FileInputStream("C:/hello.txt");

3.使用FileInputStream读取文件

public class DemoApplication {
        public static void main(String[] args)throws IOException {
    
            FileInputStream fis= null;
            try{
                fis = new FileInputStream("D:\\hello.txt");
                int data;
                System.out.println("可读取得字节数"+fis.available());
                System.out.print("文件内容是：");
                while((data=fis.read())!=-1){
                    System.out.print((char) data+"");		//如果不进行转换，则输出的是数字，因为read()方法返回整数，如果读取的是字符串则必须进行类型转换
                }
            }catch (FileNotFoundException e){
                e.printStackTrace();
            }catch (IOException e){
                e.printStackTrace();
            }finally {
                try{
                    if(fis!=null){
                        fis.close();
                    }
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

*  **使用字节流写文本文件**  
    1.字节输出流OutputStream类（把内存中的数据输出到文件中）

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>int write()</td> 
   <td>写入一个字节数据</td> 
  </tr> 
  <tr> 
   <td>int write(byte[] buf)</td> 
   <td>写入数组buf的所有字节</td> 
  </tr> 
  <tr> 
   <td>int write(byte[] b,int off,int len)</td> 
   <td>将字节数组中从off位置开始，长度为len的字节数据输出到输出流中</td> 
  </tr> 
  <tr> 
   <td>void close()</td> 
   <td>关闭输出流</td> 
  </tr> 
 </tbody> 
</table>

2.字节输出流FileOutputStream类  
我们通常使用OutputStream的子类FileOutputStream类来实现向文本文件写入数据；以下是常用的三个构造方法(第一种和第二种方法在向文件写数据时将覆盖文件中原有的内容)：

(1).FileOutputStream(File file)，其中file是指定文件数据源;案例如下：

File file = new File("C:/hello.txt");
    FileOutputStream fos= new FileOutputStream(file);

(2).FileOutputStream(String name)，其中name是指定文件数据源，可以是路径;案例如下：

FileOutputStream fos= new FileOutputStream("C:/hello.txt");

(3).FileOutputStream(String name,boolean append)，其中name是指定文件数据源，可以是路径;append表示是否在文件末尾添加数据，如果设置为ture，则在文件末尾添加数据；案例如下：

FileOutputStream fos= new FileOutputStream("C:/hello.txt",true);

3.使用FileOutputStream写文本文件

public class DemoApplication {
        public static void main(String[] args)throws IOException {
            FileOutputStream fos= null;
            try{
                String str="哈哈哈哈";
                byte[] words= str.getBytes();//字节数组
                //创建流对象，以追加方式写入文件
                fos= new FileOutputStream("D:\\hello.txt");
                //写入文件
                fos.write(words,0,words.length);
                System.out.println("文件已经更新完成");
            }catch (IOException e){
                System.out.println("创建文件时出错！！！");
            }finally {
                try{
                    if(fos!=null){
                        fos.close();
                    }
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

*  **使用字符流服务文本文件**  
    1.字符输入流Reader类（读取字符流的抽象类）

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>int read()</td> 
   <td>从输入流中读取单个字符</td> 
  </tr> 
  <tr> 
   <td>int read(byte[] c)</td> 
   <td>从输入流中读取c.length长度的字符，保存到字符数组c中，返回实际读取的字符数</td> 
  </tr> 
  <tr> 
   <td>int read(char[] c,int off,int len)</td> 
   <td>从输入流中读取最多len长度的字符，保存到字符数组c中，保存的位置从off开始，返回实际读取的字符长度</td> 
  </tr> 
  <tr> 
   <td>void close()</td> 
   <td>关闭输入流</td> 
  </tr> 
 </tbody> 
</table>

2.字符输入流FileReader类  
我们通常使用Reader的子类FileReader类来实现从文本文件读取数据；  
FileReader(String fileName) //其中file是指要从中读取数据的文件的名称;  
案例如下：

Reader fr=new FileReader("D:\\hello.txt");

3.使用FileReader读取文件

public class DemoApplication {
        public static void main(String[] args)throws IOException {
            //创建FileReader对象
            Reader reader= null;
            StringBuffer sb=null;
            try{
                reader = new FileReader("D:\\hello.txt");
                char ch[] = new char[1024];     //创建字符数组作为中转站
                sb=new StringBuffer();
                int length= reader.read(ch);    //将字符读入数组
                //循环读取并追加字符
                while(length!=-1){
                    sb.append(ch);          //追加到字符串
                    length = reader.read();
                }
            }catch (FileNotFoundException e){
                e.printStackTrace();
            }catch (IOException e){
                e.printStackTrace();
            }finally {
            	System.out.println(sb);
                try{
                    if(reader!=null){
                        reader.close();
                    }
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

4.字符输入流BufferedReader类  
BufferedReader 类是 Reader 类的子类,它与FileReader 类的区别在于,BufferedReader 类带有缓冲区，它可以先把一批数据读到缓冲区，接下来的读操作都是从缓冲区内获取数据，避免每次都从数据源读取数据进行字符编码转换，从而提高读取操作的效率。BufferedReader 类常用的构造方法格式如下：

BufferedReader(Reader in)

使用此构造方法创建字符输入对象如下。

Reader fr=new FileReader("C:\\myTest.txt") ;
    BufferedReader br=new BufferedReader(fr);

5.使用FileReader和BufferedReader读取文本文件

public class DemoApplication {
        public static void main(String[] args)throws IOException {
            FileReader fileReader= null;
            BufferedReader bufferedReader=null;
            try{
                //创建一个FileReader对象
                fileReader = new FileReader("D:\\\\hello.txt");
                //创建一个BufferedReader对象（缓冲对象br）
                bufferedReader = new BufferedReader(fileReader);
                //读取一行数据
                String line = bufferedReader.readLine();
                while(line!=null){
                    System.out.println(line);
                    line=bufferedReader.readLine();
                }
            }catch (IOException e){
                e.printStackTrace();
            }finally {
                try{
                    if(bufferedReader!=null){
                        bufferedReader.close();
                    }
                    if(fileReader!=null){
                        fileReader.close();
                    }
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

*  **使用字符流写文本文件**  
    1.字符输出流Writer类（向文件写入数据的字符流）

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>write(String str)</td> 
   <td>将str字符串里包含的字符输出到指定的输出流中</td> 
  </tr> 
  <tr> 
   <td>write(String str,int off,int len)</td> 
   <td>将str字符串里从off位置开始长度为len的字符输出到输出流中</td> 
  </tr> 
  <tr> 
   <td>void close()</td> 
   <td>关闭输出流</td> 
  </tr> 
  <tr> 
   <td>void flush()</td> 
   <td>刷新输出流</td> 
  </tr> 
 </tbody> 
</table>

2.字符输出流FileWriter类  
我们通常使用Writer的子类FileWriter类来实现向文本文件写入数据；  
FileWriter(String fileName) //其中file是指往文件中写入数据文件的名称;  
案例如下：

Writer fr=new FileWriter("D:\\hello.txt");

3.使用FileWriter向文件中写入内容

public class DemoApplication {
        public static void main(String[] args)throws IOException {
            Writer fw = null;
            try{
                fw = new FileWriter("D:\\hello.txt");
                fw.write("哈哈哈哈哈哈");
                fw.flush();
            }catch (IOException e){
                e.printStackTrace();
            }finally {
                try{
                    if(fw!=null){
                        fw.close();
                    }
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

4.字符输出流BufferedWriter类  
BufferedWriter是Writer类的子类。BufferedWriter 与BufferedReader的流方向正好相反，BufferedWriter是把一批数据写到缓冲区，当缓冲区满的时候，再把缓冲区的数据写到字符输出流中。这可以避免每次都执行物理写操作，从而提高输入/输出操作的效率。BufferedWriter 类的常用构造方法如下：

BufferedReader(Writer out)

使用此构造方法创建字符输出流对象如下。

Writer fw=new FileWriter("C:\\myTest.txt");
    BufferedWriter bw=new BufferedWriter(fw);

其中，bw就是创建的使用默认大小输出缓冲区的缓冲字符输出流。

5.使用BufferedWriter和FileWriter写文本文件

public class DemoApplication {
        public static void main(String[] args)throws IOException {
            FileWriter fw = null;
            BufferedWriter bw=null;
            try{
                //创建一个FileWriter对象
                fw=new FileWriter("D:\\hello.txt");
                //创建一个BufferedWriter对象
                bw=new BufferedWriter(fw);
                //写入信息
                bw.write("你好");
                bw.write("我是张三");
                bw.newLine();
                bw.write("你是谁");
                bw.newLine();   //插入换行符
                bw.flush();     //刷新缓冲区
                bw.close();     //关闭流
                //读取文件内容
                FileReader fr=new FileReader("D:\\hello.txt");
                BufferedReader br=new BufferedReader(fr);
                String line=br.readLine();
                while(line!=null){
                    System.out.println(line);
                    line = br.readLine();
                }
            }catch (IOException e){
                e.printStackTrace();
            }finally {
                try{
                    if(bw!=null){
                        bw.close();
                    }
                    if(fw!=null){
                        fw.close();
                    }
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

## 四，二进制文件的读写 ##

1.使用字节流类DataInputStream读二进制文件  
DataInputStream类是FileInputStream的子类，他是FileInputStream类的拓展，利用DataInputStream类读取二进制文件的实现步骤其实与用FileInputStream类读取文本文件的步骤及其相似，而且还要用到FileInputStream类。  
(1).引入相关的类

import java.io.DataInputStream;
    import java.io.FileInputStream;

(2).构造一个数据输入流对象

FileInputStream fis= new FileInputStream("");
    DataInputStream dis = new DataInputStream(fis);

(3).利用数据输入流类的方法读取二进制文件的数据

dis.read();

(4).关闭数据输入流

dis.close();

2.使用字节流类DataOutputStream写二进制文件  
DataOutputStream类是FileOutputStream的子类，他是FileOutputStream类的拓展，利用DataOutputStream类写二进制文件的实现步骤其实与用FileOutputStream类读取文本文件的步骤及其相似，而且还要用到FileOutputStream类。  
(1).引入相关的类

import java.io.DataOutputStream;
    import java.io.FileOutputStream;

(2).构造一个数据输出流对象

FileOutputStream fos= new FileOutputStream("");
    DataOutputStream dos = new DataOutputStream(fos);

(3).利用数据输出流类的方法读取二进制文件的数据

dos.write();

(4).关闭数据输入流

dos.close();

案例：

public class DemoApplication {
        public static void main(String[] args) throws IOException {
            DataOutputStream out = null;
            DataInputStream dis = null;
            try {
                //创建输入流对象
                FileInputStream fis=new FileInputStream("");
                dis = new DataInputStream(fis);
                //创建输出流对象
                FileOutputStream fos=new FileOutputStream("");
                out = new DataOutputStream(fos);
                int temp;
                //读取文件并写入文件
                while ((temp=dis.read())!=-1){
                    out.write(temp);
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (dis!=null){
                    dis.close();
                }
                if (out!=null){
                    out.close();
                }
            }
        }
    }