文件操作File、RandomAccessFile

最新推荐文章于 2022-11-29 15:59:43 发布

亚索king

最新推荐文章于 2022-11-29 15:59:43 发布

阅读量241

点赞数

本文链接：https://blog.csdn.net/m0_53167050/article/details/114330534

版权

文件操作 File

/**
 * java.io.File可以表示硬盘上的一个文件或目录
 * 使用File可以:
 * 1.访问该文件或目录的属性信息(大小，修改日期，可读可写等)
 * 2.创建或删除文件和目录
 * 3.访问一个目录中的所有子项
 *
 * 但是File不能访问文件中的数据
 */
public class FileDemo {
    public static void main(String[] args) {
        /**
         * File创建时可以指定路线经
         * 该路径通常使用相对路径，它有更好的跨平台性
         *
         * 相对路径中“./”表示当前目录，当前目录具体是哪里要视
         * 当前程序的运行环境而定，在idea或eclipse里运行时，
         * 当前目录就是这个程序所在的项目目录
         */
        File file = new File("D:./demo.txt");
        String name = file.getName();
        System.out.println(name);

        long len = file.length();
        System.out.println(len+"字节");

        boolean cr = file.canRead();
        System.out.println("可读:"+cr);
        boolean cw = file.canWrite();
        System.out.println("可写:"+cw);
        boolean ih = file.isHidden();
        System.out.println("是否隐藏"+ih);
    }
}

package file;

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

/**
 * 使用File创建一个文件
 */
public class CreateNewFileDemo {
    public static void main(String[] args) throws IOException {
        //在当前目录下新建一个文件test.txt
        File file = new File("./test.txt");
        /*
           boolean exists()
           判断当前File表示的文件或目录是否已经存在，存在则返回true
         */
        if(file.exists()){
            System.out.println("该文件已存在");
        }else{
            //将File表示的文件创建出来
            file.createNewFile();
            System.out.println("该文件已创建");
        }
    }
}

/**
 * 删除一个文件
 */
public class DeleteFileDemo {
    public static void main(String[] args) {
        //将test.txt文件删除

        //相对路径中”./“可以不写，不写默认就是从”./“开始的
        File file = new File("test.txt");
        if(file.exists()){
            file.delete();
            System.out.println("该文件已删除");
        }else{
            System.out.println("该文件不存在");
        }
    }
}

/**
 * 使用File创建一个目录
 */
public class MKDirDemo {
    public static void main(String[] args) {
        //在当前目录下新建一个目录demo
        File dir = new File("demo");
        if(dir.exists()){
            System.out.println("该目录已存在");
        }else{
            dir.mkdir();//将当前File对象表示的目录创建出来
            System.out.println("该目录已创建");
        }
    }
}

/**
 * 创建一个多级目录
 */
public class MKDirsDemo {
    public static void main(String[] args) {
        //在当前目录下新建目录a/b/c/d/e/f
        File dir = new File("a/b/c/d/e/f");
        if(dir.exists()){
            System.out.println("该文件已存在");
        }else{
            /*
               与mkdir方法的区别是mkdirs会将所有不存在的父目录
               自动创建出来。而mkdir则不会，如果父目录不存在则创建不成功。
             */
            dir.mkdirs();
            System.out.println("该文件已创建");
        }
    }
}

/**
 * 删除目录
 */
public class DeleteDirDemo {
    public static void main(String[] args) {
        //将当前目录下的demo目录删除
        File dir = new File("demo");
        if(dir.exists()){
            //delete方法删除目录时要求该目录必须是一个空目录才可以
            dir.delete();
            System.out.println("目录已删除");
        }else {
            System.out.println("目录不存在");
        }
    }
}

/**
 * 获取一个目录中所有的子项
 */
public class ListFilesDemo {
    public static void main(String[] args) {
        //获取当前目录中所有的子项并输出
        File dir = new File(".");
        /*
           boolean isFile()
           判断当前File表示的是否为一个文件

           boolean isDirectory()
           判断当前File表示的是否为一个目录
         */
        if(dir.isDirectory()){
            File[] subs = dir.listFiles();
            System.out.println(subs.length);
            for (int i = 0; i <subs.length ; i++) {
                System.out.println(subs[i].getName());
            }
        }
    }
}

import java.io.File;
import java.io.FileFilter;

/**
 * 获取一个目录中满足指定条件的所有子项
 *
 * File[] listFiles(FileFilter filter)
 * 将当前File对象表示的目录中所有符合给定过滤器要求的子项返回。
 * 该方法会将该目录中所有的子项都经过一次给定的过滤器，然后仅保留
 * 并返回符合要求的子项。
 */
