传统IO（一）：File类，字节流，字符流

（1）文件属性访问方法
fl:一个目录（文件夹） fw：位于E盘java file文件下的记事本（内写ceshi）

boolean exists():判断File对象对应的文件或目录是否存在。
boolean isFile():测试此抽象路径名表示的文件是否是一个标准文件。
boolean isDirectory():测试此抽象路径名表示的文件是否是一个目录。
public String getName()：返回由此抽象路径名表示的文件或目录的名称。
long lastModified():返回此抽象路径名表示的文件最后一次被修改的时间
long length():返回由此抽象路径名表示的文件的长度

（2）目录相关的操作方法
fl:一个目录（文件夹） f2：没有对应文件

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

 import java.io.File;
public class FileText {
    public static void main(String[] args) {
        File fl=new File("E:\\java file");
        File fl2=new File("E:\\java file\\java");
        String[] q=fl.list();//将fl表示的目录中的文件或目录以字符串的方式返回
        System.out.println("fl目录下的文件和目录有：");
        for(String i:q){
            System.out.println(i);
        }
        Boolean b=fl2.mkdir();//按照fl2表示的路径创建目录或文件
        q=fl.list();//将fl表示的目录中的文件或目录以字符串的方式返回
        System.out.println("f1目录下的文件和目录名字：");
        for(String i:q){
            System.out.println(i);
        }
        System.out.println("fl表示的目录中的文件或目录：");
        File[] F=fl.listFiles();//将fl所表示的文件夹中的文件或目录以文件的形式保存在文件数组中
        for(int i=0;i<F.length;i++){
            System.out.println("F["+i+"]:"+F[i].getName());
        }
    }
}

（3）文件相关的操作方法(删除，增加，重命名)
将java file目录下的三个文件：java text.txt text2.txt
更改为 java text3.txt filetext.txt

boolean createNewFile():检查文件是否存在，若不存在则创建该文件
boolean delete():删除此抽象路径名表示的文件或目录
boolean renameTo(File newName):重命名此File对象对应的文件或目录，如果重命名成功返回true了否则返回false

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

public class FileText {
    public static void main(String[] args) throws IOException {
        File fl=new File("E:\\java file");
        File fr=new File("E:\\java file\\text2.txt");
        File fw=new File("E:\\java file\\text3.txt");
        File fd=new File("E:\\java file\\text.txt");
        String[] s=fl.list();
        System.out.println("***f1表示的目录下的文件如下***");
        for(String i:s){
            System.out.print(i+"      ");
        }
        System.out.println();
        System.out.println("******按fw表示的文件创建文件******");
        Boolean f=fw.createNewFile();//创建文件观察返回值
        System.out.println("不存在，创建成功返回值为"+f);
        f=fw.createNewFile();//再次创建相同文件观察返回值
        System.out.println("存在，不需要创建时返回值为"+f);
        System.out.println();
        System.out.println("******按fd表示的文件路径将文件删除******");
        f=fd.delete();//删除文件观察返回值
        System.out.println("存在，需要删除时返回值为"+f);
        f=fd.delete();//再次删除相同文件观察返回值
        System.out.println("不存在，无需删除时返回值为"+f);
        System.out.println();
        System.out.println("******将fr表示的 text2.txt 目录重命名为 filetext.txt ******");
        System.out.println("fr所指为"+fr.getName()+"      fr是否存在"+fr.exists());
        //核心********************
        Boolean r=fr.renameTo(new File("E:\\java file\\filetext.txt"));//重命名
        //********************核心
        System.out.println("更改后fr所指为"+fr.getName()+"     fr是否存在"+fr.exists());
        //重新赋值********************
        fr=new File("E:\\java file\\filetext.txt");//将fr的路径更改
        //*********************重新赋值
        System.out.println("fr重新创立之后：fr所指为"+fr.getName()+"     fr是否存在"+fr.exists());
        System.out.println("所以，重命名时会删除文件同时生成新的,需要将新的路径赋予文件对象");
        System.out.println();
        System.out.println("******fl表示的目录下的文件如下******");
        s=fl.list();
        for(String i:s){
            System.out.print(i+"      ");
        }
    }
}

（3）【1】FileInputStream字节流
filetext.txt中保存有数据： FileInputStream输入流测试

