IO

IO流

什么是IO流

存储和读取数据的解决方案

I：input O：output

流：像水流一样传输数据
IO流的作用

用于读写数据（本地文件，网络）
IO流按照流向可以分为两种流

输出流：程序--->文件

输入流：文件--->程序
IO流按照操作文件的类型可以分类两种流

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

字符流：只能操作纯文本文件
什么是纯文本文件

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

1.字节输出流基本用法

package com.tian.mybytestream;

import com.sun.xml.internal.ws.policy.privateutil.PolicyUtils;

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

public class ByteStreamDemo01 {
    public static void main(String[] args) throws IOException {
        /*
        *演示：字节输出流FileOutputStream
        *实现需求：写出一段文字到文地文件中。（暂时不写中文）
        *
        *实现步骤：
        *         创建对象
        *         写出数据
        *         释放资源
        **/

        //1.创建对象
        //写出 输出流 OutputStream
        //本地文件  File
        FileOutputStream fos = new FileOutputStream("D:\\java\\java code\\IO\\a.txt");
        //2.写出数据
        fos.write(97);
        //3.释放资源
        fos.close();


    }
}

1.1字节输出流写出数据的细节

package com.tian.mybytestream;

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

public class ByteStreamDemo02 {
    public static void main(String[] args) throws IOException {
        /*
             字节输出流的细节：
                  1.创建字节输出流对象
                        细节1：参数是字符串表示的路径或者是File对象都是可以的
                        细节2：如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的。
                        细节3：如果文件已经存在，则会清空文件
                  2.写出数据
                        细节：write方法的参数是整数，但是实际上写到本地文件中的是整数在ASCII上对应的字符
                        97-->a
                        100-->d
                  3.释放资源
                        每次使用完流之后都要释放资源

         **/

        //1.创建对象
        FileOutputStream fos = new FileOutputStream("D:\\java\\java code\\IO\\a.txt");
        //2.写出数据
        fos.write(97);
        //3.释放资源
        fos.close();

1.2写出数据的三种方式

package com.tian.mybytestream;

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

public class ByteStreamDemo03 {
    public static void main(String[] args) throws IOException {
        /*
            void write(int b)                     一次写一个字节数据
            void write(byte[] b)                  一次写一个字节数组数据
            void write(byte[] b,int off,int len)  一次写一个字节数组的部分数据
            参数一:
                  数组
            参数二：
                  起始索引
            参数三：
                  个数
         */

        //1.创建对象
        FileOutputStream fos = new FileOutputStream("D:\\java\\java code\\IO\\a.txt");

        //2.写出数据

        //一次写一个字节数据
        fos.write(97);//a
        fos.write(98);//b

        //一次写一个字节数组数据
        byte[] bytes = {97, 98, 99, 100, 101};
        fos.write(bytes);

        //一次写一个字节数组的部分数据
        fos.write(bytes,1,2);

        //3.释放资源
        fos.close();

    }
}

1.3换行和续写

package com.tian.mybytestream;

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

public class ByteStreamDemo04 {
    public static void main(String[] args) throws IOException {
        /*
            换行写：
                  再次写出一个换行符就可以了
                  windows： \r\n
                  Linux:   \n
                  Mac:     \r
            细节：
                 在windows操作系统中，Java对回车换行进行了优化
                 虽然完整的是\r\n,但是我们写其中一个\r或者\n
                 java也是可以实现执行，因为java在底层会补全
            建议:
                 不要省略，还是写全了
         */
        //1.创建对象
        FileOutputStream fos = new FileOutputStream("D:\\java\\java code\\IO\\a.txt");
        //2.写出数据
        String str = "kankelaoyezuishuai";
        byte[] bytes1 = str.getBytes();
        fos.write(bytes1);

        //再次写出一个换行符就可以了
        String wrap ="\r\n";
        byte[] bytes2 = wrap.getBytes();
        fos.write(bytes2);

        String str2 = "666";
        byte[] bytes3 = str2.getBytes();
        fos.write(bytes3);

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

package com.tian.mybytestream;

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

public class ByteStreamDemo04 {
    public static void main(String[] args) throws IOException {
        /*
            续写：
                 如果想要续写，打开续写开关即可
                 开关位置：创建对象的第二个餐宿
                 默认false：表示关闭续写，此时创建对象会清空文件
                 手动传递true：表示打开续写，此时创建对象不会情空文件
         */
        //1.创建对象
        FileOutputStream fos = new FileOutputStream("D:\\java\\java code\\IO\\a.txt",true);
        //2.写出数据
        String str = "kankelaoyezuishuai";
        byte[] bytes1 = str.getBytes();
        fos.write(bytes1);

        //再次写出一个换行符就可以了
        String wrap ="\r\n";
        byte[] bytes2 = wrap.getBytes();
        fos.write(bytes2);

        String str2 = "666";
        byte[] bytes3 = str2.getBytes();
        fos.write(bytes3);

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

1.4总结

FileOutputStream的作用

可以把程序的数据写到本地文件上，是字节流的基本流
书写步骤

创建对象，写出数据，释放资源
三步操作的细节：

创建对象：文件存在、文件不存在，追加写入

写出数据：写出整数、写出字节数组、换行写

释放资源：关闭通道

2.字节输入流基本用法

package com.tian.mybytestream2;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class ByteStreamDemo01 {
    public static void main(String[] args) throws IOException {
        /*
         *演示：字节输入流FileOutputStream
         *实现需求：写出一段文字到文地文件中。（暂时不写中文）
         *
         *实现步骤：
         *         创建对象
         *         写出数据
         *         释放资源
         */

        //1.创建对象
        FileInputStream fis = new FileInputStream("D:\\java\\java code\\IO\\a.txt");
        //2.读取数据
        int b1 = fis.read();
        System.out.println((char) b1);//a
        int b2 = fis.read();
        System.out.println((char) b2);//b
        int b3 = fis.read();
        System.out.println((char) b3);//c
        int b4 = fis.read();
        System.out.println((char) b4);//d
        int b5 = fis.read();
        System.out.println((char) b5);//e
        int b6 = fis.read();
        System.out.println(b6);//-1
        //3.释放资源
        fis.close();
    }
}

2.1字节输入流写出数据的细节

package com.tian.mybytestream2;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class ByteStreamDemo02 {
    public static void main(String[] args) throws IOException {
        /*
         字节输入流的细节：
               1.创建字节输入流对象
                     细节1：如果文件不存在，就直接报错
                     Java为什么会这样设计呢？
                     输出流：不存在，则创建
                          目的：把数据写到文件当中
                     输入流：不存在，则报错
                          因为创建处理的文件是没有数据的，没有任何一样
                          所以java就没有设计这种无意义的逻辑，文件不存在直接报错
                     程序中最重要的是：数据
               2.写数据
                     细节1：一次读一个字节，读出来是数据在ASCII上对应的数字
                     细节2：读到文件末尾了，read方法返回-1
               3.释放资源
                     细节：每次使用完流之后都要释放资源
         */

        //1.创建对象
        FileInputStream fis = new FileInputStream("D:\\java\\java code\\IO\\a.txt");
        //2.读取数据
        int b1 = fis.read();
        System.out.println((char) b1);//a
        //3.释放资源
        fis.close();
    }
}

2.2字节输入流的循环读取

package com.tian.mybytestream2;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class ByteStreamDemo03 {
    public static void main(String[] args) throws IOException {
        /*
               字节输入流循环读取
         */
        
        //1.创建对象
        FileInputStream fis = new FileInputStream("D:\\java\\java code\\IO\\a.txt");
        //2.循环读取
        int b;
        while ((b = fis.read()) != -1){
            System.out.println((char) b);
        }
        //3.释放资源
        fis.close();
    }
}

3.文件拷贝

package com.tian.mybytestream2;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
//一次读取一个字节数据
public class ByteStreamDemo04 {
    public static void main(String[] args) throws IOException {
        //记录开始时间
        long startTime = System.currentTimeMillis();

        //1.创建对象
        FileInputStream fis = new FileInputStream("C:\\Users\\26708\\Pictures\\pkq.gif");
        FileOutputStream fos = new FileOutputStream("D:\\java\\java code\\IO\\pp.gif");
        //2.拷贝
        int b;
        while ((b = fis.read()) != -1){
            fos.write(b);
        }
        //3.释放资源
        //先开的后关闭
        fos.close();
        fis.close();

        //4.计算拷贝的时间
        long endTime = System.currentTimeMillis();
        System.out.println("文件拷贝时间：" + (endTime - startTime) + "毫秒");//慢
    }
}

package com.tian.mybytestream2;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
//一次读取多个字节数据
public class ByteStreamDemo05 {
    public static void main(String[] args) throws IOException {
        //1.创建对象
        FileInputStream fis = new FileInputStream("D:\\java\\java code\\IO\\a.txt");
        //2.读取数据
        byte[] bytes = new byte[2];
        //一次读取多个字节数据，具体读多少，和数组的长度有关
        //返回值：本次读取到了多少个字节数据
        int len1 = fis.read(bytes);
        System.out.println(len1);
        String str1 = new String(bytes,0,len1);
        System.out.println(str1);
        int len2 = fis.read(bytes);
        System.out.println(len2);
        String str2 = new String(bytes,0,len2);
        System.out.println(str2);
        int len3 = fis.read(bytes);
        System.out.println(len3);
        String str3 = new String(bytes,0,len3);
        System.out.println(str3);
        //3.释放资源
        fis.close();
    }
}

改进拷贝代码

package com.tian.mybytestream2;

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

public class ByteStreamDemo06 {
    public static void main(String[] args) throws IOException {
        //记录开始时间
        long startTime = System.currentTimeMillis();

        //1.创建对象
        FileInputStream fis = new FileInputStream("C:\\Users\\26708\\Pictures\\pkq.gif");
        FileOutputStream fos = new FileOutputStream("D:\\java\\java code\\IO\\pp.gif");
        //2.拷贝
        int len;
        byte[] bytes = new byte[1024*1024*5];
        while ((len = fis.read(bytes)) != -1){
            fos.write(bytes,0,len);
        }
        //3.释放资源
        fos.close();
        fis.close();

        //4.计算拷贝的时间
        long endTime = System.currentTimeMillis();
        System.out.println("文件拷贝时间：" + (endTime - startTime) + "毫秒");//快
    }
}

4.字符集

4.1ASCII和GBK

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

4.2Unicode

UTF-8不是字符集，是Unicode字符集的一种编码方法

Unicode字符集的UTF-8编码格式
- 一个英文占一个字节，二进制第一位是0，转成十进制是正数
- 一个中文占三个字节，二进制第一位是1，第一个字节转成十进制是负数

4.3乱码

为什么会产生乱码

读取数据时未读完整个汉字
编码和解码时的方式不统一

如何不产生乱码

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

4.4解码和编码的实现

package com.tian.mycharset;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class CharSetDemo03 {
    public static void main(String[] args) throws UnsupportedEncodingException {
        /*
        java中编码的方法
           public byte[] getBytes()                             使用默认方式进行编码
           public byte[] getBytes(String charsetName)           使用指定方式进行编码
        java中解码的方法
           String(byte[] bytes)                                 使用默认方式进行解码
           String(byte[] bytes, String charsetName)             使用指定方式进行解码
         */
        //1.编码
        String str = "ai你哟";
        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);
        System.out.println(str2);

        String str3 = new String(bytes1,"GBK");
        System.out.println(str3);//出现乱码
    }
}

5.字符流

5.1字符输入流read空参

package com.tian.mycharstream1;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class CharStreamDemo01 {
    public static void main(String[] args) throws IOException {
        /*
            第一步：创建对象
            public FileReader(File file)                 创建字符输入流关联本地文件
            public FileReader(String pathname)           创建字符输入流关联本地文件
            第二步:读取数据
            public int read()                            读取数据，读到末尾返回-1
            public int read(char[] buffer)               读取多个数据，读到末尾返回-1
            第三步：释放资源
            public void close()                          释放资源/关流
         */
        //1.创建对象并关联本地文件
        FileReader fr = new FileReader("D:\\java\\java code\\IO\\a.txt");
        //2.读取数据 read()
        //字符流的底层也是字节流，默认也是一个字节一个字节的读取的。
        //如果遇到中文就会一次读取多个，GBK一次读两个字节，UTF-8一次读三个字节

        //read()细节；
        //1.read()：默认也是一个字节一个字节的读取的，如果遇到中文就会一次读取多个
        //2.在读取之后，方法的底层还会进行解码并转成十进制
        // 最终把整个十进制作为返回值
        // 整个十进制的数据也表示在字符集上的数字
        // 英文：文件里面的二进制数据 0110 0001
        //           read方法进行读取，解码并转成十进制97
        // 中文：文件里面的二进制数据 11100110 10110001 10001001
        //           read方法进行读取，解码并转成十进制27721
        //想看到中文汉字，就把这些十进制数据，进行强转就可以了
        int ch;
        while ((ch = fr.read()) != -1){
            System.out.print((char)ch);
        }
        //3.释放资源
        fr.close();
    }
}

5.2字符输入流read有参

package com.tian.mycharstream1;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class CharStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //1.创建对象
        FileReader fr = new FileReader("D:\\java\\java code\\IO\\a.txt");
        //2.读取数据
        char[] chars = new char[2];
        int len;
        //read(chars):读取数据，解码，强转三步合并了，把强转之后的字符放到数组当中
        //空参的read + 强转类型转换
        while ((len = fr.read(chars)) != -1){
            //把数组中的数据变成字符串再进行打印
            System.out.print(new String(chars,0,len));
        }
        //3.释放资源
        fr.close();
    }
}

5.3 字符输出流写出数据

package com.tian.mycharstream1;

import java.io.FileWriter;
import java.io.IOException;

public class CharStreamDemo03 {
    public static void main(String[] args) throws IOException {
     /*
     第一步：创建对象
        public FileWriter(File file)                             //创建字符输出流关联本地文件
        public FileWriter(String pathname)                       //创建字符输出流关联本地文件
        public FileWriter(File file,boolean append)              //创建字符输出流关联本地文件，续写
        public FileWriter(String pathname,boolean append)        //创建字符输出流关联本地文件，续写
     第二步：读取数据
        void write(int c)                                 //写出一个字符
        void write(String str)                            //写出一个字符串
        void write(String str,int off,int len)            //写出一个字符串的一部分
        void write(char[] cbuf)                           //写出一个字符数组
        void write(char[] cbuf,int off,int len)           //写出一个字符数组的一部分
     第三步：释放资源
        public void close()                            //释放资源
      */
        FileWriter fw = new FileWriter("D:\\java\\java code\\IO\\a.txt",true);

        fw.write(25105);
        fw.write("你好威啊???");
        char[] chars = {'a','b','c','我'};
        fw.write(chars);

        fw.close();
    }
}

5.4字符输入流底层原理

创建字符输入流对象

底层：关联文件，并创建缓冲区（长度为8192的字节数组）
读取数据

底层：1. 判断缓冲区中是否有数据可以读取

2.缓冲区没有数据：就从文件中获取数据，装到缓冲区中，每次尽可能装满缓冲区

如果文件中也没有数据了，返回-1
缓冲区有数据：就从缓冲区中读取

空参的read方法：一次读取一个字节，遇到中文一次读多个字节，把字节解码并转成十进制返回

有参的read方法：把读取字节，解码，强转三步合并了，强转之后的字符放到数组中

5.5字符输出流底层原理

6.综合练习

6.1拷贝文件夹

package com.tian.mytest;

import java.io.*;

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

        //1.创建对象表示数据源
        File src = new File("D:\\aaa\\src");
        //2.创建对象表示目的地
        File dest = new File("D:\\aaa\\dest");
        
        //3.调用方法开始拷贝
        copydir(src,dest);
    }

    private static void copydir(File src, File dest) throws IOException {
        dest.mkdir();
        //递归
        //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()));
            }
        }
    }
}