public class ListFilesDemo2 {
    public static void main(String[] args) {
        /*
           获取当前目录中的所有名字中含有字母"e"的子项
         */
        File dir = new File(".");
        if(dir.isDirectory()){
            FileFilter filter = new FileFilter() {
                public boolean accept(File file) {
                    String name = file.getName();
                    return name.contains("e");
                }
            };
            /*
               重载的listFiles方法会将dir中每个子项都经过一次给定的过滤器的accept方法，
               并最终返回所有返回为true的子项。
             */
            File[] subs = dir.listFiles(filter);
            System.out.println("子项个数:"+subs.length);
            for (int i = 0; i <subs.length ; i++) {
                System.out.println(subs[i].getName());
            }
        }
    }
}

import java.io.File;
import java.io.FileFilter;

/**
 * JDK8之后推出了一个新的特性:lambda表达式
 * lambda表达式可以用更简短的语法创建匿名内部类。
 * 语法:
 * (参数列表)->{
 *     方法体
 * }
 * 需要注意，使用lambda表达式创建时实现的接口中只能有一个抽象方法
 */
public class LambdaDemo1 {
    public static void main(String[] args) {
        //使用匿名内部类方式创建的文件过滤器
        FileFilter filter = new FileFilter() {
            public boolean accept(File file) {
                return file.getName().contains("e");
            }
        };
        //lambda表达式写法
        /*
           编译器会结合程序语义分析出实现的是哪个结构，由于要求接口只能有一个抽象方法，
           所以也能知道重写的方法是什么。最终将它还原为匿名内部类。
         */
        FileFilter filter1 = (File file)->{
            return file.getName().contains("e");
        };

        //参数类型可以忽略不写
        FileFilter filter2 = (file)->{
            return file.getName().contains("e");
        };
        /*
           当方法中只有一句代码，name方法体的“{}”可以忽略不写
           并且如果该方法要求返回值，则return关键字也要一同忽略。
         */
        FileFilter filter3 = (File file)->file.getName().contains("e");
    }
}

RandomAccessFile

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.Random;
import java.util.RandomAccess;

/**
 * java.io.RandomAccessFile
 * RAF是专门用来读写文件的类。其基于指针对文件进行随机读写。
 */
public class RAFDemo1 {
    public static void main(String[] args) throws IOException {
        //想对当前目录下的raf.dat文件进行操作
        /*
           RAF常用构造器
           RandomAccessFile(File file,String mode)
           RandomAccessFile(String path,String mode)
           第一个参数为要进行读写的文件，可以传入file对象也可以
           直接给定该文件的路径。
           第二个参数为操作模式，有两种:
           "r":只读模式，仅对该文件做读取数据操作
           “rw”:读写模式，对文件读写均可。
         */
        RandomAccessFile raf = new RandomAccessFile(
                "./raf.dat","rw"
        );
        //向文件中写入一个字节的2进制数据
        /*
           void write(int b)
           向文件中写入1个字节，写入的是给定的int值所对应的2进制的“低八位”
           int型整数1的2进制:
           00000000 00000000 00000000 00000001

           write方法写入该int值对应2进制的低八位:
                                      vvvvvvvv
           00000000 00000000 00000000 00000001
         */
        raf.write(1);
        raf.write(2);
        System.out.println("执行完毕!");
        /*
           raf.dat文件数据内容:
           00000001 00000010
         */
        raf.close();//最终要调用close方法!
    }
}

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

/**
 * 从文件中读取数据
 */
public class RAFDemo2 {
    public static void main(String[] args) throws IOException {
        RandomAccessFile raf = new RandomAccessFile("raf.dat","r");
        /*
           raf.dat文件数据
           00000001 00000010
         */
        /*
           int read()
           从文件中读取1个字节，并以int型返回。实际读取的字节是在
           返回int值对应的2进制的低八位上。
           但如果返回值为-1，则表示文件末尾。EOF:end of file
         */
        //00000000 00000000 00000000 00000001
        int d = raf.read();//1
        System.out.println(d);
        //00000000 00000000 00000000 00000010
        d= raf.read();//2
        System.out.println(d);
        //11111111 11111111 11111111 11111111
        d = raf.read();//-1 文件末尾
        System.out.println(d);
        raf.close();
    }
}

/**
 * 文件的复制
 */
public class CopyDemo {
    public static void main(String[] args) throws IOException {
        /*
           复制的原理:从原文件中顺序读取每个字节并写入到另一个文件中
         */
        RandomAccessFile src = new RandomAccessFile("love.jpg","r");
        RandomAccessFile desc = new RandomAccessFile("love_1.jpg","rw");
        /*
           love.jpg:
           10001010 00101010 11010001 11000100.....

           d:00000000 00000000 00000000 10001010

           love_.jpg:
           10001010 00101010 11010001 11000100.....
         */
        //用来记录每次读取到的字节
        int d;
        //获取当前系统时间的毫秒值
        long start = System.currentTimeMillis();
        while((d = src.read())!=-1){
            desc.write(d);
        }
        long end = System.currentTimeMillis();
        System.out.println("复制完毕！耗时"+(end-start)+"ms");
        src.close();
        desc.close();
    }
}

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

