文件操作File类和IO流

 

File 类

java.io包

File的对象创建：

public class TestFile1 {
    public static void main(String[] args) {
        File file1=new File("D:\\hello.txt");
        if(file1.exists()) {
            System.out.println("文件存在");
        }else {
            System.out.println("文件不存在");
        }
        File file2=new File("D:\\","test.txt");
        if(file2.exists()) {
            System.out.println("文件存在");
        }else {
            System.out.println("文件不存");
        }
        File file=new File("D:\\");
        File file3=new File(file,"test.txt");
        if(file3.exists()) {
            System.out.println("文件存在");
        }else {
            System.out.println("文件不存在");
        }
    }
}

File的createNewFile()方法: 当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件.

返回： 
如果指定的文件不存在并成功地创建，则返回 true；如果指定的文件已经存在，则返回 false 

public class TestFie2 {
    public static void main(String[] args) throws IOException {
        File file=new File("D:\\test.txt");
        if(file.exists()) {
            System.out.println("文件存在");
        }else {
            //创建这个文件
            if(file.createNewFile()) {
                System.out.println("文件创建成功!");
            }
        }
    }
}

mkdir

public boolean mkdir() 创建此抽象路径名指定的目录。

public class TestFile3 {
    public static void main(String[] args) throws IOException {
        File path = new File("D:\\mydir");
        File myfile = new File(path, "test.txt");
        if (!path.exists()) {
            if (path.mkdir()) {
                if (!myfile.exists()) {
                    if (myfile.createNewFile()) {
                        System.out.println("文件创建成功!");
                    }
                }
            }
        }
    }
}

mkdirs

public boolean mkdirs() 创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。注意，此操作失败时也可能已经成功地创建了一部分必需的父目录。

public class TestFile4 {
    public static void main(String[] args) throws IOException {
        File path=new File("D:\\newdir\\myfile");
        File file=new File(path,"test.txt");
        if(!path.exists()) {
            if(path.mkdirs()) {
                if(!file.exists()) {
                    if(file.createNewFile()) {
                        System.out.println("文件创建成功!");
                    }
                }
            }
        }
    }
}

delete

