java 核心技术-------＞ IO流动

1号全栈玩家

已于 2024-05-09 10:46:09 修改

阅读量1k

点赞数 28

分类专栏： java0到1 文章标签： java 开发语言

于 2023-12-07 16:48:07 首次发布

本文链接：https://blog.csdn.net/weixin_71942139/article/details/134734804

版权

java0到1 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

IO流分类：

什么是IO流;存储和读取数据的解决方案

I：input

O：output

流：像水流一样的传输数据

IO 流的作用？

用于读写数据（本地文件，网络）

IO流按照流量可以分类哪两种：

输出流：程序 =》文件

输入流：文件 =》程序

4.IO流按照操作文件的类型可以分类哪两种流？

字节流：可以操作所有类型的文件

字符流:只能操作纯文本的文件

5、什么是纯文本文件？

用windows系统自带的记事本打开并且能读懂的文件txt文件，md文件，xml文件，lrc文件等等

FileOutputStream:

操作本地文件的字节输出流，可以把程序中的数据写到本地文件中。

书写步骤：

1、创建字节输出流对象

细节1：参数是字符串表示的路径或则是File对象都是可以的

细节2：如果文件不存在创建一个新的文件，但是要办证父级路径是存在的

细节3：如果文件已经存在，则会清空文件

2、写数据

细节：write方法的参数是整数，但是实际上写到本地文件中的是整数在ASCII上对应的字符

97——>a

100 ---->d

3、释放资源

细节：每次使用完流之后都要释放资源

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo1 {
    public static void main(String[] args) throws IOException {
        //1、创建对象
        //写出 输出流OutStream
        //本地文件  File
        FileOutputStream fos = new FileOutputStream("D:\\jdk\\code\\IoStearm\\a.txt");
        //2、写入数据
        fos.write(97);
        //3、释放资源
        fos.close();
    }
}

FileOutputStream写数据的3种方式:

FileOutputStream写数据的两个小问题：

如何换行写？

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class ByteStreamDemo1 {
    public static void main(String[] args) throws IOException {
        //1、创建对象
        FileOutputStream fos = new FileOutputStream("D:\\jdk\\code\\IoStearm\\b.txt");
        //2、写出数据:
        String str = "kankelaoyezuishuai";
        byte[] bytes = str.getBytes();
        fos.write(bytes);
        /*
        * 换行写：
        *   window: \r\n
        *   linux:  \n
        *   mac:    \r
        * 细节：window的操作系统中java对回车换行进行了优化，
        * 虽然玩完整的是\r\n。但是\r或\n，java也可以实现换行，因为java在底层会不全
        * 建议：不要省略，还是写全了
        * */
        //换行
        String wrap = "\r\n";
        byte[] bytes3 = wrap.getBytes();
        fos.write(bytes3);

        String str2 = "666";
        byte[] bytes2 = str2.getBytes();
        fos.write(bytes2);
        fos.close();
        
    }
}

如何续写？

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

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

        //续写，如果想要继续续写，打开续写开关即可
        //开关位置：创建对象的第二个参数
        //默认：false。表示关闭续写，，此时创建对象会清空文件
        //手动传递，true表示：此时创建对象不会清空文件

        //1、创建对象
        FileOutputStream fos = new FileOutputStream("D:\\jdk\\code\\IoStearm\\b.txt",true);
        //写出数据
        String str = "\r\nIloveHJ";
        byte[] bytes = str.getBytes();
        fos.write(bytes);

    }
}

总结：

1.FileOutputStream的作用
可以把程序中的数据写到本地文件上，是字节流的基本流
2.书写步骤
创建对象，写出数据，释放资源
3.三步操作的细节
创建对象:文件存在、文件不存在、追加写入
写出数据:写出整数、写出字节数组、换行写

FileInputStream：

操作本地文件的字节输入流，可以把本地文件中的数据读取到程序中来。

书写步骤：