/**
 * 通过提高每次读写的数据量减少实际读写的次数可以提高读写效率。
 * 单字节读写是随机读写
 * 一组字节读写是块读写
 * 对于机械硬盘而言，单字节读写几乎没有效率可言，块读写效率很好。
 * 对于大部分硬件而言，减少硬件调用次数都可以提高效率。
 */
public class CopyDemo2 {
    public static void main(String[] args) throws IOException {
        RandomAccessFile src = new RandomAccessFile("love.jpg","r");
        RandomAccessFile desc = new RandomAccessFile("love_2.jpg","rw");

        /*
           RAF提供的块读写方法:
           块写:
           void write(byte[] data)
           一次性将给定的字节数组中所有字节写入文件

           void write(byte[] data,int offset,int len)
           一次性给定数组中从下标offset处开始的连续len个字节写入文件

           块读:
           int read(byte[] data)
           一次性从文件中读取给定的字节数组data总长度的字节量并将
           读取到的字节顺序的存入到该数组中。返回值为实际读取到的字节
           量。如果返回值为-1则表示读取到了文件末尾

           文件数据:
           10110101 00010111 10000101 01111011 000010111

           块读操作:
           byte[] data new byte[6];//6字节的数组
           data:[00000000,00000000,00000000,00000000,00000000,00000000]
           int len = raf.read(data);
           data:[10110101 00010111 10000101 01111011 000010111 00000000]
           len:5//read方法返回值为5，说明本次实际只读取到5个字节
           与单字节读取的区别:
           int d = raf.read();//读取一个字节，返回值就是实际读取的字节数据
           d:00000000 00000000 00000000 10110101//该字节放在低八位上
         */
        int len;//记录每次块读取数据后，实际读取到的字节数
        byte[] data = new byte[1024*10];//10kb
        long start = System.currentTimeMillis();
        while((len = src.read(data))!=-1){//读10kb
            desc.write(data,0,len);//读了多少字节就一次写多少字节
        }
        long end = System.currentTimeMillis();
        System.out.println("复制完毕！耗时"+(end-start)+"ms");
        src.close();
        desc.close();
    }
}

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.io.UnsupportedEncodingException;

/**
 * 向文件中写入文本数据
 */
public class WriteStringDemo {
    public static void main(String[] args) throws IOException {
        RandomAccessFile raf = new RandomAccessFile("raf.txt","rw");
        /*
           常见的支持中文的字符集:
           UTF-8:万国码，其中英文1字节，中文3字节
         */
        String str = "每个人的身上都有毛毛";
        /*
           String提供的方法:
           String[] getBytes(String csn)
           将当前字符串内容按照指定的字符集转换为一组字节
           注:字符集名字大小写无所谓。不要拼错
           该方法要求必须处理:UnsupportedEncodingException异常
           当指定的字符集合名字不对时会抛出该异常
         */
        byte[] data = str.getBytes("UTF-8");
        raf.write(data);

        str = "让我为你唱毛毛";
        data = str.getBytes("UTF-8");
        raf.write(data);
        System.out.println("写出完毕");
        raf.close();
    }
}

import java.io.*;
import java.util.Scanner;

/**
 * 简易记事本工具
 * 程序启动后要求用户输入一个文件名，然后对该文件进行写操作。
 * 之后用户在控制台输入的每一行字符串都写入到该文件中。
 * 当用户单独输入"exit"时程序退出。
 */
public class Note {
    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入文件名:");
        String fileName = scanner.nextLine();
        RandomAccessFile raf = new RandomAccessFile(fileName+".txt","rw");
        System.out.println("请输入内容:");
        while(true) {
            String line = scanner.nextLine();
            if("exit".equals(line)){
                break;
            }
            byte[] data = line.getBytes("UTF-8");
            raf.write(data);
        }
        raf.close();
        System.out.println("完毕");
    }
}

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

/**
 * 读取文本数据
 */
public class ReadStringDemo {
    public static void main(String[] args) throws IOException {
        RandomAccessFile raf = new RandomAccessFile("raf.txt","r");
        byte[] data = new byte[(int)raf.length()];
        raf.read(data);//一次性将文件所有字节读入数组
        //String的构造方法允许将给定的字节数组内容按照指定字符集还原文字
        String line = new String(data,"UTF-8");
        System.out.println(line);
        raf.close();
    }
}

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

/**
 * 使用RAF读写基本类型数据，以及RAF指针的操作
 */
