JAVASE02-Unit06： 文件操作——File 、 文件操作—— RandomAccessFile

　　　　Unit06： 文件操作——File 、 文件操作—— RandomAccessFile　　　　

java.io.File
File的每一个实例是用来表示文件系统中的一个文件或目录

package day06;

import java.io.File;

/**
 * java.io.File
 * File的每一个实例是用来表示文件系统中的一个
 * 文件或目录
 * 使用File可以:
 * 1:访问文件或目录的属性信息
 * 2:操作文件或目录(创建，删除)
 * 3:访问一个目录的子项
 * 但是不能:
 * 访问文件数据。
 * @author adminitartor
 *
 */
public class File_Properties {
    public static void main(String[] args) {
        /*
         * 描述路径时应当使用相对路径。
         * 常用相对路径:
         * 类加载路径
         *
         * 当前目录"."，在eclipse下是当前类所在
         * 项目的跟目录(jsd1611_se这个目录)
         */
        File file = new File(
            "."+File.separator+"demo.txt"
        );

        String name = file.getName();
        System.out.println("name:"+name);

        long length = file.length();
        System.out.println("length:"+length);

        boolean canRead = file.canRead();
        boolean canWrite = file.canWrite();

        System.out.println("可读:"+canRead);
        System.out.println("可写:"+canWrite);
        //最后修改时间
        long time = file.lastModified();

        boolean isHidden = file.isHidden();
    }
}

File_Properties.java

使用File创建一个文件

package day06;

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

/**
 * 使用File创建一个文件
 * @author adminitartor
 *
 */
public class File_CreateNewFile {
    public static void main(String[] args) throws IOException {
        /*
         * 当前目录下创建一个名为test.txt的文件
         */
        File file = new File("test.txt");
        /*
         * boolean exists()
         * 判断当前File表示的文件或目录是否已经真实
         * 存在
         */
        if(!file.exists()){
            /*
             * 创建File表示的文件
             */
            file.createNewFile();
            System.out.println("文件已创建!");
        }else{
            System.out.println("文件已存在!");
        }

    }
}

File_CreateNewFile.java

删除一个文件

package day06;

import java.io.File;

/**
 * 删除一个文件
 * @author adminitartor
 *
 */
