JAVA学习笔记09——文件类，IO流

文件类

1.构造方法

public File(String pathname):通过给定的路径字符串转换为抽象路径名来创建新的File实例
路径可以是文件结尾，也可以是文件夹结尾
路径可以是相对路径也可以是绝对路径
路径可以是存在的也可以是不存在的
创建File对象，只是把字符串路径封装为File对象，不考虑存在情况

public class Demo01 {
    
    
    public static void main(String[] args) {
    
    
        show();
    }

    private static void show() {
    
    
        File fl=new File("D:\\JAVA\\File\\text.txt");
        System.out.println(fl); //D:\JAVA\File\text.txt
    }
}

public File(String parent,String child):从父路径名字符串和子路径名字符串创建新的File实例
parent:父路径
child:子路径
好处：父路径与子路径可以单独书写，使用灵活

public class Demo01 {
    
    
    public static void main(String[] args) {
    
    
        show();
    }

    private static void show() {
    
    
        File fl=new File("D:\\JAVA\\File","text.txt");
        System.out.println(fl); //D:\JAVA\File\text.txt
    }
}

public File(File parent,String child):从父抽象路径名和子路径名字符串创建新的File实例
好处：父路径可以使用File的方法对路径进行一些操作

public class Demo01 {
    
    
    public static void main(String[] args) {
    
    
        show();
    }

    private static void show() {
    
    
        File parent=new File("D:\\JAVA\\File");
        File fl=new File(parent,"text.txt");
        System.out.println(fl); //D:\JAVA\File\text.txt
    }
}

2.常用方法

public String getAbsolutePath():返回此File的绝对路径字符串
public String getPath():将此File转换为路径名字符串
public String getName():返回此File表示的文件或目录名称
public long length():返回此File表示的文件的长度

public class Demo01 {
    
    
    public static void main(String[] args) {
    
    
        File f=new File("F:\\JAVA\\File");
        System.out.println(f.getAbsolutePath());
        System.out.println(f.getPath());
        System.out.println(f.getName());
        System.out.println(f.length());
        /*
        F:\JAVA\File
        F:\JAVA\File
        File
        0
         */
    }
}

判断方法
public boolean exists():此File表示的文件或目录是否实际存在
public boolean isDirectory():此File表示的是否为目录
public boolean isFile():此File表示的是否是文件

public class Demo01 {
    
    
    public static void main(String[] args) {
    
    
        File f=new File("F:\\JAVA\\File");
        System.out.println(f.exists());
        System.out.println(f.isDirectory());
        System.out.println(f.isFile());
        /*
        true
        true
        false
         */
    }
}

删除方法
public boolean createNewFile():当且仅当具有该名称的文件尚不存在时，创建一个新的空文件夹
1.此方法只能创建文件，不能创建文件夹
2.创建文件的路径必须存在，否则会出现异常

public class Demo01 {
    
    
    public static void main(String[] args) throws IOException {
    
    
        File f=new File("F:\\JAVA\\File\\text.txt");
        boolean b=f.createNewFile();	//只能创建文件，不能创建文件夹
        System.out.println(b);
    }
}

public boolean delete():删除由此File表示的文件或目录
如果文件夹中存在文件，则返回false；如果不存在文件，则返回true

public class Demo01 {
    
    
    public static void main(String[] args) throws IOException {
    
    
        File f1=new File("F:\\JAVA\\File\\text\\text1\\text2");
        boolean b1=f1.delete();
        System.out.println(b1);
    }
}

public boolean mkdir():创建由此File表示的目录，创建单级空文件夹
public boolean mkdirs():创建由此File表示的目录，包括任何必须但不存在的父目录，创建单级空文件夹，也可以创建多级文件夹

