Java 常用IO流的举例系列之一

最新推荐文章于 2024-05-24 02:08:26 发布

iteye_2642

最新推荐文章于 2024-05-24 02:08:26 发布

阅读量97

点赞数

分类专栏： common just do it 备忘录 java more and more 文章标签： java IO

备忘录同时被 3 个专栏收录

47 篇文章 0 订阅

订阅专栏

java

47 篇文章 0 订阅

订阅专栏

more and more

45 篇文章 0 订阅

订阅专栏

由于项目的原因，自己好久都没有接触Java了，怕自己会什么都忘记，所以还是时不时写写，废话不多说，现在开始

[b]第一个：InputStream的实现类：FileInputStream[/b]

由于它是一个接口，因此不对其进行举例，直接看它的子类吧，直接例子：

代码1：

package com.fit.test.test04;

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

public class FileStreamDemo {

	public static void main(String[] args) {


		InputStream fis = null;

		try {
			fis = new FileInputStream("E:\\work\\test\\t.txt");

			int i = 0;

			while ((i = fis.read()) != -1) {
				System.out.print((char)i);
			}

		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件找不到");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生异常了");
		} finally {
			try {
				if (fis != null) {
					fis.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}
		}

	}

}

此代码要运行成功，E:\work\test\t.txt这个文件要存在；运行结果如下：

package com.fit.io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;


out.flush();
out.close();

[b]第二个：OutputStream的实现类：FileOutputStream[/b]

既然我们能把文件读出来，那同样的，我们也能利用文件写相关的类把文件给写出来，代码如下：
代码2：

package com.fit.test.test04;

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

public class FileStreamDemo {

	public static void main(String[] args) {

		InputStream fis = null;
		OutputStream fos = null;

		try {
			fis = new FileInputStream("E:\\work\\test\\t.txt");
			fos = new FileOutputStream("E:\\work\\test\\t1.txt");
			int i = 0;

			while ((i = fis.read()) != -1) {
				fos.write(i);
			}
                        fos.flush();

		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件找不到");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生异常了");
		} finally {
			try {
				if (fis != null) {
					fis.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}

			try {
				if (fos != null) {
					fos.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}
		}

	}

}

运行之后，E:\work\test\下有一个t1.txt这个文件，和t.txt文件一模一样。

好了，我们现在把读取的文件做一点小小的改变，加入几个汉字，看能不能读取出来，并且正常展示，此时我们还用代码1。

运行结果如下：

package com.fit.io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;

out.println("?ó????2");
out.println("??????????????2");

out.flush();
out.close();

发现了什么？乱码，不错，这是因为Java在读取的汉字的时候把汉字给拆开了，所以我们要改变读取的方式，用InputStreamReader进行一个包装。

[b]第三个：Reader的子类：InputStreamReader[/b]

代码3：

package com.fit.test.test04;

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

public class FileStreamReaderDemo {

	public static void main(String[] args) {


		InputStreamReader fis = null;

		try {
			fis = new InputStreamReader(new FileInputStream("E:\\work\\test\\t.txt"));

			int i = 0;

			while ((i = fis.read()) != -1) {
				System.out.print((char)i);
			}

		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件找不到");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生异常了");
		} finally {
			try {
				if (fis != null) {
					fis.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}
		}

	}

}

运行结果如下：

package com.fit.io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;

out.println("大家好2");
out.println("这是一个测试！2");

out.flush();
out.close();

好了，现在是不是正常展示了？同样的，我们仍然可以把这些含有汉字的文本写入到文件中。

[b]第四个：Writer的子类：OutputStreamWriter[/b]
代码4：

package com.fit.test.test04;

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

public class FileStreamDemo {