6.2加密和解密文件

package com.tian.mytest;

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

public class Test02 {
    public static void main(String[] args) throws IOException {
        /*
        为了保证文件的安全性，需要对原始文件进行加密存储，再使用的时候再对其进行解密处理
        加密原理：
            对原始文件的每一个字节数据进行更改，然后将更改以后的数据存储到新的文件中
        解密原理：
            读取加密之后的文件，按照加密的规则反向操作，变成原始文件
         ^ :异或
            两边相同：false
            两边不同：true
         */

        //1.创建对象关联原始文件
        FileInputStream fis = new FileInputStream("D:\\java\\java code\\IO\\pp.gif");
        //2.创建对象关联加密文件
        FileOutputStream fos = new FileOutputStream("D:\\java\\java code\\IO\\ency.gif");
        //3.加密处理
        int b;
        while ((b = fis.read()) != -1){
            fos.write(b^2);
        }
        //4.释放资源
        fos.close();
        fis.close();

        //解密
        //pp.gif-->ency.gif
        //ency.gif-->redu.gif
    }
}

6.3修改文件中的数据

方法一：

package com.tian.mytest;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;

public class Test03 {
    public static void main(String[] args) throws IOException {
        /*
             文本文件中有以下的数据：
                2-1-9-4-7-8
             将文件中的数据进行排序，变成以下的数据：
                1-2-4-7-8-9
             细节1:文件中的数据不要换行
             细节2：不要带bom头
         */
        //1.读取数据
        FileReader fr = new FileReader("D:\\java\\java code\\IO\\a.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);
        }
        Collections.sort(list);
        System.out.println(list);
        //3.写出
        FileWriter fw = new FileWriter("D:\\java\\java code\\IO\\a.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();
    }
}

方法二：

package com.tian.mytest;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;

public class Test04 {
    public static void main(String[] args) throws IOException {
        //1.读取数据
        FileReader fr = new FileReader("D:\\java\\java code\\IO\\a.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);
        //3.写出
        FileWriter fw = new FileWriter("D:\\java\\java code\\IO\\a.txt");
        String s = Arrays.toString(arr).replace(", ","-");
        String result = s.substring(1,s.length() - 1);
        fw.write(result);
        fw.close();
    }
}

7.字节缓冲流拷贝文件

7.1一次读取一个字节

package com.tian.mybufferedstream1;

import java.io.*;

public class BufferedStreamDemo01 {
    public static void main(String[] args) throws IOException {
        /*
        需求：
               利用字节缓冲流拷贝文件
        字节缓冲输入流的构造方法：
                  public BufferedInputSteam(InputStream is)
        字节缓冲输出流的构造方法：
                  public BufferedOutputStream(OutputStream os)
         */
        //1.创建缓冲流的对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\java\\java code\\IO\\a.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\java\\java code\\IO\\copy.txt"));
        //2.循环读取并写到目的地
        int b;
        while ((b = bis.read()) != -1){
            bos.write(b);
        }
        //3.释放资源
        bos.close();
        bis.close();
    }
}

7.2一次读取一个字节数组

package com.tian.mybufferedstream1;

import java.io.*;

public class BufferedStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //1.创建缓冲流的对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\java\\java code\\IO\\a.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\java\\java code\\IO\\copy2.txt"));
        //2.拷贝(一次读写多个字节)
        byte[] bytes = new byte[1024];
        int len;
        while ((len = bis.read(bytes)) != -1){
            bos.write(bytes,0,len);
        }
        //3.释放资源
        bos.close();
        bis.close();
    }
}

