Java基础学习 day_14 File类

File类

//构造方法
File file=new File("");
File file=new File("","")

创建文件

 //创建文件
        File file=new File("d:\\Test01\\aaa.txt");
        File file1=new File("D:\\Test01","qq.txt");
        if(!file1.exists()){
            boolean b=file1.createNewFile();
            System.out.println("创建结果:"+b);
        }else{
            System.out.println("文件已经创建");
        }
        //删除文件
        //直接删除
        boolean delete = file.delete();
        System.out.println("删除结果："+delete);
        //JVM删除
//       Thread.sleep(5000); 
        file.deleteOnExit();
        //获取信息
        System.out.println("文件长度："+file.length());
        System.out.println("文件名称："+file.getName());
        System.out.println("字符串绝对路径："+file.getAbsolutePath());
        System.out.println("相对路径："+file.getPath());
        System.out.println("父目录："+file.getParent());
        System.out.println("规范名称："+file.getCanonicalPath());
        System.out.println("文件格式绝对路径："+file.getAbsoluteFile().toString());
        System.out.println(new Date(file.lastModified()).toLocaleString());
        //判断
        System.out.println("是否存在"+file.exists());
        System.out.println("是否只读："+file.canRead());
        System.out.println("是否隐藏："+file.isHidden());
        System.out.println("是否是文件："+file.isFile());
        System.out.println("是否是绝对路径："+file.isAbsolute());

        //修改名称（具有剪切的功能）
        file.renameTo(new File("D:\\Test01\\haha.txt"));

Filefilter接口

当调用File类中的listFiles()方法时，对获取文件进行过滤，只要满足条件的文件的才可以出现在listFiles()的返回值中。

过滤文件
创建目录

  //创建文件夹
        File dir=new File("d:\\aaa\\bbb\\ccc");
        if(!dir.exists()){
            //dir.mkdir() 创建单级目录
            boolean b=dir.mkdirs();//创建多级目录
            System.out.println("创建结果："+b);
        }else{
            System.out.println("目录已存在");
        }
        //删除
        //直接删除 只能删除最里层的空目录
//        boolean b= dir.delete();
//        System.out.println("删除结果："+b);
        //JVM删除
//        Thread.sleep(5000);
//        dir.deleteOnExit();
        //获取信息
        System.out.println("获取绝对路径："+dir.getAbsolutePath());
        System.out.println("获取路径："+dir.getPath());
        System.out.println("获得父目录："+dir.getParent());
        System.out.println("获得名称："+dir.getName());
        System.out.println("规范名称："+dir.getCanonicalPath());
        System.out.println("长度；"+dir.length());
        //判断
        System.out.println("是否存在："+dir.exists());
        System.out.println("是否隐藏："+dir.isHidden());
        System.out.println("是不是文件夹："+dir.isDirectory());
        System.out.println("是不是绝对路径："+dir.isAbsolute());
        //重命名 只能修改最后一个目录的名字
        System.out.println("是否修改成功："+dir.renameTo(new File("d:\\aaa\\bbb\\hello")));
        //获取目录的子目录和文件
        File dir1=new File("D:\\aaa");
        System.out.println("-----------------aaa---------------");
        String[] list = dir1.list();
        for (String s : list) {
            System.out.println(s);
        }
        System.out.println("-----------aaaFile形式------------");
        File[] files = dir1.listFiles();
        for (File file : files) {
            System.out.println(file.toString());
        }
        //获取目录下的.txt
        System.out.println("-------------FilenameFilter--------------");
        String[] list1 = dir1.list(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                if (name.endsWith(".txt")) {
                    return true;
                }
                return false;
            }
        });
        for (String s : list1) {
            System.out.println(s);
        }
        //方法二
        System.out.println("------------特定文件---------------");
        File[] files1=dir1.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if(pathname.getName().endsWith(".txt")){
                    return true;
                }
                return false;
            }
        });
        for (File file : files1) {
            System.out.println(file.getName());
        }
        //获取根目录
        System.out.println("---------获取根目录--------------");
        File[] files2=File.listRoots();
        for (File file : files2) {
            System.out.println(file);
        }

流

输入流（读取）：由存储设备流向内存，如果没有文件，会报错
输出流（写入）：由内存流向存储设备，如果没有文件，会自动创建文件。

字节流

InputStream(抽象类):
read():返回值为int
read(byte[] b);返回值为int
read(byge[]b,int off,int len);返回值为int
close();关闭流
outputStream（抽象类）:
write(int b);
write(byte[] b);
write(byte[]b ,int off,int len)

文件输入输出字节流

构造方法：
FileInputStream(实现类):
FileOutputStream（实现类）:

true,表示追加。默认为false，也就是覆盖。

字节缓冲流

缓冲区大小默认为8k。
BufferedOutputStream:

并没有写入硬盘，写入了缓冲区。如果想及时写入硬盘，对象.flush()；
当调用对象.close(),会自动调用flush(),执行写入硬盘操作。

BufferedInputStream:
参数要是个字节流，本身没有读入读出功能。
关闭缓冲流，会自动关闭真正具有读写功能的流。

try(类 对象=对象或则new 类){
}
他会调用对象的close()方法，但是这个类要实现Closeable接口的close()方法。如果想释放多个资源的话，中间可以加分号


