文章目录
- 1. 不需要实例化的类构造器要私有化
- 2. 构造器参数太多引入Builder模式
- 3. MyBatis 不要为了多个查询条件而写 1 = 1
- 4. 迭代entrySet() 获取Map 的key 和value
- 5. 不要创建不必要对象
- 6. 避免使用终结方法
- 7. 使用Collection.isEmpty() 检测空
- 8. 初始化集合时尽量指定其大小
- 9. 类跟成员的可访问性最小化
- 10. 使可变性最小化
- 11. 使用StringBuilder 拼接字符串
- 12. 若需频繁调用Collection.contains 方法则使用Set
- 13. 接口优于抽象类
- 14. 可变参数谨慎使用
- 15. 使用静态代码块实现赋值静态成员变量
- 16. 删除未使用的局部变量、方法参数、私有方法、字段和多余的括号。
- 17. 尽量不要返回NULL,尽量返回零数组或集合
- 18. 优先使用标准异常
- 19. 局部变量作用域最小化
- 20. 对于精度技术不用float或double
- 21. 避免使用BigDecimal(double)
- 22. 删除多余的异常捕获并抛出
- 23. 字符串操作少用String
- 24. 对资源的close建议分开操作
- 25. 数据类型转换
- 26. 字符串转化使用String.valueOf(value) 代替 " " + value
- 27. 优先使用常量或确定值调用equals 方法
- 28. 枚举的属性字段必须是私有且不可变
- 29. 不用的对象记得置NULL
- 30. 同步方法跟同步方法块
- 31. 方法要尽可能小
- 32. 一定记得写注释
- 33. String.split(String regex)部分关键字需要转译
- 参考文章
前言： 最近看了几篇博文，觉得提到的一些编码习惯、规范、技巧、还有一些开发要注意的坑，还是值得关注的，我摘录和收集了下来。快来一起看看有没有你平时开发中疏漏的，祝大家都写得一手好代码，0Bug！未来也会持续收集和更新，欢迎收藏关注~
1. 不需要实例化的类构造器要私有化
经常用到的Utils类，是一堆静态字段和函数的集合，其不应该被实例化；但是，Java 为每个没有明确定义构造函数的类添加了一个隐式公有构造函数，为了避免不必要的实例化，应该显式定义私有构造函数来屏蔽这个隐式公有构造函数。比如Java自带的java.util.Arrays 这样的类，工具类都尽量不要实例化。
public class Arrays {
private static final int MIN_ARRAY_SORT_GRAN = 8192;
private static final int INSERTIONSORT_THRESHOLD = 7;
private Arrays() {
}
}
反例
public class PasswordUtils {
//工具类构造函数反例
private static final Logger LOG = LoggerFactory.getLogger(PasswordUtils.class);
public static final String DEFAULT_CRYPT_ALGO = "xxxxxxxx";
public static String encryptPassword(String aPassword) throws IOException {
return new PasswordUtils(aPassword).encrypt();
}
正例
public class PasswordUtils {
//工具类构造函数正例
private static final Logger LOG = LoggerFactory.getLogger(PasswordUtils.class);
//定义私有构造函数来屏蔽这个隐式公有构造函数
private PasswordUtils(){}
public static final String DEFAULT_CRYPT_ALGO = "xxxxxxxx";
public static String encryptPassword(String aPassword) throws IOException {
return new PasswordUtils(aPassword).encrypt();
}
2. 构造器参数太多引入Builder模式
public class Computer {
protected String mBoard;
protected String mDisplay;
protected String mOs;
private Computer(Builder builder) {
this.mOs = builder.mOs;
this.mBoard = builder.mBoard;
this.mDisplay = builder.mDisplay;
}
@Override
public String toString() {
return "Computer{" +
"mBoard='" + mBoard + '\'' +
", mDisplay='" + mDisplay + '\'' +
", mOs='" + mOs + '\'' +
'}';
}
static class Builder {
protected String mBoard;
protected String mDisplay;
protected String mOs;
public Builder setmOs(String mOs) {
this.mOs = mOs;
return this;
}
public Builder setmBoard(String mBoard) {
this.mBoard = mBoard;
return this;
}
public Builder setmDisplay(String mDisplay) {
this.mDisplay = mDisplay;
return this;
}
public Computer build() {
return new Computer(this);
}
}
}
调用的时候如下：
public static void main(String[] args) {
Computer macbook = new Computer.Builder()
.setmBoard("board")
.setmDisplay("sowhat")
.setmOs("Mac")
.build();
System.out.println(macbook);
}
3. MyBatis 不要为了多个查询条件而写 1 = 1
当遇到多个查询条件，使用where 1=1 可以很方便的解决我们的问题，但是这样很可能会造成非常大的性能损失，因为添加了 “where 1=1 ”的过滤条件之后，数据库系统就无法使用索引等查询优化策略，数据库系统将会被迫对每行数据进行扫描（即全表扫描） 以比较此行是否满足过滤条件，当表中的数据量较大时查询速度会非常慢；此外，还会存在SQL 注入的风险。
反例
<select id="queryBookInfo" parameterType="com.tjt.platform.entity.BookInfo" resultType="java.lang.Integer">
select count(*) from t_rule_BookInfo t where 1=1
<if test="title !=null and title !='' ">
AND title = #{title}
</if>
<if test="author !=null and author !='' ">
AND author = #{author}
</if>
</select>
正例：
<select id="queryBookInfo" parameterType="com.tjt.platform.entity.BookInfo" resultType="java.lang.Integer">
select count(*) from t_rule_BookInfo t
<where>
<if test="title !=null and title !='' ">
title = #{title}
</if>
<if test="author !=null and author !='' ">
AND author = #{author}
</if>
</where>
</select>
UPDATE 操作也一样，可以用 标记代替 1=1。
4. 迭代entrySet() 获取Map 的key 和value
当循环中只需要获取Map 的主键key时，迭代keySet() 是正确的；但是，当需要主键key 和取值value 时，迭代entrySet() 才是更高效的做法，其比先迭代keySet() 后再去通过get 取值性能更佳。
反例
//Map 获取value 反例:
HashMap<String, String> map = new HashMap<>();
for (String key : map.keySet()){
String value = map.get(key);
}
正例：
//Map 获取key - value 正例:
HashMap<String, String> map = new HashMap<>();
for (Map.Entry<String,String> entry : map.entrySet()){
String key = entry.getKey();
String value = entry.getValue();
}
5. 不要创建不必要对象
- 能用基本类型到时候尽量要用基本类型。比如我们做数字运算，如果定义称了个Long 类型，会涉及到自动装箱。大大耗时。
- 对于一些程序中共用的参数尽量设置为static类型变量。
- 对于一些耗时性较大的对象比如数据库连接，尽量创建数据库连接池。
- 对于一些占据内存较大的对象也尽量少创建。因为在eden区来回倒腾，它累啊！。
public class Sum {
public static void main(String[] args) {
long start = System.currentTimeMillis();
Long sum = 0L; //对象
for(long i=0;i<Integer.MAX_VALUE;i++) {
sum = sum+i;
//new 20多亿的Long的实例
}
System.out.println("spend time:"+(System.currentTimeMillis()-start)+"ms");
}
}
耗时：spend time:7042ms
public class Sum {
public static void main(String[] args) {
long start = System.currentTimeMillis();
long sum = 0L; //基本类型
for(long i=0;i<Integer.MAX_VALUE;i++) {
sum = sum+i;
}
System.out.println("spend time:"+(System.currentTimeMillis()-start)+"ms");
}
}
耗时：spend time:820ms
6. 避免使用终结方法
finalze方法：
- finalize()是Object的protected方法，子类可以覆盖该方法以实现资源清理工作，GC在回收对象之前调用该方法。
- finalize()与C++中的析构函数不是对应的，但Java中的finalize的调用具有不确定性。
- finalize方法在垃圾回收器准备垃圾回收前被调用，但是不一定会被调用 4.finalize()其实是用来释放不是通过java的new关键字分配的内存，比如说通过本地方法调用了c程序，该c程序malloc分配了内存，那么垃圾回收器就不能通过java语言来释放内存，只能在finalize方法内通过本地方法调用c程序进行释放内存。
一个对象要被回收要经过一次标记可达法已经两次check才算死亡。总结来说：finalize()并不是必须要执行的，它只能执行一次或者0次。如果在finalize中建立对象关联，则当前对象可以复活一次
System.gc：用System.gc()的时候，其实并不会马上进行垃圾回收，甚至不一定会执行垃圾回收。查看System.gc()的源码可以看到只有当justRanFinalization=true的时候系统才会真正GC。如果真要回收查看源码知道System.gc()要跟System.runFinalization()一起搭配使用才好。
7. 使用Collection.isEmpty() 检测空
使用Collection.size() 来检测是否为空在逻辑上没有问题，但是使用Collection.isEmpty() 使得代码更易读，并且可以获得更好的性能；除此之外，任何Collection.isEmpty() 实现的时间复杂度都是O(1) ，不需要多次循环遍历，但是某些通过Collection.size() 方法实现的时间复杂度可能是O(n)。O(1)纬度减少循环次数
反例
LinkedList<Object> collection = new LinkedList<>();
if (collection.size() == 0){
System.out.println("collection is empty.");
}
正例：
LinkedList<Object> collection = new LinkedList<>();
if (collection.isEmpty()){
System.out.println("collection is empty.");
}
//检测是否为null 可以使用CollectionUtils.isEmpty()
if (CollectionUtils.isEmpty(collection)){
System.out.println("collection is null.");
}
8. 初始化集合时尽量指定其大小
尽量在初始化时指定集合的大小，能有效减少集合的扩容次数，因为集合每次扩容的时间复杂度很可能时O(n)，耗费时间和性能。
反例
//初始化list，往list 中添加元素反例：
int[] arr = new int[]{1,2,3,4};
List<Integer> list = new ArrayList<>();
for (int i : arr){
list.add(i);
}
正例：
//初始化list，往list 中添加元素正例：
int[] arr = new int[]{1,2,3,4};
//指定集合list 的容量大小
List<Integer> list = new ArrayList<>(arr.length);
for (int i : arr){
list.add(i);
}
9. 类跟成员的可访问性最小化
这个说白了就是设计模式中的迪米特法则。定义：要求一个对象应该对其他对象有最少的了解，所以迪米特法则又叫做最少知识原则（Least Knowledge Principle, LKP）。
意义：迪米特法则的意义在于降低类之间的耦合。由于每个对象尽量减少对其他对象的了解，因此，很容易使得系统的功能模块功能独立，相互之间不存在（或很少有）依赖关系，日常最常见的比如成员变量私有化。
10. 使可变性最小化
尽可能的使用final 来修饰一些变量，这样的化线程操作就不需要考虑同步问题，同时也对于一个变量不同setX方法也 OK。
11. 使用StringBuilder 拼接字符串
一般的字符串拼接在编译期Java 会对其进行优化，但是在循环中字符串的拼接Java 编译期无法执行优化，所以需要使用StringBuilder 进行替换。
反例
//在循环中拼接字符串反例
String str = "";
for (int i = 0; i < 10; i++){
//在循环中字符串拼接Java 不会对其进行优化
str += i;
}
正例：
//在循环中拼接字符串正例
String str1 = "Love";
String str2 = "Courage";
String strConcat = str1 + str2; //Java 编译器会对该普通模式的字符串拼接进行优化
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10; i++){
//在循环中，Java 编译器无法进行优化，所以要手动使用StringBuilder
sb.append(i);
}
12. 若需频繁调用Collection.contains 方法则使用Set
在Java 集合类库中，List的contains 方法普遍时间复杂度为O(n)，若代码中需要频繁调用contains 方法查找数据则先将集合list 转换成HashSet 实现，将O(n) 的时间复杂度将为O(1)。
反例
//频繁调用Collection.contains() 反例
List<Object> list = new ArrayList<>();
for (int i = 0; i <= Integer.MAX_VALUE; i++){
//时间复杂度为O(n)
if (list.contains(i))
System.out.println("list contains "+ i);
}
正例：
//频繁调用Collection.contains() 正例
List<Object> list = new ArrayList<>();
Set<Object> set = new HashSet<>();
for (int i = 0; i <= Integer.MAX_VALUE; i++){
//时间复杂度为O(1)
if (set.contains(i)){
System.out.println("list contains "+ i);
}
}
13. 接口优于抽象类
简而言之，Java只允许单继承但是允许实现多个接口。通过接口扩充方法很简单，这样也复合设计模式中的开闭原则。接口可以简单的理解比抽象类还要抽象的一层，是我们对外提供的接口。同时这里提一下骨架抽象类。
骨架类存在的意义是实现一个接口中设计者认为比较公用的方法，然后在具体类实现的时候，具体类继承自骨架类同时实现接口类的若干方法。
HashSet源码
public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, java.io.Serializable
看Set源码
public interface Set<E> extends Collection<E> {
}
AbstractSet源码
public abstract class AbstractSet<E> extends
AbstractCollection<E> implements Set<E> //
AbstractSet抽象类有若干函数已经实现了。
HashSet实现了Set<E>的接口，同时它还继承自AbstractSet<E>这个骨架类(类中有一些公用方法)
14. 可变参数谨慎使用
JDK5增加了可变参数方法(variable arity method)，可变参数方法接受0个或多个指定类型的参数。可变参数机制：先创建一个数组，数组大小为调用位置所传递的参数数量，然后将参数值传递到数组中，最后将数组传递给方法。弊端如下：
- 如果所传参数为null，方法里有对参数的引用（比如 args[0]）时，那么就会在运行时失败（编译时却检测不出错误）；
- 在对性能有要求时，我们要慎重考虑是否使用可变参数。因为，可变参数方法的调用都会引起array的内存分配和初始化，这会给性能带来损耗。
- 当可变参数的使用发生变动时（比如：以前用可变参数方法，现在用普通方法），所有引用参数列表的类的.class都要重新生成，因为可变参数的array的分配和初始化是在编译期间完成的。
Effective Java给我们的建议是：假设调用可变参数的方法中，有95%只是调用参数个数小于4，那么就可以将个数小于4的方法，用普通方法定义；剩余的5%，调用可变参数方法。
public void foo() {}
public void foo(int a1) {}
public void foo(int a1, int a2) {}
public void foo(int a1, int a2, int a3) {}
public void foo(int a1, int a2, int a3, int... rest) {}
15. 使用静态代码块实现赋值静态成员变量
对于集合类型的静态成员变量，应该使用静态代码块赋值，而不是使用集合实现来赋值。
反例
//赋值静态成员变量反例
private static Map<String, Integer> map = new HashMap<String, Integer>(){
{
map.put("Leo",1);
map.put("Family-loving",2);
map.put("Cold on the out side passionate on the inside",3);
}
};
private static List<String> list = new ArrayList<>(){
{
list.add("Sagittarius");
list.add("Charming");
list.add("Perfectionist");
}
};
正例：
//赋值静态成员变量正例
private static Map<String, Integer> map = new HashMap<String, Integer>();
static {
map.put("Leo",1);
map.put("Family-loving",2);
map.put("Cold on the out side passionate on the inside",3);
}
private static List<String> list = new ArrayList<>();
static {
list.add("Sagittarius");
list.add("Charming");
list.add("Perfectionist");
}
16. 删除未使用的局部变量、方法参数、私有方法、字段和多余的括号。
如标题~
17. 尽量不要返回NULL,尽量返回零数组或集合
函数中如果返回NULL，那么代码还要去重新的判断返回值。JDK都主动给我们提供好了Collections.EMPTY_LIST。当然如果是对象就只能是NULL了。阿里巴巴开发手册也是这样建议的哦。
返回值为null并不会有什么问题，但是在“解引用”（dereference）时，调用者没有对null进行判断就会出现NullPointerException。
在返回值为数组或者集合时，尽量返回长度为零的数组或者集合，而不是null，这样在调用时就能简化代码，减少不必要的麻烦，并且不必担心NullPointer异常（除非这对性能会造成很大的影响)。
反例
//返回null 反例
public static Result[] getResults() {
return null;
}
public static List<Result> getResultList() {
return null;
}
public static Map<String, Result> getResultMap() {
return null;
}
正例：
//返回空数组和空集正例
public static Result[] getResults() {
return new Result[0];
}
public static List<Result> getResultList() {
return Collections.emptyList();
}
public static Map<String, Result> getResultMap() {
return Collections.emptyMap();
}
18. 优先使用标准异常
总结来说好处就是：追求代码的重用考虑，在装载类的性能上面考虑。具体细节如下：
- 它使你对官方API更加易于学习和使用，因为他与程序员已经熟悉的习惯用法是一致的。
- 对于用到这些API的程序而言，他们的可读性会更好，因为他们不会出现很多程序员不熟悉的异常。
- 异常类越少，意味着内存印迹就越小，装载这些类的时间开销也越少。
19. 局部变量作用域最小化
- 从系统GC的角度考虑(一个变量的周期越短整个gc过程越快)。2.从栈桢中的局部变量表的可重用性来看，作用域越小系统的栈桢空间利用了越大。
- 可以增强代码的可读性和可维护性，并降低出错的可能性。
应该：
- 在第一次使用某个局部变量的地方进行声明。
- 如果你还没有足够的前置信息来对一个变量进行有意义的初始化，就应该推迟这个声明，直到可以初始化为止。
- 尽量将方法小而集中。方法的功能尽量单一。
20. 对于精度技术不用float或double
Java在允许float或者double类之间计算的时候会有误差。
double a = 0.2;
double b = 0.1;
double c = a+ b;
System.out.println(c);
-----
0.30000000000000004
要用：BigDecimal 或者FloatDecimal。具体类用法自行百度。
21. 避免使用BigDecimal(double)
BigDecimal(double) 存在精度损失风险，在精确计算或值比较的场景中可能会导致业务逻辑异常。
反例：
BigDecimal bigDecimal = new BigDecimal(0.11D);
正例：
BigDecimal bigDecimal1 = bigDecimal.valueOf(0.11D);
22. 删除多余的异常捕获并抛出
用catch 语句捕获异常后，若什么也不进行处理，就只是让异常重新抛出，这跟不捕获异常的效果一样，可以删除这块代码或添加别的处理。
反例
//多余异常反例
private static String fileReader(String fileName)throws IOException{
try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
String line;
StringBuilder builder = new StringBuilder();
while ((line = reader.readLine()) != null) {
builder.append(line);
}
return builder.toString();
} catch (Exception e) {
//仅仅是重复抛异常 未作任何处理
throw e;
}
}
正例：
//多余异常正例
private static String fileReader(String fileName)throws IOException{
try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
String line;
StringBuilder builder = new StringBuilder();
while ((line = reader.readLine()) != null) {
builder.append(line);
}
return builder.toString();
//删除多余的抛异常，或增加其他处理：
/*catch (Exception e) {
return "fileReader exception";
}*/
}
}
23. 字符串操作少用String
这点操作是大家都知道的，String定义为private final byte[] value;是不可变的。StringBuilder 和 StringBuffer都继承于：AbstractStringBuilder他们的底层使用的是没有用final修饰的字符数组：char[]
如果要操作少量的数据用 String；
多线程操作字符串缓冲区下操作大量数据 StringBuffer；
单线程操作字符串缓冲区下操作大量数据 StringBuilder。
24. 对资源的close建议分开操作
比如说我们有这样的一个close方法，
try{
a.close()
b.close()
}catch(Exception e){
...
}
上面这样写一旦a关闭的时候出错了，b的关闭也会出错。尽量分开来关闭。
try{
a.close()
}catch(Exception e){
...
}
try{
b.close()
}catch(Exception e){
...
}
25. 数据类型转换
基本数据类型转换为String的时候注意性能优化，比如Integer类型数据转换为String一般有三种方法
- Integer.toString方法，首先推荐。速度最好
- String.valueOf() ，该方法底层调用的是Integer.toString方法，速度中等。
- i + “” 这种方法，底层是用StringBuilder实现，先用append方法拼接，再用toString方法获取字符串。速度最慢。
26. 字符串转化使用String.valueOf(value) 代替 " " + value
把其它对象或类型转化为字符串时，使用String.valueOf(value) 比 “”+value 的效率更高。
反例
//把其它对象或类型转化为字符串反例：
int num = 520;
// "" + value
String strLove = "" + num;
正例：
//把其它对象或类型转化为字符串正例：
int num = 520;
// String.valueOf() 效率更高
String strLove = String.valueOf(num);
27. 优先使用常量或确定值调用equals 方法
对象的equals 方法容易抛空指针异常，应使用常量或确定有值的对象来调用equals 方法。
反例
//调用 equals 方法反例
private static boolean fileReader(String fileName)throws IOException{
// 可能抛空指针异常
return fileName.equals("Charming");
}
正例：
//调用 equals 方法正例
private static boolean fileReader(String fileName)throws IOException{
// 使用常量或确定有值的对象来调用 equals 方法
return "Charming".equals(fileName);
//或使用：java.util.Objects.equals() 方法
return Objects.equals("Charming",fileName);
}
28. 枚举的属性字段必须是私有且不可变
枚举通常被当做常量使用，如果枚举中存在公共属性字段或设置字段方法，那么这些枚举常量的属性很容易被修改；理想情况下，枚举中的属性字段是私有的，并在私有构造函数中赋值，没有对应的Setter 方法，最好加上final 修饰符。
反例
public enum SwitchStatus {
// 枚举的属性字段反例
DISABLED(0, "禁用"),
ENABLED(1, "启用");
public int value;
private String description;
private SwitchStatus(int value, String description) {
this.value = value;
this.description = description;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
}
正例：
public enum SwitchStatus {
// 枚举的属性字段正例
DISABLED(0, "禁用"),
ENABLED(1, "启用");
// final 修饰
private final int value;
private final String description;
private SwitchStatus(int value, String description) {
this.value = value;
this.description = description;
}
// 没有Setter 方法
public int getValue() {
return value;
}
public String getDescription() {
return description;
}
}
29. 不用的对象记得置NULL
我们不用一个空间对象后而没有将其置NULL，JDK底层代码对用不到的对象都会立马置空，如果不这样容易造成内存泄露，比如我自己实现了一个栈
public class Stack {
public Object[] elements;
private int size = 0; //指示器，用来指示当前栈顶的位置
private static final int Cap = 16;
public Stack() {
elements = new Object[Cap];
}
//入栈
public void push(Object e){
elements[size] = e;
size++;
}
//出栈
public Object pop(){
size = size-1;
Object object = elements[size];
elements[size] = null; // 这里很重要 JDK底层都是这样实现的，不用了，及时置NULL
return object;
}
}
1
30. 同步方法跟同步方法块
尽量使用同步方法块而不是同步方法，这点在多线程模块中的synchronized锁 方法块文章中已经讲得很清楚了，除非我们能确定一整个方法都是需要进行同步的，否则尽量使用同步代码块，避免对那些不需要进行同步的代码也进行了同步，影响了代码执行效率。
31. 方法要尽可能小
一个方法要尽量实现单一指责，方法编译后字节码越小越可能会引发JIT的方法内联，
public void SetAge(int age){
this.age = age
}
-------JIT 优化后直接就是 如下，避免类方法调用。
this.age = age
32. 一定记得写注释
代码写的再好也要记得写类跟方法的大概注释，不然接收你工作的人绝对分分钟化身祖安玩家！
33. String.split(String regex)部分关键字需要转译
使用字符串String 的plit 方法时，传入的分隔字符串是正则表达式，则部分关键字（比如 .| 等）需要转义。
反例
// String.split(String regex) 反例
String[] split = "a.ab.abc".split(".");
System.out.println(Arrays.toString(split)); // 结果为[]
String[] split1 = "a|ab|abc".split("|");
System.out.println(Arrays.toString(split1)); // 结果为["a", "|", "a", "b", "|", "a", "b", "c"]
正例：
// String.split(String regex) 正例
// . 需要转译
String[] split2 = "a.ab.abc".split("\\.");
System.out.println(Arrays.toString(split2)); // 结果为["a", "ab", "abc"]
// | 需要转译
String[] split3 = "a|ab|abc".split("\\|");
System.out.println(Arrays.toString(split3)); // 结果为["a", "ab", "abc"]
参考文章
- 阿里Java编码规范
- 深入理解String
- Builder模式
- sowhat1412 https://mp.weixin.qq.com/s?__biz=MzA3ODg3OTk4OA==&mid=2651111477&idx=3&sn=1e709417cad5d468fa2915dcf2417a0c&chksm=844c6daeb33be4b8bfdde775aaa9dfc34b3dbc2376a65d2a72215e5b1379ba8a0475933647ed&mpshare=1&scene=24&srcid=01013jcG8fht07fLqSc2AOip&sharer_sharetime=1609454187507&sharer_shareid=05e3f93694ffaeb19fe4fc20d6c2089a#
- 涛姐涛哥 cnblogs.com/taojietaoge/p/11575376.html
扫一扫
129
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