public boolean delete( 删除此抽象路径名表示的文件或目录。如果此路径名表示一个目录，则该目录必须为空才能删除。

public class TestFile5 {
    public static void main(String[] args) {
        File file=new File("D:\\newdir\\myfile\\test.txt");
        if(file.delete()) {
            System.out.println("删除成功!");
        }else {
            System.out.println("删除失败!");
        }
    }
}

getName

public String getName() 返回由此抽象路径名表示的文件或目录的名称。该名称是路径名名称序列中的最后一个名称。如果路径名名称序列为空，则返回空字符串。

getPath

public String getPath() 将此抽象路径名转换为一个路径名字符串。所得字符串使用默认名称分隔符分隔名称序列中的名称。

length

public long length() 返回由此抽象路径名表示的文件的长度。如果此路径名表示一个目录，则返回值是不确定的。

public class TestFile6 {
    public static void main(String[] args) {
        File file=new File("D:\\newdir\\myfile\\test.txt");
        String absolutePath=file.getAbsolutePath();
        System.out.println(absolutePath);

        String path=file.getPath();
        System.out.println(path);

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

        long length=file.length();
        System.out.println("文件的长度:"+length);
    }
}

lastModified

public long lastModified() 返回此抽象路径名表示的文件最后一次被修改的时间。

返回： 
表示文件最后一次被修改的时间的 long 值

public class TestFile7 {
    public static void main(String[] args) {
        File file=new File("D:\\newdir\\myfile\\test.txt");
        long lastModified=file.lastModified();
        Date date=new Date(lastModified);
        System.out.println(date.toLocaleString());
    }
}

isDirectory

public boolean isDirectory() 测试此抽象路径名表示的文件是否是一个目录。

isFile

public boolean isFile() 测试此抽象路径名表示的文件是否是一个标准文件。

list

public String[] list() 返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。

public class TestFile8 {
    public static void main(String[] args) {
        File file = new File("D:\\demo");
        //判断此file对象是否是一个目录
        if (file.isDirectory()) {
            String[] list = file.list();
            if (list != null) {
                for (int i = 0; i < list.length; i++) {
                    System.out.println(list[i]);
                }
            }
        }
    }
}

动态获取系统相关的分隔符

public class TestFile10 {
    public static void main(String[] args) {
        File file=new File("D:"+File.separator+"newdir"+
                File.separator+"myfile"+File.separator+"test.txt");
        if(file.exists()) {
            System.out.println("文件存在");
        }
    }
}

IO流

I指的是Input的首字母

O指的是Output的首字母

文件流中流动的是数据，从外部设备（磁盘文件，键盘，网络）流入程序的称为输入流，从程序流到外部设备的流称为输出流。

文件流按方向分可分为输入流和流出流。

文件流按流中流动的内容分为字节流和字符流。

InputStream此抽象类是表示字节输入流的所有类的超类。

OutputStream此抽象类是表示输出字节流的所有类的超类。

如果想要通过字节输出流，创建文件，并把程序数据输出到文件，需要使用OutputStream的子类。

FileOutputStream

public FileOutputStream(String name)
                 throws FileNotFoundException

创建一个向具有指定名称的文件中写入数据的输出文件流

public class OutputStreamTest1 {
    public static void main(String[] args) 
            throws IOException {
        OutputStream os=
                new FileOutputStream("D:"+File.separator+"abc.txt");
        String data="hello";
        os.write(data.getBytes());
        os.close();
        System.out.println("写文件已完成");
    }
}

FileOutputStream

public FileOutputStream(String name,
                        boolean append)
                 throws FileNotFoundException
参数： 
name - 与系统有关的文件名 
append - 如果为 true，则将字节写入文件末尾处，而不是写入文件开始处 

这种构造方法，可以通过设置第二个参数，实现追加文件内容，而不是覆盖文件的内容的功能。

public class OutPutStreamTest2 {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("D:\\a2.txt",true);
            fos.write("bbbbb".getBytes());
        } catch (FileNotFoundException ex) {
            ex.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(fos!=null) {
                try {
                    fos.close();
                }catch(Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
    }
}
以上示例实现向已存在文件a2.txt追加内容的功能。

从磁盘文件中读取数据到程序，需要用到文件输入流，如果要以字节流的方式读取数据，要用到InputStream，InputStream是一个抽象类，所以要想实现字节方式从文件中读数据，要用到InputStream的子类，FileInputStream。

InputStream：此抽象类是表示字节输入流的所有类的超类。
public class FileInputStream
    extends InputStream

FileInputStream 从文件系统中的某个文件中获得输入字节。哪些文件可用取决于主机环境。

public class InputStreamTest1 {
    public static void main(String[] args) throws IOException {
        InputStream is=new FileInputStream("D:\\abc.txt");
        //把流中的数据
        byte[] buffer=new byte[100];
        int length=is.read(buffer);
        if(length>0) {
            String s=new String(buffer);
            System.out.println(s);
        }
        is.close();
    }
}

使用FileInputStream实现文件的读取操作的标准写法

public class InputStreamTest2 {
    public static void main(String[] args) throws IOException {
        InputStream is=new FileInputStream("D:\\abc.txt");
        //把流中的数据
        byte[] buffer=new byte[1024];
        int len=-1;
        while((len=is.read(buffer))!=-1) {
            String s=new String(buffer,0,len);
            System.out.println(s);
        }
        is.close();
    }
}

练习：利用FileOutputStream和FileInputStream实现D:\abc.txt文件复制到C:\abc.txt

public class FileCopy1 {
    public static void main(String[] args) {
        // 从读取文件，到程序中，再把程序中读到的数据写到C磁盘根目录
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("D:\\a.png");
            byte[] buffer = new byte[1024];
            int len = -1;// 读取到的数据的实际长度
            fos = new FileOutputStream("D:\\b.png");
            while ((len = fis.read(buffer)) != -1) {
                // 把读到的数据再写到C:\\abc.txt
                fos.write(buffer, 0, len);
            }

        } catch (FileNotFoundException ex) {
            System.out.println("访问的文件不存在!");
        } catch (IOException ex) {
            System.out.println("文件的读取错误");
        } catch (Exception ex) {
            System.out.println("未知类型的错误");
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException ex) {
                    System.out.println(ex.getMessage());
                }
            }
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException ex) {
                    System.out.println(ex.getMessage());
                }
            }
        }

        System.out.println("复制完成!");
    }
}