8.字符缓冲流

8.1输入流

package com.tian.mybufferedstream1;

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

public class BufferedStreamDemo03 {
    public static void main(String[] args) throws IOException {
        /*
    字符缓冲输入流：
         构造方法：
              public BufferedReader(Reader r)
         特有方法：
              public String readLine()    读一整行
     */
        //1.创建字符缓冲输入流的对象
        BufferedReader br = new BufferedReader(new FileReader("D:\\java\\java code\\IO\\a.txt"));
        //2.读取数据
        //readLine方法在读取的时候，一次读一整行，遇到回车换行结束
        //       但是他不会把回车换行读到内存当中
        String line1 = br.readLine();
        System.out.println(line1);

        String line2 = br.readLine();
        System.out.println(line2);

        String line;
        while ((line = br.readLine()) != null){
            System.out.println(line);
        }
        //3.释放资源
        br.close();
    }
}

8.2输出流

package com.tian.mybufferedstream1;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedStreamDemo04 {
    public static void main(String[] args) throws IOException {
         /*
    字符缓冲输出流：
         构造方法：
              public BufferedWriter(Writer r)
         特有方法：
              public void newLine()    跨平台的换行
     */
        //1.创建字符缓冲输出流的对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt",true));
        //2.写出数据
        bw.write("你嘴角上扬的样子，百度搜索不到");
        bw.newLine();
        bw.write("以后如果我结婚了，你一定要来哦，没有新娘我会很尴尬");
        bw.newLine();
        //2.释放资源
        bw.close();
    }
}

