这篇文章主要围绕这4款MySQL调优工具yyds和mysql调优策略展开，旨在为您提供一份详细的参考资料。我们将全面介绍这4款MySQL调优工具yyds的优缺点，解答mysql调优策略的相关问题，同时

这篇文章主要围绕这 4 款 MySQL 调优工具 yyds和mysql调优策略展开，旨在为您提供一份详细的参考资料。我们将全面介绍这 4 款 MySQL 调优工具 yyds的优缺点，解答mysql调优策略的相关问题，同时也会为您带来16 条 yyds 的代码规范、16 条 yyds 的代码规范，使编写的代码更高效、优雅！、32 条 yyds 的 MySQL 军规，含索引、锁、事务、分库分表、4 款 MySQL 调优工具，公司大神都在用！的实用方法。

本文目录一览：

• 这 4 款 MySQL 调优工具 yyds（mysql调优策略）
• 16 条 yyds 的代码规范
• 16 条 yyds 的代码规范，使编写的代码更高效、优雅！
• 32 条 yyds 的 MySQL 军规，含索引、锁、事务、分库分表
• 4 款 MySQL 调优工具，公司大神都在用！

这 4 款 MySQL 调优工具 yyds（mysql调优策略）

点击上方蓝色字体，选择“标星公众号”

优质文章，第一时间送达

关注公众号后台回复pay或mall获取实战项目资料+视频

作者：老王谈运维

来源：toutiao.com/a6691523026984370699

对于正在运行的mysql，性能如何，参数设置的是否合理，账号设置的是否存在安全隐患，你是否了然于胸呢？

俗话说工欲善其事，必先利其器，定期对你的MYSQL数据库进行一个体检，是保证数据库安全运行的重要手段，因为，好的工具是使你的工作效率倍增！

今天和大家分享几个mysql 优化的工具，你可以使用它们对你的mysql进行一个体检，生成awr报告，让你从整体上把握你的数据库的性能情况。

mysqltuner.pl

是mysql一个常用的数据库性能诊断工具，主要检查参数设置的合理性包括日志文件、存储引擎、安全建议及性能分析。针对潜在的问题，给出改进的建议。是mysql优化的好帮手。

在上一版本中，MySQLTuner支持MySQL / MariaDB / Percona Server的约300个指标。

项目地址：https://github.com/major/MySQLTuner-perl

1.1 下载

[root@localhost ~]#wget https://raw.githubusercontent.com/major/MySQLTuner-perl/master/mysqltuner.pl

1.2 使用

[root@localhost ~]# ./mysqltuner.pl --socket /var/lib/mysql/mysql.sock
 >> MySQLTuner 1.7.4 - Major Hayden <major@mhtx.net>
 >> Bug reports, feature requests, and downloads at http://mysqltuner.com/
 >> Run with ''--help'' for additional options and output filtering
[--] Skipped version check for MySQLTuner script
Please enter your MySQL administrative login: root
Please enter your MySQL administrative password: [OK] Currently running supported MySQL version 5.7.23
[OK] Operating on 64-bit architecture 

1.3、报告分析

1）重要关注[!!]（中括号有叹号的项）例如[!!] Maximum possible memory usage: 4.8G (244.13% of installed RAM)，表示内存已经严重用超了。

2）关注最后给的建议“Recommendations ”。

tuning-primer.sh

mysql的另一个优化工具，针于mysql的整体进行一个体检，对潜在的问题，给出优化的建议。

项目地址：https://github.com/BMDan/tuning-primer.sh

目前，支持检测和优化建议的内容如下：

2.1 下载

[root@localhost ~]#wget https://launchpad.net/mysql-tuning-primer/trunk/1.6-r1/+download/tuning-primer.sh

2.2 使用

[root@localhost ~]# [root@localhost dba]# ./tuning-primer.sh 
 
 -- MYSQL PERFORMANCE TUNING PRIMER --
 - By: Matthew Montgomery -

2.3 报告分析

重点查看有红色告警的选项，根据建议结合自己系统的实际情况进行修改，例如：

pt-variable-advisor

pt-variable-advisor 可以分析MySQL变量并就可能出现的问题提出建议。

3.1 安装

https://www.percona.com/downloads/percona-toolkit/LATEST/

