I/O框架知识

I/0框架

什么是流？

• 概念：内存与存储设备之间传输数据的通道

流的分类

• 按方向（重点）

  • 输入流: 将<存储设备>的内容读入到<内存>中，

  • 输出流：将<内存>中的内容写入到<存储设备>中

 

• 按单位

  • 字节流：以字节为单位，可以读写所有数据

  • 字符流：以字符为单位，只能读写文本数据

• 按功能

  • 节点流：具有实际传输数据的读写功能

  • 过滤流：在节点流的基础上增强功能

字节流

• 字节流的父类（抽象类）

  • InputStream：字节输入流

  • OutputStream：字节输出流

序列化和反序列化

• 将对象通过流写入到文件，或将对象通过流读取到文件，必须实现Serializable接口

File对象

• 代表物理盘中的一个文件或者文件夹

文件字节流

• 文件字节输入流（FileInputStream）

import java.io.FileInputStream;

//FileInputStream的使用
//文件字节输入流
public class Demo1 {
    public static void main(String[] args) throws  Exception{
        //创建FileInputStream，并指定文件路径
        FileInputStream  fis =new FileInputStream("d:\\qqq.txt");
        //读取文件
        //1 fis.read();
        //1.1 单个字节读取
        /*int date=0;
        while ((date=fis.read())!=-1){
            System.out.print((char) date);
        }
        */
        //1.2 一次读多个字节
        byte[] buf=new byte[1024];
        int count =0;
        while ((count=fis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        /*int count=fis.read(buf);
        System.out.println(new String(buf));
        System.out.println(count);*/
        //关闭
        fis.close();
        System.out.println();
        System.out.println("执行完毕");
    }
}

 

 文件字节输出流

import java.io.FileOutputStream;

//FileOutputStream使用
//文件字节输出流
public class Demo2 {
    public static void main(String[] args) throws Exception{
        //创建文件字节输出流对象
        FileOutputStream fos=new FileOutputStream("d:\\eee.txt");
        //写入文件
        //单个写入
      /*  fos.write(97);
        fos.write('b');
        fos.write('c');
        */
      //多个写入
        String string="linxin";
        fos.write(string.getBytes());
        //关闭
        fos.close();
        System.out.println("执行完毕");
    }
}

 

 

使用文件流实现文件的复制

import java.io.FileInputStream;
import java.io.FileOutputStream;

//使用文件流实现文件的复制
public class Demo3 {
    public static void main(String[] args) throws Exception{
        //创建文件输入流
        FileInputStream fis =new FileInputStream("d:\\www.txt");
        //创建文件输出流
        FileOutputStream fos =new FileOutputStream("d:\\eee.txt");
        //一边读，一边写
        byte[] buf=new byte[1024];
        int count =0;
        while((count=fis.read(buf))!=-1){
          fos.write(buf,0,count);
        }
        //关闭
        fis.close();
        fos.close();
        System.out.println("复制完毕");
    }
}

 

字节缓冲流

• 缓冲流:BufferedInputStream/BufferedOutputStream

  • 提高IO效率，减少访问磁盘的次数

  • 数据存储在缓冲区中，flush是将缓存区的内容写入文件中，也可以直接close

import java.io.BufferedInputStream;
import java.io.FileInputStream;

//字节缓冲流读取文件
//BufferInputStream
public class Demo4 {
    public static void main(String[] args)throws Exception{
        //创建BufferInputStream
        FileInputStream fis =new FileInputStream("d:\\qqq.txt");
        BufferedInputStream bis =new BufferedInputStream(fis);
        //读取
        /*int date=0;
        while ((date=bis.read())!=-1){
            System.out.print((char )date);
        }
         */
        byte[] buf=new byte[1024];
        int count=0;
        while ((count=bis.read(buf))!=-1){
            System.out.println((new String(buf,0,count)));
        }
        //关闭
        bis.close();
        System.out.println();
        System.out.println("执行完毕");
    }
}
-----------------------------------
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

//字节缓冲流写入文件
//BufferOutputStream
public class Demo5 {
    public static void main(String[] args) throws Exception{
        //创建字节输出缓冲流
        FileOutputStream fos =new FileOutputStream("d:\\qqq.txt");
        BufferedOutputStream bos =new BufferedOutputStream(fos);
        //写入文件
        for (int i = 0; i <10 ; i++) {
            bos.write("linxinihao \n".getBytes());//先写入8k缓冲区
            bos.flush();//刷新到硬盘
        }
        //关闭（内部调用flush方法）
        bos.close();
    }
}

 

对象流

• 对象流：ObjectOutputStream/ObjectInputStream

  • 增强缓冲区功能

  • 增强了读取8种基本数据类型和字符串功能

  • 增强了读写对象的功能

    • readObject（）从流中读取一个数据

    • writeObject（Object obj）向流中写入一个对象

  • 使用流传输对象的过程称为序列化和反序列化

import java.io.Serializable;

//学生类
public class Student implements Serializable {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "name="+name+"age="+age;
    }
}
===================================================
    import java.io.FileOutputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;

//使用ObjectOutputStream实现对象的序列化
//要求;序列化的类必须要实现Serializable
public class Demo1 {
    public static void main(String[] args) throws Exception{
        //创建对象流
        FileOutputStream fos =new FileOutputStream("d:\\qqq.txt");
        ObjectOutputStream  oos =new ObjectOutputStream(fos);
        //实现序列化（写入）
        Student s1=new Student("林夕",20);
         oos.writeObject(s1);
         oos.flush();
         //关闭
        oos.close();
        System.out.println();
        System.out.println("序列化完毕");
    }
}
================================================
    //使用ObjectInputStream实现反序列化（读取重构成对象）

import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class Demo2 {
    public static void main(String[] args) throws Exception{
        //创建对象流
        FileInputStream fis =new FileInputStream("d:\\qqq.txt");
        ObjectInputStream ois=new ObjectInputStream(fis);
        //读取文件
        Student s=(Student) ois.readObject();
        //关闭
        ois.close();
        System.out.println("反序列化完毕");
        System.out.println(s.toString());
    }
}

序列化和反序列化的注意事项

• 序列化类必须要实现Serializable接口

• 序列化类中对象属性要求实现Serializable接口

• 序列化版本号ID serialVersionUID，保证序列化的类和反序列化的类是同一个类

• 使用transient（瞬间的）修饰属性，这个属性不能序列化

• 静态属性不能被序列化

• 序列化多个对象，可以借助集合实现

import java.io.FileOutputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

//使用ObjectOutputStream实现对象的序列化
//要求;序列化的类必须要实现Serializable
public class Demo1 {
    public static void main(String[] args) throws Exception{
        //创建对象流
        FileOutputStream fos =new FileOutputStream("d:\\qqq.txt");
        ObjectOutputStream  oos =new ObjectOutputStream(fos);
        //实现序列化（写入）
        Student s1=new Student("林夕",20);
        Student s2=new Student("花海",21);
        ArrayList<Student> list=new ArrayList<>();
        list.add(s1);
        list.add(s2);
        oos.writeObject(list);
         oos.flush();
         //关闭
        oos.close();
        System.out.println();
        System.out.println("序列化完毕");
    }
}
======================================
    //使用ObjectInputStream实现反序列化（读取重构成对象）

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

public class Demo2 {
    public static void main(String[] args) throws Exception{
        //创建对象流
        FileInputStream fis =new FileInputStream("d:\\qqq.txt");
        ObjectInputStream ois=new ObjectInputStream(fis);
        //读取文件
       ArrayList<Student> list=(ArrayList<Student>) ois.readObject();
        //关闭
        ois.close();
        System.out.println("反序列化完毕");
        System.out.println(list.toString());
    }
}

字符编码

• ISO-8859-1收录了出ASCII外，还包括西欧，希腊语，泰语，阿拉伯语，希伯来语对应的文字符号

• UTF-8 针对Unicode码表的可变长度字符编码

• GB2312 简体中文

• GBK 简体中文，扩码

• BIG5 台湾，繁体中文

字符流

• 字符流的父类（抽象类）、

