回顾内容:
IO流的字节输入流以及字符流:
字节输入流读数据的两种方式:
字节输出流:OutputStream--->FileOutputStream(String pathName,boolean append)
1)一次读取一个字节
模板代码:
int by = 0 ;
while((by=字节输入流对象.read())!=-1){
System.out.print((char)by)
}
2)一次读取一个字节数组
模板代码:
byte[] buffer = new byte[1024] ;
int len = 0 ;
while((len=字节输入流对象.read(buffer))!=-1){
System.out.println(buffer,0,len);
}
高效的字节缓冲流:
BufferedInputStream读取数据的速率>基本字节输入流读取数据的速率
读数据:上面两种方式
BufferedOutputStream
BuffferedOutputStream(OutputStream out)
刷新缓冲区的流:flush();上传图片的时候,防止图片加载不完全,所以刷新一下;
字符流和字节流的使用:
当我们如果操作的是一个文本文件,优先采用字符流,如果用记事本打开之后,文件读不懂,那么使用字节流,比如:视频,音频,动画,图片资源文件...
字符输入流:Reader
InputStreamReader = 字节输入流+编码格式(平台默认编码集:GBK)
书写格式名称非常长,---->该类的子类:便捷类:FileReader
字符输出流:Writer
OutputStreamWriter = 字节输出流+编码格式(平台默认编码集:GBK)
-该类的子类:便捷类:FileWriter
FileWriter有一种构造方式:FileWriter(OutputStream out,boolean apppend) ;//追加写入
高效的字符缓冲流:
BufferedReader:字符缓冲输入流
特有功能:
public String readLine():一次读取一行数据
模板代码:
String line = null ;
while((line=字符缓冲输入流对象.readLine())!=null){
System.out.println(line) ;
}
BufferedWriter:字符缓冲输出流
关闭流之前,close(),必须要刷新流:flush()
特有功能:
newLine():写入一个新的分隔符
递归:方法调用方法的一种现象
考点:递归和File类中一些方法,Timer类(定时器)综合使用
前提条件:
1)定义一个方法
2)找当前需求中的规律
3)要出口条件
DAY19
DataOutputStream和DataInputStream
都属于数据流:可以针对Java基本数据类型的数据进行读写操作
DataOutputStream构造方法
public DataOutputStream(OutputStream out)
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class DataStreamDemo {
public static void main(String[] args) throws IOException {
write();
read();
}
//读数据
private static void read() throws FileNotFoundException, IOException {
//读数据
//创建数据输入流对象
DataInputStream dis = new DataInputStream(
new FileInputStream("EDG.txt"));
//读数据
byte b = dis.readByte() ;
int i = dis.readInt() ;
short s = dis.readShort() ;
long l = dis.readLong() ;
char ch = dis.readChar() ;
boolean flag = dis.readBoolean() ;
float f = dis.readFloat() ;
double d = dis.readDouble() ;
//释放资源
dis.close() ;
System.out.println(b);
System.out.println(i);
System.out.println(s);
System.out.println(l);
System.out.println(ch);
System.out.println(flag);
System.out.println(f);
System.out.println(d);
}
//写数据
private static void write() throws FileNotFoundException, IOException {
//创建数据输出流对象
DataOutputStream dos = new DataOutputStream(new FileOutputStream(
"dos.txt"));
//写数据
dos.writeByte(100) ;
dos.writeInt(1000) ;
dos.writeShort(120) ;
dos.writeLong(1000000L);
dos.writeChar('A') ;
dos.writeBoolean(true) ;
dos.writeFloat(12.34F) ;
dos.writeDouble(12.56) ;
//释放资源
dos.close() ;
}
}
ByteArrayInputStream和ByteArrayOutStream(重点)
内存操作流:针对内存的数据进行操作的,程序一结束,这些内存中的数据就消失掉了!
特点:针对小文件进行操作!(聊天室项目中使用它进行发送文件)
ByteArrayOutputStream:
public ByteArrayOutputStream():创建默认的缓冲区大小的内存操作输出流(单位是字节)
成员方法:
public byte[] toByteArray()创建一个新分配的 byte 数组(将内存操作输出流对象转换成字节数组)
void reset():重置内存操作输出流
ByteArrayInputStream:内存操作输入流:
public ByteArrayInputStream(byte[] buf):参数数一个字节数组(缓冲数组)
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
public class ByteArrayStreamDemo {
public static void main(String[] args) throws IOException {
//创建内存操作输出流对象
ByteArrayOutputStream baos = new ByteArrayOutputStream() ;
//写数据
for(int x = 0 ; x <5 ; x ++){
baos.write(("hello"+x).getBytes()) ;
}
/**
* 内存操作流:查看其释放流对象的源码:
* public void close() throws IOException {}
* 并没有具体的关闭流对象,所以此流对象可以不关闭
*/
//关闭资源
// baos.close() ;
//将内存操作输出流对象转换成字节数组
//public byte[] toByteArray()创建一个新分配的 byte 数组(将内存操作输出流对象转换成字节数组)
byte[] buffer = baos.toByteArray() ;
//创建内存操作输入流对象
ByteArrayInputStream bais = new ByteArrayInputStream(buffer) ;
//一次读取一个字节
int by = 0 ;
while((by=bais.read())!=-1){
System.out.print((char)by);
}
//关闭
// bais.close() ;
}
}
;
打印流:
字节打印流:PrintStream
字符打印流:PrintWriter
打印流特点:
1)在复制文件的,打印流不能操作数据源,只能操作目的地的数据(只能输出数据)
2)打印流可以有自动刷新的功能
3)打印流可以直接针对文本文件进行操作:
什么情况下是直接可以针对文本文件进行操作?
查API的时候,看流中构造方法,只要构造方法的参数有File类或者是String类型,都可以针对文本文件进行操作
FileInputStream
FileOutputStream
FileReader
FileWriter
PrintWriter:
构造方法:
public PrintWriter(String fileName)
import java.io.IOException;
import java.io.PrintWriter;
public class PrintWriterDemo {
public static void main(String[] args) throws IOException {
//创建字符打印流对象
PrintWriter pw = new PrintWriter("pw.txt") ;
//写数据
pw.write("hello") ;
pw.write("world") ;
pw.write("Java") ;
//刷新
pw.flush() ;
//释放资源
pw.close() ;
}
}
PrintWriter:有自动刷新功能:
public PrintWriter(Writer out,boolean autoFlush)
第二个参数指定为true,则启动自动刷新
PrintWriter pw = new PrintWriter(new FileWriter("pw.txt"),true) ;
加入自动刷新功能并且在写数据的时候,使用println():换行
println("hello")
相当于:
pw.write("") ;
pw.newLine() ;
pw.flush() ;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
public class PrintWriterDemo2 {
public static void main(String[] args) throws IOException {
//创建字符打印流对象
PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true) ;//启动自动刷新功能
//写数据
/* pw.write("hello") ;
pw.write("world") ;
pw.write("java") ;*/
//使用println
//public void println(String x):打印字符串,并且终止该行
pw.println("hello") ;
pw.println("world") ;
pw.println("java") ;
//关闭流资源
pw.close() ;
}
}
复制文件
需求:将当前项目下的DataStreamDemo.java中的内容复制到当前项目下Copy.java文件中
数据源:DataStreamDemo.java---->BufferedReader---->读数据--->readLine()
目的地:Copy.java------>BufferedWriter---->写数据
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
public class CopyFileDemo {
public static void main(String[] args) throws IOException {
/*//1)封装数据源
BufferedReader br = new BufferedReader(new FileReader("DataStreamDemo.java")) ;
//2)封装目的地
BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java")) ;
//使用BufferedReader中的特有功能读写操作
String line = null ;
while((line=br.readLine())!=null){
//写数据
bw.write(line) ;
//换行
bw.newLine() ;
//刷新流
bw.flush() ;
}
//释放资源
bw.close() ;
br.close() ;*/
//改进
// 1)封装数据源
BufferedReader br = new BufferedReader(new FileReader("DataStreamDemo.java")) ;
2)封装目的地
//创建字符打印流对象,并且启动自动刷新功能
PrintWriter pw = new PrintWriter(new FileWriter("Copy.java"), true) ;
//读写操作
String line = null ;
while((line=br.readLine())!=null){
//写数据
pw.println(line) ;
}
//关闭资源
pw.close() ;
br.close() ;
}
}
键盘录入的两种方式
1)Scanner类
Scanner sc = new Scanner(System.in) ;
2)使用IO流的形式进行录入数据
BufferedReader br = new BufferedReader(new InputStreamReader(System.in)) ;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
public class SystemInDemo {
public static void main(String[] args) throws IOException {
//创建一个字节输入流对象
/*InputStream is = System.in ; //标准输入流
//要一次读取一行数据使用BufferedReader的readLine()
//BufferedReader字符缓冲输入流只能针对字符流进行操作
//将当前is对象转换字符流,使用字符转换输入流
InputStreamReader isr = new InputStreamReader(is) ;
//在创建BufferedReader对象
BufferedReader br = new BufferedReader(isr) ;*/
//另一种录入数据的方式
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
//录入数据
System.out.println("请输入一个字符串:");
String line = br.readLine() ;
System.out.println("您录入的字符串是:"+line);
System.out.println("请输入一个整数数据:");
String s = br.readLine() ;
int a = Integer.parseInt(s) ;//long l = Long.pareLong(s) ;
System.out.println("您输入的整数是:"+a);
}
}
标准输入和输出流
System类中有两个字段:
in:----->InputStream is = System.in ;
out----->PrintStream ps = System.out ;
System.out.println();
import java.io.PrintStream;
public class SystemOutDemo {
public static void main(String[] args) {
//经常使用输出语句
System.out.println("helloworld") ;
System.out.println("helloworld") ;
//字节打印流
PrintStream ps = System.out ;
//字节打印流调用PrintStream类中的方法
// ps.print() ;这个方法不存在
ps.println("javaweb") ;//打印一个字符串数据并且终止当前行
}
}
使用BufferedReader完成了录入数据:
使该流封装字符转换输入流,然后使用字符转换输入流封装字节流
按照上述方式,将BufferedWriter层层封装标准输出流,将数据打印控制台
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
public class SystemOutDemo2 {
public static void main(String[] args) {
/*PrintStream ps = System.out ;
//写入一个分隔符:newLine()是BufferedWriter类中的方法
// BufferedWriter bw = new BufferedWriter(ps) ;
//将字节打印流转换成字符流
OutputStreamWriter osw = new OutputStreamWriter(ps) ;
//创建字符缓冲输出流对象
BufferedWriter bw = new BufferedWriter(osw) ;*/
BufferedWriter bw = null ;
try {
bw = new BufferedWriter(new OutputStreamWriter(
System.out));
//写数据
bw.write("hello") ;
bw.newLine() ;
bw.write("world") ;
bw.newLine() ;
bw.write("Javaweb") ;
bw.newLine() ;
//刷新
bw.flush() ;
} catch (IOException e) {
e.printStackTrace();
}finally{
//对流对象进行判断
if( bw!=null){
try {
bw.close() ;
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
5 java.io
RandomAccessFile:随机访问流:此类的实例支持对随机访问文件的读取和写入
不是实际意义上的流,因为它继承自Object类
常用的构造方法:
ublic RandomAccessFile(String name, String mode)
参数一:指定该文件的路径
参数二:指定的一种模式:常用的模式:"rw",这种模式是可以读也可以写
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
public class RandomAccessFileDemo {
public static void main(String[] args) throws IOException {
write();
read();
}
//读数据
private static void read() throws FileNotFoundException, IOException {
RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw") ;
读数据
//public long getFilePointer():返回此文件中的当前偏移量。 文件开头的偏移量（以字节为单位
byte b = raf.readByte() ;
System.out.println(b);
System.out.println("getFilePointer:"+raf.getFilePointer());
char ch = raf.readChar() ;
System.out.println(ch);
String str = raf.readUTF() ;
System.out.println(str);
//关闭资源
raf.close() ;
}
//写数据
private static void write() throws FileNotFoundException, IOException {
//创建随机访问流对象
RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw") ;
//写数据
raf.writeByte(100) ;
raf.writeChar('a') ;
raf.writeUTF("中国") ;
//关闭资源
raf.close() ;
}
}
;
SequenceInputStream:合并流(读数据):表示其他输入流的逻辑串联
合并流在复制文件的时候,只能操作数据源,不能操作目的地
之前的操作:
a.txt-->b.txt
c.txt--->d.txt
现在有合并流(将两个文件中的内容复制到另一个文件中)
a.txt+b.txt--->c.txt文件中
构造方法:
public SequenceInputStream(InputStream s1,InputStream s2)
需求:将DataStreamDemo.java和ByteArrayStreamDemo.java两个java文件中的内容复制到
Copy.java文件中
1)数据源:DataStreamDemo.java和ByteArrayStreamDemo.java----->SequenceInputStream----->分别读取第一个和第二个java文件
2)目的地:Copy.java----->BufferedOutputStream---->写数据
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStreampublic class SequenceInputStreamDemo {
public static void main(String[] args) throws IOException {
//分别封装这个两个java文件
InputStream s1 = new FileInputStream("DataStreamDemo.java") ;
InputStream s2 = new FileInputStream("ByteArrayStreamDemo.java") ;
//创建合并流对象
SequenceInputStream sis = new SequenceInputStream(s1, s2) ;
//封装目的地
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream("Copy.java"));
//一次一个字节数组
byte[] bys = new byte[1024] ;
int len = 0 ;
while((len = sis.read(bys))!=-1){
//写数据
bos.write(bys, 0, len) ;
bos.flush() ;
}
// 释放资源
sis.close() ;
bos.close() ;
}
}
SequenceInputStream的另一种构造方法:复制多个文件
public SequenceInputStream(Enumeration<? extends InputStream> e)
Vector集合中的特有功能:
public Enumeration<E> elements()
之前的操作:
a.txt--->b.txt
c.txt--->d.txt
e.txt--->f.txt
* 现在:a.txt+b.txt+e.txt---->f.txt
需求:将DataStreamDemo.java,ByteArrayStreamDemo.java,以及CopyFileDemo.java将这三个文件中的内容复制到当前项目下:Copy.java文件中
分析:数据源:DataStreamDemo.java,ByteArrayStreamDemo.java,以及CopyFileDemo.java--->SequenceInputStream--->读数据
目的地:Copy.java----->BufferedOutStream---->写数据
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vectopublic class SequenceInputStreamDemo2 {
public static void main(String[] args) throws IOException {
//创建一个Vector集合,泛型数据类型<InputStream>
Vector<InputStream> v = new Vector<InputStream>() ;
//封装者三个java文件
InputStream s1 = new FileInputStream("DataStreamDemo.java") ;
InputStream s2 = new FileInputStream("ByteArrayStreamDemo.java") ;
InputStream s3 = new FileInputStream("CopyFileDemo.java") ;
//添加到集合中
v.add(s1) ;
v.add(s2) ;
v.add(s3) ;
//调用特有功能:
//public Enumeration<E> elements()
Enumeration<InputStream> en = v.elements() ;
//创建合并刘对象
SequenceInputStream sis = new SequenceInputStream(en) ;
//封装目的地
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream("Copy.java"));
//一次读取一个字节数组
byte[] bys = new byte[1024] ;
int len = 0 ;
while((len=sis.read(bys))!=-1){
//写数据
bos.write(bys, 0, len) ;
bos.flush() ;
}
//释放资源
bos.close() ;
sis.close() ;
}
}
7
序列化流:将对象像流的方式或者网络传输中的数据写数据.对象---->流数据:ObjectOutputStream
反序列化:将流数据或者网络传输中的流数据读取出来.流数据---->还原成对象:ObjectInputStream
ObjectOutputStream中的成员方法:
public final void writeObject(Object obj):将obj对象写入到当前的序列化流中
ObjectInputStream中的成员方法:
public final Object readObject():从当前反序列化流中读取一个对象
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class ObjectStreamDemo {
public static void main(String[] args) throws Exception {
write() ;
read();
}
//读数据
private static void read() throws IOException, FileNotFoundException,
ClassNotFoundException {
//反序列化:将当前流数据--->对象
//创建一个反序列化流对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
"oos.txt"));
//使用反序列化:将流数据--->对象
Object obj = ois.readObject() ;
//关闭资源
ois.close() ;
System.out.println(obj);
}
//序列化
private static void write() throws IOException {
//创建一个对象
Person p = new Person("高圆圆", 27) ;
//创建一个序列化流对象
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
"oos.txt"));
//写数据
// writeObject(Object obj)
oos.writeObject(p) ;
//释放资源
oos.close() ;
}
}
报异常了:NotSerializableException(没有实现序列化接口的异常)
Serializeable:序列化接口
类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化,如果自定义一个类没有实现这个接口,就不能使用
序列化或者是反序列化!如果一个接口中没有字段,没有构造方法,没有成员方法,叫做标记接口
更改了Pereson类中的一个成员变量,重新去反序列化:出现异常:
stream classdesc serialVersionUID = -1389484787812115752,
local class serialVersionUID = -8105095612190351088
如果一个类实现了标记接口:Serializable,那么对应的该类加载的时候,会产生一个ID
Person.class------->id ,假设id=100
成员变量:name和age---->对应一个固定id= 100
后面重新改动了Person类的成员,Person.class ---->id = 200 ;name,age-------->id = 200 ;
序列化和反序列化版本号不一致,会出现InvalidClassException
解决这个异常两种方案:
1)要么改动当前某个类中的数据之后,然后重新序列化和反序列化
这种做法不符实实际要求,在实际开发中,可能直接读数据:将流数据--->还原成对象
2)发现黄色警告线,点击它:生成一个固定ID
注意事项:
比如一个类中有很多成员变量,并不想让一些成员变量被序列化,Java提供了一个关键字:
transient:不用被序列化的时候用它修饰
序列化和反序列化考点:
1)将对象--->流数据或者流数据--->对象,该对象所在的类要实现一个标记接口:serializable 多线程有一个关键字:同步机制(synchronized)
2)序列化和反序列化生产的版本Id不一致的时候,会出现异常,所以使用生产随机ID或者固定ID解决
3)transient:修饰的变量不会被序列化...
//如果启用序列化功能,那么必须实现一个接口:Serializable
public class Person implements Serializable {
private static final long serialVersionUID = 1L;
/**
* default Servial ID
*/
生成一个ID
Properties:属性集合类,该类继承自Hashtable<K,V>,该类属于Map集合
Properties 类表示了一个持久的属性集。
Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串(一般情况:它用作配置文件去使用,MySQL或者Oracle中用它做配置文件)
构造方法:
public Properties():创建一个空属性列表
import java.util.Properties;
import java.util.Set;
public class PropertiesDemo {
public static void main(String[] args) {
//创建属性集合类对象
// Properties<String,String> prop = new Properties<String,String>() ;
Properties prop = new Properties() ;
//既然是Map集合怎么添加元素?
prop.put("RNG", "666") ;
prop.put("EDG", "233") ;
prop.put("LGD", "334") ;
//遍历集合
//获取所有的键的集合
Set<Object> keySet = prop.keySet() ;
//增强for遍历
for(Object key :keySet){
Object value = prop.get(key) ;
System.out.println(key+"="+value);
}
}
}
属性集合类:Properties有自己的遍历和添加元素的功能
给属性列表中添加元素:
public Object setProperty(String key,String value)
public Set<String> stringPropertyNames():获取当前属性列表中所有的键的集合,键值都是String类型
public String getProperty(String key)用指定的键在此属性列表中搜索属性值
import java.util.Properties;
import java.util.Set;
public class PropertiesDemo2 {
public static void main(String[] args) {
//创建属性集合类对象
Properties prop = new Properties() ;
//添加元素
//public Object setProperty(String key,String value)
prop.setProperty("RNG", "666") ;
prop.setProperty("EDG", "233") ;
prop.setProperty("LGD", "334") ;
//遍历属性列表:public Set<String> stringPropertyNames()
Set<String> keySet = prop.stringPropertyNames() ;
for(String key:keySet){
//通过键搜索值
//public String getProperty(String key)
String value = prop.getProperty(key) ;
System.out.println(key+"="+value);
}
}
}
Properties 可保存在流中或从流中加载。
将文件中的数据加载到属性集合中:public void load(Reader reader)
将属性集合中的数据保存到文件中:public void store(Writer writer,String comments)
第二个参数:comments:对当前属性列表 的描述
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
public class PropertiesDemo {
public static void main(String[] args) throws IOException {
myStore();
myLoad() ;
}
//将文件中的数据加载到属性集合中
private static void myLoad() throws IOException {
//public void load(Reader reader)
//创建属性集合类对象
Properties prop = new Properties() ;
= //创建字符输入流对象
FileReader fr = new FileReader("name.txt") ;
//调用方法
prop.load(fr) ;
//释放资源
fr.close() ;
//显示输出
System.out.println(prop);
}
private static void myStore() throws IOException {
//创建属性集合类对象
Properties prop = new Properties();
//给属性集合中添加数据
prop.setProperty("RNG", "666") ;
prop.setProperty("EDG", "233") ;
prop.setProperty("LGD", "334") ;
//将属性列表中的数据保存到文件中
// public void store(Writer writer,String comments)
//创建字符输出流
FileWriter fw = new FileWriter("name.txt") ;
//调用方法
prop.store(fw, "names content") ;
//释放资源
fw.close() ;
}
}
课堂练习
有一个文本文件(user.txt)，我知道数据是键值对形式的，但是不知道内容是什么。
请写一个程序判断是否有“lisi”这样的键存在，如果有就改变其值为”100”
分析:
1)将user.txt文件中的内容加载到属性集合类中
2)遍历属性列表:获取所有的键的集合:stringPropertyNames(String key );
判断:如果"lisi"这个键中key值相等
修改:setProperty(key,"100") ;
3)重新将属性集合中的数据写到user.txt中
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
import java.util.Properties;
import java.util.Set;
public class PropertiesTest {
public static void main(String[] args) throws IOException {
//创建属性集合类对象
Properties prop = new Properties() ;
//创建字符输入流对象
Reader r = new FileReader("user.txt") ;
//加载到属性集合中
prop.load(r) ;
//关闭流资源
r.close() ;
//遍历属性列表
Set<String> keySet = prop.stringPropertyNames() ;
for(String key:keySet){
//判断
if("lisi".equals(key)){
//修改
prop.setProperty(key, "100") ;
}
}
//创建字符输出流丢向
Writer w = new FileWriter("user.txt") ;
//调用功能
prop.store(w, "content") ;
//释放资源
w.close() ;
}
}
864
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