java.io

类 Reader用于读取字符流的抽象类。

FileReader类的继承关系 FileReader-->InputStreamReader-->Reader

FileReader(String fileName) 
      在给定从中读取数据的文件名的情况下创建一个新 FileReader。
read()方法：
     public int read()
         throws IOException
读取单个字符
     public int read(char[] cbuf)
         throws IOException

将字符读入缓冲区数组中

public class FileRaderTest1 {
    public static void main(String[] args) throws IOException {
        FileReader fr=new FileReader("D:\\a2.txt");
        char[] cbuffer=new char[100];
        fr.read(cbuffer);
        String s=new String(cbuffer);
        System.out.println(s);
    }
}

如果文件的长度大于缓冲区的长度，那么需要进行循环读取,参考代码:

public class FileRaderTest1 {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("D:\\a2.txt");
        char[] cbuffer = new char[100];
        int len = -1;
        while ((len = fr.read(cbuffer)) != -1) {
            fr.read(cbuffer);
            String s = new String(cbuffer);
            System.out.println(s);
        }
        fr.close();
    }
}

java.io

类 Writer写入字符流的抽象类。

FileWriter这个类是Writer类的一个间接子类。

它和Writer之间的继承关系是: FileWriter->OuputStreamWriter->Writer

FileWriter构造方法:
FileWriter(String fileName) 
    根据给定的文件名构造一个 FileWriter 对象。
FileWriter(String fileName, boolean append) 
据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。

public class FileWriterTest1 {
    public static void main(String[] args) throws IOException {
        FileWriter writer=new FileWriter("D:\\a3.txt",true);
        String s="hello world!";
        char[] cbuf=s.toCharArray();
        writer.write(cbuf);
        //刷新缓冲区
        writer.flush();
        //关闭字符输出流
        writer.close();
    }
}

如果在使用构造方法时设置了append这个参数，则可以通过true实现向已有文件进行内容的追加，如果没有使用append则文件不存在就创建，存在就覆盖。

使用:FileReader和FileWriter实现文件的复制。

键盘输入6个学生的信息包括学生的姓名、语文、数学、英语 的考试成绩:
public class LianXi {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        FileWriter writer = null;
        try {
            writer = new FileWriter("D:\\student.txt");
            for (int i = 0; i < 3; i++) {
                System.out.println("请输入第"+(i+1)+"信息:");
                System.out.println("请输入姓名:");
                String name=input.next();
                System.out.println("请输入语文:");
                String chinese=input.next();
                System.out.println("请输入数学:");
                String math=input.next();
                System.out.println("请输入英语:");
                String english=input.next();

                writer.write(name+"\t"+chinese+"\t"+math+"\t"+english+"\r\n");
                writer.flush();
            }
        } catch (Exception ex) {
            throw new RuntimeException();
        }finally {
            if(writer!=null) {
                try {
                    writer.close();
                }catch(Exception ex) {
                    ex.printStackTrace();
                }finally {
                    writer=null;
                }
            }
        }
        System.out.println("保存完成!");
    }
}