FindBugs质量管理

1. FindBugs是什么

FindBugs 是一个静态分析工具，它检查类或者 JAR 文件，将字节码与一组缺陷模式进行对比以发现可能的问题。有了静态分析工具，就可以在不实际运行程序的情况对软件进行分析。

FindBugs就是对编译后的class进行扫描，以发现一些隐藏的bug。如果你拥有这些.class档对应的代码文件，可把这些源代码文件再选上，这样便可以从稍后得出的报告中快捷的定位到出问题的代码上面。此外，还可以选上工程所使用的library，这样似乎可以帮助FindBugs做一些高阶的检查，以发现一些更深层的bug。

2. FindBugs的作用

使用FindBugs一般建议是在开发阶段，在这个阶段将 FindBugs 加入到编译过程中，可以尽可能早地在进行编译时发现问题，从而保证保证项目研发质量。尤其当团队扩大，并且不可避免地在项目中加入更多新开发人员时，FindBugs 可以作为一个安全网，检测出已经识别的缺陷模式。如果让一定数量的开发人员共同工作，那么在代码中就会出现缺陷。像 FindBugs 这样的工具当然不会找出所有的缺陷，但是它们会帮助找出其中的部分。

一旦确定了加入哪些过滤器和类，运行 FindBugs 就没什么成本了，而带来的好处就是它会检测出新缺陷。如果编写特定于应用程序的检测器，则这个好处可能更大。

3. FindBugs的使用

FindBugs的使用一般分为独立使用和集成使用，独立使用是指单独安装FindBugs程序，然后在命令行或其他流程中全套使用，如DevOps平台。嵌入使用一般是与开发工具或集成工具使用，如eclipse、idea、Jenkins等。

4. FindBugs规则分类

FindBugs的规则在3.0.1版本中一共有453个，规则分为八类，分别为：

l Bad practice：不好的实践方面的

l Correctness：正确性方面的

l Internationalization：国际化的方面的

l Malicious code vulnerability：存在漏洞的有害代码方面的

l Multithreaded correctness：多线程正确性方面的

l Performance：性能 方面的

l Security：安全方面的

l Dodgy code：不可靠代码方面的

5. FindBugs规则详情

