目录

 IO流体系结构

文件基础知识 

常用的文件操作

 获取文件信息方法 

 IO流原理和流的分类

IO流常用的类

节点流

FileInputStream 字节输入流

FileoutputStream 字节输出流

实现拷贝任务。

字符流FileRead和FileWrite

​编辑 FileRead

FileWriter

节点流和处理流

缓冲流 

BufferedReader

BufferedWriter

复制操作

BufferedInputStreamBufferedOutputStream复制二进制文件

对象处理流 

ObjectOutputStream 序列化保存

 ObjectInputStream 反序列化

标准输入输出流

结点和处理流

 ImputStreamReader

 OutputStreamWriter

 打印流printStream和printWriter

 Properties类

 IO流体系结构

文件基础知识 

 

常用的文件操作

 获取文件信息方法 

@Test
    public void info(){
        File file = new File("e:\news1.txt");
        System.out.println("文件名字"+file.getName());
        System.out.println("文件绝对路径"+file.getAbsolutePath());
        System.out.println("文件父目录"+file.getParent());
        System.out.println("文件大小"+file.length());
        System.out.println("文件是否存在"+file.exists());
        System.out.println("是不是一个文件"+file.isFile());
        System.out.println("是不是一个目录"+file.isDirectory());
    }

 IO流原理和流的分类

 

字节流主要用来处理二进制文件（doc、音频、视频），也可以处理文本文件

字符流用来处理字符文件（文本文件） 

IO流常用的类

 类的继承关系

节点流

FileInputStream 字节输入流

 read（）读取文件中的数据