创建字节输入流对象
读取数据
释放资源

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class ByteStreamDemo1 {
    public static void main(String[] args) throws IOException {
        /*
        演示:字节输入流FileInputStream
        实现需求:
            读取文件中的数据。(暂时不写中文)
        实现步骤:
                创建对象
                读取数据
                释放资源
        */
        //1.创建对象
        FileInputStream fis = new FileInputStream("D:\\jdk\\code\\IoStearm\\b.txt");
        //2、读取数据(读不到的，返回-1)
        int b1 = fis.read();
        System.out.println((char)b1);
        int b2 = fis.read();
        System.out.println((char)b2);
        int b3 = fis.read();
        System.out.println((char)b3);

        //3、释放资源
        fis.close();


    }
}

FileInputStream书写细节

创建字节输入流对象
- 细节1:如果文件不存在，就直接报错
读取数据
- 细节1:一次读一个字节，读出来的是数据在ASCII上对应的数字细节2:读到文件末尾了，read方法返回-1。
释放资源
- 细节1:每次使用完流必须要释放资源

文件拷贝：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class ByteStreamDemo1 {
    public static void main(String[] args) throws IOException {
        /*
        字节输入流循环读取
        */
        //1.创建对象
        FileInputStream fis = new FileInputStream("C:\\Users\\hpl\\Downloads\\qqmo.mp4");
        FileOutputStream fos = new FileOutputStream("D:\\jdk\\code\\IoStearm\\c.mp4");
        //2、拷贝
        int b;
        while ((b = fis.read()) != -1){
            fos.write(b);
        }
        //3、释放资源(先开的最后关闭)
        fos.close();
        fis.close();


    }
}

FileInputStream书一次读多个字节：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class ByteStreamDemo1 {
    public static void main(String[] args) throws IOException {
        /*
        练习：
            文件拷贝
        */


        long start = System.currentTimeMillis();

        //1.创建对象
        FileInputStream fis = new FileInputStream("C:\\Users\\hpl\\Downloads\\zgp.mp4");
        FileOutputStream fos = new FileOutputStream("D:\\jdk\\code\\IoStearm\\bd.mp4");
        //2、拷贝
        byte[] bytes = new byte[1024 * 1024 * 5];

        int len;
        while ((len = fis.read(bytes)) != -1){
            fos.write(bytes,0,len);
        }

        //3、释放资源(先开的最后关闭)
        fos.close();
        fis.close();

        long end = System.currentTimeMillis();

        System.out.println("程序运行时间>>>"+(end-start)+"ms");


    }
}

try...catch异常处理：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class ByteStreamDemo1 {
    public static void main(String[] args) throws IOException {
        /*
        练习：
            文件拷贝
        */


        long start = System.currentTimeMillis();

        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            //1.创建对象
            fis = new FileInputStream("C:\\Users\\hpl\\Downloads\\zgp.mp4");
            fos = new FileOutputStream("D:\\jdk\\code\\IoStearm\\bd.mp4");
            //2、拷贝
            byte[] bytes = new byte[1024 * 1024 * 5];

            int len;
            while ((len = fis.read(bytes)) != -1){
                fos.write(bytes,0,len);
            }

        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (fos != null){
                try {
                    fos.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }

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

        }

        long end = System.currentTimeMillis();

        System.out.println("程序运行时间>>>"+(end-start)+"ms");


    }
}

IO流-13-字符集详解（ASCLL,GBK）：

计算机的存储规则：

总结：

1.在计算机中，任意数据都是以二进制的形式来存储的
2.计算机中最小的存储单元是一个字节
3.ASCII字符集中，一个英文占一个字节
4.简体中文版Windows，默认使用GBK字符集
5.GBK字符集完全兼容ASCII字符集
- 一个英文占一个字节，二进制第一位是0
- 一个中文占两个字节，二进制高位字节的第一位是1

字符集：

UTF-8是Unicode字符集的一种编码方式

如何不产生乱码？

不要用字节流读取文本文件
编码解码时使用用一个码表

java中编码的方法：