[root@localhost ~]#wget https://www.percona.com/downloads/percona-toolkit/3.0.13/binary/redhat/7/x86_64/percona-toolkit-3.0.13-re85ce15-el7-x86_64-bundle.tar
[root@localhost ~]#yum install percona-toolkit-3.0.13-1.el7.x86_64.rpm 

3.2 使用

pt-variable-advisor是pt工具集的一个子工具，主要用来诊断你的参数设置是否合理。

[root@localhost ~]# pt-variable-advisor localhost --socket /var/lib/mysql/mysql.sock

3.3 报告分析

重点关注有WARN的信息的条目，例如：

pt-qurey-digest

pt-query-digest 主要功能是从日志、进程列表和tcpdump分析MySQL查询。

4.1安装

具体参考3.1节

4.2使用

pt-query-digest主要用来分析mysql的慢日志，与mysqldumpshow工具相比，py-query_digest 工具的分析结果更具体，更完善。

[root@localhost ~]# pt-query-digest /var/lib/mysql/slowtest-slow.log 

4.3 常见用法分析

1）直接分析慢查询文件:

pt-query-digest /var/lib/mysql/slowtest-slow.log > slow_report.log

2）分析最近12小时内的查询：

pt-query-digest --since=12h /var/lib/mysql/slowtest-slow.log > slow_report2.log

3）分析指定时间范围内的查询：

pt-query-digest /var/lib/mysql/slowtest-slow.log --since ''2017-01-07 09:30:00'' --until ''2017-01-07 10:00:00''> > slow_report3.log

4）分析指含有select语句的慢查询

pt-query-digest --filter ''$event->{fingerprint} =~ m/^select/i'' /var/lib/mysql/slowtest-slow.log> slow_report4.log

5）针对某个用户的慢查询

pt-query-digest --filter ''($event->{user} || "") =~ m/^root/i'' /var/lib/mysql/slowtest-slow.log> slow_report5.log

6）查询所有所有的全表扫描或full join的慢查询

pt-query-digest --filter ''(($event->{Full_scan} || "") eq "yes") ||(($event->{Full_join} || "") eq "yes")'' /var/lib/mysql/slowtest-slow.log> slow_report6.log

4.4 报告分析

第一部分：总体统计结果

• Overall：总共有多少条查询
• Time range：查询执行的时间范围
• unique：唯一查询数量，即对查询条件进行参数化以后，总共有多少个不同的查询
• total：总计
• min：最小
• max：最大
• avg：平均
• 95%：把所有值从小到大排列，位置位于95%的那个数，这个数一般最具有参考价值
• median：中位数，把所有值从小到大排列，位置位于中间那个数

第二部分：查询分组统计结果

• Rank：所有语句的排名，默认按查询时间降序排列，通过--order-by指定
• Query ID：语句的ID，（去掉多余空格和文本字符，计算hash值）
• Response：总的响应时间
• time：该查询在本次分析中总的时间占比
• calls：执行次数，即本次分析总共有多少条这种类型的查询语句
• R/Call：平均每次执行的响应时间
• V/M：响应时间Variance-to-mean的比率
• Item：查询对象

第三部分：每一种查询的详细统计结果

• ID：查询的ID号，和上图的Query ID对应
• Databases：数据库名
• Users：各个用户执行的次数（占比）
• Query_time distribution ：查询时间分布, 长短体现区间占比。
• Tables：查询中涉及到的表
• Explain：SQL语句

   
   
   

 
    
    
    
有热门推荐

   
   
   

   
   
   

 
    
    
    

  
     
     
     

   
      
      
      
Spring Boot 项目打包 + Shell 脚本部署实践，太有用了!

   
      
      
      
一个Java程序员，发现自己被绿了，于是研发了一款跟踪神器！！

   
      
      
      
快手二面：MySQL 时间类型 datetime、bigint、timestamp，选哪个？很多人答错了！！

   
      
      
      
快手二面：MySQL 时间类型 datetime、bigint、timestamp，选哪个？很多人答错了！！

   
      
      
      
Spring Boot + Vue 竟如此强大？这个项目让所有人都惊艳了。。。

   
      
      
      
图解：订单系统的设计

   
      
      
      
6个顶级SpringCloud微服务开源项目，企业开发必备！

   
      
      
      
美团面试官：如果要存ip地址，用什么数据类型比较好
  
     
     
     
 
    
    
    

   
   
   
点击阅读原文，前往学习SpringCloud实战项