	public static void main(String[] args) {

		InputStream fis = null;
		OutputStream fos = null;

		try {
			fis = new FileInputStream("E:\\work\\test\\t.txt");
			fos = new FileOutputStream("E:\\work\\test\\t1.txt");
			int i = 0;

			while ((i = fis.read()) != -1) {
				fos.write(i);
			}
			fos.flush();

		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件找不到");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生异常了");
		} finally {
			try {
				if (fis != null) {
					fis.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}

			try {
				if (fos != null) {
					fos.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}
		}

	}

}

运行之后，E:\work\test\下有一个t2.txt这个文件，和t.txt文件一模一样。

其实代码2也能实现和代码4一样的功能，但是效率上可能会慢点，但是比较通用，如果要想提高效率的话，那我们在代码2的基础上再加一层封装。

[b]第五个：FilterInputStream的子类：OutputStreamWriter[/b]
代码5：

package com.fit.test.test04;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class BufferInputStreamDemo {

	public static void main(String[] args) {

		InputStream fis = null;
		OutputStream fos = null;
		BufferedInputStream bis = null;

		try {
			fis = new FileInputStream("E:\\work\\test\\t.txt");
			fos = new FileOutputStream("E:\\work\\test\\t1.txt");
			bis = new BufferedInputStream(fis);
			int i = 0;

			while ((i = bis.read()) != -1) {
				fos.write(i);
			}
			fos.flush();

		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件找不到");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生异常了");
		} finally {
			try {
				if (bis != null) {
					bis.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}

			try {
				if (fos != null) {
					fos.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}
		}

	}

}

运行结果也是正常的，但是一般情况下，我们用了BufferedInputStream，那么相应的，我们就最好去用，上述例子我执行是正常的，但是不能保证数据量大的时候还是正常的，个人对这块也不是很深入了解，如果有人知道，可以告诉我，大家共同进步。 :D

[b]第六个：FilterOutputStream的子类：OutputStreamWriter[/b]
和五个例子是对应的。
代码6：

package com.fit.test.test04;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class BufferOutputStreamDemo {

	public static void main(String[] args) {

		InputStream fis = null;
		OutputStream fos = null;
		BufferedInputStream bis = null;
		BufferedOutputStream bos = null;

		try {
			fis = new FileInputStream("E:\\work\\test\\t.txt");
			fos = new FileOutputStream("E:\\work\\test\\t1.txt");
			bis = new BufferedInputStream(fis);
			bos = new BufferedOutputStream(fos);
			int i = 0;

			while ((i = bis.read()) != -1) {
				bos.write(i);
			}
			bos.flush();

		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件找不到");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生异常了");
		} finally {
			try {
				if (bis != null) {
					bis.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}

			try {
				if (bos != null) {
					bos.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}
		}

	}

}

上述涉及到了用FileInputStream读取原始字节流，但是JDK为我们封装了一个更方便的读取文件的类，FileReader，用于读取字符流。

[b]第七个：InputStreamReader的子类：FileReader[/b]

代码7：

package com.fit.test.test04;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;

public class FileReaderDemo {

	public static void main(String[] args) {

		Reader reader = null;

		try {
			reader = new FileReader("E:\\work\\test\\t.txt");
			int i = 0;

			while ((i = reader.read()) != -1) {
				System.out.print((char)i);
			}

		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件找不到");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生异常了");
		} finally {
			try {
				if (reader != null) {
					reader.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}

		}

	}

}

运行结果：

package com.fit.io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;

out.println("大家好2");
out.println("这是一个测试！2");

out.flush();
out.close();

有FileReader，那么对应的应该也有FileWriter吧。

[b]第八个：OutputStreamWriter的子类：FileWriter[/b]
直接代码：
代码8：

package com.fit.test.test04;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

public class FileWriterDemo {

	public static void main(String[] args) {

		Reader reader = null;
		Writer writer = null;

		try {
			reader = new FileReader("E:\\work\\test\\t.txt");
			writer = new FileWriter("E:\\work\\test\\t3.txt");
			int i = 0;

			while ((i = reader.read()) != -1) {
				writer.write(i);
			}
			writer.flush();

		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件找不到");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生异常了");
		} finally {
			try {
				if (reader != null) {
					reader.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}

			try {
				if (writer != null) {
					writer.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}

		}

	}

}

上述的代码在功能上没有问题，但是在性能上却存在缺陷，通常，Reader 所作的每个读取请求都会导致对底层字符或字节流进行相应的读取请求。因此，建议用 BufferedReader 包装所有其 read() 操作可能开销很高的 Reader（如 FileReader 和 InputStreamReader）。例如，
BufferedReader in = new BufferedReader(new FileReader("foo.in"));
将缓冲指定文件的输入。如果没有缓冲，则每次调用 read() 或 readLine() 都会导致从文件中读取字节，并将其转换为字符后返回，而这是极其低效的。
通过用合适的 BufferedReader 替代每个 DataInputStream，可以对将 DataInputStream 用于文字输入的程序进行本地化。

[b]第九个：Reader的子类：BufferedReader[/b]

代码9：

package com.fit.test.test04;

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

public class BufferReaderDemo {

	public static void main(String[] args) {

		Reader reader = null;

		try {
			reader = new BufferedReader(new FileReader("E:\\work\\test\\t.txt"));
			int i = 0;

			while ((i = reader.read()) != -1) {
				System.out.print((char)i);
			}

		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件找不到");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生异常了");
		} finally {
			try {
				if (reader != null) {
					reader.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}

		}

	}

}

运行结果肯定是正确的，还是和之前的一样，既然有BufferedReader，那么肯定有BufferedWriter。

[b]第十个：Writer的子类：BufferedWriter[/b]

代码10：

package com.fit.test.test04;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

public class BufferWriterDemo {

	public static void main(String[] args) {

		Reader reader = null;
		Writer writer = null;

		try {
			reader = new BufferedReader(new FileReader("E:\\work\\test\\t.txt"));
			writer = new BufferedWriter(new FileWriter("E:\\work\\test\\t5.txt"));
			int i = 0;

			while ((i = reader.read()) != -1) {
				writer.write(i);
			}
			writer.flush();

		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件找不到");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生异常了");
		} finally {
			try {
				if (reader != null) {
					reader.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}

			try {
				if (writer != null) {
					writer.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}

		}

	}

}

其实JDK中有提到一个示例：
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("foo.out")));

那么根据上述示例，我们代码10就可以做如下的改动了：

替换

writer = new BufferedWriter(new FileWriter("E:\\work\\test\\t5.txt"));

为

writer = new PrintWriter(new BufferedWriter(new FileWriter("E:\\work\\test\\t6.txt")));

[b]第十一个：OutputStream的子类：DataOutputStream[/b]

数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后，应用程序可以使用数据输入流将数据读入。

代码11：

package com.fit.test.test04;

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

public class DataOutputStreamDemo {

	public static void main(String[] args) {

		DataOutputStream out = null;
		try {
			out = new DataOutputStream(new FileOutputStream("E:\\work\\test\\myfloat.txt"));

			for (int i = 0; i < 10; i++) {
				out.writeDouble(Math.random() * 100);
			}
			out.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件找不到");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生异常了");
		} finally {

			try {
				if (out != null) {
					out.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}

		}

	}

}

[b]第十二个：InputStream的子类：DataInputStream[/b]

数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。

DataInputStream 对于多线程访问不一定是安全的。线程安全是可选的，它由此类方法的使用者负责。

代码12：

package com.fit.test.test04;

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

public class DataInputStreamDemo {

	public static void main(String[] args) {

		DataInputStream in = null;
		try {
			in = new DataInputStream(new FileInputStream(
					"E:\\work\\test\\myfloat.txt"));

			while (true) {
				double d = in.readDouble();
				System.out.println(d);
			}

		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件找不到");
		} catch (EOFException e) {
			System.out.println("读取结束了");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生异常了");
		} finally {

			try {
				if (in != null) {
					in.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}

		}

	}

}

此时注意：在read的时候如果此输入流在读取这八个字节之前到达末尾。则此时会抛出EOFException异常。

DataInputStream和DataOutputStream的应用举例。

代码：

package com.fit.test.test04;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class DataStreamDemo {

	public static void main(String[] args) throws Exception {

		File file = new File("E:\\work\\test\\cnt");
		if (!file.exists()) {
			DataOutputStream out = new DataOutputStream(new FileOutputStream(
					file));
			out.writeInt(1);
			out.flush();
			out.close();
			System.out.println("本程序第1次运行！");
			return;
		}

		DataInputStream in = new DataInputStream(new FileInputStream(file));

		int cnt = in.readInt();
		in.close();
		cnt++;

		DataOutputStream out = new DataOutputStream(new FileOutputStream(file));
		out.writeInt(cnt);
		out.flush();
		out.close();
		System.out.println("本程序第" + cnt + "次运行！");

	}
}

第十三个：InputStream的子类：DataInputStream

ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream。可以使用 ObjectInputStream 读取（重构）对象。通过在流中使用文件可以实现对象的持久存储。如果流是网络套接字流，则可以在另一台主机上或另一个进程中重构对象。

只能将支持 java.io.Serializable 接口的对象写入流中。每个 serializable 对象的类都被编码，编码内容包括类名和类签名、对象的字段值和数组值，以及从初始对象中引用的其他所有对象的闭包。

代码13：

package com.fit.test.test04;

import java.io.Serializable;

public class Tiger implements Serializable {
	/**
	 * 注意此类必须实现可序列化接口，否则在流化的时候会报错
	 */
	private static final long serialVersionUID = 1L;

	private int bh;
	private String name;
	private String sex;

	public Tiger(int bh, String name, String sex) {
		super();
		this.bh = bh;
		this.name = name;
		this.sex = sex;
	}

	public Tiger() {
		super();
	}

	public int getBh() {
		return bh;
	}

	public void setBh(int bh) {
		this.bh = bh;
	}

	public String getName() {
		return name;
	}

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

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}
}

package com.fit.test.test04;

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

public class ObjectOutputStreamDemo {
	/**
	 * @param args
	 * @throws Exception
	 * @throws Exception
	 */
	public static void main(String[] args) throws Exception {

		ObjectOutputStream out = new ObjectOutputStream(

		new FileOutputStream("E:\\work\\test\\tigers")

		);

		for (int i = 1; i <= 100; i++) {

			Tiger tiger = new Tiger(i, "老虎" + i, i % 2 == 0 ? "雌" : "雄");
			out.writeObject(tiger);
		}

		out.flush();
		out.close();

	}
}

第十四个：InputStream的子类：DataInputStream

ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。

ObjectOutputStream 和 ObjectInputStream 分别与 FileOutputStream 和 FileInputStream 一起使用时，可以为应用程序提供对对象图形的持久存储。ObjectInputStream 用于恢复那些以前序列化的对象。其他用途包括使用套接字流在主机之间传递对象，或者用于编组和解组远程通信系统中的实参和形参。

ObjectInputStream 确保从流创建的图形中所有对象的类型与 Java 虚拟机中显示的类相匹配。使用标准机制按需加载类。

只有支持 java.io.Serializable 或 java.io.Externalizable 接口的对象才能从流读取。

代码14：

package com.fit.test.test04;

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

public class ObjectInputStreamDemo {
	/**
	 * @param args
	 * @throws Exception
	 * @throws Exception
	 */
	public static void main(String[] args) throws Exception {

		ObjectInputStream in = new ObjectInputStream(

		new FileInputStream("E:\\work\\test\\tigers")

		);

		try {
			while (true) {
				Tiger tiger = (Tiger) in.readObject();
				System.out.println(tiger.getBh() + "," + tiger.getName() + ","
						+ tiger.getSex());
			}
		} catch (EOFException e) {
			in.close();
		}

		System.out.println("-----");

	}
}

1,老虎1,雄
2,老虎2,雌
3,老虎3,雄
4,老虎4,雌
..........

1.OutputStreamWriter和InputStreamReader在读取文件的时候是可以指定编码的，例如：

public static void main(String[] args) throws Exception {


		Reader reader=new InputStreamReader(
						new FileInputStream("f:/my2.txt"),
						"UTF-8"
					);

		int k=0;
		while((k=reader.read())!=-1){
			System.out.print((char)k);
		}

		reader.close();

	}

public static void main(String[] args) throws Exception {


		BufferedReader reader=new BufferedReader(
			new InputStreamReader(
						new FileInputStream("f:/my2.txt"),
						"UTF-8"
			)
		);

		PrintWriter out=new PrintWriter(
			new OutputStreamWriter(
				new FileOutputStream("f:/my9.txt"),
				"GBK"
			)
		);

		/*int k=0;
		while((k=reader.read())!=-1){
			out.write(k);
		}*/

		String line=null;
		while((line=reader.readLine())!=null){
			out.println(line);
		}

		reader.close();
		out.flush();
		out.close();

	}

其实FileInputStream和FileOutputStream在读取的时候“也是可以指定编码的”,当然是变相的哦。

代码：(注意代码有缺陷)

InputStream in = new FileInputStream("E:\\work\\test\\t6.txt");
		byte[] b = new byte[in.available()];
		in.read(b);
		in.close();
		String str = new String(b, "UTF-8");
		System.out.println(str);

		byte[] b2 = str.getBytes();// unicode--->GBk(平台默认)
		// byte[] b2=str.getBytes("UTF-8");

		OutputStream out = new FileOutputStream("E:\\work\\test\\t7.txt");
		out.write(b2);
		out.flush();
		out.close();

写了这么多，纯粹是为了备忘，现在的编程语言和框架太多了，不去记录一下，时间长不用了，很容易忘记的，此文章仅作备忘，全文以举例为主，写的比较凌乱，欢迎大家指正。关于其他几个流，以及上述涉及到的流的一些其他用法，将在后续的文章中涉及。

iteye_2642

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java 常用IO流的举例系列之一

由于项目的原因，自己好久都没有接触Java了，怕自己会什么都忘记，所以还是时不时写写，废话不多说，现在开始[b]第一个：InputStream的实现类：FileInputStream[/b]由于它是一个接口，因此不对其进行举例，直接看它的子类吧，直接例子：代码1：[code="java"]package com.fit.test.test04;import ja...
复制链接

扫一扫