java中解码的方法：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

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

        //使用默认方式进行编码
        //使用指定方式进行编码

        //1、编码
        String str = "爱你哟 hj";
        byte[] bytes1 = str.getBytes();
        System.out.println(Arrays.toString(bytes1));

        byte[] bytes2 = str.getBytes("GBK");
        System.out.println(Arrays.toString(bytes2));

        //2、解码
        String str2 = new String(bytes1,"GBK");
        System.out.println(str2); //乱码（编码和解码的方式不一样）

        String str4 = new String(bytes2,"GBK");
        System.out.println(str4);

        String str3 = new String(bytes1);
        System.out.println(str3);

    }
}

字符流是什么？

FileReader：

步骤：

import java.io.*;
import java.util.Arrays;

public class ByteStreamDemo1 {
    public static void main(String[] args) throws IOException {
        //1、创建对象
        FileReader fr = new FileReader("D:\\jdk\\code\\IoStearm\\b.txt");

        //2、读取数据
        //read ()细节:
        //1.read():默认也是一个字节一个字节的读取的,如果遇到中文就会一次读取多个
        // 2.在读取之后，方法的底层还会进行解码并转成十进制。最终把这个十进制作为返回值,这个十进制的数据也表示在字符集上的数字
        //英文:文件里面二进制数据 @11 @@e1
            //read方法进行读取，解码并转成十进制97
        //中文:文件里面的二进制数据 111@911e 1011001 1001001
            //read方法进行读取，解码并转成十进制27721
        // 我想看到中文汉字，就是把这些十进制数据，再进行强转就可以了
        int ch;
        while ((ch = fr.read()) != -1){
            System.out.print((char)ch);
        }

        //3、释放资源
        fr.close();
    }
}

import java.io.*;
import java.util.Arrays;

public class ByteStreamDemo1 {
    public static void main(String[] args) throws IOException {
        //1、创建对象
        FileReader fr = new FileReader("D:\\jdk\\code\\IoStearm\\b.txt");

        //2、读取数据
        char[] chars = new char[2];
        int len;
        while ((len = fr.read(chars)) != -1) {
            System.out.print(new String(chars, 0, len));
        }

        //3、释放资源
        fr.close();
    }
}

FileWriter书写细节：

import java.io.FileWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;

public class BytesStreamDemo2 {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("D:\\jdk\\code\\IoStearm\\cd.txt");

        fw.write(25105);//根据字符集的编码方式进行编码，把编码之后的数据写到文件中去
                            //Utf-8

        fw.close();
    }
}

import java.io.FileWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;

public class BytesStreamDemo2 {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("D:\\jdk\\code\\IoStearm\\cd.txt", true);

        fw.write("\n你好啊威啊？？？");//根据字符集的编码方式进行编码，把编码之后的数据写到文件中去
                            //Utf-8

        fw.close();
    }
}

import java.io.FileWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;

public class BytesStreamDemo2 {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("D:\\jdk\\code\\IoStearm\\cd.txt", true);

        char[] chars = {'\n','b','c','d','我'};

        fw.write(chars);//根据字符集的编码方式进行编码，把编码之后的数据写到文件中去
                            //Utf-8

        fw.close();
    }
}

使用场景：

综合练习：

1、拷贝文件夹：

package Text;

import java.io.*;

public class text01 {
    public static void main(String[] args) throws IOException {
        //拷贝一个文件夹，考虑子文件夹

        //1、创建对象表示数据源
        File src = new File("D:\\jdk\\code\\IoStearm\\src");

        //创建对象表示目的地
        File dest = new File("D:\\jdk\\code\\IoStearm\\dest");

        //调用方法开始拷贝
        copydir(src,dest);
    }

    private static void copydir(File src, File dest) throws IOException {
        dest.mkdirs();
        //1、进入数据源
        File[] files = src.listFiles();
        //2、遍历数组
        for (File file : files){
            if (file.isFile()){
                //3、判断文件，拷贝
                FileInputStream fis = new FileInputStream(file);
                FileOutputStream fos = new FileOutputStream(new File(dest,file.getName()));
                byte[] bytes = new byte[1024];
                int len;
                while ((len = fis.read(bytes)) != -1){
                    fos.write(bytes,0,len);
                }
                fos.close();
                fis.close();
            }else {
                //4、判断文件夹，递归
                copydir(file,new File(dest,file.getName()));

            }
        }
    }

}

2、文件加密和解密：

