文件 File

文件

1. 文件的一些常用方法

package com.ljw.study;

import java.io.File;
import java.util.Arrays;
import java.util.Date;

public class FileDemo {

    public static void main(String[] args) {
        // 构造文件对象
        // 绝对路径，构造文件夹对象
        File f1 = new File("d:/work/code/ljw/Test");
        System.out.println(f1.exists()); // 文件是否存在

        // 相对路径,如果是eclipse的话，就是相对于项目目录
        File f2 = new File("employee.ser");
        System.out.println("f2的绝对路径：" + f2.getAbsolutePath());
        System.out.println(f2.exists());

        // 以f1为父目录创建文件对象
        File f3 = new File(f1,"LOL.exe");
        System.out.println("f3的绝对路径：" + f3.getAbsolutePath());

        System.out.println(f2.isDirectory()); // 是否是文件夹

        System.out.println(f2.isFile()); // 是否为文件(非文件夹)

        System.out.println(f2.length()); // 文件长度

        System.out.println(new Date(f2.lastModified())); // 最后的修改时间

//      System.out.println(f2.renameTo(new File("employee.ser")));// 文件重命名

        System.out.println(Arrays.toString(f1.list())); // 以字符串数组的形式，返回当前文件夹下的所有文件（不包含子文件及子文件夹）

        System.out.println(Arrays.toString(f1.listFiles())); // 以文件数组的形式，返回当前文件夹下的所有文件（不包含子文件及子文件夹）

        // 以字符串形式返回获取所在文件夹
        System.out.println(f1.getParent());

        // 以文件形式返回获取所在文件夹
        f2.getParentFile();
        // 创建文件夹，如果父文件夹skin不存在，创建就无效
        f1.mkdir();

        // 创建文件夹，如果父文件夹skin不存在，就会创建父文件夹
        f1.mkdirs();

        // 创建一个空文件,如果父文件夹skin不存在，就会抛出异常
        f1.createNewFile();
        // 所以创建一个空文件之前，通常都会创建父目录
        f1.getParentFile().mkdirs();

        // 列出所有的盘符c: d: e: 等等
        f1.listRoots();

        // 刪除文件
        f.delete();

        // JVM结束的时候，刪除文件，常用于临时文件的删除
        f.deleteOnExit()
    }
}

2. 读取和写入文件数据

2.1 以字节流方式