本文分享自微信公众号 - java版web项目（java_project）。
如有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一起分享。

16 条 yyds 的代码规范

如何更规范化编写Java 代码
Many of the happiest people are those who own the least. But are we really so happy with our IPhones, our big houses, our fancy cars?

忘川如斯，拥有一切的人才更怕失去。

背景：如何更规范化编写Java 代码的重要性想必毋需多言，其中最重要的几点当属提高代码性能、使代码远离Bug、令代码更优雅。

一、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 操作也一样，可以用<set> 标记代替 1=1。

二、 迭代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();
}

三、使用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.");

  }

四、初始化集合时尽量指定其大小

尽量在初始化时指定集合的大小，能有效减少集合的扩容次数，因为集合每次扩容的时间复杂度很可能时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);
  }

五、使用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);
  }

六、若需频繁调用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);
      }
  }

七、使用静态代码块实现赋值静态成员变量

对于集合类型的静态成员变量，应该使用静态代码块赋值，而不是使用集合实现来赋值。

反例：

//赋值静态成员变量反例
    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");
    }

八、删除未使用的局部变量、方法参数、私有方法、字段和多余的括号。

九、工具类中屏蔽构造函数

工具类是一堆静态字段和函数的集合，其不应该被实例化；但是，Java 为每个没有明确定义构造函数的类添加了一个隐式公有构造函数，为了避免不必要的实例化，应该显式定义私有构造函数来屏蔽这个隐式公有构造函数。

反例：

public class PasswordUtils {
  //工具类构造函数反例
  private static final Logger LOG = LoggerFactory.getLogger(PasswordUtils.class);

  public static final String DEFAULT_CRYPT_ALGO = "PBEWithMD5AndDES";

  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 = "PBEWithMD5AndDES";

  public static String encryptPassword(String aPassword) throws IOException {
      return new PasswordUtils(aPassword).encrypt();
  }

十、删除多余的异常捕获并抛出

用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";
        }*/
    }
}

十一、字符串转化使用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);
十二、避免使用BigDecimal(double)

BigDecimal(double) 存在精度损失风险，在精确计算或值比较的场景中可能会导致业务逻辑异常。

反例：

// BigDecimal 反例
BigDecimal bigDecimal = new BigDecimal(0.11D);

正例：

// BigDecimal 正例
BigDecimal bigDecimal1 = bigDecimal.valueOf(0.11D);

图1. 失去精度

十三、返回空数组和集合而非 null

若程序运行返回null，需要调用方强制检测null，否则就会抛出空指针异常；返回空数组或空集合，有效地避免了调用方因为未检测null 而抛出空指针异常的情况，还可以删除调用方检测null 的语句使代码更简洁。

反例：

//返回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();
}

十四、优先使用常量或确定值调用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);
 }

十五、枚举的属性字段必须是私有且不可变

枚举通常被当做常量使用，如果枚举中存在公共属性字段或设置字段方法，那么这些枚举常量的属性很容易被修改；理想情况下，枚举中的属性字段是私有的，并在私有构造函数中赋值，没有对应的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;
    }
}

十六、tring.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"]

图2. String.split(String regex) 正反例

16 条 yyds 的代码规范，使编写的代码更高效、优雅！

<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>

//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();
}

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.");

}

//初始化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);
}

//在循环中拼接字符串反例
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);
}

//频繁调用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);
    }
}

//赋值静态成员变量反例
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");
}

public class PasswordUtils {
//工具类构造函数反例
private static final Logger LOG = LoggerFactory.getLogger(PasswordUtils.class);

public static final String DEFAULT_CRYPT_ALGO = "PBEWithMD5AndDES";

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 = "PBEWithMD5AndDES";

public static String encryptPassword(String aPassword) throws IOException {
    return new PasswordUtils(aPassword).encrypt();
}

//多余异常反例
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";
        }*/
    }
}

//把其它对象或类型转化为字符串反例：
int num = 520;
// "" + value
String strLove = "" + num;

//把其它对象或类型转化为字符串正例：
int num = 520;
// String.valueOf() 效率更高
String strLove = String.valueOf(num);

// BigDecimal 反例
BigDecimal bigDecimal = new BigDecimal(0.11D);

// BigDecimal 正例
BigDecimal bigDecimal1 = bigDecimal.valueOf(0.11D);

//返回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();
}

//调用 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);
}

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;
    }
}

// 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"]