加密原理：对原始文件中的没一个字节数据进行更改，然后将更改以后的数据存储到新的文件当中

解密文件：读取加密之后的文件，按照加密逻辑反过来操作

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;

public class BytesStreamDemo2 {
    public static void main(String[] args) throws IOException {
        //创建对象关联原始文件
        FileInputStream fis = new FileInputStream("D:\\jdk\\code\\IoStearm\\puturelast.jpg");

        //创建对象关联加密文件
        FileOutputStream fos = new FileOutputStream("D:\\jdk\\code\\IoStearm\\puture.jpg");
        int b;
        while ((b = fis.read()) != -1){
            fos.write(b ^ 2);
        }
        fos.close();



    }
}

3、将文件中的1-3-4-5-2-8-6-10-9排序

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class BytesStreamDemo2 {
    public static void main(String[] args) throws IOException {
        //2-1-9-4-7-8将这个信息进行排序

        //1、读取数据
        FileReader fr = new FileReader("D:\\jdk\\code\\IoStearm\\b.txt");
        StringBuilder sb = new StringBuilder();
        int ch;
        while ((ch = fr.read()) != -1){
            sb.append((char) ch);
        }
        fr.close();
        System.out.println(sb);

        //2、排序
        String str = sb.toString();
        String[] arrstr = str.split("-");

        ArrayList<Integer> list = new ArrayList<>();
        for (String s : arrstr) {
            int i = Integer.parseInt(s);
            list.add(i);
        }
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);


        //3、写出
        FileWriter fw = new FileWriter("D:\\jdk\\code\\IoStearm\\b.txt");
        for (int i = 0; i < list.size(); i++) {
            if (i != list.size()-1){
                fw.write(list.get(i)+"-");
            }else {
                fw.write(list.get(i)+"");
            }
        }
        fw.close();




    }
}

升级版：

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class BytesStreamDemo2 {
    public static void main(String[] args) throws IOException {
        //2-1-9-4-7-8将这个信息进行排序

        //1、读取数据
        FileReader fr = new FileReader("D:\\jdk\\code\\IoStearm\\b.txt");
        StringBuilder sb = new StringBuilder();
        int ch;
        while ((ch = fr.read()) != -1){
            sb.append((char) ch);
        }
        fr.close();
        System.out.println(sb);

        //2、排序
       ;

       Integer[] arr = Arrays.stream(sb.toString()
                       .split("-"))
                       .map(Integer::parseInt)
                       .sorted()
                       .toArray(Integer[]::new);
        System.out.println(Arrays.toString(arr));

        //3、写出
        FileWriter fw = new FileWriter("D:\\jdk\\code\\IoStearm\\b.txt");
        String s = Arrays.toString(arr).replace(", ","-");
        System.out.println(s);

        String result = s.substring(1, s.length() - 1);
        fw.write(result);
        fw.close();




    }
}

高级流——缓冲流：

字节缓冲流：

拷贝文件：

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

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

        //1、创建缓冲流对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\jdk\\code\\IoStearm\\b.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\jdk\\code\\IoStearm\\a.txt"));
        //2、循环读取并写道目的地
        int b;
        while ((b = bis.read()) != -1){
            bos.write(b);
        }

        //1、释放资源
        bos.close();
        bis.close();

    }
}

一次操作多个字节：

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

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

        //1、创建缓冲流对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\jdk\\code\\IoStearm\\b.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\jdk\\code\\IoStearm\\a.txt"));
        //2、循环读取并写道目的地
        byte[] bytes = new  byte[1024];
        int len;
        while ((len = bis.read(bytes)) != -1){
            bos.write(bytes,0,len);
        }

        //1、释放资源
        bos.close();
        bis.close();

    }
}

字符缓冲流：

特有方法：

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

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

        //1、创建缓冲流对象
        BufferedReader br = new BufferedReader(new FileReader("D:\\jdk\\code\\IoStearm\\b.txt"));

        //2、读取数据
        String line;
        while((line = br.readLine()) != null){
            System.out.println(line);
        }

        //1、释放资源
        br.close();


    }
}

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

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

        //1、创建缓冲流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\jdk\\code\\IoStearm\\bcd.txt",true));

        //2、读取数据
        bw.write("123");
        bw.newLine();
        bw.write("456");
        //1、释放资源
        bw.close();


    }
}