public class File_Delete {
    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_Delete.java

创建一个目录

package day06;

import java.io.File;

/**
 * 创建一个目录
 * @author adminitartor
 *
 */
public class File_Mkdir {
    public static void main(String[] args) {
        /*
         * 当前目录下创建一个目录demo
         */
        File dir = new File("demo");
        if(!dir.exists()){
            dir.mkdir();
            System.out.println("目录创建完毕!");
        }else{
            System.out.println("该目录已存在!");
        }

    }
}

File_Mkdir.java

创建一个多级目录

package day06;

import java.io.File;

/**
 * 创建一个多级目录
 * @author adminitartor
 *
 */
public class File_Mkdirs {
    public static void main(String[] args) {
        /*
         * 在当前目录下创建目录:
         * a/b/c/d/e/f
         */
        File dir = new File(
            "a"+File.separator+
            "b"+File.separator+
            "c"+File.separator+
            "d"+File.separator+
            "e"+File.separator+
            "f"
        );
        if(!dir.exists()){
            /*
             * 在创建File表示的目录同时将所有
             * 不存在的父目录自动创建出来
             */
            dir.mkdirs();
            System.out.println("目录已创建!");
        }else{
            System.out.println("该目录已存在!");
        }

    }
}

File_Mkdirs.java

删除一个目录

package day06;

import java.io.File;

/**
 * 删除一个目录
 * @author adminitartor
 *
 */
public class File_Delete2 {
    public static void main(String[] args) {
        File dir = new File("a");
        if(dir.exists()){
            /*
             * 若删除目录，必须保证该目录是一个
             * 空目录(不含有任何子项)
             */
            dir.delete();
            System.out.println("删除目录完毕!");
        }else{
            System.out.println("该目录不存在!");
        }
    }
}

File_Delete2.java

获取一个目录中的所有子项

package day06;

import java.io.File;

/**
 * 获取一个目录中的所有子项
 * @author adminitartor
 *
 */
public class File_ListFiles {
    public static void main(String[] args) {
        /*
         * 查看当前目录下的所有子项
         */
        File dir = new File(".");
        /*
         * boolean isFile()
         * 判断当前File表示的是否是一个文件
         * boolean isDirectory()
         * 判断当前File表示的是否是一个目录
         */
        if(dir.isDirectory()){
            File[] subs = dir.listFiles();
            for(File sub : subs){
                if(sub.isFile()){
                    System.out.print("文件:");
                }else{
                    System.out.print("目录:");
                }
                System.out.println(sub.getName());
            }
        }
    }
}

File_ListFiles.java

（用递归实现）编写一个方法，用来将给定的File表示的文件或目录删除

package day06;

import java.io.File;

/**
 * 编写一个方法，用来将给定的File表示的文件或
 * 目录删除
 * @author adminitartor
 *
 */
public class Test {
    public static void main(String[] args) {
        File dir = new File("a");
        delete(dir);
    }
    public static void delete(File f){
        //若是一个目录，需要先将其所有子项删除
        if(f.isDirectory()){
            File[] subs = f.listFiles();
            for(File sub : subs){
                delete(sub);
            }
        }
        f.delete();
    }
}

/*
 * 1:编写一段代码，实现1+2+3+....100
 *   并输出结果。
 *   要求在整段代码中不得出现while,for关键字
 *
 * 2:一个人有20块钱，去买汽水
 *   1块钱1瓶汽水，3个瓶盖可以换一瓶汽水，2个
 *   空瓶可以换一瓶汽水，问:总共可以喝多少瓶汽水
 *
 */

Test.java

* File提供了一个重载的listFiles方法，允许传入
 * 一个文件过滤器java.io.FileFilter,然后将满足
 * 该过滤器要求的子项返回。

package day06;

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

/**
 * File提供了一个重载的listFiles方法，允许传入
 * 一个文件过滤器java.io.FileFilter,然后将满足
 * 该过滤器要求的子项返回。
 * @author adminitartor
 *
 */
public class File_ListFiles2 {
    public static void main(String[] args) {
        File dir = new File(".");
        /*
         * 获取当前目录下所有的文本文件
         */
        FileFilter filter = new FileFilter(){
            /**
             * 过滤器中的accept方法的作用是定义过滤
             * 规则。若给定的File对象满足要求则返回
             * true。listFiles方法将来就会将所有满足
             * 要求的子项返回。
             */
            public boolean accept(File f) {
                String fileName = f.getName();
                System.out.println("正在过滤:"+fileName);
                return fileName.endsWith(".txt");
            }
        };

        File[] subs = dir.listFiles(filter);
        for(File sub : subs){
            System.out.println(sub.getName());
        }
    }
}

File_ListFiles2.java

java.io.RandomAccessFile
 用于读写文件数据

package day06;

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

/**
 * java.io.RandomAccessFile
 * 用于读写文件数据，读写操作是基于指针进行的，即
 * RAF总是在指针位置读写字节，并且指针会自动向后
 * 移动。
 * RAF有两种常用的创建模式:
 * "r":只读模式，仅对文件进行读取操作
 * "rw":读写模式，对文件又读又写
 *
 * @author adminitartor
 *
 */
public class RandomAccessFile_Write {
    public static void main(String[] args) throws IOException {
        /*
         * RandomAccessFile提供的常用构造方法:
         * RandomAccessFile(String path,String mode)
         * RandomAccessFile(File file,String mode)
         *
         * mode对应的就是操作模式:"rw","r"
         */
        RandomAccessFile raf
            = new RandomAccessFile(
                "raf.dat","rw"
            );
        /*
         * void write(int d)
         * 将给定的int值对应的2进制的"低八位"写
         * 入文件.写出1个字节
         *                            vvvvvvvv
         * 00000000 00000000 00000000 00000001
         */
        raf.write(1);
        System.out.println("写出完毕!");
        raf.close();
    }
}

RandomAccessFile_Write.java

使用RandomAccessFile读取文件数据

package day06;

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

/**
 * 使用RandomAccessFile读取文件数据
 * @author adminitartor
 *
 */
public class RandomAccessFile_Read {
    public static void main(String[] args) throws IOException {
        RandomAccessFile raf
            = new RandomAccessFile(
                "raf.dat","r"
            );
        /*
         * 读取一个字节，并以10进制形式的int值
         * 返回。若返回值为-1,则表示读取到了文件
         * 的末尾。
         *
         * 00000000 00000000 00000000 00000001
         */
        int d = raf.read();//
        System.out.println(d);

        d = raf.read();
        System.out.println(d);//?

        raf.close();
    }
}

RandomAccessFile_Read.java

复制文件

package day06;

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

/**
 * 复制文件
 * @author adminitartor
 *
 */
public class CopyDemo1 {
    public static void main(String[] args) throws IOException {
        RandomAccessFile src
            = new RandomAccessFile(
                "mv.mp4","r"
            );

        RandomAccessFile desc
            = new RandomAccessFile(
                "mv_cp.mp4","rw"
            );

        int d = -1;

        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();
    }
}

CopyDemo1.java

若想提高读写效率，可以通过提高每次读写的数据量减少读写次数来达到

package day06;

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

/**
 * 若想提高读写效率，可以通过提高每次读写的数据
 * 量减少读写次数来达到
 * @author adminitartor
 *
 */
public class CopyDemo2 {
    public static void main(String[] args) throws IOException {
        RandomAccessFile src
            = new RandomAccessFile(
                "mv.mp4","r"
            );

        RandomAccessFile desc
            = new RandomAccessFile(
                "mv_cp2.mp4","rw"
            );

        /*
         * int read(byte[] data)
         * 一次性读取给定字节数组长度的字节量，并
         * 将读取到的字节存入到该数组中。返回值为
         * 实际读取到的字节量，若本次没有读取到任
         * 何字节(文件末尾)则返回值为-1
         */
        // 10k
        byte[] buf = new byte[1024*10];
        //表示每次实际读取到的字节量
        int len = -1;

        long start = System.currentTimeMillis();
        while( (len = src.read(buf)) !=-1 ){
            /*
             * void write(byte[] data)
             * 将给定的字节数组中的所有字节一次性
             * 写出
             *
             * void write(byte[] data,int i,int len)
             * 将给定的字节数组中从下标为i处的字节开始的连续
             * len个字节写出
             */
            desc.write(buf,0,len);
        }

        long end = System.currentTimeMillis();
        System.out.println("复制完毕!耗时:"+(end-start)+"ms");

        src.close();
        desc.close();
    }
}

CopyDemo2.java

使用RAF读写数据，以及理解基于指针的操作

package day06;

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

/**
 * 使用RAF读写数据，以及理解基于指针的操作
 * @author adminitartor
 *
 */
public class RandomAccessFile_RW_DATA {
    public static void main(String[] args) throws IOException {
        RandomAccessFile raf
            = new RandomAccessFile(
                "raf.dat","rw"
            );
        //获取指针当前位置
        long pos = raf.getFilePointer();
        System.out.println("pos:"+pos);

        //向文件中写入int值
        int max = Integer.MAX_VALUE;
        /*
         *                            vvvvvvvv
         * 01111111 11111111 11111111 11111111
         */
        raf.write(max>>>24);

        System.out.println("pos:"+raf.getFilePointer());

        raf.write(max>>>16);
        raf.write(max>>>8);
        raf.write(max);
        System.out.println("pos:"+raf.getFilePointer());
        /*
         * void writeInt(int d)
         * 将给定的int值对应的4个字节的2进制
         * 写入文件
         */
        raf.writeInt(max);
        System.out.println("pos:"+raf.getFilePointer());

        raf.writeDouble(123.123);
        System.out.println("pos:"+raf.getFilePointer());

        raf.writeLong(1234L);
        System.out.println("pos:"+raf.getFilePointer());

        System.out.println("写出完毕!");

        /*
         * void seek(long pos)
         * 将指针移动到指定位置
         */
        //移动到文件最开始
        raf.seek(0);
        System.out.println("pos:"+raf.getFilePointer());
        /*
         * RAF提供了方便读取基本类型的方法
         * 如:
         * int readInt()
         * 该方法会连续读取4个字节并转换为int值
         * 返回，若在文件末尾读取，则抛出
         * EOFException这个异常.
         * End Of File 文件末尾
         */
        int n = raf.readInt();
        System.out.println(n);
        System.out.println("pos:"+raf.getFilePointer());

        //读取long
        raf.seek(16);
        long l = raf.readLong();
        System.out.println(l);
        System.out.println("pos:"+raf.getFilePointer());

        //读取double
        raf.seek(8);
        double d = raf.readDouble();
        System.out.println(d);

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

        raf.close();
    }
}

RandomAccessFile_RW_DATA.java

读写字符串

package day06;

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

/**
 * 读写字符串
 * @author adminitartor
 *
 */
public class RandomAccessFile_RW_String {
    public static void main(String[] args) throws IOException {
        RandomAccessFile raf
            = new RandomAccessFile(
                "raf.txt","rw"
            );

        String str = "简单点,说话的方式简单点.";
        /*
         * byte getBytes()
         * byte getBytes(String csn)
         * 字符串提供了将内容转换为一组字节的方法。
         * 无参的是按照系统默认字符集，有参数的
         * 则是按照给定名字的字符集转换。
         */
        byte[] data = str.getBytes("UTF-8");
        raf.write(data);

        str = "递进的情绪请省略，你又不是个演员，别设计那些情节";
        raf.write(str.getBytes("UTF-8"));

        System.out.println("写出完毕!");

        raf.seek(0);
        byte[] array = new byte[200];
        int len = raf.read(array);
        /*
         * String提供了构造方法可以将给定的字节数组
         * 按照指定的字符集转换为字符串内容
         */
        String s = new String(array,0,len,"UTF-8");
        System.out.println(s);

        raf.close();
    }
}

RandomAccessFile_RW_String.java