总结：

缓冲流有几种
- 字节缓冲输入流：BufferedInputStream
- 字节缓冲输出流：BufferedOutputStream
- 字符缓冲输入流：BufferedReader
- 字符缓冲输出流：BufferedWriter
缓冲流为什么能提高性能
- 缓冲流自带长度为8192的缓冲区
- 可以显著提高字节流的读写性能
- 对于字符流提升不明显，对于字符缓冲流而言，关键点是两个特有的方法
字符缓冲流两个特有的方法是什么
- 字符缓冲输入流BufferedReader：readLine()
- 字符缓冲输出流BufferedWriter：newLine()

9.综合练习

9.1四种方式拷贝文件效率对比

package com.tian.mytest;

import java.io.*;

public class Test05 {
    public static void main(String[] args) throws IOException {
        long start = System.currentTimeMillis();
        //method1();
        //method2();
        //method3();
        //method4();
        long end = System.currentTimeMillis();
        System.out.println((end - start) / 1000.0 + "秒");
    }
    //字节流的基本流：一次读写一个字节
    public static void method1() throws IOException {
        FileInputStream fis = new FileInputStream("C:\\Users\\26708\\Pictures\\pkq.gif");
        FileOutputStream fos = new FileOutputStream("D:\\java\\java code\\IO\\pp.gif");
        int b;
        while ((b = fis.read()) != -1){
            fos.write(b);
        }
        //3.释放资源
        //先开的后关闭
        fos.close();
        fis.close();
    }
    //字节流的基本流：一次读写一个字节数组
    public static void method2() throws IOException {
        //1.创建对象
        FileInputStream fis = new FileInputStream("C:\\Users\\26708\\Pictures\\pkq.gif");
        FileOutputStream fos = new FileOutputStream("D:\\java\\java code\\IO\\pp.gif");
        //2.拷贝
        int len;
        byte[] bytes = new byte[8192];
        while ((len = fis.read(bytes)) != -1){
            fos.write(bytes,0,len);
        }
        //3.释放资源
        fos.close();
        fis.close();
    }
    //字节缓冲流一次读写一个字节
    public static void method3() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\Users\\26708\\Pictures\\pkq.gif"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\java\\java code\\IO\\pp.gif"));
        int b;
        while ((b = bis.read()) != -1){
            bos.write(b);
        }
        bos.close();
        bis.close();
    }
    //字节缓冲流：一次读写一个字节数组
    public static void method4() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\Users\\26708\\Pictures\\pkq.gif"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\java\\java code\\IO\\pp.gif"));
        byte[] bytes = new byte[8192];
        int len;
        while ((len = bis.read(bytes)) != -1){
            bos.write(bytes,0,len);
        }
        bos.close();
        bis.close();
    }
}

