Java(8)I/O

目录

一、File类

1、File类概述

  • java.io.File类:一个java.io.File类的对象,表示文件和文件目录路径(就是文件夹)
  • File 能新建、删除、重命名文件和目录,但 File 不能访问文件内容本身。如果需要访问文件内容本身,则需要使用输入/输出流。
  • 想要在Java程序中表示一个真实存在的文件或目录,那么必须有一个File对 象,但是Java程序中的一个File对象,可能没有一个真实存在的文件或目录。

Java(8)I/O插图

  • 经典应用场景:File对象可以作为参数传递给流的构造器。

2、File类实例化

  • 构造器
构造器 描述
File(String pathname) 路径名称来创建
File(String parent, String child) 上层目录路径+文件名来创建
File(File parent, String child) 上层文件名+文件名来创建
File(URI uri) uri来创建
  • 路径

    • 绝对路径:是一个固定的路径,从盘符开始
    • 相对路径:是相对于某个位置开始。在IDEA中是相对于当前的module
  • 路径分隔符

    • windows和DOS系统默认使用“”来表示
    • UNIX和URL使用“/”来表示
    • Java程序支持跨平台运行,因此路径分隔符要慎用。为了解决这个隐患,File类提供了一个常量:public static final String separator,根据操作系统,动态的提供分隔符。
    • 举例
    File file1 = new File("d:\atguigu\info.txt");
    
    File file2 = new File("d:" + File.separator + "atguigu" + File.separator + "info.txt");
    
    File file3 = new File("d:/atguigu");
    

3、File类常用方法

  • **获取
方法 描述
getAbsolutePath() 获取绝对路径
getPath() 获取路径
getName() 获取名
getParent() 获取上层文件目录路径。若无,返回null
length() 获取文件长度(即:字节数)。不能获取目录的长度。
lastModified() 获取最后一次的修改时间,毫秒值
下面两个是针对目录的
public String[] list() 获取指定目录下的所有文件或者文件目录的名称数组
public File[] listFiles() 获取指定目录下的所有文件或者文件目录的File数组
  • 重命名

public boolean renameTo(File dest):把文件重命名为指定的文件路径。(实际上就是把file1的内容复制到file2,并把file1删除)

对于 file1.renameTo(file2)要求:file1存在,file2不存在

  • 判断
方法 描述
isDirectory() 判断是否是文件目录
isFile() 判断是否是文件
exists() 判断是否存在
canRead() 判断是否可读
canWrite() 判断是否可写
isHidden() 判断是否隐藏
  • 创建和删除
方法 描述 注意事项
public boolean createNewFile() 创建文件 若文件存在,则不创建,返回false
public boolean mkdir() 创建文件目录 如果此文件目录存在,就不创建;
如果此文件目录的上层目录不存在,也不创建
public boolean mkdirs() 创建文件目录 如果上层文件目录不存在,一并创建
public boolean delete() 删除文件或者文件夹 Java中的删除不走回收站
要删除的文件目录内不能包含文件或文件目录

如果你创建文件或者 文件 目录没有写盘符路径 , 那么 ,默认在项目路径下。

二、IO流的原理

