2018年4月20日JAVA

File类

文件操作在Java的io操作中占有十分重要的地位，本文从以下几个方面来接受Java中对文件的操作。 

1.Java中新建或者删除一个文件,文件夹以及createNewFile(),delete(),mkdir(),mkdirs()函数的使用。 
2. 判断文件的函数：exists(),isFile(),isAbsolute(),isDirectory(),canRead(),canWrite(),isHidden()函数的使用。 
3. 文件属性的函数：lastModified(),length(),list(),listFiles(),renameTo()，getName(),getParent(),getPath(),getAbsolutePath()，delete()函数的使用。 
4. 文件输入输出操作中的FileInputStream(),InputStreamReader()的使用和差别。 
一：创建一个文件或者文件夹：

public class FileTest {
    public static void main(String[] args) throws IOException {
        File file = new File("D:/hust/file.txt");
        File directory = new File("D:/hust/hk");
        File dir = new File("D:/hank/hu/file.txt");
        if (!directory.exists()) {
            System.out.println(directory.mkdir());
        }
        if (!dir.exists()) {
            System.out.println(dir.mkdirs());
        }
        if (!file.exists()) {
            System.out.println(":" + file.createNewFile());
        }
    }
}

上面介绍了创建文件，以及创建文件夹的两种方式。首先是创建文件： 
在D盘的hust的目录下面新建一个file.txt文件，通过exist()来判断文件是否已经存在，如果文件不存在调用createNewFile(),CreateNewFile()返回一个Boolean值，如果指定的文件不存在并成功地创建，则返回 true；如果指定的文件已经存在，则返回 false。 
创建文件夹如果指定的文件夹不存在可以通过mkdir(),mkdirs()来创建文件夹。 
mkdir(),和mkdirs()都返回一个Boolean值，如果指定文件夹不存在并且通过mkdir()或者mkdirs()创建成功则返回一个true 值否则返回false。 
mkdir(),和mkdirs()的区别是如果新建的文件目录的上级目录不存在则mkdir()回报异常不能成功创建文件夹，而mkdirs(),会将目录与上级目录一起创建。 
二：判断文件属性的函数： 
exists()判断文件是否存在如果不存在则返回一个true，否则返回一个false。isFile()和isDirectory()分别用于判断是不是文件和是不是文件夹，canRead(),canWrite(),isHidden(),分别用于判断文件是否可读，可写，是否隐藏。

public class FileTest {
    public static void main(String[] args) throws IOException {
        File file = new File("D:/hust/file.txt");
        File directory = new File("D:/hust/hk");
        File dir = new File("D:/hank/hu/file.txt");
        if (!directory.exists()) {
            System.out.println(directory.mkdir());
        }
        if (!dir.exists()) {
            System.out.println(dir.mkdirs());
        }
        if (!file.exists()) {
            System.out.println(":" + file.createNewFile());
        }
        file.setReadable(true);
        file.setWritable(false);
        System.out.println("isFile:"+file.isFile()+"	isDirectory:"+file.isDirectory()+"	canRead:"+file.canRead()+"	canWrite:"+file.canWrite());
        System.out.println(dir.isFile()+":"+dir.isDirectory());
    }
}

输出结果如下： 
isFile:true isDirectory:false 
canRead:true canWrite:false 
isFile:false isDirectory:true 
三：文件属性的函数 
：lastModified(),length(),list(),listFiles(),renameTo(),getName(),getParent(),getPath(),getAbsolutePath()函数的使用。