9.2恢复数据的顺序

方法一

package com.tian.mytest;

import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Test06Case1 {
    public static void main(String[] args) throws IOException {
        //1.读取数据
        BufferedReader br = new BufferedReader(new FileReader("D:\\java\\java code\\IO\\csb.txt"));
        String line;
        ArrayList<String> list = new ArrayList<>();
        while ((line = br.readLine()) != null){
            list.add(line);
        }
        br.close();
        //2.排序
        //排序规则：按照每一行前面的序号进行排序
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //回去o1和o2的序号
                int i1 = Integer.parseInt(o1.split("\\.")[0]);
                int i2 = Integer.parseInt(o2.split("\\.")[0]);
                return i1-i2;
            }
        });
        //3.写出
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\java\\java code\\IO\\result.txt"));
        for (String str : list) {
            bw.write(str);
            bw.newLine();
        }
        bw.close();
    }
}

方法二

package com.tian.mytest;

import java.io.*;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class Test06Case2 {
    public static void main(String[] args) throws IOException {
        //1.读取数据
        BufferedReader br = new BufferedReader(new FileReader("D:\\java\\java code\\IO\\csb.txt"));
        String line;
        TreeMap<Integer,String> tm = new TreeMap<>();
        while ((line = br.readLine()) != null){
            String[] arr = line.split("\\.");
            //0:序号  1:内容
            tm.put(Integer.parseInt(arr[0]),line);
        }
        br.close();
        //2.写出数据
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\java\\java code\\IO\\result2.txt"));
        Set<Map.Entry<Integer,String>> entries = tm.entrySet();
        for (Map.Entry<Integer, String> entry : entries) {
            String value = entry.getValue();
            bw.write(value);
            bw.newLine();
        }
        bw.close();
    }
}

9.3控制软件运行次数

package com.tian.mytest;

import java.io.*;

public class Test07 {
    public static void main(String[] args) throws IOException {
        //1.把文件中的数字读取到内存中
        BufferedReader br = new BufferedReader(new FileReader("D:\\java\\java code\\IO\\count.txt"));
        String line = br.readLine();
        int count = Integer.parseInt(line);
        //表示当前软件又运行了一次
        count++;
        //2.判断
        if (count <= 3){
            System.out.println("欢迎使用本软件，第"+count+"次使用免费~");
        }else {
            System.out.println("本软件只能免费使用3次，欢迎您注册会员后续继续使用~");
        }
        //3.把当前自增之后的count写出到文件当中
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\java\\java code\\IO\\count.txt"));
        bw.write(count+"");
        bw.close();
    }
}

10.转换流

10.1利用转换流按照指定字符编码读取

package com.tian.myconvertStream;

import sun.nio.cs.ext.GBK;

import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.Charset;

public class ConvertStreamDemo01 {
    public static void main(String[] args) throws IOException {
        /*
        利用转换流按照指定字符编码读取
        "D:\aaa\gbkfile.txt"
         */

        //1.创建对象并指定字符编码
        InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\java\\java code\\IO\\gbkfile.txt"),"GBK");
        //2.读取数据
        int ch;
        while ((ch = isr.read()) != -1){
            System.out.print((char) ch);
        }
        //3.释放资源
        isr.close();   //(了解即可，这种方案被淘汰了)

//        FileReader fr = new FileReader("D:\\java\\java code\\IO\\gbkfile.txt",Charset.forName("GBK"));
//        //2.读取数据
//        int ch;
//        while ((ch = isr.read()) != -1){
//            System.out.println((char) ch);
//        }
//        //3.释放资源
//        fr.close();           最新的方式，不过在JDK11才能使用
    }
}

10.2利用转换流按照指定字符编码写出