如果文件中有中文，会出现中文乱码问题

 @Test
    public void readFile01(){
        String filePath = "e:\IoTest\hello.txt";
        int read = 0;
        FileInputStream fileInputStream =null;
        try {
            fileInputStream = new FileInputStream(filePath);
            while ((read = fileInputStream.read()) != -1){
                System.out.print((char)read);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {//关闭流 释放资源
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

 read（byte[] b）一次性一个数组长度的字符

@Test //使用read（byte[] b）的方法一次性读取多个字符
    public void readFile02(){
        String filePath = "e:\IoTest\hello.txt";
        int read = 0;
        //新建个数组
        byte[] buf =new byte[8];//一次读取8个字符
        int readLen = 0;
        FileInputStream fileInputStream =null;
        try {
            fileInputStream = new FileInputStream(filePath);
            //该输入流最多读取b。length字节的数据到字节数组。
            //返回值为-1 表示读取完毕
            //如果读取正常，返回读取的字符数
            while ((readLen = fileInputStream.read(buf)) != -1){
                System.out.print(new String(buf,0,readLen));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {//关闭流 释放资源
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

FileoutputStream 字节输出流

 write（）三种输出到文件方法

 @Test
    public void writeFile(){
        String filePath = "e:\IoTest\hello.txt";
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream(filePath);
             //方法一

            //方法2

            //方法3输出指定长度字符串
            String string = "hhh hello world";
            fileOutputStream.write(string.getBytes(),0,3);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

上面的方法会覆盖原来的内容，要想追加用

实现拷贝任务。

public class FileCopy {
    public static void main(String[] args) {
        byte[] buf = new byte[1024];
        int fileLen = 0;

        FileInputStream fileInputStream =null;
        FileOutputStream fileOutputStream =null;
        String filePath1 ="e:\copy.png";
        String filePath2 ="d:\copy.png";
        try {
            fileInputStream = new FileInputStream(filePath1);
            fileOutputStream = new FileOutputStream(filePath2);
            while ((fileLen = fileInputStream.read(buf))!= -1){//边读边传
                fileOutputStream.write(buf,0,fileLen);
            }


        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileInputStream != null){
                    fileInputStream.close();
                }
                if (fileOutputStream != null){
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }
}

字符流FileRead和FileWrite

 FileRead

 单个字符读取

@Test //单个字符读取
    public void Reader01(){
    FileReader fileReader01 =null;
    String filePath = "e:\hello.txt";
    int date = 0;
        try {
        fileReader01 = new FileReader(filePath);
        //单个字符读取
        while ((date = fileReader01.read())!= -1){
            System.out.print((char) date);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (fileReader01 != null){
            try {
                fileReader01.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

数组读取

@Test //数组读取
    public void reader(){
        FileReader fileReader02 =null;
        char[] buf = new char[10];
        int readLen = 0;
        String filePath = "e:\hello.txt";
        try {
            fileReader02 = new FileReader(filePath);
            while ((readLen = fileReader02.read(buf)) != -1){
                System.out.println(new String(buf,0,readLen));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileReader02 != null){
                try {
                    fileReader02.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

FileWriter

使用方法

@Test
    public void writer(){
        FileWriter fileWriter = null;
        String filePath ="e:\hello.txt";
        char[] buf = {'A','B','C'};

        try {
            fileWriter = new FileWriter(filePath);
            fileWriter.write('擦');//输入单个字符
            fileWriter.write("输入整个字符串");//输入
            fileWriter.write("输入整个字符串",0,3);
            fileWriter.write(buf);//输入整个buf数组
            fileWriter.write(buf,0,1);//输入buf数组0-1部分
            

            System.out.println("添加成功");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

节点流和处理流

 

缓冲流 

BufferedReader

//bufferedReader 使用
public class BufferedReader_ {
    public static void main(String[] args) throws Exception {
        String filePath = "e:\hello.txt";
        String line;//按行读取
        //创建bufferedReader
        BufferedReader bufferedReader =new BufferedReader(new FileReader(filePath));
        while ((line = bufferedReader.readLine()) != null){//readLine 返回为null时表示为读取完毕
            System.out.println(line);
        }
        bufferedReader.close();//只需要关闭bufferedReader就行，传入的new FileReader(filePath)会在底层关闭
    }
}

BufferedWriter

public class BufferedWriter_ {
    public static void main(String[] args) throws IOException {
        String filePath = "e:\hello.txt";
        char[] buf ={'a','b','c'};
        //创建BufferedWriter
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath,true));
        bufferedWriter.write("红红火火恍恍惚惚");
        bufferedWriter.newLine();//插入一个换行
        bufferedWriter.write(buf,1,2);
        //关闭外层流
        bufferedWriter.close();
    }
}

复制操作

public class BufferedCopy_ {
    public static void main(String[] args) throws IOException {
        String filePath = "e:\hello.txt";
        String destFilePath = "d:\hello.txt";
        String line;
        BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(destFilePath));
        while ((line = bufferedReader.readLine()) != null){
            bufferedWriter.write(line);//每读取一行，粘贴一行
            bufferedWriter.newLine();//换行
            System.out.println("以复制过去一行");
        }
        bufferedReader.close();
        bufferedWriter.close();
    }
}

BufferedInputStreamBufferedOutputStream复制二进制文件

public class BufferedCopy02_ {
    public static void main(String[] args) throws IOException {
        int date = 0;
        byte[] buf = new byte[1080];//每次读取1080个字节
        String srcFilePath = "e:\copy.png";//初始路径
        String destFilePath = "d:\copy.png";//复制后路径
        BufferedInputStream bufferedReader =
new BufferedInputStream(new FileInputStream(srcFilePath));//使用BufferedInputStream创建对象
        BufferedOutputStream bufferedOutputStream =
new BufferedOutputStream(new FileOutputStream(destFilePath));//使用BufferedInputStream创建对象
        while ((date = bufferedReader.read(buf)) != -1){//循环取出字节，当bufferedReader.read(buf) = -1时表示取出完毕
            bufferedOutputStream.write(buf,0,date);
        }
        //关闭流
        bufferedOutputStream.close();
        bufferedReader.close();

    }
}

对象处理流 

ObjectOutputStream 序列化保存

//演示ObjectOutputStream的使用，完成数据的序列化
public class ObjectOutputStream_ {
    public static void main(String[] args) throws IOException {
        //序列化后，保存的文本格式不是纯文本，而是按照他的格式来保存
        String filePath = "e:\data.dat";
        ObjectOutputStream objectOutputStream =
                new ObjectOutputStream(new FileOutputStream(filePath));
        //序列化数据到指定位置
        objectOutputStream.writeInt(100);//int-->Integer(实现了Serializable)
        objectOutputStream.writeBoolean(true);//boolean->Boolean(实现了Serializable)
        objectOutputStream.writeChar('a');//char -Character
        objectOutputStream.writeDouble(0.5);//double Double
        objectOutputStream.writeUTF("是是是");//String
        objectOutputStream.writeObject(new Dog("旺财",10));
        objectOutputStream.close();
        System.out.println("数据保存完毕(以序列化形式)");
    }
}
class Dog implements Serializable {
    private String name;
    private int age;

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

 这些类都实现了Serializable接口，如下图。所有我们要把 Dog类也实现下。

 看下保存的文件

出现乱码很正常，因为这个文件不是存文本的。 

 ObjectInputStream 反序列化

//演示ObjectOutputStream的使用，完成数据的序列化
public class ObjectOutputStream_ {
    public static void main(String[] args) throws IOException {
        //序列化后，保存的文本格式不是纯文本，而是按照他的格式来保存
        String filePath = "e:\data.dat";
        ObjectOutputStream objectOutputStream =
                new ObjectOutputStream(new FileOutputStream(filePath));
        //序列化数据到指定位置
        objectOutputStream.writeInt(100);//int-->Integer(实现了Serializable)
        objectOutputStream.writeBoolean(true);//boolean->Boolean(实现了Serializable)
        objectOutputStream.writeChar('a');//char -Character
        objectOutputStream.writeDouble(0.5);//double Double
        objectOutputStream.writeUTF("是是是");//String
        objectOutputStream.writeObject(new Dog("旺财",10));
        objectOutputStream.close();
        System.out.println("数据保存完毕(以序列化形式)");
    }
}

反序列化成功 如果要重写toString方法，记得要再序列化一次再反序列化。要不然会抛出异常。

可以理解成dog的存储内容也变了。

 

 3.

加了这句话后如果对Dog类进行修改，程序就不会认为你是个全新的类，会认为只是版本号的修改 

标准输入输出流

public static void main(String[] args) {
        //System 类的 public final static InputSteam in = null；
        //System.in 编译类型 InputStream
        //System,in 运行类型 BufferedInputStream
        //代表标准输入 键盘
        System.out.println(System.in.getClass());

        //System.in 编译类型 printStream
        //System,in 运行类型 printStream
        //代表标准输出 显示器
        System.out.println(System.out.getClass());

        //用法
        System.out.println("hello");
        Scanner scanner = new Scanner(System.in);
        String next = scanner.next();
        System.out.println(next);
    }

结点和处理流

读取文件如下

public class CodeQuestion {
    public static void main(String[] args) throws IOException {
        //读取文件
        //思路 使用BufferedReader对象读取文件
        //默认条件下是按照 utf-8 编码
        String filePath = "e:\hello.txt";
        BufferedReader bufferedReader =
                new BufferedReader(new FileReader(filePath));
        String s = bufferedReader.readLine();
        System.out.println(s);
        bufferedReader.close();
    }
}

没有任何问题，但这是读取编码为UTF-8的文件，我们把文件格式换一个读取试试 

出现了乱码，结点和处理流就是用来防止乱码的，出现这个问题的根本原因是没有指定这个文件的编码方式。

 

 ImputStreamReader

//用InputStreamReader 解决中文乱码问题
//将字节流 FileStreamReader 转成字符流 InputStreamReader
public class InputStreamReader_ {
    public static void main(String[] args) throws IOException {
        String filePath ="e:\hello.txt";
        // FileStreamReader 转成字符流 InputStreamReader 将InputStreamReader 转成 BufferedReader指定编码为gdk
        BufferedReader br =
                new BufferedReader(new InputStreamReader(new FileInputStream(filePath),"gbk"));
        String len = br.readLine();
        System.out.println(len);
    }
}

 OutputStreamWriter

 

 打印流printStream和printWriter

 字节打印流printStream

public class PrentStream {
    public static void main(String[] args) throws IOException {
        PrintStream out = System.out;
        out.println("sdads");//在标准情况下，PrintStream输出数据位置是 标准输出 （显示器）
        //因为Print底层用的是write 使用可以直接调用write进行打印
        out.write("sdasfasd".getBytes());

        //修改打印流输出的位置或设备
        System.setOut(new PrintStream("e:\t1.txt"));
        System.out.println("hello zzz");
        out.close();
    }

}

 字符打印流printWriter

public class PrintWriter_ {
    public static void main(String[] args) throws IOException {
        PrintWriter printWriter = new PrintWriter(//FileWriter(System.in)就是默认输出位置
                new FileWriter("e:\t1.txt"));
        printWriter.println("hhhhhh,您好");
        printWriter.close();
    }
}

 Properties类

 

 

//使用Properties来读取对象
public class Properties1 {
    public static void main(String[] args) throws IOException {
        //1。创建Properties对象
        Properties properties = new Properties();
        //2.指定文件
        String filePath = "src\mysql.properties";
        properties.load(new FileReader(filePath));
        //3.把键值对显示到控制台
        //properties.list(System.out);

        //根据k 获取对应的值(读取)
        String user = properties.getProperty("user");
        System.out.println(user);

        //创建（如果该文件没有这个key 是成绩，有这个key就是修改
        properties.setProperty("charset","utf8");
        properties.setProperty("pwd","abc111");
        properties.setProperty("name","汤姆");
        //将配置文件存储到文件中
        properties.store(new FileOutputStream
                ("src\mysql.properties"),null);//这里的null代表注释
    }
}