规格分类英文	错误码	错误规则	中文翻译
Bad practice	AM_CREATES_EMPTY_JAR_FILE_ENTRY	AM: Creates an empty jar file entry	调用putNextEntry()方法写入新的 jar 文件条目时立即调用closeEntry()方法。这样会造成JarFile条目为空。
Bad practice	AM_CREATES_EMPTY_ZIP_FILE_ENTRY	AM: Creates an empty zip file entry	调用putNextEntry()方法写入新的 zip 文件条目时立即调用closeEntry()方法。这样会造成ZipFile条目为空。
Bad practice	BC_EQUALS_METHOD_SHOULD_WORK_FOR_ALL_OBJECTS	BC: Equals method should not assume anything about the type of its argument	equals(Object o)方法不能对参数o的类型做任何的假设。比较此对象与指定的对象。当且仅当该参数不为 null，并且是表示与此对象相同的类型的对象时，结果才为 true。
Bad practice	BIT_SIGNED_CHECK	BIT: Check for sign of bitwise operation	检查位操作符运行是否合理 ((event.detail & SWT.SELECTED) > 0) If SWT.SELECTED is a negative number, this is a candidate for a bug. Even when SWT.SELECTED is not negative, it seems good practice to use '!= 0' instead of '> 0'.
Bad practice	CN_IDIOM	CN: Class implements Cloneable but does not define or use clone method	按照惯例，实现此接口的类应该使用公共方法重写 Object.clone（它是受保护的），以获得有关重写此方法的详细信息。此接口不 包含 clone 方法。因此，因为某个对象实现了此接口就克隆它是不可能的,应该实现此接口的类应该使用公共方法重写 Object.clone
Bad practice	CN_IDIOM_NO_SUPER_CALL	CN: clone method does not call super.clone()	一个非final类型的类定义了clone()方法而没有调用super.clone()方法。例如：B扩展自A，如果B中clone方法调用了spuer.clone（），而A中的clone没有调用spuer.clone()，就会造成结果类型不准确。要求A的clone方法中调用spuer.clone()方法。
Bad practice	CN_IMPLEMENTS_CLONE_BUT_NOT_CLONEABLE	CN: Class defines clone() but doesn't implement Cloneable	类中定义了clone方法但是它没有实现Cloneable接口
Bad practice	CNT_ROUGH_CONSTANT_VALUE	CNT: Rough value of known constant found	建议使用预定义的库常量以提高代码的清晰度和精度。
Bad practice	CO_ABSTRACT_SELF	Co: Abstract class defines covariant compareTo() method	抽象类中定义了多个compareTo()方法，正确的是覆写Comparable中的compareTo方法，方法的参数为Object类型，如下例： int compareTo(T o)  比较此对象与指定对象的顺序。
Bad practice	CO_COMPARETO_INCORRECT_FLOATING	Co: compareTo()/compare() incorrectly handles float or double value	此方法使用如下模式比较双值或浮点值：val1>val2？1:val1<val2-1 : 0. 此模式不适用于-0.0和NaN值，这可能会导致不正确的排序结果或集合损坏（如果将比较值用作键）。考虑使用Double.compare或Float.com.pare静态方法，这些方法可以正确处理所有特殊情况。
Bad practice	CO_COMPARETO_RESULTS_MIN_VALUE	Co: compareTo()/compare() returns Integer.MIN_VALUE	在某些情况下，此compareTo或compare方法返回常量Integer。MIN_VALUE，这是一种异常糟糕的做法。compareTo的返回值唯一重要的是结果的符号。但人们有时会否定compareTo的返回值，以为这会否定结果的符号。它会的，除非返回的值是Integer。最小值。所以只需返回-1而不是Integer。最小值。
Bad practice	CO_SELF_NO_OBJECT	Co: Covariant compareTo() method defined	类中定义了多个compareTo()方法，正确的是覆写Comparable中的compareTo方法，方法的参数为Object类型
Bad practice	DE_MIGHT_DROP	DE: Method might drop exception	方法可能抛出异常
Bad practice	DE_MIGHT_IGNORE	DE: Method might ignore exception	方法可能忽略异常
Bad practice	DMI_ENTRY_SETS_MAY_REUSE_ENTRY_OBJECTS	DMI: Adding elements of an entry set may fail due to reuse of Entry objects	entrySet（）方法被允许返回底层Map的视图，在该视图中，单个Entry对象在迭代过程中被重用并返回。从Java 1.6开始，IdentityHashMap和EnumMap都是这样做的。当迭代这样的Map时，Entry值只有在进入下一次迭代之前才有效。例如，如果您试图将这样一个entrySet传递给addAll方法，那么事情就会严重出错。
Bad practice	DMI_USING_REMOVEALL_TO_CLEAR_COLLECTION	DMI: Don't use removeAll to clear a collection	不要用removeAll方法去clear一个集合
Bad practice	DM_EXIT	Dm: Method invokes System.exit(...)	在方法中调用System.exit(...)语句，考虑用RuntimeException来代替
Bad practice	DM_RUN_FINALIZERS_ON_EXIT	Dm: Method invokes dangerous method runFinalizersOnExit	在方法中调用了System.runFinalizersOnExit 或者Runtime.runFinalizersOnExit方法，因为这样做是很危险的。
Bad practice	ES_COMPARING_PARAMETER_STRING_WITH_EQ	ES: Comparison of String parameter using == or !=	用==或者!=方法去比较String类型的参数
Bad practice	ES_COMPARING_STRINGS_WITH_EQ	ES: Comparison of String objects using == or !=	用==或者！=去比较String类型的对象
Bad practice	EQ_CHECK_FOR_OPERAND_NOT_COMPATIBLE_WITH_THIS	Eq: Equals checks for incompatible operand	equals方法检查不一致的操作。两个类根本就是父子关系而去调用equals方法去判读对象是否相等。 public boolean equals(Object o) {   if (o instanceof Foo)     return name.equals(((Foo)o).name);   else if (o instanceof String)     return name.equals(o);   else return false;
Bad practice	EQ_COMPARETO_USE_OBJECT_EQUALS	Eq: Class defines compareTo(...) and uses Object.equals()	类中定义了compareTo方法但是继承了Object中的compareTo方法
Bad practice	EQ_GETCLASS_AND_CLASS_CONSTANT	Eq: equals method fails for subtypes	类中的equals方法可能被子类中的方法所破坏，当使用类似于Foo.class == o.getClass()的判断时考虑用this.getClass() == o.getClass()来替换
Bad practice	EQ_SELF_NO_OBJECT	Eq: Covariant equals() method defined	类中定义了多个equals方法。正确的做法是覆写Object中的equals方法，它的参数为Object类型的对象。
Bad practice	FI_EMPTY	FI: Empty finalizer should be deleted	为空的finalizer方法应该删除。一下关于finalizer的内容省略
Bad practice	HE_EQUALS_NO_HASHCODE	HE: Class defines equals() but not hashCode()	方法定义了equals方法却没有定义hashCode方法
Bad practice	HE_HASHCODE_NO_EQUALS	HE: Class defines hashCode() but not equals()	类定义了hashCode方法去没有定义equal方法
Bad practice	HE_EQUALS_USE_HASHCODE	HE: Class defines hashCode() and uses Object.equals()	一个类覆写了equals方法，没有覆写hashCode方法，使用了Object对象的hashCode方法
Bad practice	HE_INHERITS_EQUALS_USE_HASHCODE	HE: Class inherits equals() and uses Object.hashCode()	子类继承了父类的equals方法却使用了Object的hashCode方法
Bad practice	IMSE_DONT_CATCH_IMSE	IMSE: Dubious catching of IllegalMonitorStateException	捕捉违法的监控状态异常，例如当没有获取到对象锁时使用其wait和notify方法
Bad practice	ISC_INSTANTIATE_STATIC_CLASS	ISC: Needless instantiation of class that only supplies static methods	为使用静态方法而创建一个实例对象。调用静态方法时只需要使用类名+静态方法名就可以了。
Bad practice	IT_NO_SUCH_ELEMENT	It: Iterator next() method can't throw NoSuchElementException	迭代器的next方法不能够抛出NoSuchElementException
Bad practice	J2EE_STORE_OF_NON_SERIALIZABLE_OBJECT_INTO_SESSION	J2EE: Store of non serializable object into HttpSession	在HttpSession对象中保存非连续的对象
Bad practice	JCIP_FIELD_ISNT_FINAL_IN_IMMUTABLE_CLASS	JCIP: Fields of immutable classes should be final	The class is annotated with net.jcip.annotations.Immutable, and the rules for that annotation require that all fields are final. .
Bad practice	NP_BOOLEAN_RETURN_NULL	NP: Method with Boolean return type returns explicit null	返回值为boolean类型的方法直接返回null，这样会导致空指针异常
Bad practice	NP_EQUALS_SHOULD_HANDLE_NULL_ARGUMENT	NP: equals() method does not check for null argument	变量调用equals方法时没有进行是否为null的判断
Bad practice	NP_TOSTRING_COULD_RETURN_NULL	NP: toString method may return null	toString方法可能返回null
Bad practice	NM_CLASS_NAMING_CONVENTION	Nm: Class names should start with an upper case letter	类的名称以大写字母名称开头
Bad practice	NM_CLASS_NOT_EXCEPTION	Nm: Class is not derived from an Exception, even though it is named as such	类的名称中含有Exception但是却不是一个异常类的子类，这种名称会造成混淆
Bad practice	NM_CONFUSING	Nm: Confusing method names	令人迷惑的方面命名
Bad practice	NM_FIELD_NAMING_CONVENTION	Nm: Field names should start with a lower case letter	非final类型的字段需要遵循驼峰命名原则
Bad practice	NM_FUTURE_KEYWORD_USED_AS_IDENTIFIER	Nm: Use of identifier that is a keyword in later versions of Java	验证是否是java预留关键字
Bad practice	NM_FUTURE_KEYWORD_USED_AS_MEMBER_IDENTIFIER	Nm: Use of identifier that is a keyword in later versions of Java	验证是否是java预留关键字
Bad practice	NM_METHOD_NAMING_CONVENTION	Nm: Method names should start with a lower case letter	方法名称以小写字母开头
Bad practice	NM_SAME_SIMPLE_NAME_AS_INTERFACE	Nm: Class names shouldn't shadow simple name of implemented interface	实现同一接口实现类不能使用相同的名称，即使它们位于不同的包中
Bad practice	NM_SAME_SIMPLE_NAME_AS_SUPERCLASS	Nm: Class names shouldn't shadow simple name of superclass	继承同一父类的子类不能使用相同的名称，即使它们位于不同的包中
Bad practice	NM_VERY_CONFUSING_INTENTIONAL	Nm: Very confusing method names (but perhaps intentional)	很容易混淆的方法命名，例如方法的名称名称使用使用大小写来区别两个不同的方法。
Bad practice	NM_WRONG_PACKAGE_INTENTIONAL	Nm: Method doesn't override method in superclass due to wrong package for parameter	由于错误引用了不同包中相同类名的对象而不能够正确的覆写父类中的方法 import alpha.Foo; public class A {   public int f(Foo x) { return 17; } } import beta.Foo; public class B extends A {   public int f(Foo x) { return 42; }   public int f(alpha.Foo x) { return 27; } }
Bad practice	OBL_UNSATISFIED_OBLIGATION	ODR: Method may fail to close database resource	这种方法可能无法清除（关闭，处置）一个流，数据库对象，或其他资源需要一个明确的清理行动。 一般来说，如果一个方法打开一个流或其他资源，该方法应该使用try / finally块来确保在方法返回之前流或资源已经被清除了。这种错误模式基本上和OS_OPEN_STREAM和ODR_OPEN_DATABASE_RESOURCE错误模式相同，但是是在不同在静态分析技术。我们正为这个错误模式的效用收集反馈意见。
Bad practice	ODR_OPEN_DATABASE_RESOURCE	ODR: Method may fail to close database resource on exception	方法中可能存在关闭数据连接失败的情况
Bad practice	OS_OPEN_STREAM	OS: Method may fail to close stream	方法中可能存在关闭流失败的情况
Bad practice	OS_OPEN_STREAM_EXCEPTION_PATH	OS: Method may fail to close stream on exception	方法中可能存在关闭流时出现异常情况
Bad practice	RC_REF_COMPARISON_BAD_PRACTICE	RC: Suspicious reference comparison to constant	当两者为不同类型的对象时使用equals方法来比较它们的值是否相等，而不是使用==方法。例如比较的两者为java.lang.Integer, java.lang.Float
Bad practice	RC_REF_COMPARISON_BAD_PRACTICE_BOOLEAN	RC: Suspicious reference comparison of Boolean values	使用== 或者 !=操作符来比较两个 Boolean类型的对象，建议使用equals方法。
Bad practice	RR_NOT_CHECKED	RR: Method ignores results of InputStream.read()	InputStream.read方法忽略返回的多个字符，如果对结果没有检查就没法正确处理用户读取少量字符请求的情况。
Bad practice	SR_NOT_CHECKED	RR: Method ignores results of InputStream.skip()	InputStream.skip()方法忽略返回的多个字符，如果对结果没有检查就没法正确处理用户跳过少量字符请求的情况
Bad practice	RV_RETURN_VALUE_IGNORED_BAD_PRACTICE	RV: Method ignores exceptional return value	方法忽略返回值的异常信息
Bad practice	SI_INSTANCE_BEFORE_FINALS_ASSIGNED	SI: Static initializer creates instance before all static final fields assigned	在所有的static final字段赋值之前去使用静态初始化的方法创建一个类的实例。
Bad practice	SE_BAD_FIELD_STORE	Se: Non-serializable value stored into instance field of a serializable class	非序列化的值保存在声明为序列化的的非序列化字段中
Bad practice	SE_COMPARATOR_SHOULD_BE_SERIALIZABLE	Se: Comparator doesn't implement Serializable	Comparator接口没有实现Serializable接口
Bad practice	SE_INNER_CLASS	Se: Serializable inner class	序列化内部类
Bad practice	SE_NONFINAL_SERIALVERSIONID	Se: serialVersionUID isn't final	关于UID类的检查内容省略
Bad practice	SE_NO_SUITABLE_CONSTRUCTOR	Se: Class is Serializable but its superclass doesn't define a void constructor	子类序列化时父类没有提供一个void的构造函数
Bad practice	SE_NO_SUITABLE_CONSTRUCTOR_FOR_EXTERNALIZATION	Se: Class is Externalizable but doesn't define a void constructor	Externalizable 实例类没有定义一个void类型的构造函数
Bad practice	SE_READ_RESOLVE_MUST_RETURN_OBJECT	Se: The readResolve method must be declared with a return type of Object.	readResolve从流中读取类的一个实例，此方法必须声明返回一个Object类型的对象
Bad practice	UI_INHERITANCE_UNSAFE_GETRESOURCE	UI: Usage of GetResource may be unsafe if class is extended	当一个类被子类继承后不要使用this.getClass().getResource(...)来获取资源
Correctness	BC_IMPOSSIBLE_CAST	BC: Impossible cast	不可能的类转换，执行时会抛出ClassCastException
Correctness	BC_IMPOSSIBLE_DOWNCAST	BC: Impossible downcast	父类在向下进行类型转换时抛出ClassCastException
Correctness	BC_IMPOSSIBLE_INSTANCEOF	BC: instanceof will always return false	采用instaneof方法进行比较时总是返回false。前提是保证它不是由于某些逻辑错误造成的。
Correctness	BIT_AND	BIT: Incompatible bit masks	错误的使用&位操作符，例如(e & C)
Correctness	BIT_AND_ZZ	BIT: Check to see if ((...) & 0) == 0	检查恒等的逻辑错误
Correctness	BIT_IOR	BIT: Incompatible bit masks	错误的使用|位操作符，例如(e | C)
Correctness	BIT_SIGNED_CHECK_HIGH_BIT	BIT: Check for sign of bitwise operation	检查逻辑运算符操作返回的标识。例如((event.detail & SWT.SELECTED) > 0)，建议采用!=0代替>0
Correctness	BOA_BADLY_OVERRIDDEN_ADAPTER	BOA: Class overrides a method implemented in super class Adapter wrongly	子类错误的覆写父类中用于适配监听其他事件的方法，从而导致当触发条件发生时不能被监听者调用
Correctness	DLS_DEAD_STORE_OF_CLASS_LITERAL	DLS: Dead store of class literal	以类的字面名称方式为一个字段赋值后再也没有去使用它，在1.4jdk中它会自动调用静态的初始化方法，而在jdk1.5中却不会去执行。
Correctness	DLS_OVERWRITTEN_INCREMENT	DLS: Overwritten increment	覆写增量增加错误i = i++
Correctness	DMI_BAD_MONTH	DMI: Bad constant value for month	月份的错误常量值
Correctness	DMI_COLLECTIONS_SHOULD_NOT_CONTAIN_THEMSELVES	DMI: Collections should not contain themselves	集合没有包含他们自己本身。
Correctness	DMI_INVOKING_HASHCODE_ON_ARRAY	DMI: Invocation of hashCode on an array	数组直接使用hashCode方法来返回哈希码。 int [] a1 = new int[]{1,2,3,4};  System.out.println(a1.hashCode());  System.out.println(java.util.Arrays.hashCode(a1));
Correctness	DMI_VACUOUS_SELF_COLLECTION_CALL	DMI: Vacuous call to collections	集合的调用不能被感知。例如c.containsAll(c)总是返回true，而c.retainAll(c)的返回值不能被感知。
Correctness	DMI_ANNOTATION_IS_NOT_VISIBLE_TO_REFLECTION	Dm: Can't use reflection to check for presence of annotation without runtime retention	Unless an annotation has itself been annotated with @Retention(RetentionPolicy.RUNTIME), the annotation can't be observed using reflection (e.g., by using the isAnnotationPresent method). .
Correctness	EC_ARRAY_AND_NONARRAY	EC: equals() used to compare array and nonarray	数组对象使用equals方法和非数组对象进行比较。即使比较的双方都是数组对象也不应该使用equals方法，而应该比较它们的内容是否相等使用java.util.Arrays.equals(Object[], Object[]);
Correctness	EC_INCOMPATIBLE_ARRAY_COMPARE	EC: equals(...) used to compare incompatible arrays	使用equls方法去比较类型不相同的数组。例如：String[] and StringBuffer[], or String[] and int[]
Correctness	EC_UNRELATED_CLASS_AND_INTERFACE	EC: Call to equals() comparing unrelated class and interface	使用equals方法比较不相关的类和接口
Correctness	EC_UNRELATED_INTERFACES	EC: Call to equals() comparing different interface types	调用equals方法比较不同类型的接口
Correctness	EC_UNRELATED_TYPES	EC: Call to equals() comparing different types	调用equals方法比较不同类型的类
Correctness	EC_UNRELATED_TYPES_USING_POINTER_EQUALITY	EC: Using pointer equality to compare different types	This method uses using pointer equality to compare two references that seem to be of different types. The result of this comparison will always be false at runtime.
Correctness	EQ_ALWAYS_FALSE	Eq: equals method always returns false	使用equals方法返回值总是false
Correctness	EQ_ALWAYS_TRUE	Eq: equals method always returns true	equals方法返回值总是true
Correctness	EQ_COMPARING_CLASS_NAMES	Eq: equals method compares class names rather than class objects	使用equals方法去比较一个类的实例和类的类型
Correctness	EQ_OTHER_NO_OBJECT	Eq: equals() method defined that doesn't override equals(Object)	类中定义的equals方法时不要覆写equals（Object）方法
Correctness	EQ_OTHER_USE_OBJECT	Eq: equals() method defined that doesn't override Object.equals(Object)	类中定义的equals方法时不要覆写Object中的equals（Object）方法
Correctness	EQ_SELF_USE_OBJECT	Eq: Covariant equals() method defined, Object.equals(Object) inherited	类中定义了一组equals方法，但是都是继承的java.lang.Object class中的equals(Object)方法
Correctness	VA_FORMAT_STRING_BAD_ARGUMENT	FS: Format string placeholder incompatible with passed argument	错误使用参数类型来格式化字符串
Correctness	VA_FORMAT_STRING_BAD_CONVERSION	FS: The type of a supplied argument doesn't match format specifier	指定的格式字符串和参数类型不匹配，例如：String.format("%d", "1")
Correctness	VA_FORMAT_STRING_EXPECTED_MESSAGE_FORMAT_SUPPLIED	FS: MessageFormat supplied where printf style format expected	但用String的format方法时实际调用了MessageFormat中干的格式化方法而引起格式化结果出错。
Correctness	VA_FORMAT_STRING_EXTRA_ARGUMENTS_PASSED	FS: More arguments are passed than are actually used in the format string	使用String的format方法时有非法的参数也经过了格式化操作。
Correctness	VA_FORMAT_STRING_ILLEGAL	FS: Illegal format string	格式化String对象语句错误
Correctness	VA_FORMAT_STRING_MISSING_ARGUMENT	FS: Format string references missing argument	String的format操作缺少必要的参数。
Correctness	VA_FORMAT_STRING_NO_PREVIOUS_ARGUMENT	FS: No previous argument for format string	格式字符串定义错误，例如：formatter.format("%<s %s", "a", "b"); 抛出MissingFormatArgumentException异常
Correctness	ICAST_INT_CAST_TO_DOUBLE_PASSED_TO_CEIL	ICAST: Integral value cast to double and then passed to Math.ceil	integral的值转换为double后使用了Math.ceil方法
Correctness	ICAST_INT_CAST_TO_FLOAT_PASSED_TO_ROUND	ICAST: int value cast to float and then passed to Math.round	int 类型的值转换为float类型之后调用了Math.round方法
Correctness	IJU_ASSERT_METHOD_INVOKED_FROM_RUN_METHOD	IJU: JUnit assertion in run method will not be noticed by JUnit	在JUnit中的断言在run方法中不会被告知
Correctness	IJU_BAD_SUITE_METHOD	IJU: TestCase declares a bad suite method	在一个JUnit类中声明的一个suite()方法必须声明为 public static junit.framework.Test suite() 或者 public static junit.framework.TestSuite suite()的形式。
Correctness	IL_CONTAINER_ADDED_TO_ITSELF	IL: A collection is added to itself	集合本身作为add方法的参数，这样会引起内容溢出。
Correctness	IL_INFINITE_LOOP	IL: An apparent infinite loop	方法的自调用引起的死循环
Correctness	IM_MULTIPLYING_RESULT_OF_IREM	IM: Integer multiply of result of integer remainder	和整数余数进行乘法运算。例如：i % 60 * 1000 是进行(i % 60) * 1000运算而不是 i % (60 * 1000)
Correctness	INT_BAD_COMPARISON_WITH_NONNEGATIVE_VALUE	INT: Bad comparison of nonnegative value with negative constant or zero	保证非负数和负数进行比较
Correctness	INT_BAD_COMPARISON_WITH_SIGNED_BYTE	INT: Bad comparison of signed byte	比较有符合数，要先把有符号数转换为无符合数再进行比较
Correctness	IO_APPENDING_TO_OBJECT_OUTPUT_STREAM	IO: Doomed attempt to append to an object output stream	宣布试图在对象的输出流处添加元素，如果你希望能够添加进一个对象的输出流中必须保证对象的输出流处于打开状态。
Correctness	IP_PARAMETER_IS_DEAD_BUT_OVERWRITTEN	IP: A parameter is dead upon entry to a method but overwritten	传入参数的值被忽略，但是对传入值进行了修改，并返回给了调用者
Correctness	MF_CLASS_MASKS_FIELD	MF: Class defines field that masks a superclass field	子类中定义了和父类中同名的字段。在调用时会出错
Correctness	MF_METHOD_MASKS_FIELD	MF: Method defines a variable that obscures a field	在方法中定义的局部变量和类变量或者父类变量同名，从而引起字段混淆。
Correctness	NP_ALWAYS_NULL	NP: Null pointer dereference	对象赋为null值后 没有被重新赋值
Correctness	NP_ALWAYS_NULL_EXCEPTION	NP: Null pointer dereference in method on exception path	空指针引用上调用去除引用方法，将发生空指针异常
Correctness	NP_ARGUMENT_MIGHT_BE_NULL	NP: Method does not check for null argument	方法没有判断参数是否为空
Correctness	NP_CLOSING_NULL	NP: close() invoked on a value that is always null	一个为空的对象调用close方法
Correctness	NP_GUARANTEED_DEREF	NP: Null value is guaranteed to be dereferenced	在正常的null判断分支上，对象去除引用操作是受保护的不允许的
Correctness	NP_GUARANTEED_DEREF_ON_EXCEPTION_PATH	NP: Value is null and guaranteed to be dereferenced on exception path	There is a statement or branch on an exception path that if executed guarantees that a value is null at this point, and that value that is guaranteed to be dereferenced (except on forward paths involving runtime exceptions).
Correctness	NP_NONNULL_PARAM_VIOLATION	NP: Method call passes null to a non-null parameter	方法中为null的参数没有被重新赋值  void test(){ String ss = null; sya(ss);  }  public void sya(String ad){ ad.getBytes();  }
Correctness	NP_NONNULL_RETURN_VIOLATION	NP: Method may return null, but is declared @Nonnull	方法声明了返回值不能为空，但是方法中有可能返回null
Correctness	NP_NULL_INSTANCEOF	NP: A known null value is checked to see if it is an instance of a type	检查一个为null的值是否是想要的类型对象，而不是由于粗心或者逻辑错误引起的
Correctness	NP_NULL_ON_SOME_PATH	NP: Possible null pointer dereference	对象可能没有重新赋值
Correctness	NP_NULL_ON_SOME_PATH_EXCEPTION	NP: Possible null pointer dereference in method on exception path	在异常null值处理分支调用的方法上，可能存在对象去除引用操作
Correctness	NP_NULL_PARAM_DEREF_ALL_TARGETS_DANGEROUS	NP: Method call passes null for non-null parameter	方法参数中声明为nonnull类型的参数为null void test(){ String ss = null; sya(ss);  }  public void sya(@nonnull String ad){ ad.getBytes();  }
Correctness	NP_STORE_INTO_NONNULL_FIELD	NP: Store of null value into field annotated @Nonnull	为一个已经声明为不能为null值的属性赋值为null。
Correctness	NM_BAD_EQUAL	Nm: Class defines equal(Object); should it be equals(Object)?	类中定义了一个equal方法但是却不是覆写的Object对象的equals方法
Correctness	NM_LCASE_HASHCODE	Nm: Class defines hashcode(); should it be hashCode()?	类中定义了一个hashCode方法但是却不是覆写的Object中的hashCode方法
Correctness	NM_LCASE_TOSTRING	Nm: Class defines tostring(); should it be toString()?	类中定义了一个toString方法但是却不是覆写的Object中的toString方法
Correctness	NM_METHOD_CONSTRUCTOR_CONFUSION	Nm: Apparent method/constructor confusion	构造方法定义混乱，保证一个标准的构造函数。 例如：  SA(){ }  void SA(){  }
Correctness	NM_VERY_CONFUSING	Nm: Very confusing method names	混乱的方法命名，如getName和getname方法同时出现的时候
Correctness	NM_WRONG_PACKAGE	Nm: Method doesn't override method in superclass due to wrong package for parameter	方法因为取了不同包中的同名的对象而没有正确覆写父类中的同名方法 import alpha.Foo; public class A {   public int f(Foo x) { return 17; } } ---- import beta.Foo; public class B extends A {   public int f(Foo x) { return 42; } }
Correctness	QBA_QUESTIONABLE_BOOLEAN_ASSIGNMENT	QBA: Method assigns boolean literal in boolean expression	再if或者while表达式中使用boolean类型的值时应该使用==去判断，而不是采用=操作
Correctness	RC_REF_COMPARISON	RC: Suspicious reference comparison	比较两个对象值是否相等时应该采用equals方法，而不是==方法
Correctness	RE_BAD_SYNTAX_FOR_REGULAR_EXPRESSION	RE: Invalid syntax for regular expression	对正则表达式使用了错误的语法，会抛出未经检查的异常，表明正则表达式模式中的语法错误。
Correctness	RE_CANT_USE_FILE_SEPARATOR_AS_REGULAR_EXPRESSION	RE: File.separator used for regular expression	使用正则表达式使用了错误的文件分隔符，在windows系统中正则表达式不会匹配’\’而应该使用'\\'
Correctness	RV_01_TO_INT	RV: Random value from 0 to 1 is coerced to the integer 0	从0到1随机值被强制为整数值0。在强制得到一个整数之前，你可能想得到多个随机值。或使用Random.nextInt（n）的方法。
Correctness	RV_ABSOLUTE_VALUE_OF_HASHCODE	RV: Bad attempt to compute absolute value of signed 32-bit hashcode	此代码生成一个哈希码，然后计算该哈希码的绝对值。如果哈希码是Integer.MIN_VALUE的，那么结果将是负数（因为Math.abs（Integer.MIN_VALUE的）== Integer.MIN_VALUE的）。 在2^ 32值之外字符串有一个Integer.MIN_VALUE的hashCode包括“polygenelubricants”，“GydZG_”和“，”DESIGNING WORKHOUSES “。
Correctness	RV_ABSOLUTE_VALUE_OF_RANDOM_INT	RV: Bad attempt to compute absolute value of signed random integer	此代码生成一个随机的符号整数，然后计算该随机整数的绝对值。如果随机数生成数绝对值为Integer.MIN_VALUE的，那么结果将是负数（因为Math.abs（Integer.MIN_VALUE的）== Integer.MIN_VALUE的）。
Correctness	RV_EXCEPTION_NOT_THROWN	RV: Exception created and dropped rather than thrown	此代码创建一个异常（或错误）的对象，但不会用它做任何事情。例如：if (x < 0)   new IllegalArgumentException("x must be nonnegative"); 这可能是程序员的意图抛出创建的异常： if (x < 0)   throw new IllegalArgumentException("x must be nonnegative");
Correctness	RpC_REPEATED_CONDITIONAL_TEST	RpC: Repeated conditional tests	该代码包含对同一个条件试验了两次，两边完全一样例如：（如X == 0 | | x == 0）。可能第二次出现是打算判断别的不同条件（如X == 0 | | y== 0）。
Correctness	SA_FIELD_SELF_ASSIGNMENT	SA: Self assignment of field	方法中包含自己对自己赋值的字段。例如： int x;   public void foo() {     x = x;   }
Correctness	SA_FIELD_SELF_COMPARISON	SA: Self comparison of field with itself	字段自己进行自比较可能表明错误或逻辑错误。
Correctness	SA_LOCAL_SELF_COMPUTATION	SA: Nonsensical self computation involving a field (e.g., x & x)	此方法对同一变量执行了荒谬的计算（如x&x或x-x）操作。由于计算的性质，这一行动似乎没有意义，并可能表明错误或逻辑错误。
Correctness	SF_DEAD_STORE_DUE_TO_SWITCH_FALLTHROUGH	SF: Dead store due to switch statement fall through	在swtich中先前的case值因为swtich执行失败而被覆写，这就像是忘记使用break推出或者没有使用return语句放回先前的值一样。
Correctness	SF_DEAD_STORE_DUE_TO_SWITCH_FALLTHROUGH_TO_THROW	SF: Dead store due to switch statement fall through to throw	在swtich中因为出现异常而忽略了对case值的保存。
Correctness	SIC_THREADLOCAL_DEADLY_EMBRACE	SIC: Deadly embrace of non-static inner class and thread local	如果是一个静态内部类。实际上，在内部类和当前线程有死锁的可能。由于内部类不是静态的，它保留了对外部类的引用。如果线程包含对一个内部类实例的引用，那么内外实例的实例都可以被获取，这样就不具备垃圾会回收的资格。
Correctness	SIO_SUPERFLUOUS_INSTANCEOF	SIO: Unnecessary type check done using instanceof operator	在进行instanceof操作时进行没有必要的类型检查
Correctness	STI_INTERRUPTED_ON_CURRENTTHREAD	STI: Unneeded use of currentThread() call, to call interrupted()	此方法调用Thread.currentThread（）调用，只需调用interrupted（）方法。由于interrupted（）是一个静态方法， Thread.interrupted（）更简单易用。
Correctness	STI_INTERRUPTED_ON_UNKNOWNTHREAD	STI: Static Thread.interrupted() method invoked on thread instance	调用不是当前线程对象的Thread.interrupted()方法，由于interrupted（）方法是静态的，interrupted方法将会调用一个和作者原计划不同的对象。
Correctness	SE_METHOD_MUST_BE_PRIVATE	Se: Method must be private in order for serialization to work	这个类实现了Serializable接口，并定义自定义序列化的方法/反序列化。但由于这种方法不能声明为private，将被序列化/反序列化的API忽略掉。
Correctness	SE_READ_RESOLVE_IS_STATIC	Se: The readResolve method must not be declared as a static method.	为使readResolve方法得到序列化机制的识别，不能作为一个静态方法来声明。
Correctness	UMAC_UNCALLABLE_METHOD_OF_ANONYMOUS_CLASS	UMAC: Uncallable method defined in anonymous class	在匿名类中定义了一个既没有覆写超类中方法也不能直接调用的方法。因为在其他类的方法不能直接引用匿名类声明的方法，似乎这种方法不能被调用，这种方法可能只是没有任何作用的代码，但也可能覆写超类中声明。
Correctness	UR_UNINIT_READ	UR: Uninitialized read of field in constructor	此构造方法中使用了一个尚未赋值的字段或属性。  String a;  public SA() { String abc = a; System.out.println(abc);  }
Correctness	DMI_INVOKING_TOSTRING_ON_ANONYMOUS_ARRAY	USELESS_STRING: Invocation of toString on an array	该代码调用上匿名数组的toString（）方法，产生的结果形如[@ 16f0472并没有实际的意义。考虑使用Arrays.toString方法来转换成可读的字符串，提供该数组的内容数组。例如： String[] a = { "a" }; System.out.println(a.toString()); //正确的使用为 System.out.println(Arrays.toString(a));
Correctness	UWF_NULL_FIELD	UwF: Field only ever set to null	字段的值总是为null值，所有读取该字段的值都为null。检查错误，如果它确实没有用就删除掉。
Correctness	UWF_UNWRITTEN_FIELD	UwF: Unwritten field	此字段是永远不会写入值。所有读取将返回默认值。检查错误（如果它被初始化？），如果它确实没有用就删除掉。
Internationalization	DM_CONVERT_CASE	Dm: Consider using Locale parameterized version of invoked method	使用平台默认的编码格式对字符串进行大小写转换，这可能导致国际字符的转换不当。使用以下方式对字符进行转换 String.toUpperCase( Locale l ) String.toLowerCase( Locale l )
Malicious code vulnerability	DP_CREATE_CLASSLOADER_INSIDE_DO_PRIVILEGED	DP: Classloaders should only be created inside doPrivileged block	类加载器只能建立在特殊的方法体内
Malicious code vulnerability	EI_EXPOSE_REP	EI: May expose internal representation by returning reference to mutable object	返回一个易变对象引用并把它保存在对象字段中时会暴露对象内部的字段描述，如果接受不守信任的代码访问或者没有检查就去改变易变对象的会涉及对象的安全和其他重要属性的安全。返回一个对象的新副本，在很多情况下更好的办法。
Malicious code vulnerability	EI_EXPOSE_REP2	EI2: May expose internal representation by incorporating reference to mutable object	此代码把外部可变对象引用存储到对象的内部表示。如果实例受到不信任的代码的访问和没有检查的变化危及对象和重要属性的安全。存储一个对象的副本，在很多情况下是更好的办法。
Malicious code vulnerability	FI_PUBLIC_SHOULD_BE_PROTECTED	FI: Finalizer should be protected, not public	一个类中的finalize（）方法必须声明为protected，而不能为public类型
Malicious code vulnerability	MS_EXPOSE_REP	MS: Public static method may expose internal representation by returning array	一个public类型的静态方法返回一个数组，可能引用内部属性的暴露。任何代码调用此方法都可以自由修改底层数组。一个解决办法是返回一个数组的副本。
Malicious code vulnerability	MS_FINAL_PKGPROTECT	MS: Field should be both final and package protected	一个静态字段可能被恶意代码或另外一个包所改变的。字段可以放到protected包中也可以定义为final类型的以避免此问题。
Malicious code vulnerability	MS_MUTABLE_ARRAY	MS: Field is a mutable array	一个定义为final类型的静态字段引用一个数组时它可以被恶意代码或在另其他包中所使用。这些代码可以自由修改数组的内容。
Malicious code vulnerability	MS_MUTABLE_HASHTABLE	MS: Field is a mutable Hashtable	一个定义为final类型的静态字段引用一个Hashtable时可以被恶意代码或者在其他包中被调用，这些方法可以修改Hashtable的值。
Malicious code vulnerability	MS_OOI_PKGPROTECT	MS: Field should be moved out of an interface and made package protected	将域尽量不要定义在接口中，并声明为包保护在接口中定义了一个final类型的静态字段，如数组或哈希表等易变对象。这些对象可以被恶意代码或者在其他包中被调用，为了解决这个问题，需要把它定义到一个具体的实体类中并且声明为保护类型以避免这种错误。
Malicious code vulnerability	MS_PKGPROTECT	MS: Field should be package protected	一个静态字段是可以改变的恶意代码或其他的包访问修改。可以把这种类型的字段声明为final类型的以防止这种错误。
Multithreaded correctness	DM_MONITOR_WAIT_ON_CONDITION	Dm: Monitor wait() called on Condition	方法中以java.util.concurrent.locks.Condition对象调用wait（）。等待一个条件发生时应该使用在Condition接口中定义的await()方法。
Multithreaded correctness	DM_USELESS_THREAD	Dm: A thread was created using the default empty run method	这个方法没有通过run方法或者具体声明Thread类，也没有通过一个Runnable对象去定义一个线程，而这个线程出来浪费资源却什么也没有去做。
Multithreaded correctness	ESync_EMPTY_SYNC	ESync: Empty synchronized block	该代码包含一个空的同步块：synchronized() {}
Multithreaded correctness	IS2_INCONSISTENT_SYNC	IS: Inconsistent synchronization	不合理的同步
Multithreaded correctness	IS_FIELD_NOT_GUARDED	IS: Field not guarded against concurrent access	域不是良好的同步访问---此字段被标注为net.jcip.annotations.GuardedBy，但可以在某种程度上违反注释而去访问
Multithreaded correctness	JLM_JSR166_LOCK_MONITORENTER	JLM: Synchronization performed on Lock	实现java.util.concurrent.locks.Lock的对象调用了同步的方法。应该这样处理，对象被锁定/解锁时使用acquire（）/ release（）方法而不是使用同步的方法。
Multithreaded correctness	LI_LAZY_INIT_STATIC	LI: Incorrect lazy initialization of static field	静态域不正确的延迟初始化-- 这种方法包含了一个不同步延迟初始化的非volatile静态字段。因为编译器或处理器可能会重新排列指令，如果该方法可以被多个线程调用，线程不能保证看到一个完全初始化的对象。你可以让字段可变来解决此问题
Multithreaded correctness	LI_LAZY_INIT_UPDATE_STATIC	LI: Incorrect lazy initialization and update of static field	这种方法包含一个不同步延迟初始化的静态字段。之后为字段赋值，对象存储到该位置后进一步更新或访问。字段后尽快让其他线程能够访问。如果该方法的进一步访问该字段为初始化对象提供服务，然后你有一个非常严重的多线程bug，除非别的东西阻止任何其他线程访问存储的对象，直到它完全初始化。即使你有信心，该方法是永远不会被多个线程调用时，在它的值还没有被充分初始化或移动，不把它设定为static字段时它可能会更好。
Multithreaded correctness	ML_SYNC_ON_UPDATED_FIELD	ML: Method synchronizes on an updated field	对象获取一个可变字段时进行同步。这是没有意义的，因为不同的线程可以在不同的对象同步。
Multithreaded correctness	MSF_MUTABLE_SERVLET_FIELD	MSF: Mutable servlet field	一个web服务一般只能创建一个servlet或者jsp的实例（例如：treates是一个单利类），它会被多个线程调用这个实例的方法服务于多个同时的请求。因此使用易变的字段属性产生竞争的情况。
Multithreaded correctness	MWN_MISMATCHED_NOTIFY	MWN: Mismatched notify()	此方法调用Object.notify（）或Object.notifyAll（）而没有获取到该对象的对象锁。调用notify（）或notifyAll（）而没有持有该对象的对象锁，将导致IllegalMonitorStateException异常。
Multithreaded correctness	MWN_MISMATCHED_WAIT	MWN: Mismatched wait()	此方法调用Object.wait()而没有获取到该对象的对象锁。调用wait（）而没有持有该对象的对象锁，将导致IllegalMonitorStateException异常。
Multithreaded correctness	NP_SYNC_AND_NULL_CHECK_FIELD	NP: Synchronize and null check on the same field.	如果代码块是同步的，那么久不可能为空。如果是空，同步时就会抛出NullPointerException异常。最好是在另一个代码块中进行同步。
Multithreaded correctness	NO_NOTIFY_NOT_NOTIFYALL	No: Using notify() rather than notifyAll()	调用notify（）而不是notifyAll（）方法。 Java的监控器通常用于多个条件。调用notify（）只唤醒一个线程，这意味着该线程被唤醒只是满足的当前的唯一条件。
Multithreaded correctness	RS_READOBJECT_SYNC	RS: Class's readObject() method is synchronized	序列化类中定义了同步的readObject（）。通过定义，反序列化创建的对象只有一个线程可以访问，因此没有必要的readObject（）进行同步。如果的readObject（）方法本身造成对象对另一个线程可见，那么这本身就是不好的编码方式。
Multithreaded correctness	RU_INVOKE_RUN	Ru: Invokes run on a thread (did you mean to start it instead?)	这种方法显式调用一个对象的run（）。一般来说，类是实现Runnable接口的，因为在一个新的线程他们将有自己的run（）方法，在这种情况下Thread.start（）方法调用是正确的。
Multithreaded correctness	SC_START_IN_CTOR	SC: Constructor invokes Thread.start()	在构造函数中启动一个线程。如果类曾经被子类扩展过，那么这很可能是错的，因为线程将在子类构造之前开始启动。
Multithreaded correctness	SP_SPIN_ON_FIELD	SP: Method spins on field	方法无限循环读取一个字段。编译器可合法悬挂宣读循环，变成一个无限循环的代码。这个类应该改变，所以使用适当的同步（包括等待和通知要求）
Multithreaded correctness	STCAL_INVOKE_ON_STATIC_CALENDAR_INSTANCE	STCAL: Call to static Calendar	即使JavaDoc对此不包含暗示，而Calendars本身在多线程中使用就是不安全的。探测器发现当调用Calendars的实例时将会获得一个静态对象。Calendar rightNow = Calendar.getInstance();
Multithreaded correctness	STCAL_INVOKE_ON_STATIC_DATE_FORMAT_INSTANCE	STCAL: Call to static DateFormat	在官方的JavaDoc，DateFormats多线程使用本事就是不安全的。探测器发现调用一个DateFormat的实例将会获得一个静态对象。 myString = DateFormat.getDateInstance().format(myDate);
Multithreaded correctness	STCAL_STATIC_CALENDAR_INSTANCE	STCAL: Static Calendar field	Calendar在多线程中本身就是不安全的，如果在线程范围中共享一个Calendarde 实例而不使用一个同步的方法在应用中就会出现一些奇怪的行为。在sun.util.calendar.BaseCalendar.getCalendarDateFromFixedDate()中会抛出ArrayIndexOutOfBoundsExceptions or IndexOutOfBoundsExceptions异常。
Multithreaded correctness	STCAL_STATIC_SIMPLE_DATE_FORMAT_INSTANCE	STCAL: Static DateFormat	DateFormat 在多线程中本身就是不安全的，如果在线程范围中共享一个DateFormat的实例而不使用一个同步的方法在应用中就会出现一些奇怪的行为。
Multithreaded correctness	SWL_SLEEP_WITH_LOCK_HELD	SWL: Method calls Thread.sleep() with a lock held	当持有对象时调用Thread.sleep（）。这可能会导致很差的性能和可扩展性，或陷入死锁，因为其他线程可能正在等待获得锁。调用wait（）是一个更好的主意，释放对象的持有以允许其他线程运行。
Multithreaded correctness	UG_SYNC_SET_UNSYNC_GET	UG: Unsynchronized get method, synchronized set method	这个类包含类似命名的get和set方法。在set方法是同步方法和get方法是非同步方法。这可能会导致在运行时的不正确行为，因为调用的get方法不一定返回对象一致状态。 GET方法应该同步。
Multithreaded correctness	UL_UNRELEASED_LOCK	UL: Method does not release lock on all paths	方法获得了当前的对象所，但是在方法中始终没有释放它。一个正确的示例如下：   Lock l = ...;     l.lock();     try {         // do something     } finally {         l.unlock();     }
Multithreaded correctness	UL_UNRELEASED_LOCK_EXCEPTION_PATH	UL: Method does not release lock on all exception paths	方法获得了当前的对象所，但是在所有的异常处理中始终没有释放它。一个正确的示例如下：   Lock l = ...;     l.lock();     try {         // do something     } finally {         l.unlock();     }
Multithreaded correctness	UW_UNCOND_WAIT	UW: Unconditional wait	方法中包含调用java.lang.Object.wait（），而却没有放到条件流程控制中。该代码应确认条件尚未满足之前等待;先前任何通知将被忽略。
Multithreaded correctness	VO_VOLATILE_REFERENCE_TO_ARRAY	VO: A volatile reference to an array doesn't treat the array elements as volatile	声明一个变量引用数组，这可能不是你想要的。如果一个变量引用数组，那么对引用数组的读和写都是不安全的，但是数组元素不是变量。取得数组的变量值你可以使用java.util.concurrent包中的数组的原子性特性
Multithreaded correctness	WS_WRITEOBJECT_SYNC	WS: Class's writeObject() method is synchronized but nothing else is	这个类有一个writeObject（）方法是同步的，但是这个类中没有其他的同步方法。
Multithreaded correctness	WA_AWAIT_NOT_IN_LOOP	Wa: Condition.await() not in loop	方法没有在循环中调用java.util.concurrent.await()。如果对象是用于多种条件，打算调用wait()方法的条件可能不是实际发生的。
Multithreaded correctness	WA_NOT_IN_LOOP	Wa: Wait not in loop	这种方法包含调用java.lang.Object.wait（），而这并不是一个循环。如果监视器用于多个条件，打算调用wait()方法的条件可能不是实际发生的。
Performance	BX_BOXING_IMMEDIATELY_UNBOXED	Bx: Primitive value is boxed and then immediately unboxed	对原始值进行装箱，然后立即取消装箱。这可能是在一个未要求装箱的地方进行了手动装箱，从而迫使编译器进行立即撤消装箱的操作
Performance	BX_BOXING_IMMEDIATELY_UNBOXED_TO_PERFORM_COERCION	Bx: Primitive value is boxed then unboxed to perform primitive coercion	对原始值进行装箱然后立即把它强制转换为另外一种原始类型。例如： new Double(d).intValue()应该直接进行强制转换例如：(int) d
Performance	BX_UNBOXED_AND_COERCED_FOR_TERNARY_OPERATOR	Bx: Primitive value is unboxed and coerced for ternary operator	在三元运算符操作时如果没有对值进行封装或者类型转换。例如：b ? e1 : e2
Performance	DM_FP_NUMBER_CTOR	Bx: Method invokes inefficient floating-point Number constructor; use static valueOf instead	使用new Double(double)方法总是会创建一个新的对象，然而使用Double.valueOf(double)方法可以把值保存在编辑器或者class library、JVM中。使用存储值的方式来避免对象的分配可以或得更好的代码性能除非类必须符合Java 1.5以前的JVM，否则请使用自动装箱或valueOf（）方法创建Double和Float实例。
Performance	DM_NUMBER_CTOR	Bx: Method invokes inefficient Number constructor; use static valueOf instead	使用new Integer(int)方法总是会创建一个新的对象，然而使用Integer.valueOf(int)方法可以把值保存在编辑器或者class library、JVM中。使用存储值的方式来避免对象的分配可以或得更好的代码性能除非类必须符合Java 1.5以前的JVM，否则请使用自动装箱或valueOf（）方法创建Long, Integer, Short, Character, Byte实例。
Performance	DMI_BLOCKING_METHODS_ON_URL	Dm: The equals and hashCode methods of URL are blocking	使用equals和hashCode方法来对url进行资源标识符解析时会引起堵塞。考虑使用java.net.URI来代替。
Performance	DMI_COLLECTION_OF_URLS	Dm: Maps and sets of URLs can be performance hogs	方法或者字段使用url的map/set集合。因为equals方法或者hashCode方法来进行资源标识符解析时都会引起堵塞。考虑使用java.net.URI来代替。
Performance	DM_BOOLEAN_CTOR	Dm: Method invokes inefficient Boolean constructor; use Boolean.valueOf(...) instead	使用new方法创建一个java.lang.Boolean类型能够的实例对象是浪费空间的，因为Boolean对象是不可变的而且只有两个有用的值。使用Boolean.valueOf()或者Java1.5中的自动装箱功能来创建一个Boolean实例。
Performance	DM_GC	Dm: Explicit garbage collection; extremely dubious except in benchmarking code	在代码中显式的调用垃圾回收命名，这样做并不能起作用。在过去，有人在关闭操作或者finalize方法中调用垃圾回收方法导致了很多的性能浪费。这样大规模回收对象时会造成处理器运行缓慢。
Performance	DM_NEXTINT_VIA_NEXTDOUBLE	Dm: Use the nextInt method of Random rather than nextDouble to generate a random integer	如果r是一个java.util.Random对象，你可以使r.nextInt(n)生成一个0到n-1之前的随机数，而不是使用(int)(r.nextDouble() * n)
Performance	DM_STRING_CTOR	Dm: Method invokes inefficient new String(String) constructor	使用java.lang.String(String)构造函数会浪费内存因为这种构造方式和String作为参数在功能上容易混乱。只是使用String直接作为参数的形式
Performance	DM_STRING_TOSTRING	Dm: Method invokes toString() method on a String	调用String.toString()是多余的操作，只要使用String就可以了。
Performance	DM_STRING_VOID_CTOR	Dm: Method invokes inefficient new String() constructor	使用没有参数的构造方法去创建新的String对象是浪费内存空间的，因为这样创建会和空字符串“”混淆。Java中保证完成相同的构造方法会产生描绘相同的String对象。所以你只要使用空字符串来创建就可以了。
Performance	ITA_INEFFICIENT_TO_ARRAY	ITA: Method uses toArray() with zero-length array argument	当使用集合的toArray()方法时使用数组长度为0的数组作为参数。比这更有效的一种方法是myCollection.toArray(new Foo[myCollection.size()])，如果数组的长度足够大就可以直接把集合中的内容包装到数组中直接返回从而避免了第二次创建一个新的数组来存放集合中值。
Performance	SS_SHOULD_BE_STATIC	SS: Unread field: should this field be static?	类中所包含的final属性字段在编译器中初始化为静态的值。考虑在定义时就把它定义为static类型的。
Performance	UPM_UNCALLED_PRIVATE_METHOD	UPM: Private method is never called	定义为Private类型方法从未被调用，应该被删除。
Performance	URF_UNREAD_FIELD	UrF: Unread field	类中定义的属性从未被调用，建议删除。
Performance	UUF_UNUSED_FIELD	UuF: Unused field	类中定义的属性从未被使用，建议删除。
Performance	WMI_WRONG_MAP_ITERATOR	WMI: Inefficient use of keySet iterator instead of entrySet iterator	当方法中接受一个Map类型的参数时，使用keySet的迭代器比使用entrySet的迭代器效率要高。
Security	DMI_CONSTANT_DB_PASSWORD	Dm: Hardcoded constant database password	代码中创建DB的密码时采用了写死的密码。
Security	DMI_EMPTY_DB_PASSWORD	Dm: Empty database password	创建数据库连接时没有为数据库设置密码，这会使数据库没有必要的保护。
Security	HRS_REQUEST_PARAMETER_TO_COOKIE	HRS: HTTP cookie formed from untrusted input	此代码使用不受信任的HTTP参数构造一个HTTP Cookie。
Security	HRS_REQUEST_PARAMETER_TO_HTTP_HEADER	HRS: HTTP Response splitting vulnerability	在代码中直接把一个HTTP的参数写入一个HTTP头文件中，它为HTTP的响应暴露了漏洞。
Security	SQL_NONCONSTANT_STRING_PASSED_TO_EXECUTE	SQL: Nonconstant string passed to execute or addBatch method on an SQL statement	该方法以字符串的形式来调用SQLstatement的execute方法，它似乎是动态生成SQL语句的方法。这会更容易受到SQL注入攻击。
Security	XSS_REQUEST_PARAMETER_TO_JSP_WRITER	XSS: JSP reflected cross site scripting vulnerability	在代码中在JSP输出中直接写入一个HTTP参数，这会造成一个跨站点的脚本漏洞。
Security	XSS_REQUEST_PARAMETER_TO_SEND_ERROR	XSS: Servlet reflected cross site scripting vulnerability in error page	在代码中在Servlet输出中直接写入一个HTTP参数，这会造成一个跨站点的脚本漏洞。
Security	XSS_REQUEST_PARAMETER_TO_SERVLET_WRITER	XSS: Servlet reflected cross site scripting vulnerability	代码直接写入参数的HTTP服务器错误页（使用HttpServletResponse.sendError）。表达了类似的不受信任的输入会引起跨站点脚本漏洞。
Dodgy code	BC_BAD_CAST_TO_ABSTRACT_COLLECTION	BC: Questionable cast to abstract collection	在代码投把一个集合强制类型转换为一个抽象的集合（如list，set或map）。保证该对象类型和将要转换的类型是一致的。如果你只是想要便利一个集合，那么你就不必将它转换为Set或List。
Dodgy code	BC_BAD_CAST_TO_CONCRETE_COLLECTION	BC: Questionable cast to concrete collection	代码把抽象的集合（如List，Set，或Collection）强制转换为具体落实类型（如一个ArrayList或HashSet）。这可能不正确，也可能使您的代码很脆弱，因为它使得难以在今后的切换指向其他具体实现。除非你有特别理由这样做，否则只需要使用抽象的集合类。
Dodgy code	BC_UNCONFIRMED_CAST	BC: Unchecked/unconfirmed cast	强制类型转换操作没有经过验证，而且不是所有的此种类型装换过的类都可以再强制类型转换为原类型。在代码中需要进行逻辑判断以保证可以进行这样的操作。
Dodgy code	BC_VACUOUS_INSTANCEOF	BC: instanceof will always return true	instanceof测试将始终返回真（除非被测试的值为空）。虽然这是安全，确保它是不是说明一些误解或其他一些逻辑错误。如果你真的想测试是空的价值，也许会更清楚这样做的更好空试验，而不是一个instanceof测试。
Dodgy code	ICAST_QUESTIONABLE_UNSIGNED_RIGHT_SHIFT	BSHIFT: Unsigned right shift cast to short/byte	无符号数右移后进行转换为short或者byte类型时可能会丢弃掉高位的值，这样的结果就是有符合数和无符号数无法区分（这取决于移位大小）
Dodgy code	CI_CONFUSED_INHERITANCE	CI: Class is final but declares protected field	这个类被声明为final的，而是字段属性却声明为保护类型的。由于是final类，它不能再被继承，而再声明为保护类型的很容易造成混淆。为了从外部能正确的使用它应该把它们声明为private或者public类型。
Dodgy code	DB_DUPLICATE_BRANCHES	DB: Method uses the same code for two branches	此方法使用相同的代码，以实现两个有条件的分支。检查以确保这是不是一个编码错误。
Dodgy code	DB_DUPLICATE_SWITCH_CLAUSES	DB: Method uses the same code for two switch clauses	他的方法使用相同的代码来实现两个switch的声明条款。这可能是重复代码的情况，但可能也显示出编码的错误。
Dodgy code	DLS_DEAD_LOCAL_STORE	DLS: Dead store to local variable	该指令为局部变量赋值，但在其后的没有对她做任何使用。通常，这表明一个错误，因为值从未使用过。
Dodgy code	DLS_DEAD_LOCAL_STORE_IN_RETURN	DLS: Useless assignment in return statement	本声明把一个局部变量放到方法的返回语句中。这对于方法中局部变量来说是没有意思的。
Dodgy code	DLS_DEAD_LOCAL_STORE_OF_NULL	DLS: Dead store of null to local variable	把一个本地变量赋值为null值，并且再也没有对这个变量做任何的操作。这样可能是为了垃圾回收，而是Java SE 6.0，这已不再需要。
Dodgy code	DMI_HARDCODED_ABSOLUTE_FILENAME	DMI: Code contains a hard coded reference to an absolute pathname	此代码包含文件对象为一个绝对路径名
Dodgy code	DMI_NONSERIALIZABLE_OBJECT_WRITTEN	DMI: Non serializable object written to ObjectOutput	代码中让一个非序列化的对象出现在ObjectOutput.writeObject()方法中，这样会引起一个错误。
Dodgy code	DMI_USELESS_SUBSTRING	DMI: Invocation of substring(0), which returns the original value	此代码调用了subString(0)方法，它将返回原来的值。
Dodgy code	EQ_DOESNT_OVERRIDE_EQUALS	Eq: Class doesn't override equals in superclass	子类定义了一个新的equals方法但是却不是覆写了父类本省的equals()方法。
Dodgy code	FE_FLOATING_POINT_EQUALITY	FE: Test for floating point equality	此操作比较两个浮点值是否相等。由于浮点运算可能会涉及到舍入，计算float和double值可能不准确。如果要求值必须准确，如货币值，可以考虑使用固定精度类型，如BigDecimal类型的值来比较
Dodgy code	VA_FORMAT_STRING_BAD_CONVERSION_TO_BOOLEAN	FS: Non-Boolean argument formatted using %b format specifier	使用%b去格式化Boolean类型的值不正确的但是它不会抛出异常，任何非空的值都会输出true，任何为空的值都会输出false
Dodgy code	IC_INIT_CIRCULARITY	IC: Initialization circularity	在引用两个相互调用为环状static方法去初始化一个实例时是错误的。
Dodgy code	ICAST_IDIV_CAST_TO_DOUBLE	ICAST: Integral division result cast to double or float	整形数除法强制转换为double或者float类型。 int x = 2; int y = 5; // Wrong: yields result 0.0 double value1 =  x / y; // Right: yields result 0.4 double value2 =  x / (double) y;
Dodgy code	IM_AVERAGE_COMPUTATION_COULD_OVERFLOW	IM: Computation of average could overflow	代码中使用x % 2 == 1的方法去验证运算是否存在余数的情况，但是如果出现负数的情况就不起作用了。使用x & 1 == 1, or x % 2 != 0来代替
Dodgy code	INT_VACUOUS_COMPARISON	INT: Vacuous comparison of integer value	整形数进行比较结果总是不变。例如：x <= Integer.MAX_VALUE
Dodgy code	MTIA_SUSPECT_SERVLET_INSTANCE_FIELD	MTIA: Class extends Servlet class and uses instance variables	这个类扩展从Servlet类，并使用实例的成员变量。由于只有一个Servlet类的实例，并在多线程方式使用，这种模式有可能存在问题。考虑只使用方法的局部变量。
Dodgy code	MTIA_SUSPECT_STRUTS_INSTANCE_FIELD	MTIA: Class extends Struts Action class and uses instance variables	类扩展自Struts的Action类并使用这个实例的成员变量，因为在Struts框架中只存在一个Action实例对象并且使用在多线程的情况下很可能会出现问题。
Dodgy code	NP_DEREFERENCE_OF_READLINE_VALUE	NP: Dereference of the result of readLine() without nullcheck	对readLine()的结果值没有进行判空操作就去重新赋值，这样的操作可以会抛出空指针异常。
Dodgy code	NP_IMMEDIATE_DEREFERENCE_OF_READLINE	NP: Immediate dereference of the result of readLine()	对readLine()的结果立即赋值，这样的操作可以会抛出空指针异常。
Dodgy code	NP_NULL_ON_SOME_PATH_FROM_RETURN_VALUE	NP: Possible null pointer dereference due to return value of called method	方法的返回值没有进行是否为空的检查就重新赋值，这样可能会出现空指针异常。
Dodgy code	NP_PARAMETER_MUST_BE_NONNULL_BUT_MARKED_AS_NULLABLE	NP: Parameter must be non-null but is marked as nullable	参数值在任何情况下都不能为空，但是有明确的注释它可以为空。
Dodgy code	NS_DANGEROUS_NON_SHORT_CIRCUIT	NS: Potentially dangerous use of non-short-circuit logic	代码中使用（& or |）代替（&& or ||）操作，这会造成潜在的危险。
Dodgy code	NS_NON_SHORT_CIRCUIT	NS: Questionable use of non-short-circuit logic	代码中使用（& or |）代替（&& or ||）操作，会引起不安全的操作
Dodgy code	PZLA_PREFER_ZERO_LENGTH_ARRAYS	PZLA: Consider returning a zero length array rather than null	考虑返回一个零长度的数组，而不是null值
Dodgy code	QF_QUESTIONABLE_FOR_LOOP	QF: Complicated, subtle or wrong increment in for-loop	确定这个循环是正确的变量递增，看起来，另一个变量被初始化，检查的循环。这是由于for循环中太复杂的定义造成的。
Dodgy code	RCN_REDUNDANT_COMPARISON_OF_NULL_AND_NONNULL_VALUE	RCN: Redundant comparison of non-null value to null	方法中包含一个不能为空的赋值还包含一个可以为空的赋值。冗余比较非空值为空。
Dodgy code	RCN_REDUNDANT_COMPARISON_TWO_NULL_VALUES	RCN: Redundant comparison of two null values	方法中对两个null值进行比较
Dodgy code	RCN_REDUNDANT_NULLCHECK_OF_NONNULL_VALUE	RCN: Redundant nullcheck of value known to be non-null	方法中对不为空的值进行为空的判断。
Dodgy code	REC_CATCH_EXCEPTION	REC: Exception is caught when Exception is not thrown	在try/catch块中捕获异常，但是异常没有在try语句中抛出而RuntimeException又没有明确的被捕获
Dodgy code	RI_REDUNDANT_INTERFACES	RI: Class implements same interface as superclass	子类和父类都实现了同一个接口，这种定义是多余的。
Dodgy code	RV_DONT_JUST_NULL_CHECK_READLINE	RV: Method discards result of readLine after checking if it is non-null	readLine方法的结果不为空时被抛弃
Dodgy code	RV_REM_OF_RANDOM_INT	RV: Remainder of 32-bit signed random integer	此代码生成一个随机的符号整数，然后计算另一个值的。由于随机数可以是负数，所以其余操作的结果也可以是负面的。考虑使用Random.nextInt（int）方法代替。
Dodgy code	SA_FIELD_DOUBLE_ASSIGNMENT	SA: Double assignment of field	方法中的字段包含了双重任务，例如：  int x;   public void foo() {    x = x = 17;   } 这种为变量赋值是无用的，并可能表明一个逻辑错误或拼写错误。
Dodgy code	SA_LOCAL_DOUBLE_ASSIGNMENT	SA: Double assignment of local variable	为一个局部变量两次赋值，这样是没有意义的。例如： public void foo() {     int x,y;     x = x = 17;   }
Dodgy code	SA_LOCAL_SELF_ASSIGNMENT	SA: Self assignment of local variable	局部变量使用自身给自己赋值 public void foo() {     int x = 3;     x = x;   }
Dodgy code	SF_SWITCH_FALLTHROUGH	SF: Switch statement found where one case falls through to the next case	Switch语句中一个分支执行后又执行了下一个分支。通常case后面要跟break 或者return语句来跳出。
Dodgy code	SF_SWITCH_NO_DEFAULT	SF: Switch statement found where default case is missing	Switch没有默认情况下执行的case语句。
Dodgy code	SE_PRIVATE_READ_RESOLVE_NOT_INHERITED	Se: Private readResolve method not inherited by subclasses	声明为private的序列化方法被子类继承
Dodgy code	UCF_USELESS_CONTROL_FLOW	UCF: Useless control flow	没有任何作用的条件语句。 if (argv.length == 0) {  // TODO: handle this case  }
Dodgy code	UCF_USELESS_CONTROL_FLOW_NEXT_LINE	UCF: Useless control flow to next line	无效的条件控制语句，注意if (argv.length == 1);以“;”结尾，下面的语句无论是否满足都会运行。 if (argv.length == 1);  System.out.println("Hello, " + argv[0]);
Dodgy code	XFB_XML_FACTORY_BYPASS	XFB: Method directly allocates a specific implementation of xml interfaces	方法自定义了一种XML接口的实现类。最好是使用官方提供的工厂类来创建这些对象，以便可以在运行期中改变。例如： javax.xml.parsers.DocumentBuilderFactory javax.xml.parsers.SAXParserFactory javax.xml.transform.TransformerFactory org.w3c.dom.Document.createXXXX