close()关闭是按倒序关闭的。
比如：try(Student student=new Student;Person person=new Person()){
}

对象流

不具有真正的写入和读出功能，需要借助文件字节流等来实现。
ObjectOutputStream:
ObjectInputStream:

1.序列化的类必须实现Serializable(自动序列化,标记接口)或则Externalizable(手动序列化，要重写他的方法）
2.序列化的类要添加一个私有的long类型的静态常量：serialVersionUID,保证序列化的类和反序列化的类是一致的。

3.使用transient修饰的属性，不可序列化。
4.静态属性不可序列化。
5。但是使用Externalizable接口，可以把transient修饰的属性序列化。
6。读取到文件的末尾，在读取，会出现java.io.EOFException异常。

实现serializable接口

public static void serializable() throws Exception{
    Person person=new Person("轩轩",12);
    Person person1=new Person("轩二",21);
    ObjectOutputStream obj=new ObjectOutputStream(new FileOutputStream("D:\\person.txt"));
    ArrayList<Person> array=new ArrayList<>();
    array.add(person);
    array.add(person1);
    obj.writeObject(array);
    System.out.println("序列化成功");
    obj.close();
}
public static void fanSerializable() throws Exception{
    ObjectInputStream obj=new ObjectInputStream(new FileInputStream("D:\\person.txt"));
    ArrayList<Person> array=(ArrayList<Person>)obj.readObject();
    for (Person person : array) {
        System.out.println(person.toString());
    }
    array.close();
}

Externalizable接口：

public class Person implements Externalizable {
    private String name;
    private int age;
    private transient String color;

    public Person(String name, int age,String color) {
        this.name = name;
        this.age = age;
        this.color=color;
    }

    public Person() {
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                '}';
    }
    @Override
    public void writeExternal(ObjectOutput out) throws IOException {//重写
        out.writeObject(name);
        out.writeObject(age);
    }
    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        name=(String)in.readObject();
        age=(int)in.readObject();
    }
}

Java中的对象的创建四种方式

1.new 方法，调用构造方法
2.反射，调用构造方法
3.反序列化，不会调用构造方法（Serializable）,(Externalizable会调构造方法)
4.克隆, 实现Cloneable接口（标记接口）,调用构造方法。如果一个类中还有个类对象，浅克隆只是把地址克隆了下来，深克隆则创建了个新的对象。
5.clone():创建并返回此对象的副本, 如果一个类仅包含原始字段或对不可变对象的引用，则通常情况下,super.clone返回的对象中的字段通常不需要修改。如果要进行深拷贝，就需要重新写clone()方法中的代码。

字符编码

UTF-8：有可能是一个字节，两个或则三个，中文是三个字节。
ISO-8859-1：一个字节。0-255

字符流（抽象类）本质上是没有字符流的，他的源码是用的字节流，采用了特定的编码方式转换

抽象类：
Reader:
close()
read()
read(char[])
read(char[],int off,int len)
Writer:
flush()
write(int c)
write(char[])
write(char[],int off,int len)
write(String)
write(String,int off,int len)
#


# 文件字符流（实现类）
有缓冲区，flush()可以使用。关闭的时候会自动调用flush()方法。
FileReader
FileWriter

字符缓冲流(需要借助字符流)

BufferedReader:
除了普通的字符流方法外，还增加了：
对象.readLine():读取一个文本行。返回值为String
BufferedWriter:
对象.newLine();换行（可以实现跨平台）
对象.flush();刷新

转换流

可将字节流转换为字符流
可设置字符的编码方式
InputStreamReader:将硬盘的字节转换成字符**（参数是字节流）(字节流，编码方式)**
OutputStreamWriter:将内存的字符转换成字节**（参数是字节流）(字节流，编码方式)**

打印流（原样打印，看到的是什么，打印出来的就是什么）

print();
println();
flush();
构造方法，可以直接写文件，也可以使用字节流。
PrintStream:字节打印流
PrintWriter:字符打印流

重定向标准输出流

system.out.println():默认输出到控制台
修改输出位置
system.out中的out是个打印字节流
system.in中的in是个字节输入流
system.setOut(new PrintStream(" "))

RandomAccessFile（随机流 对字节进行操作）

对应的读也是一样。
此类的实例支持对随机访问文件的读取和写入。随机访问文件的行为类似存储在文件系统中的一个大型 byte数组。存在指向该隐含数组的光标或索引，称为文件指针；输入操作从文件指针开始读取字节，并随着对字节的读取而前移此文件指针。
length():返回lang型
seek(long a)：文件指针的偏移量，以开头的位置，也就是0的位置。
skipBytes(int a):跳过字节个数，从当前位置跳。

Properties属性集合

list(打印流)：遍历输出
对象.list(new PrintSteam());
对象.list(new PrintWriter());

store(字符流或者字节流输出流)：保存到文件
load(字符输入流或者字节输入流)：加载文件

除了文件字节输出流之外的其他输出流都有缓冲区。都可以用对象.flush();

切记，除了文件字节输出流之外的其他输出流，需要flush()，所有的流必须加上close()。

来源：oschina

链接：https://my.oschina.net/u/4301949/blog/4482465