package com.tian.myconvertStream;

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

public class ConvertStreamDemo02 {
    public static void main(String[] args) throws IOException {
        /*
        利用转换流按照指定字符编码写出
         */

    /*  （淘汰）
        //1.创建转换流的对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\java\\java code\\IO\\b.txt"),"GBK");
        //2.写出数据
        osw.write("你好你好");
        //3.释放资源
        osw.close();         */

//        FileWriter fw = new FileWriter("D:\\java\\java code\\IO\\c.txt", Charset.forName("GBK"));
//        fw.write("你好你好");
//        fw.close();          JDK11才能使用
    }
}

10.3将本地文件中的GBK文件，转成UTF-8

package com.tian.myconvertStream;

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

public class ConvertStreamDemo03 {
    public static void main(String[] args) throws IOException {
        /*
        将本地文件中的GBK文件，转成UTF-8
         */

        //1.JDK11以前的方案
        /* InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\java\\java code\\IO\\b.txt"),"GBK");
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\java\\java code\\IO\\d.txt"),"UTF-8");

        int b;
        while ((b = isr.read()) != -1){
            osw.write(b);
        }

        osw.close();
        isr.close(); */
        //2.替代方案
//        FileReader fr = new FileReader("D:\\java\\java code\\IO\\b.txt", Charset.forName("GBK"));
//        FileWriter fw = new FileWriter("D:\\java\\java code\\IO\\e.txt",Charset.forName("UTF-8"));
//        int b;
//        while ((b = fr.read()) != -1){
//            fw.write(b);
//        }
//        fw.close();
//        fr.close();
    }
}

10.4利用字节流读取文件中的数据，每次读一整行，而且不能出现乱码

package com.tian.myconvertStream;

import java.io.*;

public class ConvertStreamDemo04 {
    public static void main(String[] args) throws IOException {
        /*
               利用字节流读取文件中的数据，每次读一整行，而且不能出现乱码
               1.字节流在读取中文的时候，是会出现乱码的，但是字符流可以搞定
               2.字节流里面是没有读一整行的方法的，只有字符缓冲流才能搞定
         */
        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("D:\\java\\java code\\IO\\a.txt")));
        String line;
        while ((line = br.readLine()) != null){
            System.out.println(line);
        }
        br.close();
    }
}

10.5总结

转换流的名字是什么
- 字符转换输入流：InputStreamReader
- 字符转换输出流：OutputStreamWriter
转换流的作用是什么
- 指定字符集读写数据（JDK11之后已经淘汰）
- 字节流想要使用字符流中的方法了

11序列化流

11.1利用序列化流/对象操作输出流，把一个对象写到本地文件中

package com.tian.myobjectstream;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class ObjectStreamDemo01 {
    public static void main(String[] args) throws IOException {
        /*
        需求：
             利用序列化流/对象操作输出流，把一个对象写到本地文件中
        构造方法：
             public ObjectOutputStream(OutputStream out)     把基本流变成高级流
        成员方法：
             public final void writeObject(Object obj)       把对象序列化（写出）到文件中去
         */
        //1.创建对象
        Student stu = new Student(23,"zhangsan");

        //2.创建序列化流的对象/对象操作输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\java\\java code\\IO\\a.txt"));

        //3.写出数据
        oos.writeObject(stu);

        //4.释放资源
        oos.close();
    }
}

11.2利用反序列化流/对象操作输入流，把文件中的对象读到程序当中

package com.tian.myobjectstream;

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

public class ObjectStreamDemo02 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        /*
        需求：
             利用反序列化流/对象操作输入流，把文件中的对象读到程序当中
        构造方法：
             public ObjectInputStream(InputStream out)     把基本流变成高级流
        成员方法：
             public Object readObject ()       把序列化到本地文件中的对象，读取到程序中来
         */
        //1.创建反序列化流的对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\java\\java code\\IO\\a.txt"));
        //2.读取数据
        Student o = (Student) ois.readObject();
        //3.打印对象
        System.out.println(o);
        //4.释放资源
        ois.close();
    }
}

11.3细节

序列化对象后，修改了javabean类，再次反序列化，会出现问题，给javabean类添加serialVersionUID就可以了
使用序列化流将对象写到文件时，需要让javabean类实现Serializable接口
序列化流写到文件中的数据不能修改，一旦修改就无法再次读回来了
如果一个对象中的某一个成员变量的值不想被序列化，给该成员变量加transient关键词修饰，该关键词标记的成员变量不参与序列化过程

11.4练习

package com.tian.mytest;

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

public class Test08 {
    public static void main(String[] args) throws IOException {
        /*
        需求：将多个自定义对象序列化到文件中，但是对象的个数不确定，该如何操作
         */

        //1.序列化多个对象
        Student s1 = new Student("zhangsan",23,"南京");
        Student s2 = new Student("lisi",24,"重庆");
        Student s3 = new Student("wangwu",25,"北京");

        ArrayList<Student> list = new ArrayList<>();
        list.add(s1);
        list.add(s2);
        list.add(s3);

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\java\\java code\\IO\\a.txt"));
        oos.writeObject(list);

        oos.close();
    }
}

package com.tian.mytest;

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

public class Test09 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1.创建反序列化流的对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\java\\java code\\IO\\a.txt"));
        //2.读取数据
        ArrayList<Student> list = (ArrayList<Student>) ois.readObject();
        for (Student student : list) {
            System.out.println(student);
        }

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

package com.tian.mytest;

import java.io.Serializable;

public class Student implements Serializable {

