File I/O（2）

最新推荐文章于 2023-04-21 12:39:45 发布

Dylan_wf

最新推荐文章于 2023-04-21 12:39:45 发布

阅读量368

点赞数

分类专栏： java高级特性文章标签： io java高级特性

本文链接：https://blog.csdn.net/Dylan_wf/article/details/78420284

版权

java高级特性专栏收录该内容

6 篇文章 0 订阅

订阅专栏

File不能访问文件的内容，即不能从文件中读取数据或者向文件中写入数据，这时就要用到流。

读文件，是指把文件中的数据读到内存中，写文件，是指把内存中的数据写到文件中。

流：是指一串流动的字符，以先进先出的方式发送和接收数据的通道。流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。

IO流的分类

根据处理数据类型的不同分为：字符流和字节流
根据数据流向不同分为：输入流和输出流

字符流和字节流

字符流的由来：因为数据编码的不同，而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时，去查了指定的码表。

字节流和字符流的区别：

读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。
处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。
结论：只要是处理纯文本数据，就优先考虑使用字符流。 除此之外都使用字节流。

Java流操作有关的类或接口：
这里写图片描述

Java流类图结构：
这里写图片描述

字节输入流InputStream:

实际应用中使用FileInputStream
public class Main {

public static void main(String[] args) {  
    FileInputStream fis=null;
    try {
        fis=new FileInputStream("D:\\java.txt");
        int data;
        try {
            System.out.println("可读取的字节数："+fis.available());
            System.out.println("文件内容为：");
            while((data=fis.read())!=-1){//如果fis.read没有读到数据返回-1
                System.out.print((char)data);//强转为char类型，否则输出的是整数
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }finally{
        if(fis!=null){
            try {
                fis.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

}

字节输出流OutputStream:

同样，实际应用中使用FileOutputStream
注意：为防止覆盖文件原有的内容，构造方法最好为此种形式：
FileOutputStream fos=new FileOutputStream("D:\\a.txt",true)true表示在文件末尾增加数据。

public class Main {  

    public static void main(String[] args){  
        FileOutputStream fos=null;
        String str="好好学习";
        byte[] b=str.getBytes();//字节数组
        //创建输出字节流对象
        try {
            fos=new FileOutputStream("D:\\java.txt",true);
            fos.write(b, 0, b.length);
            System.out.println("写入");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{

                try {
                    if(fos!=null){
                    fos.close();}
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

        }
    }
}

综合运用

public class Main {  

    public static void main(String[] args){  
        FileInputStream fis=null;//先在try catch外声明，方便finally里关闭流
        FileOutputStream fos=null;
        try {
            fis=new FileInputStream("D:\\我.txt");
            fos=new FileOutputStream("E:\\我.txt",true);
            byte[]b=new byte[1024];
            int len;//存储读入数组的长度
            while((len=fis.read(b))!=-1){
                fis.read(b);//读取到字符数组中
                fos.write(b, 0, len);
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            //关闭流
            //一般情况下是：先打开的后关闭，后打开的先关闭
            //但是有一种情况：要看依赖关系，如果流a依赖流b，应该先关闭流a，再关闭流b
                try {
                    if(fos!=null){
                    fos.close();
                    }
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                try {
                    if(fis!=null){
                    fis.close();
                    }
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
        }
    }
}

字符输入流Reader

使用其子类FileReader

public class Main {  

    public static void main(String[] args){  
        Reader fr=null;
        StringBuffer sb=null;
        try {
            fr=new FileReader("D:\\我.txt");
            char ch[]=new char[1024];
            sb=new StringBuffer();
            int length=fr.read(ch);//读取数据存放到ch字符数组，并返回length长度
            while(length!=-1){
                sb.append(ch);
                length=fr.read();
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            if(fr!=null){
                try {
                    fr.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }

    }
}

缓冲字符输入流BufferedReader：
自带缓冲区，可以先把一批数据读到缓冲区，然后从缓冲区读取数据，避免每次都是从数据源读取数据进行字符编码转换，从而提高效率。

Reader fr=new FileReader("D:\\a.txt");
BufferedReader br=new BufferedReader(fr);//创建对象
br.readLine()//特有方法，读取一行数据，返回字符串
br.close();//关闭流对象
fr.close();

public class Main {  

    public static void main(String[] args){  
        FileReader fr=null;
        BufferedReader br=null;

        try {
            fr=new FileReader("D:\\java.txt");
            br=new BufferedReader(fr);//创建br对象
            String line=br.readLine();//读取一行
            while(line!=null){
                System.out.println(line);
                line=br.readLine();
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }//创建fr对象
        catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            if(br!=null){
                try {
                    br.close();//先关br
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if(fr!=null){
                try {
                    fr.close();//再关fr
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }

    }
}

字符输出流Writer

使用其子类FileWriter

public class Main {  

    public static void main(String[] args){  
        Writer fw=null;
            try {
                fw=new FileWriter("D:\\java1.txt");
                fw.write("哈哈哈aaa");
                fw.flush();//刷新缓冲区
            } catch (IOException e) {
                e.printStackTrace();
            }finally{
                    try {
                        if(fw!=null){
                        fw.close();}
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }   
    }
}

缓冲字符输出流BufferedWriter ：
自带缓冲区，可以先把一批数据写到缓冲区，缓冲区写满的时候，再把缓冲区的数据写到字符输出流中，避免每次都执行物理操作，从而提高效率。

public class Main {  

    public static void main(String[] args){  
        FileWriter fw=null;
        BufferedWriter bw=null;
        try {
            fw=new FileWriter("D:\\java2.txt");
            bw=new BufferedWriter(fw);
            bw.write("hhh");
            bw.newLine();//插入换行符
            bw.write("啊");
            bw.flush();//刷新缓冲区
            fw.close();//关闭流
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }   
    }
}

序列化和反序列化

序列化：
将对象的状态存储到特定存储介质的过程。序列化过程会将对象的公有成员，私有成员（包括类名）转换为字节流，再将字节流写入数据流存储到存储介质中。

意义：序列化后可以转换为字节序列，这些字节序列可以保存在磁盘也可以通过网络传输，同时由于序列化的对象保存的是二进制状态，实现了平台无关性，无须担心数据因为平台问题显示异常。

序列化步骤：
1.创建一个对象输出流(ObjectOutputStream)
2.通过对象输出流的writeObject（）方法写对象，输出可序列化对象。

import java.io.Serializable;

public class Student implements Serializable{
private String name;
private String sex;
private int age;
public Student(String name, String sex, int age) {
    super();
    this.name = name;
    this.sex = sex;
    this.age = age;
}
public Student() {
    super();
    // TODO Auto-generated constructor stub
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public String getSex() {
    return sex;
}
public void setSex(String sex) {
    this.sex = sex;
}
public int getAge() {
    return age;
}
public void setAge(int age) {
    this.age = age;
}
@Override
public String toString() {
    return "Student [name=" + name + ", sex=" + sex + ", age=" + age + "]";
}

}

package test;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

public class SerializableObj {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ObjectOutputStream oos=null;

        try {
            //创建输出流
            oos=new ObjectOutputStream(new FileOutputStream("D:\\student.txt"));
            Student stu=new Student("安娜","女",18);
            Student stu1=new Student("玛丽","女",20);
            List list=new ArrayList();
            list.add(stu);
            list.add(stu1);
            //写入输出流
            oos.writeObject(list);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{

                try {
                    if(oos!=null){
                    oos.close();}//关闭输出流
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
        }           
    }
}

反序列化：
从特定存储介质中将数据重新构建对象的过程。
步骤：
1.创建一个对象输入流(ObjectInputStream)
2.通过他的readObject（）方法读取对象，返回的是object类型，需要强转。

package test;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;

public class SerializableReadObj {

    public static void main(String[] args) {
        ObjectInputStream ois=null;
        try {
            //输入流
            ois=new ObjectInputStream(new FileInputStream("D:\\student.txt"));
            //反序列化，并强转
            ArrayList<Student> list=(ArrayList<Student>) ois.readObject();
            //增强for循环遍历
            for(Student stu:list){
                System.out.println("姓名："+stu.getName()+"年龄："+stu.getAge()+"性别:"+stu.getSex());
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{

                try {
                    if(ois!=null){
                    ois.close();}
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
    }
}

Dylan_wf

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
File I/O（2）

File不能访问文件的内容，即不能从文件中读取数据或者向文件中写入数据，这时就要用到流。读文件，是指把文件中的数据读到内存中，写文件，是指把内存中的数据写到文件中。流：是指一串流动的字符，以先进先出的方式发送和接收数据的通道。流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作
复制链接

扫一扫

专栏目录