public class Demo01 {
    
    
    public static void main(String[] args) throws IOException {
    
    
        File f1=new File("F:\\JAVA\\File\\text");
        boolean b=f1.mkdir();
        System.out.println(b);
        File f2=new File("F:\\JAVA\\File\\text\\text1\\text2");
        boolean b2=f2.mkdirs();
        System.out.println(b2);
    }
}	//只创建文件夹

目录遍历
public String[] list():返回一个String数组，表示该File目录中的所有子文件或目录
public File[] listFiles():返回一个File数组，表示该File目录中所有的文件或目录

public class Demo01 {
    
    
    public static void main(String[] args) throws IOException {
    
    
        File f1=new File("F:\\JAVA");
        //获取当前目录下的文件以及文件夹的名称
        String[] names=f1.list();
        for (String name : names) {
    
    
            System.out.println(name);
        }
        //获取当前目录下的文件以及文件夹对象，只要拿到了文件对象，那么就可以获取更多信息
        File[] files=f1.listFiles();
        for (File file : files) {
    
    
            System.out.println(file);
        }
    }
}

IO流

1.IO概述

输入流：把数据从其他设备上读取到内存中的流
输出流：把数据从内存中写出到其他设备上的流

2.字节流

字节输出流
public void close():关闭此输出流并释放与此相关联的任何系统资源
public void flush():刷新此输出流并强制任何缓冲的输出字节被写出
public void write(byte[] b):将b.length字节从指定的字节数组写入此输出流
public void write(byte[] b,int off,int len):从指定的字节数组写入len字节，从偏移量off开始输出到此输出流
public abstract void write(int b):将指定的字节输出流
构造方法：
FileOutputStream(String name):创建一个向具有指定名称的文件中写入数据的输出文件流
FileOutputStream(File file):创建一个向指定File对象表示的文件中写入数据的文件输出流
构造方法作用：
1.创建一个FileOutputStream对象
2.会根据构造方法中传递的文件/文件路径，创建一个空文件
3.会把FileOutputStream对象指定创建好的文件

public class Demo01 {
    
    
    public static void main(String[] args) throws IOException {
    
    
        //创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
        FileOutputStream fos=new FileOutputStream("F:\\JAVA\\File\\text1.txt");
        //调用FileOutputStream对象中的write方法，把数据写入到文件中
        fos.write(97);
        //释放资源
        fos.close();
    }
}

public class Demo01 {
    
    
    public static void main(String[] args) throws IOException {
    
    
        //创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
        FileOutputStream fos=new FileOutputStream(new File("F:\\JAVA\\File\\text2.txt"));
        //调用FileOutputStream对象中的write方法，把数据写入到文件中
        /*public void write(byte[] b)一次写多个字节
        如果写的第一个字节是正数，那么现实的时候会查询ASCII表
        如果写的第一个字节是负数，那第一个字节会和第二个字节组成一个中文显示
         */
        byte[] bytes={
    
    65,66,67,68,69};
        //fos.write(bytes)  ABCDE
        fos.write(bytes,1,2);   //BC
        //释放资源
        fos.close();
    }
}

续写与换行：
使用两个参数的构造方法：
FileOutputStream(String name,boolean append):创建一个向具有指定name的文件中写入数据的输出文件流
FileOutputStream(File file,boolean):创建一个向指定File对象表示的文件中写入数据的文件输出流
参数：
name，file:写入数据的路径
boolean append:true创建对象不会覆盖原文件，继续在文件末尾追加写数据；false创建一个新文件覆盖原文件

public class Demo02 {
    
    
    public static void main(String[] args) throws IOException {
    
    
        FileOutputStream fos=new FileOutputStream("F:\\JAVA\\File\\text1.txt",true);
        fos.write("Kobe".getBytes());
        fos.close();
    }
}

换行符号：

public class Demo02 {
    
    
    public static void main(String[] args) throws IOException {
    
    
        FileOutputStream fos=new FileOutputStream("F:\\JAVA\\File\\text1.txt",true);
        for (int i=0;i<10;i++){
    
    
            fos.write("Kobe".getBytes());
            fos.write("\r\n".getBytes());
        }
        fos.close();
    }
}