    private static final long serialVersionUID = 6330225223956741049L;
    private String name;
    private int age;
    private String address;

    public Student() {
    }

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

    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;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Student{" +
                "address='" + address + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

12打印流

12.1字节打印流

package com.tian.myprintstream;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;

public class PrintStreamDemo01 {
    public static void main(String[] args) throws FileNotFoundException {
        /*
        字节打印流:
            构造方法
                 public PrintStream(OutputStream/File/string)             关联字节输出流/文件/文件路径
                 public PrintStream(String fileName,charset charset)      指定字符编码
                 public PrintStream(OutputStream,boolean autoFlush)       自动刷新
                 public PrintStream(OutputStream out, boolean autoFlush, string encoding)        指定字符编码且自动刷新
            成员方法:
                 public void write(int b)                     常规方法:规则跟之前一样，将指定的字节写出
                 public void println(xxx xx)                  特有方法:打印任意数据，自动刷新，自动换行
                 public void print(xxx xx)                    特有方法:打印任意数据，不换行
                 public void printf(string format，object...args)    特有方法:带有占位符的打印语句，不换行
         */

        //1.创建字节打印流的对象
        PrintStream ps = new PrintStream(new FileOutputStream("D:\\java\\java code\\IO\\a.txt"),true);
        //2.写出数据
        ps.println(97);//写出+自动刷新+自动换行
        ps.print(true);
        ps.println();
        ps.printf("%s爱上了%s","阿珍","阿强");
        //3.释放资源
        ps.close();
    }

}

12.2字符打印流

package com.tian.myprintstream;

import java.io.*;

public class PrintStreamDemo03 {
    public static void main(String[] args) throws IOException {
        /*
        字符打印流:
             构造方法
                 public PrintWriter(Write/File/String)                                  关联字节输出流/文件/文件路径
                 public PrintWriter(String fileName,Charset charset)                    指定字符编码
                 public PrintWriter(Write,boolean autoFlush)                            自动刷新
                 public PrintWriter(Write out, boolean autoFlush, String encoding)      指定字符编码且自动刷新
             成员方法:
                 public void write(int b)                     常规方法:规则跟之前一样，将指定的字节写出
                 public void println(xxx xx)                  特有方法:打印任意数据，自动刷新，自动换行
                 public void print(xxx xx)                    特有方法:打印任意数据，不换行
                 public void printf(String format，Object...args)    特有方法:带有占位符的打印语句，不换行
         */
        //1.创建字符打印流的对象
        PrintWriter pw = new PrintWriter(new FileWriter("D:\\java\\java code\\IO\\a.txt"),true);
        //2.写出数据
        pw.println("今天你终于叫我名字了，虽然叫错了，但是没关系，我马上改");
        pw.print("你好你好");
        pw.println();
        pw.printf("%s爱上了%s","阿珍","阿强");
        //3。释放资源
        pw.close();
    }
}

12.3总结

打印流有几种？各有什么特点？
- 有字节打印流和字符打印流两种
- 打印流不操作数据源，只能操作目的地
- 字节打印流：默认自动刷新，特有的println自动换行
- 字符打印流：自动刷新需要开启，特有的printlin自动换行
平常所用的System.out.println();就是打印流，一种特殊的打印流

13解压缩流

package com.tian.myzipstream;

import java.io.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

public class ZipStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //1.创建一个File表示要解压的压缩包
        File src = new File("D:\\aaa.zip");
        //2.创建一个File表示解压的目的地
        File dest = new File("D:\\");
        //调用方法
        unzip(src,dest);

    }
    //定义一个方法用来解压
    public static  void unzip(File src,File dest) throws IOException {
        //解压的本质：把压缩包里面的每一个文件或者文件夹读取处理，按照层级拷贝到目的地当中

        //创建一个解压缩流用来读取压缩包中的数据
        ZipInputStream zip = new ZipInputStream(new FileInputStream(src));
        //要先获取到压缩包里面的每一个zipentry对象

        //表示当前在压缩包中获取到的文件或者文件夹
        ZipEntry entry;
        while ((entry = zip.getNextEntry()) != null){
            System.out.println(entry);
            if (entry.isDirectory()){
                //文件夹：需要在目的地dest处创建一个同样的文件夹
                File file = new File(dest,entry.toString());
                file.mkdirs();
            }else {
                //文件：需要读取到压缩包中的文件，并把他存放到目的地dest文件夹中（按照层级目录进行存放）
                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();
    }
}

14压缩流

14.1压缩单个文件

package com.tian.myzipstream;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class ZipStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //1.创建File对象表示要压缩的文件
        File src = new File("D:\\a.txt");
        //2.创建File对象表示压缩包的位置
        File dest = new File("D:\\");
        //3.调用方法用来压缩
        toZip(src,dest);
    }
    public static void toZip(File src,File dest) throws IOException {
        //1.创建压缩流关联压缩包
        ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(new File(dest,"a.zip")));
        //2.创建ZipEntry对象，表示压缩包里面的每一个文件和文件夹
        ZipEntry entry = new ZipEntry("a.txt");
        //3.把ZipEntry对象放到压缩包中
        zos.putNextEntry(entry);
        //4.把src文件中的数据写到压缩包中
        FileInputStream fis = new FileInputStream(src);
        int b;
        while ((b = fis.read()) != -1){
            zos.write(b);
        }
        zos.closeEntry();
        zos.close();
    }
}

14.2压缩一个文件夹

package com.tian.myzipstream;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

import static com.tian.myzipstream.ZipStreamDemo02.toZip;