2.1.1 读取数据

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class TestStream {

    public static void main(String[] args) {
        try {
            //准备文件lol.txt其中的内容是AB，对应的ASCII分别是65 66
            File f =new File("d:/lol.txt");
            //创建基于文件的输入流
            FileInputStream fis =new FileInputStream(f);
            //创建字节数组，其长度就是文件的长度
            byte[] all =new byte[(int) f.length()];
            //以字节流的形式读取文件所有内容
            fis.read(all);
            for (byte b : all) {
                //打印出来是65 66
                System.out.println(b);
            }

            //每次使用完流，都应该进行关闭
            fis.close();

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

2.1.2 写入数据

package com.ljw.practice;

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

public class FileDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        File f = new File("d:/xyz/abc/def/lol2.txt");
        f.getParentFile().mkdirs();

        try {
            FileOutputStream outputFile = new FileOutputStream(f);
            String s = "秋天，多了一些思念";
            byte[] b = s.getBytes(); // 将字符串转换为字节数组byte[]
            outputFile.write(b);
            outputFile.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

2.2 以字符流方式

2.2.1 读取数据


package com.ljw.practice;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class FileDemo {

    public static void main(String[] args) {
        File f = new File("d:/lol.txt");

        try(FileReader fr = new FileReader(f)){ // 数据流写在try()里面，系统会帮我们自动关闭数据流
            char[] c = new char[(int) f.length()];
            fr.read(c);
            for(char i:c) {
                System.out.print(i);
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

2.2.2 写入数据


package com.ljw.practice;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileDemo {

    public static void main(String[] args) {
        File f = new File("d:/lol.txt");
        File f2 = new File("d:/lol2.txt");

        try(FileReader fr = new FileReader(f);FileWriter fw = new FileWriter(f2)){
            char[] c = new char[(int) f.length()];
            fr.read(c); // 读出数据到字符数组
            fw.write(c); // 写入数据从数组到文件
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

2.3 以缓存流方式

  • 缓存流必须建立在一个存在的流的基础上
  • 以介质是硬盘为例，字节流和字符流的弊端：在每一次读写的时候，都会访问硬盘。 如果读写的频率比较高的时候，其性能表现不佳。
  • 为了解决以上弊端，采用缓存流。缓存流在读取的时候，会一次性读较多的数据到缓存中，以后每一次的读取，都是在缓存中访问，直到缓存中的数据读取完毕，再到硬盘中读取。
  • 如果需要立即将缓存中的数据写入硬盘，可以使用flush()方法

2.3.1 读取数据


package stream;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class TestStream {
    public static void main(String[] args) {
        File f = new File("d:/lol.txt");
        // 创建文件字符流
        // 缓存流必须建立在一个存在的流的基础上
        try (
                FileReader fr = new FileReader(f);
                BufferedReader br = new BufferedReader(fr);
            )
        {
            while (true) {
                // 一次读一行
                String line = br.readLine();
                if (null == line)
                    break;
                System.out.println(line);
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

2.3.2 写入数据

package com.ljw.practice;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class FileDemo {

    public static void main(String[] args) {
        File f = new File("d:/lol2.txt");

        try (
                // 创建文件字符流
                FileWriter fw = new FileWriter(f);
                // 缓存流必须建立在一个存在的流的基础上
                PrintWriter pw = new PrintWriter(fw);
        ) {
            pw.println("garen kill teemo");
            pw.println("teemo revive after 1 minutes");
            pw.println("teemo try to garen, but killed again");
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

2.4 以数据流方式

  • 使用数据流的writeUTF()和readUTF() 可以进行数据的格式化顺序读写
  • 要用DataInputStream 读取一个文件，这个文件必须是由DataOutputStream 写出的，否则会出现EOFException，因为DataOutputStream 在写出的时候会做一些特殊标记，只有DataInputStream 才能成功的读取。

2.4.1 实例

  • 以数据流的方式读写数据
package com.ljw.practice;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileDemo {

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

    private static void read() {
        File f = new File("d:/lol2.txt");
        try(
                FileInputStream fi = new FileInputStream(f);
                DataInputStream di = new DataInputStream(fi); // 创建一个数据流对象
            )
        {
            boolean b = di.readBoolean();
            int i = di.readInt();
            String s = di.readUTF();
            System.out.println(b);
            System.out.println(i);
            System.out.println(s);

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }

    }

    private static void write() {
        File f = new File("d:/lol2.txt");

        try(
                FileOutputStream fo = new FileOutputStream(f);
                DataOutputStream dos = new DataOutputStream(fo);
            )
        {
            dos.writeBoolean(false);
            dos.writeInt(200);
            dos.writeUTF("中国");

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

2.5 以对象流(序列化对象)

  • 把一个对象序列化有一个前提是：这个对象的类，必须实现了Serializable接口
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

import charactor.Hero;

public class TestStream {

    public static void main(String[] args) {
        //创建一个Hero garen
        //要把Hero对象直接保存在文件上，务必让Hero类实现Serializable接口
        Hero h = new Hero();
        h.name = "garen";
        h.hp = 616;

        //准备一个文件用于保存该对象
        File f =new File("d:/garen.lol");

        try(
            //创建对象输出流
            FileOutputStream fos = new FileOutputStream(f);
            ObjectOutputStream oos =new ObjectOutputStream(fos);
            //创建对象输入流
            FileInputStream fis = new FileInputStream(f);
            ObjectInputStream ois =new ObjectInputStream(fis);
        ) {
            oos.writeObject(h);
            Hero h2 = (Hero) ois.readObject();
            System.out.println(h2.name);
            System.out.println(h2.hp);

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

3. 拆分文件 和 合并文件

3.1 拆分文件

package com.ljw.practice;

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

public class FileDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        File file = new File("d:/F.docx");

        try {
            FileInputStream inFile = new FileInputStream(file);
            int i = 1;
            while(true) {
                byte[] b = new byte[1024*100];
                int n = inFile.read(b);
                if(n==-1) {  // 没有读到数据返回 -1
                    break;
                }
                File f1 = new File(String.format("d:/F-%d.docx",i)); // 占位符
                FileOutputStream outFile = new FileOutputStream(f1);
                outFile.write(b);
                i++;
            }   

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

3.2 合并文件

package com.ljw.practice;

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

public class FileDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        File newF = new File("d:/newF.docx");
        try {
            FileOutputStream outNewF = new FileOutputStream(newF);
            for(int i=1;i<5;i++) {
                File f = new File(String.format("d:/F-%d.docx", i));
                byte[] b = new byte[(int) f.length()];
                FileInputStream inf = new FileInputStream(f);
                inf.read(b);
                outNewF.write(b);
                inf.close();
            }
            outNewF.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

4. 中文问题

package com.ljw.practice;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class FileDemo {

    public static void main(String[] args) {
        File f = new File("d:/lol.txt");
        try (FileInputStream fis = new FileInputStream(f);) {
            byte[] all = new byte[(int) f.length()];
            fis.read(all);

            //文件中读出来的数据是
            System.out.println("文件中读出来的数据是：");
            for (byte b : all)
            {
                int i = b&0xff;  //只取16进制的后两位
                System.out.println(Integer.toHexString(i));
            }
            System.out.println("把这个数字，放在GBK的棋盘上去：");
            String str = new String(all,"GBK");
            System.out.println(str);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

综合练习

  • 复制文件或文件夹
  • 查找指定的内容
package com.ljw.practice;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;

public class FilePractice {

    public static void main(String[] args) {
        //----------复制文件--------------
        File srcFile = new File("d:/lol.txt");
        File destFile = new File("d:/lol3.txt");
        copyFile(srcFile,destFile);

        //----------复制文件夹------------
        File srcFolder = new File("d:/xyz");
        File destFolder = new File("d:/xyz-副本");
        copyFolder(srcFolder,destFolder);

        //----------查找---------------
        String s = "hello";
        findFileContent(s, srcFolder);

    }

    /**
     * 复制文件
     * @param srcFile：源文件
     * @param destFile：目标文件
     * @return void
     */
    public static void copyFile(File srcFile, File destFile) {
        if(srcFile.exists()) {
            try(
                    // 创建读取文件流对象
                    FileInputStream fi = new FileInputStream(srcFile);
                    // 创建写入文件流对象
                    FileOutputStream fo = new FileOutputStream(destFile);

                )
            {
                byte[] b = new byte[10];
                int i;
                while(true) {
                    i = fi.read(b);
                    if(-1==i) {
                        break;
                    }
                    fo.write(b,0,i);
                }
            } catch (FileNotFoundException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
        }else {
            System.out.println("文件不存在");
        }
    }

    /**
     * 复制文件夹
     * @param srcFile
     * @param destFile
     */
    public static void copyFolder(File srcFile, File destFile) {
        if(srcFile.isDirectory()) {
            File[] files = srcFile.listFiles();
            destFile.mkdir();
            for(File f:files) {
                if(f.isDirectory()) {
                    String newFolderPath = destFile.getAbsolutePath()+"\\"+f.getName();
                    File newFolder = new File(newFolderPath);
                    newFolder.mkdir();
                    System.out.println("新文件夹的位置是："+newFolderPath);
                    copyFolder(f,newFolder);
                }else {
                    String newFilePath = destFile.getAbsolutePath()+"\\"+f.getName();
                    System.out.println("新文件的位置是："+newFilePath);
                    File newF = new File(newFilePath);
                    copyFile(f,newF);
                }
            }
        }else {
            copyFile(srcFile, destFile);
        }
    }

    /**
     * 查找指定的文件内容
     * @param s：要查找的字符串
     * @param file：要查找的文件对象
     */
    public static void findFileContent(String s,File file) {
        if(file.isDirectory()) {
            File[] files = file.listFiles();
            for(File f:files) {
                findFileContent(s,f);
            }
        }else {
            try(
                    FileReader fr = new FileReader(file);
                    BufferedReader br = new BufferedReader(fr);
                ) {

                while(true) {
                    String str = br.readLine();
                    if(null == str) {break;}
                    if(str.contains(s)) {
                        System.out.println("找到目标字符串"+s+",在文件："+file.getAbsolutePath());
                        break;
                    }
                }

            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
        }
    }
}

原文地址：https://www.cnblogs.com/ljw1994/p/11823866.html

时间： 2024-08-29 14:40:28

文件 File的相关文章

Java学习记录(补充八:Date类;Java流(Stream),文件(File)和IO)

Date类,Calendar类package Box1; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; import java.util.Random; //Date类 public class DateTest { public static void main(String[] args) { Date

流Stream 文件File 流IO

Java 流(Stream).文件(File)和IO Java.io 包几乎包含了所有操作输入.输出需要的类.所有这些流类代表了输入源和输出目标. Java.io 包中的流支持很多种格式,比如:基本类型.对象.本地化字符集等等. 一个流可以理解为一个数据的序列.输入流表示从一个源读取数据,输出流表示向一个目标写数据. Java 为 I/O 提供了强大的而灵活的支持,使其更广泛地应用到文件传输和网络编程中. 但本节讲述最基本的和流与 I/O 相关的功能.我们将通过一个个例子来学习这些功能. 读取控

文件File

前面的话 不能直接访问用户计算机中的文件,一直都是Web应用开发中的一大障碍.2000年以前,处理文件的唯一方式就是在表单中加入<input type="file">字段,仅此而已.FileAPI(文件API)的宗旨是为Web开发人员提供一种安全的方式,以便在客户端访问用户计算机中的文件,并更好地对这些文件执行操作.本文将详细介绍文件File API [注意]IE9-浏览器不支持 File File API在表单中的文件输入字段的基础上,又添加了一些直接访问文件信息的接口.

Java流(Stream)、文件(File)和IO

Java流(Stream).文件(File)和IO Java.io包几乎包含了所有操作输入.输出需要的类.所有这些流类代表了输入源和输出目标. Java.io包中的流支持很多种格式,比如:基本类型.对象.本地化字符集等等. 一个流可以理解为一个数据的序列.输入流表示从一个源读取数据,输出流表示向一个目标写数据. Java为I/O提供了强大的而灵活的支持,使其更广泛地应用到文件传输和网络编程中. 但本节讲述最基本的和流与I/O相关的功能.我们将通过一个个例子来学习这些功能. 读取控制台输入 Jav

Java笔记：Java 流(Stream)、文件(File)和IO

更新时间:2018-1-7 12:27:21 更多请查看在线文集:http://android.52fhy.com/java/index.html java.io 包几乎包含了所有操作输入.输出需要的类.所有这些流类代表了输入源和输出目标. 输入输出流 简介 一个流被定义为一个数据序列.输入流用于从源读取数据,输出流用于向目标写数据. 下图是一个描述输入流和输出流的类层次图: 在java.io包中操作文件内容的主要有两大类:字节流.字符流,两类都分为输入和输出操作. 在字节流中输出数据主要是使用

Java ——流(Stream)、文件(File)和IO

本节重点思维导图 示例:将指定的字符写到文件中 public static void main(String[] args) { try { //1.创建一个空的文件 File file = new File("abc.txt"); if (!file.exists()) { file.createNewFile(); } //2.准备数据 StringBuffer data = new StringBuffer(); for(int i = 0;i<8000;i++) { da

Java 流(Stream)、文件(File)和IO

Java.io包几乎包含了所有操作输入.输出需要的类.所有这些流类代表了输入源和输出目标. Java.io包中的流支持很多种格式,比如:基本类型.对象.本地化字符集等等. 一个流可以理解为一个数据的序列.输入流表示从一个源读取数据,输出流表示向一个目标写数据. Java为I/O提供了强大的而灵活的支持,使其更广泛地应用到文件传输和网络编程中. 但本文讲述最基本的和流与I/O相关的功能.我们将通过一个个例子来学习这些功能. 读取控制台输入 Java的控制台输入由System.in完成. 为了获得一

python高效运用（十）———文件(File)、输入输出的基本操作

1. Python 文件I/O 本章只讲述所有基本的的I/O函数,更多函数请参考Python标准文档. 2.打印到屏幕 最简单的输出方法是用print语句,你可以给它传递零个或多个用逗号隔开的表达式.此函数把你传递的表达式转换成一个字符串表达式,并将结果写到标准输出如下: 示例1: #!/usr/bin/env python # -*- coding: utf-8 -*- # @Time : 2016/9/25 15:12 # @Author : wwyx print "python 是一门面向

IO流 文件File 的listFiles 方法（重要）

package com.yyq; import java.io.*; //File 类 /* * 用来将文件或者文件夹封装成对象 * 方便对文件和文件夹的属性信息进行操作 * File对象可以作为参数传递给流的构造函数 * 流只能处理数据 * */ /* * File 类的常见方法: * 1.创建 * boolean createNewFile() * 在指定位置创建文件,如果该文件已经存在,则不创建,返回false * 和输出流不一样,输出流对象--创建文件,文件存在会覆盖. * mkdir