  • Reader：字符输入流

  • Writer：字符输出流

FileReader:  public int read(char[] c)//从流中读取多个字符，将读到的数据存入c数组。返回实际读到的字符数，如果达到文件                                      的尾部，则返回-1
FileWriter： public void write（String str）//一次写入多个字符，将b数组中所有字符，写入输出流 

 

import java.io.FileReader;

//FileReader的使用
public class Deno6 {
    public static void main(String[] args)throws Exception {
        //创建FileReader流
        FileReader fr =new FileReader("d:\\qqq.txt");
        //读取数据
        //单个字符串
       /*  int date=0;
         while((date= fr.read())!=-1){
             System.out.print((char)date);
         }

        */
        char[] buf=new char[1024];
        int count=0;
        while((count= fr.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
         //关闭
        fr.close();
    }
}
========================
    import java.io.FileWriter;

//FileWriter的使用（写入文件）
public class Demo7 {
    public static void main(String[] args) throws Exception{
        //创建FileWriter对象
        FileWriter fw =new FileWriter("d:\\qqq.txt");
        //写入数据
        for (int i = 0; i < 10; i++) {
            fw.write("linxi林夕\r\n");
        }
        fw.flush();
        //关闭
        fw.close();
        System.out.println("执行完毕");
    }
}

使用文件字符流复制文件

import java.io.FileReader;
import java.io.FileWriter;
//使用文件字符流复制文件（只能复制文本）
public class Demo8 {
    public static void main(String[] args) throws Exception{
        //创建FileReader对象
        FileReader fr=new FileReader("d:\\qqq.txt");
        //创建FileWriter对象
        FileWriter fw =new FileWriter("d:\\eee.txt");
        //一边写，一边读
        char[] buf=new char[1024];
        int count=0;
        while((count=fr.read(buf))!=-1){
        fw.write(buf,0,count);
        }
        /*
        int date=0;
        while((date=fr.read())!=-1){
        fw.write(date);
        fw.flush();
        }
         */
        //关闭
        fw.close();
        fr.close();
        System.out.println("复制完毕");
    }
}

字符缓冲流

• 缓冲流：BufferedReader/BufferedWriter

  • 高效读写

  • 支持输入换行符

  • 可一次写一行，读一行

 

import java.io.BufferedReader;
import java.io.FileReader;

//使用字符缓冲流读取文件
//BufferedReader
public class Demo9 {
    public static void main(String[] args)throws Exception {
        //创建对象
        FileReader fr =new FileReader("d:\\qqq.txt");
        BufferedReader br =new BufferedReader(fr);
        //读取文件
        /*char[] buf =new char[1024];
        int count=0;
        while((count=br.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }

         */
        String line=null;
        while((line= br.readLine())!=null){
            System.out.println(line);
        }
        //关闭
        br.close();
        System.out.println("执行完毕");
    }
}
================================
    import java.io.BufferedWriter;
import java.io.FileWriter;

//使用字符缓冲流写入文件
//BufferedWriter
public class Demo10 {
    public static void main(String[] args)throws Exception {
        FileWriter fw=new FileWriter("d:\\qqq.txt");
        BufferedWriter bw =new BufferedWriter(fw);
        //写入文件
        for (int i = 0; i < 10; i++) {
            bw.write("林夕的花海，林夕");
            bw.newLine();
            bw.flush();
        }
        //关闭
        bw.close();
        System.out.println("执行完毕");
    }
}

打印流

• PrintWriter

  • 封装了print（）/println（）方法，支持写入后换行

  • 支持数据原样打印

import java.io.PrintWriter;

//演示PrintWriter的使用
public class Demo11 {
    public static void main(String[] args) throws Exception{
        PrintWriter pw=new PrintWriter("d:\\rrr.txt");
        pw.println(123);
        pw.println("明天");
        pw.println('A');
        pw.println(true);
        pw.close();
    }
}

 

转换流

• 桥转换流：InputStreamReader/OutputStreamWriter

  • 可将字节流转换为字符流

  • 可设置字符的编码方式

import java.io.FileInputStream;
import java.io.FileReader;
import java.io.InputStreamReader;

//InputStreamReader读取文件，指定使用的编码
public class Demo12 {
    public static void main(String[] args) throws  Exception{
        //创建InputStreamReader对象
        FileInputStream fis =new FileInputStream("d:\\qqq.txt");
        InputStreamReader isr =new InputStreamReader(fis,"utf-8");
        //读取文件
        int date=0;
        while((date= isr.read())!=-1){
            System.out.print((char) date);
        }
        //关闭
        isr.close();
    }
}
=====================================
    import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

//使用OutputStreamWriter写入文件,使用指定的编码
public class Demo13 {
    public static void main(String[] args) throws  Exception{
        //创建OutputStreamWriter对象
        FileOutputStream fos =new FileOutputStream("d:\\qqq.txt");
        OutputStreamWriter osw=new OutputStreamWriter(fos,"utf-8");
        //写入文件
        for (int i = 0; i <10 ; i++) {
            osw.write("你好世界！！！\r\t");
            osw.flush();
        }
        //关闭
        osw.close();
        System.out.println("执行完毕");
    }
}

File类

import javax.xml.crypto.Data;
import java.io.File;
import java.util.Date;

//File类的使用
public class Demo14 {
    public static void main(String[] args) throws Exception {
        separator();
        fileSet();
    }
    //分隔符
    public static void separator(){
        System.out.println("路径分隔符"+ File.pathSeparator);
        System.out.println("名称分隔符"+File.separator);
    }
    public static  void fileSet() throws Exception{
    //创建文件 creatNewFile（）；
    File file=new File("d:\\file.txt");
    if(!file.exists()){
        boolean b=file.createNewFile();
        System.out.println("创建结果"+b);
    }
    //删除文件
        //1 直接删
       // System.out.println("删除结果"+file.delete());
       //2 使用jvm退出时删
      //  file.deleteOnExit();
        //Thread.sleep(5000);
    //获取文件信息
        //获取绝对路径
        System.out.println("获取文件路径"+file.getAbsolutePath());
    //获取路径
        System.out.println("获取路径"+file.getPath());
        //获取文件名称
        System.out.println("获取文件名称"+file.getName());
        //获取父目录
        System.out.println("获取父目录"+file.getParentFile());
        //获取文件长度
        System.out.println("获取文件长度"+file.length());
        //获取文件创建时间
        System.out.println("文件创建时间"+new Date(file.lastModified()));
        //判断
        System.out.println("是否可写"+file.canWrite());
        System.out.println("是否是文件"+file.isFile());
        System.out.println("是否隐藏"+file.isHidden());
}
    }

 

//文件夹操作
public class Demo15 {
    public static void main(String[] args)throws Exception {
        directoryOpe();
    }
    public static void directoryOpe() throws Exception{
        //创建文件夹
        File dir=new File("d:\\qqq\\www\\eee");
        if(!dir.exists()){
            //dir.mkdir()只能创建单级目录
            //dir.mkdirs()可以创建多级目录
            System.out.println(dir.toString());
            System.out.println("创建结果："+dir.mkdirs());
        }
        //删除文件夹
        //直接删除（删除空目录）
       // System.out.println( "删除结果"+dir.delete());
        //使用jvm进行删除
       // dir.deleteOnExit();
        //Thread.sleep(500);
        //获取文件信息
        System.out.println("获取绝对路径"+dir.getAbsolutePath());
        System.out.println("获取路径"+dir.getPath());
        System.out.println("获取文件名称"+dir.getName());
        System.out.println("获取父目录"+dir.getParentFile());
        System.out.println("获取创建时间"+new Date(dir.lastModified()).toLocaleString());
        //判断是否是文件夹
        System.out.println("是否是文件夹"+dir.isDirectory());
        System.out.println("是否是隐藏文件夹"+dir.isHidden());
        //遍历文件夹
        File dir2=new File("d:\\QQ");
        String[] file=dir2.list();
        System.out.println("=======================");
        for (String string:file
             ) {
            System.out.println(string);
        }
        System.out.println("-----------------------");
        //FileFilter接口的使用
        //当调用File类中的listFiles（）方法时，支持传入FileFilter接口实现类，
        // 对获取的文件进行过滤，只有满足条件的文件才能出现在listFiles（）的返回值中
       File[] file1= dir2.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if(pathname.getName().endsWith(".txd")){
                    return true;
                }
                return false;
            }
        });
        for (File files:file1
             ) {
            System.out.println(files.getName());
        }
    }
}