public class ZipStreamDemo03 {
    public static void main(String[] args) throws IOException {
        //1.创建File对象表示要压缩的文件夹
        File src = new File("D:\\aaa");
        //2.创建File对象表示压缩包放哪里（压缩包的父级路径）
        File destParent = src.getParentFile();
        //3.创建File对象表示压缩包的路径
        File dest = new File(destParent,src.getName() + ".zip");
        //4.创建压缩流关联压缩包
        ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(dest));
        //5.获取src里面的每一个文件，变成ZipEntry对象，放入到压缩包当中
        toZip(src,zos,src.getName());
        //6.释放资源
        zos.close();
    }
    /**
     * 作用一：获取src里面的每一个文件，变成ZipEntry对象，放入到压缩包当中
     * 参数一：数据源
     * 参数二：压缩流
     * 参数三：压缩包内部的路径
     */
    public static void toZip(File src,ZipOutputStream zos,String name) throws IOException {
        //1.进入src文件夹
        File[] files = src.listFiles();
        //2.遍历数组
        for (File file : files) {
            if (file.isFile()){
                //3.判断文件，变成ZipEntry对象，放入到压缩包当中
                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();
            }else {
                //4.判断文件夹，递归
                toZip(file,zos,name + "\\" + file.getName());
            }
        }
    }
}

15常用工具包

15.1commons-io

package com.tian.mycommonsio;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;

public class CommonsIODemo01 {
    public static void main(String[] args) throws IOException {
        /*
        FileUtils类
              static void copyFile(File srcFile, File destFile)                       复制文件
              static void copyDirectory(File srcDir, File destDir)                    复制文件夹  直接拷贝文件夹
              static void copyDirectoryToDirectory(File srcDir, File destDir)         复制文件夹  例：拷贝aaa，拷贝出来是bbb\\aaa
              static void deleteDirectory(File directory)                             删除文件夹
              static void cleanDirectory(File directory)                              清空文件夹
              static string readFileToString(File file, charset encoding)             读取文件中的数据变成成字符串
              static void write(File file, CharSequence data, string encoding)        写出数据
        IOUtils类
              public static int copy(InputStream input, OutputStream output)           复制文件
              public static int copyLarge(Reader input, Writer output)                 复制大文件
              public static string readLines(Reader input)                             读取数据
              public static void write(string data, OutputStream output)               写出数据
         */

        File src = new File("目标文件");
        File dest = new File("复制的文件");
        FileUtils.copyFile(src,dest);
    }
}

15.2Hutool工具包

package com.tian.myhutool;

import cn.hutool.core.io.FileUtil;

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

public class Test1 {
    public static void main(String[] args) {
        /*
        FileUtil类：
               file：根据参数创建一个file对象
               touch：根据参数创建文件

               writeLines：把集合中的数据写出到文件中，覆盖模式
               appendLine：把集合中的数据写出到文件中，续写模式
               readLine：指定字符编码，把文件中的数据读到集合中
               readUtf8Lines：按照UTF-8的形式，把文件中的数据读到集合中

               copy：拷贝文件或者文件夹
         */
        File file1 = FileUtil.file("D:\\","aaa","bbb","a.txt");
        System.out.println(file1);

        File touch = FileUtil.touch(file1);
        System.out.println(touch);

        ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("aaa");
        list.add("aaa");

        File file2 = FileUtil.writeLines(list,"D:\\a.txt","UTF-8");
        System.out.println(file2);

        ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("aaa");
        list.add("aaa");
        File file3 = FileUtil.appendLines(list,"D:\\a.txt","UTF-8");
        System.out.println(file3);

        List<String> list = FileUtil.readLines("D:\\a.txt","UTF-8");
        System.out.println(list);
    }
}

posted @ 2025-08-09 14:12 A那就算了吧阅读(6) 评论(0) 收藏举报

刷新页面返回顶部

ths-java

IO

IO流

1.字节输出流基本用法

1.1字节输出流写出数据的细节

1.2写出数据的三种方式

1.3换行和续写

1.4总结

2.字节输入流基本用法

2.1字节输入流写出数据的细节

2.2字节输入流的循环读取

3.文件拷贝

4.字符集

4.1ASCII和GBK

4.2Unicode

4.3乱码

4.4解码和编码的实现

5.字符流

5.1字符输入流read空参

5.2字符输入流read有参

5.3 字符输出流写出数据

5.4字符输入流底层原理

5.5字符输出流底层原理

6.综合练习

6.1拷贝文件夹

6.2加密和解密文件

6.3修改文件中的数据

7.字节缓冲流拷贝文件

7.1一次读取一个字节

7.2一次读取一个字节数组

8.字符缓冲流

8.1输入流

8.2输出流

9.综合练习

9.1四种方式拷贝文件效率对比

9.2恢复数据的顺序

9.3控制软件运行次数

10.转换流

10.1利用转换流按照指定字符编码读取

10.2利用转换流按照指定字符编码写出

10.3将本地文件中的GBK文件，转成UTF-8

10.4利用字节流读取文件中的数据，每次读一整行，而且不能出现乱码

10.5总结

11序列化流

11.1利用序列化流/对象操作输出流，把一个对象写到本地文件中

11.2利用反序列化流/对象操作输入流，把文件中的对象读到程序当中

11.3细节

11.4练习

12打印流

12.1字节打印流

12.2字符打印流

12.3总结

13解压缩流

14压缩流

14.1压缩单个文件

14.2压缩一个文件夹

15常用工具包

15.1commons-io

15.2Hutool工具包

公告