1、IO流的原理

  • I/O是input/output的缩写,IO技术用于设备之间的数据传输。(如。读/写文件、网络通讯
  • Java程序中,数据的输入/输出操作以“流(stream)” 的方式进行。
  • java.io包下提供了各种“流”类和接口,用以获取不同种类的数据,并通过标准的方法输入或输出数据。

2、input和output的理解

  • 首先对于入和出,我们是站在程序的角度来说的,想象自己身处程序内部。
  • input:磁盘、光盘等存储设备的数据—–>程序、内存
  • output:程序、内存中的数据—–>磁盘、光盘等存储设备

三、IO流的分类

1、分类

  • √√√按操作的数据单位不同分为:字节流(8bit)、字符流(16bit)。字节流适合操作图片、视频等文件,字符流适合操作文本文件。

  • 按数据流的流向不同分为:输入流、输出流。

  • 流的角色不同分为:**节点流、处理流。

    • 节点流:直接从数据源或目的地读写数据。也叫文件流

      Java(8)I/O插图(1)

    • 处理流:不直接连接到数据源或目的地,而是“连接”在已存 在的流(节点流或处理流)之上,通过对数据的处理为程序提 供更为强大的读写功能

      Java(8)I/O插图(2)

2、图示

Java(8)I/O插图(3)

3、四个抽象基类

抽象基类 字节流 字符流
输入流 InputStream Reader
输出流 OutputStream Writer

4、IO流体系

Java(8)I/O插图(4)

四、FileReader和FileWriter

1、IDEA中单元测试方法和main()下相对路径对比

  • 单元测试方法下的相对路径是:相较于当前module而言
  • main()下的相对路径:相较于当前工程而言

2、使用FileReader读入数据

  • 最初的代码实现
public void test1() throws IOException {
        //1.实例化File类,指明要操作的对象.这一步的目的是建立硬盘中的文件和Java中类的对应关系.
        File file = new File("hello1.txt");

        //2.提供具体的流.参数的作用就是帮助我们并连接上文件这个"大水库"
        FileReader fileReader = new FileReader(file);

        //3.用流读取到内存
        //read():返回读入的字符,是int需要转换为char.到了文件结尾返回-1
        int read = fileReader.read();
        while (read != -1) {
            System.out.print((char) read);
            read = fileReader.read();
        }

        //4.关闭流
        fileReader.close();
    }
    //整个过程结合图示去理解很合理
  • 改进后的代码实现
	/*
    优化:
        1.第三部可以在语法上的优化,但是效率其实是一样的
        2.为了保证关闭操作一定执行,使用try-catch-finally
        3.读入的文件一定要存在,否则会出现:FileNotFoundException
    */
public void test2() {

        FileReader fileReader = null;
        try {
            File file = new File("hello1.txt");

            fileReader = new FileReader(file);

            //改进1
            int read;
            while ((read = fileReader.read()) != -1){
                System.out.print((char) read);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileReader != null)
                    fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
  • 使用缓冲流改进这个是用的最多的
//使用数组
char[] charBuffer = new char[5];
int len;//记录每次读入到charBuffer数组中的字符个数
while ((len = fileReader.read(charBuffer)) != -1){
    for (int i = 0; i < len; i++) {//这里要用len(读取的字符数)二不是数组的长度
        System.out.print(charBuffer[i]);
    }
}

//当然for循环也可以换位String的构造器来把字符串数组转换为String
String string = new String(charBuffer, 0, len);
System.out.print(string);

3、使用FileWriter写出数据

  • 代码实现
File file = new File("hello2.txt");
FileWriter fw = new FileWriter(file);
fw.write("i have a dream!");
fw.close();
//最后用try-catch处理一下异常,上面的步骤更清晰一些
  • 说明
    • 输出时,File可以不存在,不会报异常。
    • File对应的硬盘的文件如果不存在,自动创建
    • File对应的硬盘的文件如果存在
      • 如果流使用的构造器是FileWriter(file, false)/FileWriter(file),对原有的文件进行覆盖
      • 如果流使用的构造器是FileWriter(file, true),对原有的文件进行追加

4、使用FileReader和FileWriter复制文本文件

  • 代码实现
public void test5() throws IOException {
        File srcFile = new File("hello2.txt");
        File destFile = new File("hello3.txt");

        FileReader fr = new FileReader(srcFile);
        FileWriter fw = new FileWriter(destFile);

        char[] charBuffer = new char[5];
        int len;
        while ((len = fr.read(charBuffer)) != -1) {
            fw.write(charBuffer, 0, len);//和用String来取是类似的
        }

        fw.close();
        fr.close();
}
//最后用try-catch处理一下异常,上面的步骤更清晰一些

5、使用FileReader和FileWriter不能处理图片的复制的测试

  • 当把hello.txt文本文件改为图片文件时,发现代码是可以正常运行,但是复制结果并不对,新图片打不开。
  • 这是因为,图片是用字节来存储的。用字符流来处理显然不行。

五、FileInputStream和FileOutputStream

1、用FileInputStream和FileOutputStream处理文本文件会怎样?

  • 结论
    • 输出到控制台时:英文不乱码,中文可能会乱码
    • 单纯复制,而不在内存层面查看:不会乱码,是可以的。
  • 解释
    • 对于英文,utf-8和gbk都是用一个字节(4bit位)来存一个字母,因此每个字母都是完完整整的存入byte数组,从而能完整的复制过去。
    • 对于中文,utf-8中用的是三个字节来存一个汉字,那么字节数组中的数据在输出时,不确定在哪里截断,就会出现一部分字的乱码。

2、确定使用字符流还是字节流

  • 对于文本文件(.txt, .java, .cpp),使用字符流
  • 对于非文本文件(.jpg, .mp3, .mp4, .avi, .doc, .ppt…),使用字节流

3、用FileInputStream和FileOutputStream复制图片

  • 同“使用FileReader和FileWriter复制文本文件”,只要
    • 使用FileInputStream和FileOutputStream
    • 把数组改为byte数组

六、缓冲流

1、缓冲流有哪些

BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter

2、作用

  • 提高读写速度

3、原因

  • 在使用这些流类时,会创建一个内部缓冲区数组,缺省使用8192个字节(8Kb)的缓冲区。
  • 当读取数据时,数据按块读入缓冲区,其后的读操作则直接访问缓冲区
  • 当使用BufferedInputStream读取字节文件时,BufferedInputStream会一次性从文件中读取8192个(8Kb),存在缓冲区中,直到缓冲区装满了,才重新从文件中读取下一个8192个字节数组。
  • 向流中写入字节时,不会直接写到文件,先写到缓冲区中直到缓冲区写满, BufferedOutputStream才会把缓冲区中的数据一次性写到文件里。
  • 使用方法 flush()可以强制将缓冲区的内容全部写入输出流。
  • 如果是带缓冲区的流对象的close()方法,不但会关闭流,还会在关闭流之前刷 新缓冲区,关闭后不能再写出。
    • 填坑:自己写代码的时候忘记关闭流操作,导致复制的图片打不开的原因就是,没有关闭流,缓冲区内还有一部分数据没能复制过去。

4、使用缓冲流复制图片

public void test() throws IOException {
        //1.创建File
        File srcFile = new File("img1.png");
        File destFile = new File("img2.png");

        //2.创建流
        //2.1创建文件流
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(destFile);

        //2.2创建字节流
        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        //3.复制
        byte[] bytes = new byte[10];
        int len;
        while ((len = bis.read(bytes)) != -1){
            bos.write(bytes,0,len);
        }

        //4.关闭流
        bis.close();
        bos.close();
}
  • 关闭外层的流的同时,会自动关闭内层的流。所以只写外层的关闭操作就可以。

5、使用缓冲流复制文本文件

public void test1() throws IOException {
        //1.创建文件和流
        BufferedReader br = new BufferedReader(new FileReader(new File("hello1.txt")));
        BufferedWriter bw = new BufferedWriter(new FileWriter(new File("hello4.txt")));

//        //2.复制
//        char[] chars = new char[10];
//        int len;
//        while ((len = br.read(chars)) != -1) {
//            bw.write(chars, 0, len);
//        }


        // 复制:用String来实现
        String data;//但是是不带换行的,可以用一以下两种方法实现
        while ((data = br.readLine()) != null) {
//          //方法一
//            bw.write(data + "n");
            //方法二
            bw.write(data);
            bw.newLine();
        }

        //3.关闭
        br.close();
        bw.close();
    }

6、练习:统计文本每个字符出现次数

七、转换流

1、什么是转换流

  • 转换流提供了在字节流和字符流之间的转换
  • 转换流属于字符流
  • Java API提供了两个转换流
    • InputStreamReader:将InputStream转换为Reader
      • 构造器一:public InputStreamReader(InputStream in)默认使用utf-8字符集
      • 构造器二:public InputSreamReader(InputStream in,String charsetName)可以自己选择字符集。
    • OutputStreamWriter:将Writer转换为OutputStream
      • 构造器和上面类似
  • 字节流中的数据都是字符时,转成字符流操作更高效。
  • 很多时候我们使用转换流来处理文件乱码问题。实现编码和解码的功能。

2、编码与解码

  • 编码:字节、字节数组—>字符数组、字符串
  • 解码:字符数组、字符串—>字节、字节数组

3、字符集

  • 什么是编码表:计算机只能识别二进制数据,早期由来是电信号。为了方便应用计算机,让它可以识 别各个国家的文字。就将各个国家的文字用数字来表示,并一一对应,形成一张表。 这就是编码表。
  • 常见编码表
按照地区辅助记忆 编码表 描述
美国 ASCII 一个字节的7位来表示所有英文和符号
欧洲 ISO8859-1 一个字节的8位表示所有欧洲语言的字母
中国 GB2312
GBK
最多两个字节编码所有汉字
升级版,加入了更多的汉字
国际通用 Unicode
UTF-8
Unicode编码是对UTF-8/16的统称
1-4个字节表示人类所有文字

4、转换流的作用示意图

Java(8)I/O插图(5)

5、练习题

  • 综合使用:将文本文件从utf-8转换为gbk编码
  • 代码实现
@Test
    public void test2() throws Exception {
        //1.造文件、造流
        File file1 = new File("dbcp.txt");
        File file2 = new File("dbcp_gbk.txt");

        FileInputStream fis = new FileInputStream(file1);
        FileOutputStream fos = new FileOutputStream(file2);

        InputStreamReader isr = new InputStreamReader(fis,"utf-8");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");

        //2.读写过程
        char[] cbuf = new char[20];
        int len;
        while((len = isr.read(cbuf)) != -1){
            osw.write(cbuf,0,len);
        }

        //3.关闭资源
        isr.close();
        osw.close();
    }

八、标准输入输出流(了解)

1、简介

  • 标准输入流:System.in。默认输入设备是键盘。类型是InputStream。
  • 标准输出流:System.out。默认输出设备是控制台。类型是PrintStream,是OutputStream的子类。

2.练习

  • 题目:从键盘输入字符串,要求将读取到的整行字符串转成大写输出。然后继续 进行输入操作,直至当输入“e”或者“exit”时,退出程序。
  • 代码实现
public class Exercise {
    public static void main(String[] args) {//idea不支持在单元测试中输入内容,所以改用main()来测试
        BufferedReader br = null;
        try {
            InputStreamReader isr = new InputStreamReader(System.in);
            br = new BufferedReader(isr);

            while (true) {
                System.out.println("请输入字符串: ");
                String data = br.readLine();
                if ("e".equalsIgnoreCase(data)||"exit".equalsIgnoreCase(data)){
                    System.out.println("程序结束");
                    break;
                }
                String upperCase = data.toUpperCase();
                System.out.println(upperCase);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (br != null) {
                    br.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

九、打印流(了解)

1、打印流简介

  • 实现将基本数据类型的数据格式转化为字符串输出
  • 包含两个:PrintStream和PrintWriter
    • 提供了一系列重载的print()和println()方法,用于多种数据类型的输出
    • System.out返回的是PrintStream的实例

2、代码演示

  • 把标准输出流(控制台输出)改成文件
PrintStream ps = null; 
try {
	FileOutputStream fos = new FileOutputStream(new File("D:\IO\text.txt")); // 创建打印输出流,设置为自动刷新模式(写入换行符或字节 'n' 时都会刷新输出缓冲区) 
    ps = new PrintStream(fos, true); 
    if (ps != null) {// 把标准输出流(控制台输出)改成文件 
        System.setOut(ps); 
    }

	for (int i = 0; i <= 255; i++) { // 输出ASCII字符
		System.out.print((char) i); 
        if (i % 50 == 0) { // 每50个数据一行 
            System.out.println(); // 换行 
        }
    } 
} catch (FileNotFoundException e) { 
    e.printStackTrace(); 
} finally {
    if (ps != null) { 
        ps.close(); 
    } 
}

十、数据流(了解)

1、简介

  • 引入:为了方便地操作Java语言的基本数据类型和String的数据,可以使用数据流

  • 数据流有两个类:(用于读取和写出基本数据类型、String类的数据,方便持久化)

    • DataInputStream 和 DataOutputStream

    • DataInputStream中的方法

      boolean readBoolean()

      char readChar()

      double readDouble()

      long readLong()

      String readUTF()

      byte readByte()

      float readFloat()

      short readShort()

      int readInt() void

      readFully(byte[] b)

    • DataOutputStream中的方法

      将上述的方法的read改为相应的write即可

2、练习

练习:将内存中的字符串、基本数据类型的变量写出到文件中。

    注意:处理异常的话,仍然应该使用try-catch-finally.
     */
    @Test
    public void test3() throws IOException {
        //1.
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
        //2.
        dos.writeUTF("刘建辰");
        dos.flush();//刷新操作,将内存中的数据写入文件
        dos.writeInt(23);
        dos.flush();
        dos.writeBoolean(true);
        dos.flush();
        //3.
        dos.close();


    }
    /*
    将文件中存储的基本数据类型变量和字符串读取到内存中,保存在变量中。

    注意点:读取不同类型的数据的顺序要与当初写入文件时,保存的数据的顺序一致!

     */
    @Test
    public void test4() throws IOException {
        //1.
        DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
        //2.
        String name = dis.readUTF();
        int age = dis.readInt();
        boolean isMale = dis.readBoolean();

        System.out.println("name = " + name);
        System.out.println("age = " + age);
        System.out.println("isMale = " + isMale);

        //3.
        dis.close();

    }

十一、对象流

1、简介

  • 包含:两个类ObjectInputStream和ObjectOutputStream
  • 是:用于存储和读取基本数据类型数据或对象的处理流
  • 强大之处:可以把Java中的对象写入到数据源中,也能把对象从数据源中还原回来。

2、对象的序列化

  • 什么是对象的序列化机制(面试题)

    • 一方面,对象的序列化机制允许内存中的Java对象转换为平台无关的二进制流。从而允许吧二进制流持久化到磁盘,或,通过网络传给另一个网络节点
    • 另一方面,其他程序获取了二进制流,就可以恢复成原来的Java对象。
  • 序列化的好处:可将任何实现了Serializable接 使其在保存和传输时可被还原。

3、代码实现String类的对象的序列化和反序列化

public class ObjectInputOutputStream {
    /*
    代码实现String类的对象的序列化和反序列化
     */

    @Test//序列化
    public void testObjectOutputStream(){
        ObjectOutputStream oos = null;
        try {
            //1.造流和文件
            oos = new ObjectOutputStream(new FileOutputStream(new File("objectString.dat")));
            //2.写出
            oos.writeObject(new String("我爱你中国"));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //3.关闭流
            try {
                if (oos != null) {
                    oos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Test
    public void testObjectInputStream(){
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream(new File("objectString.dat")));

            Object readObject = ois.readObject();
            System.out.println(readObject);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if (ois != null) {
                    ois.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

4、自定义类的序列化

  • 要求
    • 实现Serializable接口(这是一个标识接口,内部没有方法)
    • 提供一个全局常量public static final long serialVersionUID = xxxxxxxxL;
      • 如果类没有显示定义这个静态常量,它的值是Java运行时环境根据类的内部细节自 动生成的。若类的实例变量做了修改,serialVersionUID 可能发生变化。故建议, 显式声明。
    • 还要保证类的所以属性也是可序列化的。
      • 基本数据类型是可序列化的
  • 注意:ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量
    • 因为static修饰的变量是类所有的
    • 不想序列化的就可以用transient

5、面试题

  • 谈谈你对java.io.Serializable接口的理解,我们知道它用于序列化, 是空方法接口,还有其它认识吗?
    • 实现了Serializable接口的对象,可将它们转换成一系列字节,并可在以后 完全恢复回原来的样子。这一过程亦可通过网络进行。这意味着序列化机 制能自动补偿操作系统间的差异。换句话说,可以先在Windows机器上创 建一个对象,对其序列化,然后通过网络发给一台Unix机器,然后在那里 准确无误地重新“装配”。不必关心数据在不同机器上如何表示,也不必 关心字节的顺序或者其他任何细节。
    • 由于大部分作为参数的类如String、Integer等都实现了 java.io.Serializable的接口,也可以利用多态的性质,作为参数使接口更 灵活。

十二、RandomAccessFile

1、简介

  • RandomAccessFile,随机存取文件流,直接继承于java.lang.Object类
  • 随机:RandomAccessFile 对象包含一个记录指针,用以标示当前读写处的位置。 RandomAccessFile 类对象可以自由移动记录指针
    • long getFilePointer():获取文件记录指针的当前位置
    • void seek(long pos):将文件记录指针定位到 pos 位置(这是他的灵魂所在)
      • 应用场景:可以多线程断点下载同一文件再拼接起来;下载不完,下次接着下载。
  • 存取:实现了DataInput、DataOutput两个接口,所以这个类既可以读也可以写**。
    • 可以用构造器里的参数决定是输出流还是输入流。
      • public RandomAccessFile(File file, String mode)
      • public RandomAccessFile(String name, String mode)
    • mode参数指定了访问模式
      • r: 以只读方式打开 (常用)
      • rw:打开以便读取和写入 (常用)
      • rwd:打开以便读取和写入;同步文件内容的更新
      • rws:打开以便读取和写入;同步文件内容和元数据的更新

2、用RandomAccessFile类实现文本文件的复制

@Test
public void test1() throws IOException {
    //用参数mode标识,让类代表输入
    RandomAccessFile r = new RandomAccessFile(new File("hello1.txt"), "r");
    //用参数mode标识,让类代表输出
    RandomAccessFile rw = new RandomAccessFile(new File("hello5.txt"), "rw");

    byte[] bytes = new byte[1024];
    int len;
    while ((len=r.read(bytes)) != -1){
        rw.write(bytes,0,len);
    }

    r.close();
    rw.close();
}

3、用 RandomAccessFile作为输出流时的特点

  • 如果写出到的文件不存在,就创建
  • 如果写出到的文件存在,会对原文从头开始进行覆盖,能覆盖多少算多少。

4、如何使用 RandomAccessFile对文本文件实现插入效果

/*
    使用RandomAccessFile实现数据的插入效果
     */
    @Test
    public void test3() throws IOException {

        RandomAccessFile raf1 = new RandomAccessFile("hello.txt","rw");

        raf1.seek(3);//将指针调到角标为3的位置
        //保存指针3后面的所有数据到StringBuilder中
        StringBuilder builder = new StringBuilder((int) new File("hello.txt").length());
        byte[] buffer = new byte[20];
        int len;
        while((len = raf1.read(buffer)) != -1){
            builder.append(new String(buffer,0,len)) ;
        }
        //调回指针,写入“xyz”
        raf1.seek(3);
        raf1.write("xyz".getBytes());

        //将StringBuilder中的数据写入到文件中
        raf1.write(builder.toString().getBytes());

        raf1.close();
    }

十三、第三方jar包的使用

1、为什么使用

  • 第三方jar包提供了很多方便高效的API,方便我们开发中使用,实际开发中也是用这些jar包来提高工作效率,而不只是根据JDK提供的API,因为有些不够简练。

2、IDEA中导入第三方jar包

  • 当前module下创建名为lib或libs的directory
  • 复制第三方jar包到lib目录
  • 右键jar包,选择 add as library
  • 搞定

3、用第三方jar包实现文件复制

public class JarTest {
    public static void main(String[] args) throws IOException {
        File srcFile = new File("s6_IO/hello1.txt");
        File destFile = new File("s6_IO/hello6.txt");

        FileUtils.copyFile(srcFile,destFile);

    }
}

原创文章,作者:迷途资源,如若转载,请注明出处:https://www.mipng.com/451.html

这些信息可能会帮助到你: 下载帮助 | 报毒说明 | 进站必看

修改版本安卓软件,加群提示为修改者自留,非本站信息,注意鉴别

发表评论

邮箱地址不会被公开。 必填项已用*标注