四种拷贝文件的方式时间对比：

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

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

        long start = System.currentTimeMillis();
        //1、创建缓冲流对象
        BufferedReader br = new BufferedReader(new FileReader("D:\\jdk\\code\\IoStearm\\b.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\jdk\\code\\IoStearm\\bcd.txt"));
        //2、读取数据
        String b;
        while ((b =br.readLine()) != null ){
            bw.write(b);
            bw.newLine();
        }
        //1、释放资源
        bw.close();

        long end = System.currentTimeMillis();
        System.out.println((end-start) / 1000.0+"秒");


    }
}

控制软件次数：

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

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


        BufferedReader br = new BufferedReader(new FileReader("D:\\jdk\\code\\IoStearm\\count.txt"));
        String line = br.readLine();
        br.close();
        int count = Integer.parseInt(line);
        count++;
        if (count<=3){

            System.out.println("欢迎使用本软件，第"+count+"次使用免费");
            copyfiter();
        }else {
            System.out.println("本软件只能免费使用三次，欢迎您注册后使用~");
        }
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\jdk\\code\\IoStearm\\count.txt"));
        bw.write(count+"");
        bw.close();

    }

    public static void copyfiter () throws IOException {
        long start = System.currentTimeMillis();
        //1、创建缓冲流对象
        BufferedReader br = new BufferedReader(new FileReader("D:\\jdk\\code\\IoStearm\\b.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\jdk\\code\\IoStearm\\bcd.txt"));
        //2、读取数据
        String b;
        while ((b =br.readLine()) != null ){
            bw.write(b);
            bw.newLine();
        }
        //1、释放资源
        bw.close();
        br.close();

        long end = System.currentTimeMillis();
        System.out.println((end-start) / 1000.0+"秒");
        System.out.println("复制成功");
    }
}

转换流：

是字符流和字节流之间的桥梁

import java.io.*;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class BytesStreamDemo2 {
    public static void main(String[] args) throws IOException {
        writerIn();
        writerOut();
    }

    public static void writerIn() throws IOException {
        FileReader fr = new FileReader("D:\\jdk\\code\\IoStearm\\b.txt", Charset.forName("GBK"));
        //2、读取数据
        int ch;
        while ((ch = fr.read()) != -1){
            System.out.println((char)ch);
        }
        //3、释放资源
        fr.close();
    }

    public static void writerOut() throws IOException {
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\jdk\\code\\IoStearm\\bce.txt"),"GBK");
        osw.write("你好你好");
        osw.close();
    }
}

序列化流/对象操作输出流：

可以把java中的对象写道本地文件

import Text.Books;
import org.w3c.dom.Text;

import java.io.*;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class BytesStreamDemo2 {
    public static void main(String[] args) throws IOException {
        Books books = new Books("假如给我三天光明",34.7,23);
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\jdk\\code\\IoStearm\\a.txt"));
        oos.writeObject(books);
        oos.close();

    }
}

package Text;

import java.io.Serializable;

public class Books implements Serializable {

    //Serializable是个没有抽象方法，标志形接口
    private String name;

    private double UnitPrice;

    private int Sales;

    public Books() {
    }

    public Books(String name, double unitPrice, int sales) {
        this.name = name;
        UnitPrice = unitPrice;
        Sales = sales;
    }

    public String getName() {
        return name;
    }

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

    public double getUnitPrice() {
        return UnitPrice;
    }

    public void setUnitPrice(double unitPrice) {
        UnitPrice = unitPrice;
    }

    public int getSales() {
        return Sales;
    }

    public void setSales(int sales) {
        Sales = sales;
    }

    @Override
    public String toString() {
        return name+"\t\t\t"+UnitPrice+"\t"+Sales;
    }
}

反序列化流/对象操作输入流：

可以把序列化到本地文件中的对象，读取到程序中来

import Text.Books;
import org.w3c.dom.Text;