文件夹的递归遍历与递归删除

 

import java.io.File;

//文件夹递归遍历
//文件夹递归删除
public class Demo16 {
    public static void main(String[] args) {
      //listDir(new File("d:\\垃圾"));
        deleteDir(new File("d:\\垃圾"));
    }
    /*public static void listDir(File dir){
        File[] files=dir.listFiles();
        System.out.println(dir.getAbsolutePath());
        if (files!=null&&files.length>0){
            for (File file:files) {
                if(file.isDirectory()){
                listDir(file);//递归
            }else{
                System.out.println(file.getAbsolutePath());
            }
            }
        }
    }

     */
    //递归删除文件夹
    public static void deleteDir(File dir){
            File[] file=dir.listFiles();
            if (file!=null&&file.length>0){
                for (File files:file) {
                    if (files.isDirectory()){
                        deleteDir(files);
                    }else{
                        System.out.println(files.getAbsolutePath()+"删除"+files.delete());
                    }
                }
            }
        System.out.println(dir.getAbsolutePath()+"删除"+dir.delete());
    }
}

Properties

• properties:属性集合

• 特点

  • 存储属性名和属性值

  • 属性名和属性值都是字符串类型

  • 没有泛型

  • 和流有关

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

//properties集合的使用
public class Demo17 {
    public static void main(String[] args)throws Exception {
        //创建集合
        Properties properties=new Properties();
        //添加数据
        properties.put("name","花海");
        properties.put("age","18");
        System.out.println(properties);
        //遍历
        //keySet
        Set<Object> keySet=properties.keySet();
        for (Object key:properties.keySet()
             ) {
            System.out.println(key+"---"+properties.get(key));
        }
        System.out.println("======================");
     //EntrySet
        for (Map.Entry<Object,Object> entry:properties.entrySet()
             ) {
            System.out.println(entry.getKey()+"---"+entry.getValue());
        }
        System.out.println("--------------");
        //stringPropertyName()
        Set<String> pronames=properties.stringPropertyNames();
        for (String pro:pronames
             ) {
            System.out.println(pro+"===="+properties.getProperty(pro));
        }
        System.out.println("=================");
        //和流有关的方法
       // PrintWriter pw=new PrintWriter("d:\\qqq.txt");
        //properties.list(pw);
        //pw.close();
        //store保存
       // FileOutputStream fos=new FileOutputStream("d:\\store.properties");
        //properties.store(fos,"注释");
        //fos.close();
        //load加载
        Properties properties1=new Properties();
        FileInputStream fis=new FileInputStream("d:\\store.properties");
        properties1.load(fis);
        fis.close();
        System.out.println(properties1.toString());
        }
    }