字节输入流
把硬盘中的数据读取到内存中
int read():从输入流中读取数据的下一个字节
int read(byte[] b):从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中
构造方法：
FileInputStream(String nmae)
FileInputStream(File file)
作用：
1.创建一个FileInputStream对象
2.会把FileInputStream对象指定的构造方法中要读取的文件

public class Demo03 {
    
    
    public static void main(String[] args) throws IOException {
    
    
        //创建FileInputStream对象，构造方法中绑定要读取的数据
        FileInputStream fis=new FileInputStream("F:\\JAVA\\File\\text1.txt");
        //使用FileInputStream对象中的方法read，读取文件
/*       int len=fis.read();
        System.out.println(len);*/
        int len=0;
        while((len=fis.read())!=-1){
    
    
            System.out.println((char)len);
        }
        //释放资源
       fis.close();
    }
}

public class Demo03 {
    
    
    public static void main(String[] args) throws IOException {
    
    
        //创建FileInputStream对象，构造方法中绑定要读取的数据
        FileInputStream fis=new FileInputStream("F:\\JAVA\\File\\text2.txt");
        //使用FileInputStream对象中的方法read，读取文件
        byte[] bytes=new byte[1024];
        int len=0;
        while((len=fis.read(bytes))!=-1){
    
    
            System.out.println(new String(bytes,0,len));
            //用len记录长度使读取有效字节数
        }
        //释放资源
       fis.close();
    }
}

3.字符流

字符输入流
public void close():关闭此流并释放与此相关联的任何系统资源
public int read():从输入流读取一个字符
public int read(char[] cbuf):从输入流中读取一些字符，并将他们存储到字符数组cbuf中
构造方法：
FileReader(File file):创建一个新的FileReader，给定要读取的File对象
FileReader(String fileName):创建一个新的FileReader，给定要读取的文件名称
字符输出流
void write(int c):写入单个字符
void write(char[] cbuf):写入字符数组
abstract void write(char[] cbuf,int off,int len):写入字符数组的某一部分，off数组的开始索引，len写的字符个数
void write(String str):写入字符串
void write(String ,str,int off.int len):写入字符串的某一部分，off字符串的开始索引，len写的字符个数
void flush():刷新该流的缓冲
void close():关闭此流，但是要先刷新

public class Demo05 {
    
    
    public static void main(String[] args) throws IOException {
    
    
        //使用FileWriter对象，构造方法中绑定要写入数据的目的地
        FileWriter fw=new FileWriter("F:\\\\JAVA\\\\File\\\\text2.txt");
        //使用FileWriter中的方法write，把数据写入到内存缓冲区(字符转换为字节的过程)
        fw.write(97);
        //使用FileWriter中的方法flush()，把内存缓冲区中的数据，刷新到文件中
        fw.flush();
        //释放资源
        fw.close();
    }
}

flush():刷新缓冲区，流对象可以继续使用
close():先刷新缓冲区，然后通知系统释放资源，流对象不可以再被使用了

public class Demo05 {
    
    
    public static void main(String[] args) throws IOException {
    
    
        //使用FileWriter对象，构造方法中绑定要写入数据的目的地
        FileWriter fw=new FileWriter("F:\\\\JAVA\\\\File\\\\text2.txt");
        char[] cs={
    
    'h','i','w','o','r','l','d'};
        fw.write(cs);
        fw.write(cs,2,2);
        fw.write("hello,world");
        fw.close();
    }
}

续写与换行：同上

4.IO异常处理

JDK7：在try后面增加一个(),在括号中可以定义流对象，那么这个流对象的作用域就在try中有效，try中的代码执行完毕，会自动把流对象释放
JDK9：try的前面可以定义流对象，在try的后面()中可以引入流对象的名称。在try代码执行完毕周后流对象也可以释放掉，不用写finally