import java.io.*;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class BytesStreamDemo2 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\jdk\\code\\IoStearm\\a.txt"));
        Books books = (Books) ois.readObject();
        System.out.println(books);
        ois.close();
    }
}

多个对象系列：

import Text.Books;
import org.w3c.dom.Text;

import java.io.*;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class BytesStreamDemo2 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1、序列化多个对象
        Books books1 = new Books("假如给我三天光明",56,23);
        Books books2 = new Books("老人与海",36,25);
        Books books3 = new Books("环球旅行",49.7,223);
        Books books4 = new Books("中国上下五千年",89,100);

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\jdk\\code\\IoStearm\\a.txt"));
        oos.writeObject(books1);
        oos.writeObject(books2);
        oos.writeObject(books3);
        oos.writeObject(books4);
        oos.close();
    }
}

import Text.Books;

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

public class xunliehua {
    public static void main(String[] args) throws IOException {
        //1、序列化多个对象
        Books books1 = new Books("假如给我三天光明",56,23);
        Books books2 = new Books("老人与海",36,25);
        Books books3 = new Books("环球旅行",49.7,223);
        Books books4 = new Books("中国上下五千年",89,100);

        ArrayList<Books> list = new ArrayList<>();
        list.add(books1);
        list.add(books2);
        list.add(books3);
        list.add(books4);



        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\jdk\\code\\IoStearm\\a.txt"));
        oos.writeObject(list);
        oos.close();
    }
}

import Text.Books;
import org.w3c.dom.Text;

import java.io.*;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class BytesStreamDemo2 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\jdk\\code\\IoStearm\\a.txt"));

        ArrayList<Books> list = (ArrayList<Books>) ois.readObject();

        for (Books books : list) {
            System.out.println(books);
        }
        ois.close();
    }
}

打印流：

字节打印流：

import java.io.*;
import java.nio.charset.Charset;
import java.util.Arrays;

public class ByteStreamDemo1 {
    public static void main(String[] args) throws IOException {
        PrintStream ps = new PrintStream(new FileOutputStream("D:\\jdk\\code\\IoStearm\\b.txt"),true, Charset.forName("UTF-8"));
        ps.println(97);
        ps.print(true);
        ps.println();
        ps.printf("%s 爱上了 %s","阿珍","阿强");
        ps.close();


    }
}

字符打印流：

多了一个缓冲区，效率更高

import java.io.*;
import java.nio.charset.Charset;
import java.util.Arrays;

public class ByteStreamDemo1 {
    public static void main(String[] args) throws IOException {
        PrintWriter pw = new PrintWriter(new FileWriter("D:\\jdk\\code\\IoStearm\\b.txt"),true);
        pw.println("今天天气很好，你终于叫了我名字，虽然叫错了，但是没关系，我马上改");
        pw.print("nihao nihao ");
        pw.printf("%s love %s","你好","好你");


    }
}

解压缩流和压缩流：

解压缩流：

import java.io.*;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

public class ByteStreamDemo1 {
    public static void main(String[] args) throws IOException {
        //1、创建一个file，表示要解压的压缩包
        File src = new File("D:\\jdk\\code\\IoStearm\\file.zip");

        //2、创建一个file解压目的地
        File dest = new File("D:\\jdk\\code\\IoStearm\\");

        unzip(src,dest);
    }


    public static void unzip(File src , File dest) throws IOException {
        ZipInputStream zip = new ZipInputStream(new FileInputStream(src), StandardCharsets.UTF_8);

        ZipEntry entry;
        while ((entry = zip.getNextEntry()) != null){
            System.out.println(entry);
            if (entry.isDirectory()){
                //文件夹
                File file = new File(dest,entry.toString());
                file.mkdirs();
            }else {
                //文件
                FileOutputStream fos = new FileOutputStream(new File(dest,entry.toString()));
                int b;
                while ((b = zip.read()) != -1){
                    fos.write(b);
                }
                fos.close();
                zip.closeEntry();
            }
        }
        zip.close();


    }
}

压缩流：

压缩一个文件

import Text.Books;
import org.w3c.dom.Text;

