文章目录

• IO
• • IO的体系结构
  • File类
  • • File类的构造方法
    • File类常用方法
  • 输入流与输出流
  • 字节流与字符流
  • • 字节流
    • 字符流
  • 节点流与处理流
  • • 节点流
    • 处理流
  • Print流
  • 对象输入输出流

IO

IO的体系结构

File类

文件和目录路径的抽象表示；

一个File类的对象表示计算机硬盘上的一个文件和目录；

File类的构造方法

//在当前目录下创建一个与demo.txt文件名相关联的文件对象
File f1 = new File("demo.txt"); 
//指明详细的路径以及文件名 
File f2 = new File("E:","demo.txt"); 
//指明详细的路径以及目录名
File pf = new File("E:");
File cf = new File(pf,"demo.txt");

File类常用方法

public class FileDemo1 {
    /*
       一个File类的对象,表示计算机硬盘上的一个文件和目录。
     */
    public static void main(String[] args) {
         /*
           File类的构造方法
        File f1 = new File("E:/demo.txt");

        File f2 = new File("E:","demo.txt");

        File pf = new File("E:");
        File cf = new File(pf,"demo.txt");
         */
        //File类常用方法
        File f = new File("E:/demo.txt");
        System.out.println(f.canRead());
        System.out.println(f.canWrite());
        System.out.println(f.getPath()); //获得路径
        System.out.println(f.getName()); //获取文件名
        System.out.println(f.getParent()); //E:\
        System.out.println(f.length());//文件内容长度,以字节为单位
        System.out.println(f.isFile());//是否是文件
        System.out.println(f.isDirectory());//是否为目录
        System.out.println(f.isAbsolute());//路径名是否是绝对的
        System.out.println(f.isHidden());//是否为隐藏文件
        System.out.println(f.exists());//文件是否存在
        System.out.println(f.lastModified());//对文件最后一次修改的是时间
        System.out.println(new Date(1639485687368L));
    }
}

输入流与输出流

输入：把电脑硬盘上的文件（数据）读入到程序中

输出：把程序上的数据写到目标地址中

流按着数据的传输方向分为：

输入流：往程序中读叫输入流。

输出流：从程序中往外写叫输出流。

字节流与字符流

字节流

每次读取数据时以字节为单位；

InputStream和OutputStream的子类都是字节流 ；

可以读写二进制文件，主要处理音频、图片、歌曲、字节流,处理单元

为1个字节。

public class Demo1 {

    public static void main(String[] args) {
              //把E盘中的demo.txt文件 复制到 F demo.txt
         //File f = new File("E:/demo.txt");
         FileInputStream in = null;
         FileOutputStream out = null;
        try {
            //创建字节输入流对象.接入到指定的文件上,如果找不到文件 会报异常
            in  = new FileInputStream("E:/demo.txt");
            //创建一个字节输出流对象,同时创建一个空文件, 如果路径不对,会报异常
            out = new FileOutputStream("E:/demo1.txt");
             //in.read() 返回int类  表示读到的那一个字节. 如果文件内容读完了,返回-1.
            int b = 0;
            while((b=in.read())!=-1){
                out.write(b);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件找不到");
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("读或写异常");
        }finally {
            try {
                if(in!=null){
                    in.close();//释放文件资源
                }
                if(out!=null){
                    out.close();
                }
            }catch (IOException ex){

            }
        }
    }
}

字符流

每次以字符为单位进行读取操作；

Reader和Writer的子类都是字符流 ；

主要处理字符或字符串，字符流处理单元为1个字符。

节点流与处理流

根据封装类型不同流又分为 :节点流 、处理流

节点流

流对象中直接包含数据，对数据进行操作。

节点流中常用类：

字节输入流 FileInputStream

字节输出流 FileOutputStream

字符输入流 FileReader

字符输出流 FileWriter

public class Demo3 {

    public static void main(String[] args) throws IOException {

        //节点流: 直接包含数据,对数据进行操作
        InputStream in = new FileInputStream("E:/feige.exe");
        OutputStream out = new FileOutputStream("E:/feige1.exe");

        //创建处理流(包装流)  底层有一个缓冲数组,每次将读到的数据先存入到缓冲数组中,等缓冲数组满了之后在实际操作
        // 一旦自己定义的数组长度大于缓冲区数组大小,缓冲区数组就失效了
        BufferedInputStream bin = new BufferedInputStream(in);
        BufferedOutputStream bout = new BufferedOutputStream(out);
        byte[] bytes = new byte[1024];
        int size = 0;
        while ((size = bin.read(bytes)) != -1) {
            bout.write(bytes, 0, size);
        }
        bin.close();
        bout.flush();//刷新缓冲区
        bout.close();
    }
}

处理流

如果流封装的是其它流对象，称为处理流。

处理流提供了缓冲功能，提高读写效率，同时增加了一些新的方法。

处理流中常用类 ：

缓冲字节输出流 BufferedOutputStream

缓冲字节输入流 BufferedInputStream

缓冲字符输入流 BufferedReader

缓冲字符输出流 BufferedWriter

public class CharDemo2 {
    public static void main(String[] args) throws IOException {
        FileReader reader = new FileReader("E:/demo.txt");
        FileWriter writer = new FileWriter("E:/demo.txt",true); //向文件中追加内容
        BufferedReader breader = new BufferedReader(reader);
        BufferedWriter bwriter = new BufferedWriter(writer);
        //readLine()每次读一行数据，读完返回null
        String s = null;
        while ((s=breader.readLine())!=null){
            bwriter.write(s);
            bwriter.newLine(); //换行
        }
        breader.close();
        bwriter.flush();
        bwriter.close();
    }
}

Print流

打印流只做输出，不做输入，单向从程序中向外输出。

public class PrintWriterDemo {
    public static void main(String[] args) throws FileNotFoundException {
        PrintWriter out = new PrintWriter("E:/demo.html");
        out.print("<h1>aaa</h1>"); //print打印不换行
        out.println("<h1>bbb</h1>"); //println打印换行
        /*底层都用的是write()*/
        out.write("<h1>ccc</h1>");
    }
}

对象输入输出流

对象：程序运行时，创建的对象。

将对象信息写出到文件中，做到持久保存（序列化）。

对象的输出流： ObjectOutputStream

对象的输入流: ObjectInputStream

public class Users implements Serializable {
    //为类生成一个唯一编号，
    // 如果不显示的声明此编号，运行时默认会生成一个，但是类一旦改变编号也会变
    private static final long serialVersionUID = 416774116252187404L;

    private int num;
    private String name;

    public Users(int num, String name) {
        this.num = num;
        this.name = name;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Users{" +
                "num=" + num +
                ", name='" + name + '\'' +
                '}';
    }
}

public class ObjectDemo1 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //对象输出
        FileOutputStream fout = new FileOutputStream("E:/obj.txt");
        ObjectOutputStream out = new ObjectOutputStream(fout);
        Users users = new Users(100,"Amy");
        out.writeObject(users); //对象序列化，将程序运行时创建的对象输出到指定的文件中，持久保存
        out.close();

        //对象输入
        FileInputStream in = new FileInputStream("E:/obj.txt");
        ObjectInputStream oin = new ObjectInputStream(in);
        Users users1 = (Users) oin.readObject(); //对象反序列化，是java创建对象的方法之一
        System.out.println(users1);
    }
}