public class RAFDemo3 {
    public static void main(String[] args) throws IOException {
        RandomAccessFile raf = new RandomAccessFile("raf.dat","rw");
        //获取RAF的指针位置，默认从0开始
        long pos = raf.getFilePointer();
        System.out.println("pos:"+pos);//0
        /*
           向文件写入一个int最大值
           int最大值的二进制:
           01111111 11111111 11111111 11111111
           imax>>>24
           00000000 00000000 00000000 01111111
           imax>>>16
           00000000 00000000 01111111 11111111
           imax>>>8
           00000000 01111111 11111111 11111111
           raf.dat文件数据:
           01111111 11111111 11111111 11111111
         */
        int imax = Integer.MAX_VALUE;
        raf.write(imax>>>24);
        System.out.println("pos:"+raf.getFilePointer());//1
        raf.write(imax>>>16);
        raf.write(imax>>>8);
        raf.write(imax);
        System.out.println("pos:"+raf.getFilePointer());//4
        /*
           RAF提供了方便写出来基本类型数据的方法
         */
        raf.writeInt(imax);//连续写4个字节，将int值写出，等同上面的4句代码
        System.out.println("pos:"+raf.getFilePointer());//8
        raf.writeLong(123L);
        System.out.println("pos:"+raf.getFilePointer());//16
        raf.writeDouble(123.123);
        System.out.println("pos:"+raf.getFilePointer());//24

        System.out.println("写出完毕");
        int d = raf.read();
        System.out.println(d);//-1
        
        raf.seek(0);
        System.out.println("pos:"+raf.getFilePointer());//0
        int d = raf.readInt();
        System.out.println(d);//int最大值
        System.out.println("pos:"+raf.getFilePointer());//4
        
        //读取long值
        raf.seek(8);
        long l = raf.readLong();
        System.out.println(l);//123
        System.out.println("pos:"+raf.getFilePointer());//16

        double dou = raf.readDouble();
        System.out.println(dou);//123.123
        System.out.println("pos:"+raf.getFilePointer());//24

        //修改raf.dat文件中long所在位置的值改为456
        //1.将指针移动到long值的开始位置
        raf.seek(8);
        //2.重组写入新的long值来覆盖原有的数据
        raf.writeLong(456L);

        raf.seek(8);
        l = raf.readLong();
        System.out.println(l);

        raf.close();
    }
}

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Scanner;

/**
 * 用户注册
 * 程序启动后要求用户顺序输入用户名，密码，昵称，年龄
 * 然后将该纪录写入文件user.dat中保存
 *
 * 每条记录站占用固定的100字节，其中用户名，密码，昵称为字符串，各占
 * 32字节。年龄为int值占4字节。
 *
 */
public class RegDemo {
    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);
        System.out.println("欢迎注册!");
        System.out.println("请输入用户名:");
        String username = scanner.nextLine();
        System.out.println("请输入密码:");
        String password = scanner.nextLine();
        System.out.println("请输入昵称:");
        String nickname = scanner.nextLine();
        System.out.println("请输入年龄:");
        int age = scanner.nextInt();

        RandomAccessFile raf = new RandomAccessFile("user.dat","rw");
        //将指针移动到文件末尾，以便追加记录
        raf.seek(raf.length());

        //写用户名
        byte[] data = username.getBytes("UTF-8");
        data = Arrays.copyOf(data,32);
        raf.write(data);

        //写密码
        data = password.getBytes("UTF-8");
        data = Arrays.copyOf(data,32);
        raf.write(data);

        //写用户名
        data = nickname.getBytes("UTF-8");
        data = Arrays.copyOf(data,32);
        raf.write(data);

        //写年龄
        raf.writeInt(age);
        System.out.println("注册完毕!");
        raf.close();
    }
}

/**
 * 将User.dat文件中所有用户信息读取出来并输出到控制台
 */
public class ShowAllUserDemo {
    public static void main(String[] args) throws IOException {
        RandomAccessFile raf = new RandomAccessFile("user.dat","r");

        for (int i = 0; i <raf.length()/100 ; i++) {
        //读取用户名
        byte[] data = new byte[32];
        raf.read(data);
        String username = new String(data,"UTF-8").trim();
        //读取密码
        raf.read(data);
        String password = new String(data,"UTF-8").trim();
        //读取昵称
        raf.read(data);
        String nickname = new String(data,"UTF-8").trim();
        //读取年龄
        int age = raf.readInt();
        System.out.println(username+","+password+","+nickname+","+age);
    }
        raf.close();
    }
}

亚索king

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
文件操作File、RandomAccessFile

文件操作 File/** * java.io.File可以表示硬盘上的一个文件或目录 * 使用File可以: * 1.访问该文件或目录的属性信息(大小，修改日期，可读可写等) * 2.创建或删除文件和目录 * 3.访问一个目录中的所有子项 * * 但是File不能访问文件中的数据 */public class FileDemo { public static void main(String[] args) { /** * File创建时可以指定
复制链接

扫一扫