Java I/O

File类

1.操作文件和目录

在程序中,一个Flie对象可以代表一个文件或者目录。
它可以查出文件相关的信息，如名称，修改日期，文件大小。
Flie类的构造方法定义如下：

public File(String pathName)

创建File对象的语句如下：

File file=new File("C:\\LICENSE.txt");

常用方法：

boolean createNewFile()\创建新文件
boolean delete()\删除文件
boolean existe()\判断文件是否存在
Boolean isFile()\判断是否是文件
boolean isDirectory()\判断是否是目录
long length()\返回文件长度，单位为字节：如果文件不存在，则返回0L
String getPath()\返回文件名对应的路径
String getAbsolutePath()\返回此对象表示的文件的绝对路径

代码示例：

 File file=new File("LICENSE.txt");
 	if (file.exists()){
            if (file.isFile()){
                System.out.println("文件名："+file.getName()+",文件长度："+file.length()+"字节");
                System.out.println("文件路径："+ file.getPath());
                System.out.println("文件的绝对路径："+file.getAbsolutePath());
            }
            if (file.isDirectory()){
                System.out.println("此文件是目录");
            }
        }else {
            System.out.println("此文件不存在");
        }



        if (file.exists()){
            file.delete();
            System.out.println("文件删除成功");
        }
        if(file.exists()){
            file.exists();
        }else {
            try {
                file.createNewFile();
                System.out.println("创建成功");
            }catch (IOException ex){
                ex.printStackTrace();
            }
        }

I/O流

流：指一连串流动的字符，是以先进先出的方式发送和接收数据的通道，Java把所有流类型封装到Java.io包中，以不同的角度可以对流进行分类

1.按流向划分：输入流和输出流

输入流：只能从中读取数据，不能写入数据的流，实现程序从数据源中读数据