import java.io.*;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class BytesStreamDemo2 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        File src = new File("D:\\jdk\\code\\IoStearm\\b.txt");
        File dest = new File("D:\\jdk\\code\\IoStearm\\");

        tozip(src,dest);
    }

    private static void tozip(File src, File dest) throws IOException {
        ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(new File(dest,"b.zip")));
        ZipEntry zipEntry = new ZipEntry("b.txt");
        zos.putNextEntry(zipEntry);

        FileInputStream fis = new FileInputStream(src);
        int b ;
        while ((b = fis.read()) != -1){
            zos.write(b);
        }

        zos.closeEntry();
        zos.close();





    }
}

压缩整个文件夹

import Text.Books;
import org.w3c.dom.Text;

import java.io.*;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class BytesStreamDemo2 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        File src = new File("D:\\jdk\\code\\IoStearm\\file");
        File destParent = src.getParentFile();
        File dest = new File(destParent,src.getName()+".zip");
        ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(dest));

        tozip(src,zos,src.getName());
        zos.close();

    }

    public static void tozip (File src,ZipOutputStream zos,String name) throws IOException {
        File[] files = src.listFiles();
        for (File file : files) {
            if (file.isFile()){
                ZipEntry entry = new ZipEntry(name+"\\"+file.getName());
                zos.putNextEntry(entry);
                FileInputStream fis = new FileInputStream(file);
                int b;
                while ((b=fis.read()) != -1){
                    zos.write(b);
                }
                fis.close();
                zos.closeEntry();

            }else{
                tozip(file,zos,name+"\\"+file.getName());

            }
        }

    }
}

Commons-io

Commons-io是apache开源基金组织提供的一组IO操作的开源工具包

作用：提高了io流开发效率

使用步骤：

常用方法：

import Text.Books;
import org.apache.commons.io.FileUtils;
import org.w3c.dom.Text;

import java.io.*;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class BytesStreamDemo2 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //复制文件
        File src = new File("D:\\jdk\\code\\IoStearm\\b.txt");
        File dest = new File("D:\\jdk\\code\\IoStearm\\bb.txt");

        FileUtils.copyFile(src,dest);
        
        

    }
}

其他方法如上所例

Hutool工具包

IO包的封装主要针对流、文件的读写封装，主要以工具类为主，提供常用功能的封装，这包括：

IoUtil 流操作工具类
FileUtil 文件读写和操作的工具类。
FileTypeUtil 文件类型判断工具类
WatchMonitor 目录、文件监听，封装了JDK1.7中的WatchService
ClassPathResource针对ClassPath中资源的访问封装
FileReader 封装文件读取
FileWriter 封装文件写入

import cn.hutool.core.io.FileUtil;
import org.apache.commons.io.FileUtils;

import java.io.File;
import java.util.ArrayList;

public class TEXT1 {
    public static void main(String[] args) {
        //根据参数创建一个对象
        File file = FileUtil.file("D:\\","jdk\\code\\","IoStearm\\b.txt");
        System.out.println(file);

        //根据参数创建文件
        File touch = FileUtil.touch(file);
        System.out.println(touch);

        //把集合中的数据写出文件中，覆盖模式
        ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("aaa");
        list.add("aaa");
        File file2 = FileUtil.writeLines(list,"D:\\jdk\\code\\IoStearm\\b.txt","UTF-8");
        System.out.println(file2);


    }

}

其他的就不一一展示拉

1号全栈玩家

关注

28
点赞
踩
25

收藏

觉得还不错? 一键收藏
打赏
1
评论
java 核心技术-------＞ IO流动

用windows系统自带的记事本打开并且能读懂的文件txt文件，md文件，xml文件，lrc文件等等1.FileOutputStream的作用可以把程序中的数据写到本地文件上，是字节流的基本流2.书写步骤创建对象，写出数据，释放资源3.三步操作的细节创建对象:文件存在、文件不存在、追加写入写出数据:写出整数、写出字节数组、换行写1.在计算机中，任意数据都是以二进制的形式来存储的2.计算机中最小的存储单元是一个字节3.ASCII字符集中，一个英文占一个字节。
复制链接

扫一扫