（构造方法）FileInputStream(File file)通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
void close():关闭文件输入流并释放相关资源
int read():从输入流中读取一个字节
int read(byte[] b):从输入流中一次性读出b.length个字节的数据读入byte数组中

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class FileText {
    public static void main(String[] args) throws IOException {
        File f=new File("E:\\java file\\filetext.txt");
        FileInputStream in=new FileInputStream(f);
        byte[] b=new byte[512];
        int i=0,a;
        while((a=in.read())!=-1){
            b[i]=(byte)a;
            //不可以用b[i]=(byte)(in.read()),因为每次用到in.read()都会读取一个字节，判断时读过一次，此处再用则会往下再读一个字节，则会使结果中有一半字节不能正常存储
            i++;
        }
        in.close();//read()已经读到了末尾需要关闭重开
        in=new FileInputStream(f);//重开
        System.out.println("使用read()读取的文件内容是："+new String(b));
        byte[] b2=new byte[(int)f.length()];
        in.read(b2);
        System.out.println("使用read(byte[] b)读取的文件内容是："+new String(b2));
        in.close();//输入流完成后一定要记得关闭！！！！！
    }
}

**（3）【2】FileOutputStream字节流
文件中原有：text
第一次追加数据用构造器2
第二次追加用构造器1

（构造器1）FileOutputStream(File file)：创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
（构造器2）FileOutputStream(File file, boolean append)：创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
FileOutputStream(String name)：创建一个向具有指定名称的文件中写入数据的输出文件流。
FileOutputStream(String name, boolean append)：创建一个向具有指定 name 的文件中写入数据的输出文件流。
void close():关闭文件输出流并释放相关资源。
void write(byte[] b):从byte数组中一次性读出b.length个字节的数据读入输出流中

import java.io.*;
import java.util.Scanner;
public class FileText {
    public static void main(String[] args) throws IOException {
        Scanner sc=new Scanner(System.in);
        File f=new File("E:\\java file\\filetext.txt");
        input(f);
        outputboolean(f);
        input(f);
        output(f);
        input(f);
    }
    public static void input(File f) throws IOException {
        FileInputStream in=new FileInputStream(f);
        byte[] bytes=new byte[(int)f.length()];
        in.read(bytes);
        System.out.println(f.getName()+"中的文件内容为"+new String(bytes));
        in.close();
    }
    public static void outputboolean(File f) throws IOException {
        Scanner sc=new Scanner(System.in);
        FileOutputStream out=new FileOutputStream(f,true);//若true改为false则为删除文件重新创建（同构造器1）
        System.out.print("请输入内容：");
        byte[] bytes=sc.next().getBytes();
        out.write(bytes);
        out.close();
    }
    public static void output(File f) throws IOException {
        Scanner sc=new Scanner(System.in);
        FileOutputStream out=new FileOutputStream(f);
        System.out.print("请输入内容：");
        byte[] bytes=sc.next().getBytes();
        out.write(bytes);
        out.close();
    }
}

(4)【1】FileReader字符流

（构造器）FileReader(File f):在给定从中读取数据的 File 的情况下创建一个新 FileReader。
int read():读取单个字符
void close():关闭该流并释放与之关联的所有资源。
String getEncoding():返回此流使用的字符编码的名称。

import java.io.*;
public class FileText {
    public static void main(String[] args) throws IOException {
        int a;
        File f=new File("E:\\java file\\filetext.txt");
        FileReader fr=new FileReader(f);
        while((a=fr.read())!=-1){
            System.out.print((char)a);//注意此处不能够写fr.read()
        }
        System.out.println();
        System.out.println(fr.getEncoding());
        fr.close();
    }
}

(4)【2】FileWrite字符流

(构造器)FileWriter(File file):根据给定的 File 对象构造一个 FileWriter 对象。
(构造器)FileWriter(File file, boolean append) :根据给定的 File 对象构造一个 FileWriter 对象。
Writer append(char c): 将指定字符添加到此 writer。
Writer append(CharSequence csq):将指定字符序列添加到此 writer。
void write(char[] cbuf):写入字符数组。
void write(String str):写入字符串。
void flush():刷新该流的缓冲。
void close():刷新该流的缓冲。

import java.io.*;
public class FileText {
    public static void main(String[] args) throws IOException {
        File f = new File("E:\\java file\\text.txt");
        FileWriter fw = new FileWriter(f, true);//同FileOutputStream
        input(f);
        fw.append('字').append('符');//返回值是Write，可反复调用
        fw.append("字符序列").append("输入");//返回值是Write，可反复调用
        fw.write("void write(String str)");
        System.out.println("不刷新缓冲区，输入");
        input(f);
        fw.flush();//字符流与字节流不同，字节流直接操作内容，字符流要先保存在缓冲区
        System.out.println("刷新缓冲区后，输入");
        input(f);
        fw.close();
    }
    public static void input(File f) throws IOException {
        int a;
        FileReader fr=new FileReader(f);
        while((a=fr.read())!=-1){
            System.out.print((char)a);
        }
        System.out.println();
        fr.close();
    }
}