代码示例：

 try {
            InputStream fis=new FileInputStream("E:\\a.txt");
            try {
                System.out.println(""+fis.available());
                int data=fis.read();
                while (data !=-1){
                    System.out.println((char)data );

                    data=fis.read();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

输出流：只能向其写入数据，不能从中读取数据，实现程序向目标数据源中写数据

代码示例：

try {
            OutputStream fos = new FileOutputStream("E:\\a.txt");
            String str = "我是小明";
            byte[] words = str.getBytes();
            try {
                fos.write(words, 0, words.length);
            } catch (IOException e) {
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

2.按处理单元划分：字节流和字符流

字节流：以8位字节为操作数据单元的流，可用于操作二进制数据

字节输出流基类：OutputStream
OutputStream是抽象类，必须使用该类的子类进行实例化对象，如果需要操作文件，则需要FileOutputStream实例化

OutputStream类常用方法：

viod close() 关闭输出流
viod flussh() 刷新缓冲器
viod write(byte[] b)将每个byte数组写入数据流
viod write(byte[] b,int off,int len)将每个指定范围的byte数组写入数据流
viod write(int b)将一个字节数据写入数据流

代码示例：

 FileInputStream fis=new FileInputStream("e:\\a.txt");
 		//输入流
        byte [] bytes =new byte[3];
        while (fis.read(bytes)!=-1){
            System.out.println(new String(bytes));
        }
        //输出流
        Writer fw=new FileWriter("e:\\a.txt");
        fw.write("文化部是鼠标");
        System.out.println(1);
        fw.flush();
        fw.close();

FileOutputStream类常用的构造方法：

FileOutputStream(File file)
用于创建指定File对象写数据的文件输出流 file:指定目标文件的对象

代码示例：

 File file = new File("E:\\test.txt");
        try (FileOutputStream fos = new FileOutputStream(file)) {
            String data = "Hello, world!";
            fos.write(data.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        };

FileOutputStream(String name)
用于创建指定路径的文件写数据的文件输出流。name:指定目标文件的路径字符串

代码示例：

 String fileName = "E:\\test.txt";
        try (FileOutputStream fos = new FileOutputStream(fileName)) {
            String data = "Hello, world!";
            fos.write(data.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }

FileOutputStream(String name ,boolean, append)
用于创建指定路径的文件写数据的文件输出流。name:指定目标文件的路径字符串，
append:表示是否在文件末尾追加数据，若为ture则是表示可以在文件末尾追加数据

代码示例：

String fileName = "E:\\test.txt";
        try (FileOutputStream fos = new FileOutputStream(fileName)) {
            String data = "Hello, world!";
            fos.write(data.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }

字节输入流基类：InputStream类
InputStream也是抽象类通常使用FileInputStream子类实现文本文件内容的读取

InputStream类的常用方法:

int read() 读取一个字节数据
int read(byte[] b)将数据读取字节数组中
int read(byte[] b,int off,int len)从输入流中读取最多len长度的字节，将它保存到字节数组中，保存的位置从off开始
void close()关闭输入流
int available()返回输入流读取的字节数

代码示例：

 Reader fr=new FileReader("e:\\a.txt");
        char[] c=new char[1024];
        int len=fr.read(c);
        while (len>0){
            System.out.println(new String(c,0,len));
            len=fr.read(c);
        }
		fr.close();

FileInputStream类常用构造方法：

FileInputStream(File file)
用于创建指定File对象写数据的文件输入流 file:指定目标数据源对象

        File file = new File("E:\\test.txt");
        try (FileInputStream fis = new FileInputStream(file)) {
            int data;
            while ((data = fis.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

FileInputStream(String name)
用于创建指定File对象写数据的文件输入流 file:指定目标数据源对象
name:指定目标文件数据源字符串

        String fileName = "E:\\test.txt";
        try (FileInputStream fis = new FileInputStream(fileName)) {
            int data;
            while ((data = fis.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

字符流：以16位的字符为操作数据定义的流，可用于操作文本数据

Writer类是字符输出流的抽象基类

常用方法：

viod write(String str) 将str字符串中包含的字符输出流中
viod write(String str，int off，int len)将字符串从off位置开始，长度为len的字符输出到输出流中
viod close()关闭输出流
viod flush()刷新输出流

代码示例：

        String fileName = "E:\\test.txt";
        try (FileOutputStream fos = new FileOutputStream(fileName)) {
            String data = "Hello, world!";

            // 将字符串中包含的字符写入输出流中
            fos.write(data.getBytes());

            // 将字符串从off位置开始，长度为len的字符输出到输出流中
            int off = 7;
            int len = 5;
            fos.write(data.getBytes(), off, len);

            // 关闭输出流，释放所有与之关联的系统资源
            fos.close();

            // 刷新输出流，确保所有数据都已经被刷新到目标设备中
            fos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }

字符输出流FileWriter类
FileWriter类是Writer常用的子类，使用该类可以以字符为数据处理单元向文本文件中写数据

字符输入流基类：Reaader

常用方法:

int read() 从输入流中读取单个字符，返回所读取的字符类型
int read(char[] c)从输入流中最多读取len个字符的数据并存储在字符数组c中，返回实际读取的字符数
int read(char[] c,int off, int len)从输入流中最多读取len个字符的数据并存储在字符数组c中，存入数组c时，并不是从数组起点开始的，而是从off位置开始，返回实际读取的字符数

代码示例：

		Reader fr=new FileReader("e:\\a.txt");
        char[] c=new char[1024];
        int len=fr.read(c);
        while (len>0){
            System.out.println(new String(c,0,len));
            len=fr.read(c);
        }

字符输入流FileReader类
Reaader类它是抽象类,可以使用其子类FileReader创建对象

Reader fr=new FileReader(“e:\a.txt”);

3.按流的角色划分：节点流和处理流

节点流：可以直接向一个特定的存储介质（如磁盘，文件）读写数据的流、

处理流：用于对一个已存在的流进行连接和封装，是通过封装后的流实现数据读写操作的流

字符缓冲流

BufferedWriter类是Writer类的子类，BufferedWriter类可以把一批数据写到缓冲区，只有在缓冲区满的时候，才会把缓冲区的数据真正的目的地，

BufferedWriter类常用构造方法

BufferedWriter(Writer out) 创建一个缓冲字符输出流

代码示例：

Writer fw=new FileWriter("e:\\a.txt");
``BufferedWriter bf=new BufferedWriter(fw);

BufferedReader类是Reader类的子类，它与FileReader类的区别在于BufferedReader类有缓冲流，它可以先把一批数据读到缓冲区，接下来的读操作都是从缓冲区内获取数据

BufferedReader常用构造方法

BufferedReader(Reader in) 创建一个缓冲字符输入流

代码示例：

Reader fr=new FileReader("e:\\a.txt");
BufferedReader br=new BufferedReader(fr);

数据操作流

DataOutputStream和DataInputStream类

DataOutputStream类是OutputStream类的子类，DataOutputStream类写二进制文件的实现步骤与使用FileOutputStream类写文件的步骤极其相似，而且用到FileOutputStream类，同样，DataInputStream类是InputStream类的子类，在使用和FileInputStream类相似

代码示例：

		FileInputStream fis=new FileInputStream("D:\\whb.txt");
        DataInputStream dis=new DataInputStream(fis);
        FileOutputStream ois=new FileOutputStream("C:\\abc.txt");
        DataOutputStream fos=new DataOutputStream(ois);

序列化和反序列化

对象输入流ObjectOutputStream

对象的序列化，是把一个对象变为二进制的数据流的一种方法，通过对象序列化可以方便地实现对象的传输和存储，如果一个类的对象需要被序列化，则这个对象所属类必须实现java.io.Seriaalizable接口

public interface Seriaalizable{}

常用方法

ObjectOutputStream(OutputStream out) 创建对象输出流：属于构造方法
final void writeObject(Object obj)将指定对象写入流：属于实例方法

对象输出流ObjectInputStream

执行反序列化操作需使用对象输出流ObjecInputStream,它可以直接把序列化后的对象还原

常用方法：

ObjectInputStream(InputStream in)创建对象输入流对象：构造方法
final Object readObject() 从指定位置读取对象：实例方法

代码示例：

String fileName = "E:\\person.ser";
        try (FileOutputStream fos = new FileOutputStream(fileName);
             ObjectOutputStream oos = new ObjectOutputStream(fos)) {

            // 创建一个Person对象
            Person person = new Person("Alice", 30);

            // 将Person对象写入输出流中
            oos.writeObject(person);

            System.out.println("Person object has been written to the file.");

        } catch (IOException e) {
            e.printStackTrace();
        }
    }