文章目录
第二章-实用类
1、枚举类型
枚举
枚举类更加直观，类型安全。使用常量会有以下几个缺陷：
- 类型不安全，可以随便赋值，而枚举类型的话，就只能传入枚举类中包含的对象。
- 没有命名空间。开发者要在常量命名的时候以固定格式开头，这样另外一个开发者再看这段代码的时候，才知常量的含义。
使用场景：
1）作为常量使用
枚举，可以把相关的常量分组到一个枚举类型里。
public enum CarEnum {
BMW, AUDI, BENZ
}
备注：
enum和class、interface的地位一样
使用enum定义的枚举类默认继承了java.lang.Enum，而不是继承Object类。
枚举类的所有实例都必须放在第一行展示，不需使用new 关键字。自动添加public static final修饰。
2）使用Switch选择结构
// 当匹配枚举类型时，会自动强校验，case的值，必须是枚举类中声明的枚举类型变量
CarEnum carEnum = CarEnum.BMW;
switch (carEnum) {
case BMW:
System.out.println("喜提宝马740");
break;
case AUDI:
System.out.println("喜提奥迪RS");
break;
case BENZ:
System.out.println("喜提奔驰E200");
break;
default:
break;
}
3）枚举类内也可以定义属性和方法。注意必须加对应的属性和构造方法（还有普通方法来获取属性）才可以，否则报错
public enum CarEnum {
//枚举类型实例必须放在第一行
BMW("1", "宝马"), AUDI("2", "奥迪"),BENZ("3","奔驰");
private String index;
private String name;
// 构造方法
private CarEnum(String index, String name) {
this.index = index;
this.name = name;
}
// 普通方法
public static String getNameByIndex(String index) {
for (CarEnum car : CarEnum.values()) {
if (car.index.equals(index)) {
return car.name;
}
}
return null;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getIndex() {
return index;
}
public void setIndex(String index) {
this.index = index;
}
/**
* 重新toString方法，输出枚举类型内容
*/
@Override
public String toString() {
return "CarEnum{name="+ name + ",index=" + index + "}";
}
}
2、包装类
java中的基本数据类型int，double等不是对象，无法通过向上转型获取到Object提供的方法，而像String却可以，只因为String是一个类而不是一个类型。基本数据类型由于这样的特性，导致无法参与转型，泛型等过程。为了弥补这个缺陷，java提供了包装类，包装类都在java.lang包下面。
包装类作用：
1）提供了一系列实用的方法，作为基本数据类型对应的类类型，提供了一系列实用的对象操作，如类型转换。
2）集合不允许存放基本数据类型数据，存放数字时，要用包装类型。
3）包含了每种基本数据类型的相关属性，如最大值、最小值、所占位数等
//获取基本数据类型的相关属性
System.out.println(Byte.SIZE);//8
System.out.println(Byte.MIN_VALUE);//-128
System.out.println(Byte.MAX_VALUE);//127
4）所有包装类都是final类型，不能创建它们的子类
5）JDK1.5后，允许基本数据类型和包装类型进行混合数学运算，包装类并不是用来取代基本数据类型的，在基本数据类型需要用对象表示时使用
基本类型和包装类的对应关系：
byte-Byte int-Integer short-Short long-Long float-Float
double-Double boolean-Boolean char-Character
基本数据类型的长度（位-bit）-- 一个字节占8位，char两个字节，可以存放汉字。
System.out.println(Byte.SIZE); //8
System.out.println(Short.SIZE); //16
System.out.println(Integer.SIZE); //32
System.out.println(Long.SIZE); //64
System.out.println(Float.SIZE); //32
System.out.println(Double.SIZE); //64
System.out.println(Character.SIZE);//16
所有包装类都可将与之对应的基本数据类型作为参数，来构造它们的实例：
Integer a = new Integer(100);
Double b = new Double(100.00);
Character c = new Character('A');
Boolean d = new Boolean(true);
除Character类外，其他包装类可将一个字符串作为参数构造它们的实例:
Integer a1 = new Integer("100");
Double d1 = new Double("100.00");
Boolean b1 = new Boolean("true");
注意：
1.Boolean类构造方法参数为String类型时，若该字符串内容为true(不考虑大小写)，则该Boolean对象表示true，否则表示false
Boolean d2 = new Boolean("True");
Boolean d3 = new Boolean("TRUE");
Boolean d4 = new Boolean("hello");
2.当包装类构造方法参数为String 类型时，字符串不能为null，且该字符串必须可解析为相应的基本数据类型的数据，否则编译通过，运行时NumberFormatException异常
java
Integer a2 = new Integer("");// NumberFormatException: For input string: ""
Integer a3 = new Integer(null);// NumberFormatException: null
Integer a4 = new Integer("abc");// NumberFormatException: For input string: "abc"
3、包装类的常用方法
1）valueOf
Integer intValue = Integer.valueOf(21);
除Character类外，其他包装类都可以如下操作：
Integer intValue = Integer.valueOf("12");
2) xxxValue()--包装类转换为基本数据类型
Integer in1 = new Integer(100);
int in2 = in1.intValue();
3）toString()--以字符串形式返回包装对象表示的基本类型数据
String str = Integer.toString(50);//自动装箱并调用toString()方法，这也是将基本类型转换为包装类的好处。
String sex = Character.toString('男');
// String str = String.valueOf(21); -- String类提供的方法
4）parseXXX()：把字符串转换为相应的基本数据类型数据（Character除外）
int num1 = Integer.parseInt("100");
System.out.println(num1); //100
boolean bool = Boolean.parseBoolean("false");
4、包装类的自动装箱和拆箱
装箱：基本类型转换为包装类的对象
拆箱：包装类对象转换为基本类型的值
//自动装箱
int m = 10;
Integer in = m;
System.out.println(in);//10
//自动拆箱
Integer inn = new Integer(10);
int n = inn;
System.out.println(n);//10
5、String类
定义字符串两种方式：
String s = "Hello World"; // 常用
String s = new String("Hello World");
注意：字符串一经定义，不可以修改，因为是引用地址，所以重新赋值只是指向新的地址
常用方法：
1）length()方法，确定字符串的长度，返回字符串中的字符数
注意：是length()方法，数组是length属性
2）equals()方法，比较存储在两个字符串对象的内容是否一致，区别于==(判断两个字符串在内存中的地址， 即判断是否是同一个字符串对象，object类中equals方法和==是一致的)。
3）equalsIgnoreCase()方法：不区分大小写的判断值是否一致
toLowerCase()方法：转换为小写
toUpperCase()方法：转换为大写
4) 字符串连接
方式1：使用 +
String str = "aa"+"bb"+"cc";
方式2：使用 concat 方法
String str = "aa".concat("bb").concat("cc");
5）字符串提取方法
字符串中单个字符查找
indexOf(int ch/String str)
查找当前字符串中字符或子串，返回字符或子串在当前字符串中从左边起首次出现的位置，若没有返回-1。
indexOf(int ch/String str, int fromIndex)
与第一种类似，区别在于该方法从fromIndex位置向后查找。
lastIndexOf(int ch/String str)
该方法与第一种类似，区别在于该方法从字符串的末尾位置向前查找，返回的位置仍然是左起位置。
lastIndexOf(int ch/String str, int fromIndex)
该方法与第二种方法类似，区别于该方法从fromIndex位置向前查找。
字符串截取：substring方法可以提取字符串中的子串，该方法有两种常用参数:
1)substring(int begin)
//该方法从begin位置(下标)起，从当前字符串中取出剩余的字符作为一个新的字符串返回。
2)substring(int beg, int end)
//该方法从begin位置(下标)起，从当前字符串中取出到end-1位置的字符作为一个新的字符串返回。
字符串去除首尾空格: trim()方法
截去字符串两端的空格，但对于中间的空格不处理。
字符串判断开始、结束
statWith(String prefix)
endWith(String suffix)
用来比较当前字符串的起始字符或子字符串prefix和终止字符或子字符串suffix是否和当前字符串相同
字符串判断是否包含子串
contains(String str)
判断子字符串是否被包含在字符串中，并返回一个布尔类型的值。
字符串分割
split()方法，将一个字符串分割为子字符串，结果作为字符串数组返回
6、StringBuffer对象
特点：
1)可变字符串类，创建StringBuffer类的对象后可以随意修改字符串的内容。
每个StringBuffer 类的对象都能够存储指定容量的字符串，如果字符串的长度超过了 StringBuffer 类对象的容量，则该对象的容量会自动扩大。
2)对字符串频繁修改（如字符串连接）时，使用StringBuffer类可以大大提高程序执行效率
语法：
StringBuffer() 构造一个空的字符串缓冲区，并且初始化为 16 个字符的容量。底层实现是16个字符长度的数组。
StringBuffer(int length) 创建一个空的字符串缓冲区，并且初始化为指定长度 length 的容量。
StringBuffer(String str) 创建一个字符串缓冲区，并将其内容初始化为指定的字符串内容 str，字符串缓冲区的初始容量为 16 加上字符串 str 的长度。
输出字符串的容量大小
capacity()方法返回字符串的容量大小
使用
1）toString -- 转换为String类型
2）append() -- 用于向原有 StringBuffer 对象中追加字符串，常用方法 *
append追加内容到当前 StringBuffer 对象的末尾，类似于字符串的连接。调用该方法以后，StringBuffer 对象的内容也发生了改变。
使用 append() 方法时，如果长度超过了字符串存储空间大小就需要进行扩容，它会重新分配内存，创建一个更大的数组，这个数组的容量是原来的 2 倍 + 2 的大小，并将原先的数组复制过来，再丢弃旧的数组。
3）插入字符串 -- 了解
insert(1, "**");
4）字符串倒序输出：
reverse()方法，可以将字符串内容倒序
String,StringBuffer,StringBuilder比较
1）String是不可变对象，经常改变内容的字符串最好不要使用String，任何对String的改变都 会引发新的String对象的生成
2）StringBuffer是可变的字符串，字符串经常改变的情况可使用StringBuffer，更高效，任何对它所指代的字符串的改变都不会产生新的对象。
3）JDK1.5后提供了StringBuilder，等价StringBuffer。作为一个简易替代，他们的原理和操作基本相同，区别在于StringBuffer支持并发操作，线性安全的，适合多线程中使用。StringBuilder不支持并发操作，线性不安全的，不适合多线程中使用，而且大量字符操作时候，相对来说执行会快.
因此：
String：适用于少量的字符串操作的情况
StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况
StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况
7、Math类
java.lang.Math类提供了常用的数学运算方法和两个静态常量E（自然对数的底数） 和PI（圆周率）
Math.abs(-3.5); //返回3.5
Math.max(2.5, 90.5);//返回90.5
int random = (int) (Math.random() * 10); //生成一个[0,10)之间的随机数
注：Math类方法很多，需要使用直接看API文档即可，不需要全部掌握
8、Random类 – java.util.Random类
简单介绍使用示例，不需要全部掌握，用到时候查下文档即可
//创建一个Random对象
Random rand=new Random();
for(int i=0;i<20;i++){
//随机生成20个随机整数，并显示
int num=rand.nextInt(10);//返回下一个伪随机数，整型的
System.out.println("第"+(i+1)+"个随机数是："+num);
}
9、日期操作类
1）java.util.Date类：表示日期和时间，提供操作日期和时间各组成部分的方法
Date对象本身所存储的毫秒数可以通过date.getTime()方法得到（long型的值）；该函数返回自1970年1月1日 00:00:00 GMT（格林威治平时（Greenwich Mean Time））以来此对象表示的毫秒数(实际中国获取的，是需要加上时区的概念，中国8时区，即我们获取的是1970年1月1日 08:00:00)。
日期转换：
java.text.SimpleDateFormat类
// Date指定格式：yyyy-MM-dd HH:mm:ss
// yyyy -- 年
// MM -- 月
// dd -- 天
// HH -- 24小时制 hh -- 12进制
// mm -- 分钟
// ss -- 秒
// SSS -- 毫秒
// 日期转字符串
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 创建一个date对象保存当前时间
Date date = new Date();
String dateStr = simpleDateFormat.format(date);
// 字符串转日期：
// 已知日期字符串，如何获取当前日期对象
String date1 = "2010-10-01 11:11:11";
try {
Date date2 = sdf.parse(date1);
System.out.println(date2);
} catch (ParseException e) {
e.printStackTrace();
}
//调用parse()方法时 注意 传入的格式必须符合simpleDateFormat对象的格式，即"yyyy-MM-dd HH:mm:ss" 否则会报错！！
且抛出转换异常，需要捕获异常处理。
备注：
模式字母含义：只需要知道常用的几种（一定注意大小写，容易导致数据问题，比如数据库条件用24小时制，而代码处理用12小时制，会出问题）
y 年 Year
M 年中的月份 Month
D 年中的天数 Number
d 月份中的天数 Number
a Am/pm 标记 Text
H 一天中的小时数（0-23）
h am/pm 中的小时数（1-12）
m 小时中的分钟数 Number
s 分钟中的秒数 Number
S 毫秒数 Number
扩展：日期的比较，不能直接使用 > 或者 <
// 方式一：getTime方法，比较两个日期的毫秒数大小
long time1 = date1.getTime();
long time2 = date2.getTime();
if(time1 > time2){
System.out.println("第一个日期大于第二个日期");
} else {
System.out.println("第一个日期小于第二个日期");
}
// 方式二：使用before方法，或者after方法
if(date1.before(date2)){
System.out.println("第一个日期小于第二个日期");
} else {
System.out.println("第一个日期大于第二个日期");
}
// 当前时间加1个小时
Date date3 = new Date();
System.out.println(sdf.format(date3));
long time3 = date3.getTime();
time3 += 60*60*1000;
Date date4 = new Date(time3);
System.out.println(sdf.format(date4));
2）日历Calendar类，java.util.Calendar
用于设置和获取日期/时间数据的特定部分
示例：
// 创建一个代表系统当前日期的Calendar对象
Calendar calendar = Calendar.getInstance();//默认是当前日期
方法或属性：
int get(int field) -- 返回给定日历字段的值
// 获取年
int year = calendar.get(Calendar.YEAR);
// 获取月，这里需要需要月份的范围为0~11，因此获取月份的时候需要+1才是当前月份值
int month = calendar.get(Calendar.MONTH) + 1;
// 获取日
int day = calendar.get(Calendar.DAY_OF_MONTH);
// 获取时
int hour = calendar.get(Calendar.HOUR);
// int hour = calendar.get(Calendar.HOUR_OF_DAY); // 24小时表示
// 获取分
int minute = calendar.get(Calendar.MINUTE);
// 获取秒
int second = calendar.get(Calendar.SECOND);
// 星期，英语国家星期从星期日开始计算
int weekday = calendar.get(Calendar.DAY_OF_WEEK);
设置指定日期：
// 首先创建一个Calendar的对象，然后再设定该对象中的年月日参数来完成。
// 创建一个Calendar对象
Calendar c1 = Calendar.getInstance();
// c1.set(int year,int month,int day)
c1.set(2018, 11 - 1, 21);// month从0开始
// 也可以单独设置：
c1.set(Calendar.YEAR, 2017);
// 通过日历类获取当前日期对象
Date date = calendar.getTime();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(sdf.format(date));
Calendar和Date之间的转换：
1）Calendar转Date
// Calendar-->Date
Calendar calendar = Calendar.getInstance();
Date time = calendar.getTime();
2）Date转Calendar
// 日历类和日期类型的转换
String str1 = "2010-10-01 11:11:11";
Date date2 = null;
try {
date2 = sdf.parse(str1);
System.out.println(date2);
} catch (ParseException e) {
e.printStackTrace();
}
// 通过setTime方法，将日期类转换为日历类
Calendar calendar2 = Calendar.getInstance();
calendar2.setTime(date2);
// 获取当前多少周
int weeks = calendar.get(Calendar.WEEK_OF_YEAR);
System.out.println("当前周数：" + weeks);
// 通过日历类，当前时间加一个小时
Calendar calendar3 = Calendar.getInstance();
calendar3.add(Calendar.HOUR, 1);
System.out.println(sdf.format(calendar3.getTime()));
10.实用类，日期类，日历类常用方法代码示例
public class Test {
public static void main(String[] args) {
/**
* 包装类
*/
Integer i1 = new Integer("1");//包装
Integer i = new Integer(1);//自动装箱
int j =i;//自动拆箱
System.out.println(j);
Character c = new Character('c');
//Character c = new Character("s");不支持char的包装类用字符串构造对象
//Integer i2 =new Integer("");不可以，NumberFormatException异常
//System.out.println(i2);
Boolean b = new Boolean("TRue");//只要是true四个字母不分大小写都对，不是都错
Boolean b1 = new Boolean(true);
System.out.println(b.toString());
Integer is = Integer.valueOf(100);//基本类型转包装类
Character cc = Character.valueOf('c');
int a = Integer.parseInt("11");//字符串转基本类型
System.out.println(a);
int aa = is.intValue();//包装类转基本类型
System.out.println(aa);
System.out.println(cc.toString());//所有包装类都有toString()方法
System.out.println();
System.out.println();
System.out.println("-----------------------------------------------------------");
System.out.println();
System.out.println();
/**
* Random工具类
*/
Random r1 = new Random();
System.out.println(r1.nextInt(11));
Random r2 = new Random(1);//种子相同，每次随机的值相同
Random r3 = new Random(1);
System.out.println(r2.nextInt());
System.out.println(r3.nextInt());
System.out.println();
System.out.println();
System.out.println("-----------------------------------------------------------");
System.out.println();
System.out.println();
/**
* Math工具类
*/
System.out.println(Math.random()*10);//随机生成[0，10)
System.out.println(Math.abs(-2));//取绝对值
System.out.println(Math.max(1, 4));//取最大值
System.out.println();
System.out.println();
System.out.println("-----------------------------------------------------------");
System.out.println();
System.out.println();
/**
* StringBuffer工具类
*/
StringBuffer sbf = new StringBuffer();
System.out.println(sbf.capacity());
StringBuffer sbf1 = new StringBuffer(10);
System.out.println(sbf1.capacity());
StringBuffer sbf2 = new StringBuffer("abc");
System.out.println(sbf2.capacity());
System.out.println(sbf2.toString());
System.out.println(sbf2.reverse());
sbf2.append("sfa");
System.out.println(sbf2);
System.out.println();
System.out.println();
System.out.println("-----------------------------------------------------------");
System.out.println();
System.out.println();
/**
* Date工具类
*/
Date date1 = new Date();
long time = date1.getTime();//获得当前毫秒数
System.out.println(time);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//模板
System.out.println(sdf.format(date1));
time+=60*60*1000;
date1.setTime(time);
System.out.println(time);
System.out.println(sdf.format(date1));
try {
sdf.parse(sdf.format(date1));//date转换为字符串
System.out.println(sdf.parse(sdf.format(date1)));//字符串转换为date
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Date date2 = new Date();
if(date1.getTime()>date2.getTime()){
System.out.println("第一个时间大于第二个");
}else{
System.out.println("第一个时间小于第二个");
}
if(date1.before(date2)){
System.out.println("第一个时间小于第二个");
}else{
System.out.println("第一个时间大于第二个");
}
if(date1.after(date2)){
System.out.println("第一个时间大于第二个");
}else{
System.out.println("第一个时间小于第二个");
}
System.out.println();
System.out.println();
System.out.println("-----------------------------------------------------------");
System.out.println();
System.out.println();
/**
* Calendar工具类
*/
Calendar calendar = Calendar.getInstance();
int year =calendar.get(Calendar.YEAR);
System.out.println(year);
int month =calendar.get(Calendar.MONTH);//月的范围为0到11
System.out.println(month+1);
int day =calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(day);
int weekday =calendar.get(Calendar.DAY_OF_WEEK);//从周天开始
System.out.println(weekday);
//指定日期
calendar.set(Calendar.YEAR, 2011);
calendar.set(2022, 11-1, 8);
Date date = calendar.getTime();//将日历类转换为日期类
SimpleDateFormat sdfs = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(sdfs.format(date));
calendar.setTime(date);//日期转换为日历类
int weeks = calendar.get(Calendar.WEEK_OF_YEAR);
System.out.println("当前周数：" + weeks);
System.out.println(sdf.format(calendar.getTime()));
calendar.add(Calendar.MONTH, 1);
System.out.println(sdf.format(calendar.getTime()));
System.out.println();
System.out.println();
System.out.println("-----------------------------------------------------------");
System.out.println();
System.out.println();
/**
* String工具类
*/
//注意：String:字符串有下标，字符串初始化
String s1 = new String("aa");
String s2 = "bb";
String s3 ="BB";
//注意：为什么字符串是不可变的？因为String是个特殊类，final修饰，改变字符串就是改变地址的指向
//1.s1.length()
System.out.println(s1.length());
//2.equals()由于String类重写了equals()方法，因此比较的是字符串的内容
System.out.println(s1.equals(s2));
//3.equalsIngoreCase()忽视大小写
System.out.println(s2.equalsIgnoreCase(s3));
//toUpperCase()转为大写字母
System.out.println(s2.toUpperCase());
//toLowerCase()转为小写字母
System.out.println(s3.toLowerCase());
//4.字符串的连接
System.out.println(s1.concat("bb").concat("xz"));
//5.字符数组转为字符串
char c1[] = new char[]{'a','b','c'};
String s4 = new String(c1);
System.out.println(s4);
//6，字符串查找子串，从左到右indexOf()
String s5="asdlkjfsda";
System.out.println(s5.indexOf(97));//传入的是ASCII码值，找到的是下标值,没有找到为-1
System.out.println(s5.indexOf("b"));//传入字符串包含的字串，找到的是第一个字母的下标值,没有找到为-1
System.out.println(s5.indexOf(97,0));//第一个参数是ASCII码值，第二个参数是下标值，返回值为下标值,没有找到为-1
System.out.println(s5.indexOf("a",0));//第一个参数是字串，第二个参数是下标值,返回值为下标值,没有找到为-1
//字符串查找子串，从右到左lastIndexOf()
System.out.println(s5.lastIndexOf(97));//从右往左找第一个a出现的地方，传入的是ASCII码值，找到的是下标值,没有找到为-1
System.out.println(s5.lastIndexOf("kj"));//从右往左传入字符串包含的字串，找到的是第一个字母的下标值,没有找到为-1
System.out.println(s5.lastIndexOf(97, 4));//第一个参数是ASCII码值，第二个参数是下标值，返回值为下标值,没有找到为-1
System.out.println(s5.lastIndexOf("kj", 3));//第一个参数是字串，第二个参数是下标值,返回值为下标值,没有找到为-1
//7.字符串截取substring()：包前不包后
System.out.println(s5.substring(1));//第一种，截取下标从1开始到s5.length()
System.out.println(s5.substring(2, 4));//第二中，截取下标从2到4的字符串，（包前不包后，2取的上4取不上）
//8.trim()去两头空格，中间无法去掉
String s6=" asd sfsda ";
System.out.println(s6.trim());
//9.startWith():以什么开头
System.out.println(s6.trim().startsWith("a"));//以a开头
System.out.println(s6.trim().startsWith("a", 1));//以a开头，下标为1
//endsWith():以什么结尾
System.out.println(s6.trim().concat(".java").endsWith("java"));//以java结尾
//10.contains()是否包含a，可以用indexOf代替，不为-1则存在
System.out.println(s6.contains("a"));
//11.split()
String s7 = "asfls!asd#adfj";
String s8[] = s7.split("!|#");//以！与#划分
System.out.println(Arrays.toString(s8));
//12.chatAt(下标)
String ss="";
for(int n =0 ;n<s7.length();n++){
char cc1 =s7.charAt(n);
ss += Character.toString(cc1);
}
System.out.print(ss);
//13.replace(oldStr,newStr)
System.out.println();
String ss8 = "sdjflmllfsa";
System.out.println(ss8.replace("sdjf", "jklkl"));
//13.toCharArray()
char[] s9 = ss8.toCharArray();
String ss9 = new String(s9);
System.out.println(ss9);
//14.将字符串打散为字节数组
String ss0 ="dsafsdalakfj";
byte[] bytes = ss0.getBytes();
System.out.println(Arrays.toString(bytes));
}
}
220
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