public class FileTest {
    public static void main(String[] args) throws IOException {
        File dir = new File("D:/hust");
        String[] str=dir.list();
        File[] str1=dir.listFiles();
        System.out.println("lastModified():"+new Date(dir.lastModified()));
        System.out.println("length():"+dir.length()+"
getAbsolutePath:"+dir.getAbsolutePath());
        System.out.println("getPath:"+dir.getPath());
        System.out.println("getName:"+dir.getName()+"
getParent:"+dir.getParent());
        for(int j=0;j<str1.length;j++)
            System.out.println(":"+str1[j]);
        for(int i=0;i<str.length;i++)
        {
            System.out.println(":"+str[i]);
        }
    }
}

输出结果： 
lastModified():Mon Aug 01 22:01:15 CST 2016 
length():0 
getAbsolutePath:D:hust 
getPath:D:hust 
getName:hust 
getParent:D: 
:D:hustfile.txt 
:D:husthank 
:D:husthk 
:D:hustking 
:file.txt 
:hank 
:hk 
:king 
lastModified()函数返回一个long类型的值，上面的类子中通过Date函数将long类型的值转化为了日期。getAbsolutePath()返回目录的绝对路径。最重要的两个方法是list(),和listFiles(),list()是返回目录下面所有的目录或文件的名称，返回的是一个字符串数组。而listFiles()返回的是目录下面的文件和目录数组，返回的是文件和目录的绝对路径。 
Delete()的用法，如何删除一个文件和删除一个文件夹。 
删除一个文件比较简单，直接判断文件是否存在，如果存在的话就删除，如果文件不存在可以不用操作。但是删除一个文件夹比较麻烦，我们不能够直接的删除一个文件夹，删除文件夹时必须保证该文件夹为空，也就是说文件夹里面的文件和文件夹要全部被删除之后才能够删除该文件夹。下面是实例：

public class FileTest {
    public static void main(String[] args) throws IOException {
        deleteFiles("D:/Xiaomi");
    }
    public static void deleteFiles(String path) {
        File file = new File(path);
        if (!file.exists()) {
            return;
        }
        if (file.isFile()) {
            file.delete();
        } else if (file.isDirectory()) {
            File[] files = file.listFiles();
            for (File myfile : files) {
                System.out.println(":" + myfile.getAbsolutePath());
                deleteFiles(myfile.getAbsolutePath());
            }
            file.delete();
        }
    }
}

上面的D:/xiaomi是一个文件夹，它的下面还有其他的文件夹与文件，如果直接调用delete()函数的话，是删除不了的。因此利用递归的算法先删除其里面的文件和文件夹，在删除D:/xiaomi就可以了。 
四：文件输入输出操作中的FileInputStream(),InputStreamReader()的使用和差别。 
FileInputStream ()是使用字节方式输入，InputStreamReader()字符方式输入。一般字节方式输入用来处理图片，声音，图像等二进制流。

public class FileTest {
    public static void main(String[] args) throws IOException {
        // deleteFiles("D:/Xiaomi");
        System.out.println(":" + ReadFileByByte("D:/File1/心理健康常识.txt"));
        System.out.println(":" + ReadFileByChar("D:/File1/心理健康常识.txt"));
    }

    public static String ReadFileByByte(String filepath)
            throws FileNotFoundException {
        File file = new File(filepath);
        StringBuffer sb = new StringBuffer();
        if (!file.exists() || !file.isFile()) {
            System.out.println("this file is not exist!");
            return null;
        }
        FileInputStream fileinputstream = new FileInputStream(file);
        byte[] temp = new byte[1024];
        try {
            while (fileinputstream.read(temp) != -1) {
                sb.append(new String(temp));

            }
            fileinputstream.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        // System.out.println(":"+sb.length());
        return sb.toString();
    }

    public static String ReadFileByChar(String filepath) {
        File file = new File(filepath);
        if (!file.exists() || !file.isFile()) {
            return null;
        }

        StringBuffer content = new StringBuffer();

        try {
            char[] temp = new char[1024];
            FileInputStream fileInputStream = new FileInputStream(file);
            InputStreamReader inputStreamReader = new InputStreamReader(
                    fileInputStream);
            while (inputStreamReader.read(temp) != -1) {
                content.append(new String(temp));
                temp = new char[1024];
            }

            fileInputStream.close();
            inputStreamReader.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return content.toString();
    }

 四.FileFilter接口

该接口提供accept方法，返回布尔值，可在调用listFiles方法时添加过滤规则，如果true，则向File数组添加元素，反之不添加。

public class MyFilter implements FileFilter{

    @Override
    public boolean accept(File pathname) {
        String s = pathname.getName();
        if(s.endsWith("txt")) {
            return true;
        }else {
            return false;
        }
    }
}

五.递归

在方法内调用当前方法，可以用来代替for循环，但是要注意，使用递归一定要注意设置跳出循环的条件，不然会造成栈溢出错误！

public class Test {
    static int a=0;
    static int sum = 0;
    public static void test() {
        a++;
        if(a<=10) {
            sum+=a;
            test();
        }else{
            System.out.println(sum);
            System.out.println("over");
        }
    }
    public static int test2(int n) {
        if(n==1) {
            return 1;
        }else {
            return n+test2(n-1);
        }
    }
    public static int test3(int n) {
        if(n==1) {
            return 1;
        }else {
            return n*test3(n-1);
        }
    }
    public static void main(String[] args) {
        //test();
        //System.out.println(test2(10));
        //System.out.println(test3(5));
    }

}

 六.字节流

字节流分为输入流和输出流，即inputstream和outputstream，通过输入输出流来操作外部文件。

（1）输出流

调用write方法来写数据，一次读取一个字节

构造方法：

FileOutputStream fos = new FileOutputStream(f);//如果路径文件存在，执行覆盖，如果File路径不存在，直接创建路径

FileOutputStream fos = new FileOutputStream(f，true);//不覆盖原文件，可继续写入内容

public class Test {
    public static void main(String[] args) {

        File f = new File("d:\test\test.txt");
        try (FileOutputStream fos = new FileOutputStream(f);){//如果路径文件存在，执行覆盖，如果File路径不存在，直接创建路径文件，
　　　　　　　　//注意，如果输入的是文件夹地址会报错！
            //FileOutputStream fos1 = new FileOutputStream(f,true);//不覆盖文件，继续添加
            byte[] in = {-48,-49,-50,-51,-20,-91};//如果是负数，则传入汉字，一个汉字两个字节
            fos.write(in);//传入一个byte数组
            fos.write(50);//传入单个字节值
            fos.write(in, 0, 2);//左开右闭
            byte[] word = "hello".getBytes();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

七.输入流

调用read方法来读取数据，一次读取一个字节

package edu.java.io;

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

public class Test {
    public static void main(String[] args) {
        File f = new File("d:\test\test.txt");
        try (FileInputStream fis = new FileInputStream(f)){
            byte[] read = new byte[(int)f.length()];
            int a = fis.read(read);//返回有效字节个数，和f.length()相同
            for(byte b:read) {
                System.out.print(b);//输出单个字节
                System.out.println((char)b);//输出单个字符
            }
            String str = new String(read,0,read.length);//直接生成一个String
            System.out.println(str);
        } catch (IOException e) {
            e.printStackTrace();
            throw new RuntimeException("文件读取错误！");
        }
    }

}
注意： new String（read,0,read.length）的构造方法：三个参数分别为byte数组名，起始下标，字节个数，例如new String(read,0,2)，读取从下标0开始的2个字符

 八.IO异常处理：

输入输出流必须被正确关闭，可以用try with resource（JDK1.7特性）即 try()方式关闭，或者在finally中关闭

public class Test {
    public static void main(String[] args) {
        File f = new File("d:\test\test.txt");
        //IO异常一般不能处理，只能打印错误信息或者抛出运行时异常
        FileOutputStream fos =null;//注意作用域，定义在try catch 外部
        try {
            fos = new FileOutputStream(f,true);
            String str = "JAVA是世界上最好的语言";
            byte[] s= str.getBytes();
            fos.write(s);
        } catch (IOException e1) {
            e1.printStackTrace();
            throw new RuntimeException("文件写入失败，请重试！");
        } finally {
            if(fos!=null) {
                try {
                    fos.close();
                } catch (IOException e3) {
                    e3.printStackTrace();
                }
            }
        }
        try (FileInputStream fis = new FileInputStream(f);){
            byte[] b = new byte[(int)f.length()];
            fis.read(b);
            for(byte r:b) {
                System.out.println(r);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}