1、Security 关于代码安全性防御java
DMI_CONSTANT_DB_PASSWORD
代码中建立DB的密码时采用了写死的密码。程序员
DMI_EMPTY_DB_PASSWORD
建立数据库链接时没有为数据库设置密码，这会使数据库没有必要的保护。web
HRS_REQUEST_PARAMETER_TO_COOKIE
此代码使用不受信任的HTTP参数构造一个HTTP Cookie。正则表达式
HRS_REQUEST_PARAMETER_TO_HTTP_HEADER
在代码中直接把一个HTTP的参数写入一个HTTP头文件中，它为HTTP的响应暴露了漏洞。数据库
SQL_NONCONSTANT_STRING_PASSED_TO_EXECUTE
该方法以字符串的形式来调用SQLstatement的execute方法，它彷佛是动态生成SQL语句的方法。这会更容易受到SQL注入攻击。windows
XSS_REQUEST_PARAMETER_TO_JSP_WRITER
在代码中在JSP输出中直接写入一个HTTP参数，这会形成一个跨站点的脚本漏洞。数组
2、Experimental 关于代码实验性问题
LG_LOST_LOGGER_DUE_TO_WEAK_REFERENCE
OpenJDK的引入了一种潜在的不兼容问题，特别是，java.util.logging.Logger的行为改变时。它如今使用内部弱引用，而不是强引用。–logger配置改变，它就是丢失对logger的引用，这本是一个合理的变化，但不幸的是一些代码对旧的行为有依赖关系。这意味着，当进行垃圾收集时对logger配置将会丢失。例如：安全
public static void initLogging() throws Exception {服务器
Logger logger = Logger.getLogger("edu.umd.cs");数据结构
logger.addHandler(new FileHandler()); // call to change logger configuration
logger.setUseParentHandlers(false); // another call to change logger configuration
}
该方法结束时logger的引用就丢失了，若是你刚刚结束调用initLogging方法后进行垃圾回收，logger的配置将会丢失（由于只有保持记录器弱引用）。
public static void main(String[] args) throws Exception {
initLogging(); // adds a file handler to the logger
System.gc(); // logger configuration lost
Logger.getLogger("edu.umd.cs").info("Some message"); // this isn't logged to the file as expected
}
OBL_UNSATISFIED_OBLIGATION
这种方法可能没法清除（关闭，处置）一个流，数据库对象，或其余资源须要一个明确的清理行动。
通常来讲，若是一个方法打开一个流或其余资源，该方法应该使用try / finally块来确保在方法返回以前流或资源已经被清除了。这种错误模式基本上和OS_OPEN_STREAM和ODR_OPEN_DATABASE_RESOURCE错误模式相同，可是是在不一样在静态分析技术。咱们正为这个错误模式的效用收集反馈意见。
3、Bad practice代码实现中的一些坏习惯
AM_CREATES_EMPTY_JAR_FILE_ENTRY
调用putNextEntry()方法写入新的 jar 文件条目时当即调用closeEntry()方法。这样会形成JarFile条目为空。
AM_CREATES_EMPTY_ZIP_FILE_ENTRY
调用putNextEntry()方法写入新的 zip 文件条目时当即调用closeEntry()方法。这样会形成ZipFile条目为空。
BC_EQUALS_METHOD_SHOULD_WORK_FOR_ALL_OBJECTS
equals(Object o)方法不能对参数o的类型作任何的假设。比较此对象与指定的对象。当且仅当该参数不为 null，而且是表示与此对象相同的类型的对象时，结果才为 true。
DMI_RANDOM_USED_ONLY_ONCE
随机建立对象只使用过一次就抛弃
BIT_SIGNED_CHECK
检查位操做符运行是否合理
((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'.
CN_IDIOM
按照惯例，实现此接口的类应该使用公共方法重写 Object.clone（它是受保护的），以得到有关重写此方法的详细信息。此接口不 包含 clone 方法。所以，由于某个对象实现了此接口就克隆它是不可能的,应该实现此接口的类应该使用公共方法重写 Object.clone
CN_IDIOM_NO_SUPER_CALL
一个非final类型的类定义了clone()方法而没有调用super.clone()方法。例如：B扩展自A，若是B中clone方法调用了spuer.clone（），而A中的clone没有调用spuer.clone()，就会形成结果类型不许确。要求A的clone方法中调用spuer.clone()方法。
CN_IMPLEMENTS_CLONE_BUT_NOT_CLONEABLE
类中定义了clone方法可是它没有实现Cloneable接口
CO_ABSTRACT_SELF
抽象类中定义了多个compareTo()方法，正确的是覆写Comparable中的compareTo方法，方法的参数为Object类型，以下例：
int compareTo(T o) 比较此对象与指定对象的顺序。
CO_SELF_NO_OBJECT
类中定义了多个compareTo()方法，正确的是覆写Comparable中的compareTo方法，方法的参数为Object类型
DE_MIGHT_DROP
方法可能抛出异常
DE_MIGHT_IGNORE
此方法可能忽略异常。一般，应该以某种方式处理或报告异常，或者将异常抛出方法。
DMI_USING_REMOVEALL_TO_CLEAR_COLLECTION
不要用removeAll方法去clear一个集合
DP_CREATE_CLASSLOADER_INSIDE_DO_PRIVILEGED
类加载器只能创建在特殊的方法体内
DM_EXIT
在方法中调用System.exit(...)语句，考虑用RuntimeException来代替
DM_RUN_FINALIZERS_ON_EXIT
在方法中调用了System.runFinalizersOnExit 或者Runtime.runFinalizersOnExit方法，由于这样作是很危险的。
ES_COMPARING_PARAMETER_STRING_WITH_EQ
用==或者!=方法去比较String类型的参数
ES_COMPARING_STRINGS_WITH_EQ
用==或者！=去比较String类型的对象
EQ_ABSTRACT_SELF
This class defines a covariant version of equals(). To correctly override the equals() method in java.lang.Object, the parameter of equals() must have type java.lang.Object.
这个类定义了equals()方法，可是参数倒是Object的子类。正确覆盖equals()方法，参数必须是Object
EQ_CHECK_FOR_OPERAND_NOT_COMPATIBLE_WITH_THIS
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;
EQ_COMPARETO_USE_OBJECT_EQUALS
类中定义了compareTo方法可是继承了Object中的compareTo方法
22.Eq: equals method fails for subtypes (EQ_GETCLASS_AND_CLASS_CONSTANT)
类中的equals方法可能被子类中的方法所破坏，当使用相似于Foo.class == o.getClass()的判断时考虑用this.getClass() == o.getClass()来替换
EQ_SELF_NO_OBJECT
类中定义了多个equals方法。正确的作法是覆写Object中的equals方法，它的参数为Object类型的对象。
FI_EMPTY
为空的finalizer方法应该删除。一下关于finalizer的内容省略
GC_UNCHECKED_TYPE_IN_GENERIC_CALL
This call to a generic collection method passes an argument while compile type Object where a specific type from the generic type parameters is expected. Thus, neither the standard Java type system nor static analysis can provide useful information on whether the object being passed as a parameter is of an appropriate type.
此对泛型集合方法的调用在编译类型对象时传递一个参数，其中预期泛型类型参数中的特定类型。所以，标准Java类型系统和静态分析都不能提供关于做为参数传递的对象是否属于适当类型的有用信息。
HE_EQUALS_NO_HASHCODE
方法定义了equals方法却没有定义hashCode方法
HE_HASHCODE_NO_EQUALS
类定义了hashCode方法去没有定义equal方法
HE_EQUALS_USE_HASHCODE
一个类覆写了equals方法，没有覆写hashCode方法，使用了Object对象的hashCode方法
HE_INHERITS_EQUALS_USE_HASHCODE
子类继承了父类的equals方法却使用了Object的hashCode方法
IC_SUPERCLASS_USES_SUBCLASS_DURING_INITIALIZATION
子类在父类未初始化以前使用父类对象实例
public class CircularClassInitialization {
static class InnerClassSingleton extends CircularClassInitialization {
static InnerClassSingleton singleton = new InnerClassSingleton();
}
static CircularClassInitialization foo = InnerClassSingleton.singleton;
}
IMSE_DONT_CATCH_IMSE
捕捉违法的监控状态异常，例如当没有获取到对象锁时使用其wait和notify方法
ISC_INSTANTIATE_STATIC_CLASS
为使用静态方法而建立一个实例对象。调用静态方法时只须要使用类名+静态方法名就能够了。
IT_NO_SUCH_ELEMENT
迭代器的next方法不可以抛出NoSuchElementException
J2EE_STORE_OF_NON_SERIALIZABLE_OBJECT_INTO_SESSION
在HttpSession对象中保存非连续的对象
JCIP_FIELD_ISNT_FINAL_IN_IMMUTABLE_CLASS
The class is annotated with net.jcip.annotations.Immutable, and the rules for that annotation require that all fields are final. .
该类使用net.jcip.annotations进行注释。不可变的，该注释的规则要求全部字段都是final
NP_BOOLEAN_RETURN_NULL
返回值为boolean类型的方法直接返回null，这样会致使空指针异常
NP_EQUALS_SHOULD_HANDLE_NULL_ARGUMENT
变量调用equals方法时没有进行是否为null的判断
NP_TOSTRING_COULD_RETURN_NULL
toString方法可能返回null
NM_CLASS_NAMING_CONVENTION
类的名称以大写字母名称开头
NM_CLASS_NOT_EXCEPTION
类的名称中含有Exception可是却不是一个异常类的子类，这种名称会形成混淆
NM_CONFUSING
使人迷惑的方面命名
NM_FIELD_NAMING_CONVENTION
非final类型的字段须要遵循驼峰命名原则
NM_FUTURE_KEYWORD_USED_AS_IDENTIFIER
验证是不是java预留关键字
NM_FUTURE_KEYWORD_USED_AS_MEMBER_IDENTIFIER
验证是否时java中的关键字
NM_METHOD_NAMING_CONVENTION
方法名称以小写字母开头
NM_SAME_SIMPLE_NAME_AS_INTERFACE
实现同一接口实现类不能使用相同的名称，即便它们位于不一样的包中
NM_SAME_SIMPLE_NAME_AS_SUPERCLASS
继承同一父类的子类不能使用相同的名称，即便它们位于不一样的包中
NM_VERY_CONFUSING_INTENTIONAL
很容易混淆的方法命名，例如方法的名称名称使用使用大小写来区别两个不一样的方法。
NM_WRONG_PACKAGE_INTENTIONAL
因为错误引用了不一样包中相同类名的对象而不可以正确的覆写父类中的方法
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; }
}
ODR_OPEN_DATABASE_RESOURCE
方法中可能存在关闭数据链接失败的状况
OS_OPEN_STREAM
方法中可能存在关闭流失败的状况
OS_OPEN_STREAM_EXCEPTION_PATH
方法中可能存在关闭流时出现异常状况
RC_REF_COMPARISON_BAD_PRACTICE
当二者为不一样类型的对象时使用equals方法来比较它们的值是否相等，而不是使用==方法。例如比较的二者为java.lang.Integer, java.lang.Float
RC_REF_COMPARISON_BAD_PRACTICE_BOOLEAN
使用== 或者 !=操做符来比较两个 Boolean类型的对象，建议使用equals方法。
RR_NOT_CHECKED
InputStream.read方法忽略返回的多个字符，若是对结果没有检查就无法正确处理用户读取少许字符请求的状况。
SR_NOT_CHECKED
InputStream.skip()方法忽略返回的多个字符，若是对结果没有检查就无法正确处理用户跳过少许字符请求的状况
RV_RETURN_VALUE_IGNORED_BAD_PRACTICE
方法忽略返回值的异常信息
SI_INSTANCE_BEFORE_FINALS_ASSIGNED
在全部的static final字段赋值以前去使用静态初始化的方法建立一个类的实例。
SE_BAD_FIELD_STORE
非序列化的值保存在声明为序列化的的非序列化字段中
SE_COMPARATOR_SHOULD_BE_SERIALIZABLE
Comparator接口没有实现Serializable接口
SE_INNER_CLASS
序列化内部类
SE_NONFINAL_SERIALVERSIONID
关于UID类的检查内容省略
SE_NO_SUITABLE_CONSTRUCTOR
子类序列化时父类没有提供一个void的构造函数
SE_NO_SUITABLE_CONSTRUCTOR_FOR_EXTERNALIZATION
Externalizable 实例类没有定义一个void类型的构造函数
SE_READ_RESOLVE_MUST_RETURN_OBJECT
readResolve从流中读取类的一个实例，此方法必须声明返回一个Object类型的对象
SE_TRANSIENT_FIELD_NOT_RESTORED
This class contains a field that is updated at multiple places in the class, thus it seems to be part of the state of the class. However, since the field is marked as transient and not set in readObject or readResolve, it will contain the default value in any deserialized instance of the class.
该类包含一个在类中的多个位置更新的字段，所以它彷佛是类状态的一部分。可是，因为字段被标记为transient，而且没有在readObject或readResolve中设置，因此它将在类的任何反序列化实例中包含默认值。
SE_NO_SERIALVERSIONID
一个类实现了Serializable接口可是没有定义serialVersionUID类型的变量。序列化运行时使用一个称为 serialVersionUID 的版本号与每一个可序列化类相关联，该序列号在反序列化过程当中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。若是接收者加载的该对象的类的 serialVersionUID 与对应的发送者的类的版本号不一样，则反序列化将会致使 InvalidClassException。可序列化类能够经过声明名为 "serialVersionUID" 的字段（该字段必须是静态 (static)、最终 (final) 的 long 型字段）显式声明其本身的 serialVersionUID：
ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L;
UI_INHERITANCE_UNSAFE_GETRESOURCE
当一个类被子类继承后不要使用this.getClass().getResource(...)来获取资源
4、Correctness关于代码正确性相关方面的
BC_IMPOSSIBLE_CAST
不可能的类转换，执行时会抛出ClassCastException
BC_IMPOSSIBLE_DOWNCAST
父类在向下进行类型转换时抛出ClassCastException
BC_IMPOSSIBLE_DOWNCAST_OF_TOARRAY
集合转换为数组元素时发生的类转换错误。
This code is casting the result of calling toArray() on a collection to a type more specific than Object[], as in:
String[] getAsArray(Collection<String> c) {
return (String[]) c.toArray();
}
This will usually fail by throwing a ClassCastException. The toArray() of almost all collections return an Object[]. They can't really do anything else, since the Collection object has no reference to the declared generic type of the collection.
The correct way to do get an array of a specific type from a collection is to use c.toArray(new String[]); or c.toArray(new String[c.size()]); (the latter is slightly more efficient).
BC_IMPOSSIBLE_INSTANCEOF
采用instaneof方法进行比较时老是返回false。前提是保证它不是因为某些逻辑错误形成的。
BIT_AND
错误的使用&位操做符，例如(e & C)
BIT_AND_ZZ
检查恒等的逻辑错误
BIT_IOR
错误的使用|位操做符，例如(e | C)
BIT_SIGNED_CHECK_HIGH_BIT
检查逻辑运算符操做返回的标识。例如((event.detail & SWT.SELECTED) > 0)，建议采用!=0代替>0
BOA_BADLY_OVERRIDDEN_ADAPTER
子类错误的覆写父类中用于适配监听其余事件的方法，从而致使当触发条件发生时不能被监听者调用
BX_UNBOXED_AND_COERCED_FOR_TERNARY_OPERATOR
在三元运算符操做时若是没有对值进行封装或者类型转换。例如：b ? e1 : e2
DLS_DEAD_STORE_OF_CLASS_LITERAL
以类的字面名称方式为一个字段赋值后再也没有去使用它，在1.4jdk中它会自动调用静态的初始化方法，而在jdk1.5中却不会去执行。
DLS_OVERWRITTEN_INCREMENT
覆写增量增长错误i = i++
DMI_BAD_MONTH
hashNext方法调用next方法。
DMI_COLLECTIONS_SHOULD_NOT_CONTAIN_THEMSELVES
集合没有包含他们本身自己。
DMI_INVOKING_HASHCODE_ON_ARRAY
数组直接使用hashCode方法来返回哈希码。
int [] a1 = new int[]{1,2,3,4}; System.out.println(a1.hashCode()); System.out.println(java.util.Arrays.hashCode(a1));
DMI_LONG_BITS_TO_DOUBLE_INVOKED_ON_INT
Double.longBitsToDouble invoked on an int
在int上调用了Double.longBitsToDouble
DMI_VACUOUS_SELF_COLLECTION_CALL
集合的调用不能被感知。例如c.containsAll(c)老是返回true，而c.retainAll(c)的返回值不能被感知。
DMI_ANNOTATION_IS_NOT_VISIBLE_TO_REFLECTION
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). .
除非注释自己使用@Retention(RetentionPolicy.RUNTIME)进行了注释，不然不能使用反射(例如，使用isAnnotationPresent方法)观察注释。
DMI_VACUOUS_CALL_TO_EASYMOCK_METHOD
While ScheduledThreadPoolExecutor inherits from ThreadPoolExecutor, a few of the inherited tuning methods are not useful for it. In particular, because it acts as a fixed-sized pool using corePoolSize threads and an unbounded queue, adjustments to maximumPoolSize have no useful effect.
虽然ScheduledThreadPoolExecutor继承自ThreadPoolExecutor，可是一些继承的调优方法对它并不有用。特别是，因为它使用corePoolSize线程和无界队列充当固定大小的池，因此对maximumPoolSize的调整没有任何有用的效果。
EC_ARRAY_AND_NONARRAY
数组对象使用equals方法和非数组对象进行比较。即便比较的双方都是数组对象也不该该使用equals方法，而应该比较它们的内容是否相等使用java.util.Arrays.equals(Object[], Object[]);
EC_INCOMPATIBLE_ARRAY_COMPARE
使用equls方法去比较类型不相同的数组。例如：String[] and StringBuffer[], or String[] and int[]
EC_NULL_ARG
调用equals的对象为null
EC_UNRELATED_CLASS_AND_INTERFACE
使用equals方法比较不相关的类和接口
EC_UNRELATED_INTERFACES
调用equals方法比较不一样类型的接口
EC_UNRELATED_TYPES
调用equals方法比较不一样类型的类
EC_UNRELATED_TYPES_USING_POINTER_EQUALITY
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.
该方法使用指针相等来比较两个彷佛属于不一样类型的引用。这个比较的结果在运行时老是错误的。
EQ_ALWAYS_FALSE
使用equals方法返回值老是false
EQ_ALWAYS_TRUE
equals方法返回值老是true
EQ_COMPARING_CLASS_NAMES
使用equals方法去比较一个类的实例和类的类型
EQ_DONT_DEFINE_EQUALS_FOR_ENUM
This class defines an enumeration, and equality on enumerations are defined using object identity. Defining a covariant equals method for an enumeration value is exceptionally bad practice, since it would likely result in having two different enumeration values that compare as equals using the covariant enum method, and as not equal when compared normally. Don't do it.
该类定义枚举，而且使用对象标识定义枚举上的等式。为枚举值定义一个协变等于方法是一个很是糟糕的实践，由于它可能会致使使用协变枚举方法将两个不一样的枚举值做为等于进行比较，而在正常状况下比较时做为不相等。不要这样作。
EQ_OTHER_NO_OBJECT
类中定义的equals方法时不要覆写equals（Object）方法
EQ_OTHER_USE_OBJECT
类中定义的equals方法时不要覆写Object中的equals（Object）方法
EQ_OVERRIDING_EQUALS_NOT_SYMMETRIC
name=错误用法 - equals方法覆盖了父类的equals可能功能不符
EQ_SELF_USE_OBJECT
类中定义了一组equals方法，可是都是继承的java.lang.Object class中的equals(Object)方法
FE_TEST_IF_EQUAL_TO_NOT_A_NUMBER
This code checks to see if a floating point value is equal to the special Not A Number value (e.g., if (x == Double.NaN)). However, because of the special semantics of NaN, no value is equal to Nan, including NaN. Thus, x == Double.NaN always evaluates to false. To check to see if a value contained in x is the special Not A Number value, use Double.isNaN(x) (or Float.isNaN(x) if x is floating point precision).
name=错误用法 - 测试是否与NaN相等
VA_FORMAT_STRING_BAD_ARGUMENT
错误使用参数类型来格式化字符串
VA_FORMAT_STRING_BAD_CONVERSION
指定的格式字符串和参数类型不匹配，例如：String.format("%d", "1")
VA_FORMAT_STRING_EXPECTED_MESSAGE_FORMAT_SUPPLIED
但用String的format方法时实际调用了ＭｅｓｓａｇｅＦｏｒｍａｔ中干的格式化方法而引发格式化结果出错。
VA_FORMAT_STRING_EXTRA_ARGUMENTS_PASSED
使用String的format方法时有非法的参数也通过了格式化操做。
VA_FORMAT_STRING_ILLEGAL
格式化String对象语句错误
VA_FORMAT_STRING_MISSING_ARGUMENT
String的format操做缺乏必要的参数。
VA_FORMAT_STRING_NO_PREVIOUS_ARGUMENT
格式字符串定义错误，例如：formatter.format("%<s %s", "a", "b"); 抛出MissingFormatArgumentException异常
GC_UNRELATED_TYPES
This call to a generic collection method contains an argument with an incompatible class from that of the collection's parameter (i.e., the type of the argument is neither a supertype nor a subtype of the corresponding generic type argument). Therefore, it is unlikely that the collection contains any objects that are equal to the method argument used here. Most likely, the wrong value is being passed to the method.
In general, instances of two unrelated classes are not equal. For example, if the Foo and Bar classes are not related by subtyping, then an instance of Foo should not be equal to an instance of Bar. Among other issues, doing so will likely result in an equals method that is not symmetrical. For example, if you define the Foo class so that a Foo can be equal to a String, your equals method isn't symmetrical since a String can only be equal to a String.
In rare cases, people do define nonsymmetrical equals methods and still manage to make their code work. Although none of the APIs document or guarantee it, it is typically the case that if you check if a Collection<String> contains a Foo, the equals method of argument (e.g., the equals method of the Foo class) used to perform the equality checks.
这个对泛型集合方法的调用包含一个与集合的参数(即，参数的类型既不是相应泛型类型参数的超类型，也不是相应泛型类型参数的子类型)。所以，集合不太可能包含与这里使用的方法参数相同的任何对象。极可能，传递给方法的值是错误的。
HE_SIGNATURE_DECLARES_HASHING_OF_UNHASHABLE_CLASS
A method, field or class declares a generic signature where a non-hashable class is used in context where a hashable class is required. A class that declares an equals method but inherits a hashCode() method from Object is unhashable, since it doesn't fulfill the requirement that equal objects have equal hashCodes.
方法、字段或类声明一个泛型签名，其中在须要可耐洗类的上下文中使用不可耐洗类。声明equals方法但从对象继承hashCode()方法的类是不可挂起的，由于它不知足equal对象具备相等hashCode的要求。
HE_USE_OF_UNHASHABLE_CLASS
A class defines an equals(Object) method but not a hashCode() method, and thus doesn't fulfill the requirement that equal objects have equal hashCodes. An instance of this class is used in a hash data structure, making the need to fix this problem of highest importance.
类定义了equals(Object)方法，但没有定义hashCode()方法，所以不能知足equal对象具备相等hashCode的要求。该类的一个实例用于哈希数据结构中，这使得修复这个问题变得极为重要。
ICAST_INT_CAST_TO_DOUBLE_PASSED_TO_CEIL
integral的值转换为double后使用了Math.ceil方法
ICAST_INT_CAST_TO_FLOAT_PASSED_TO_ROUND
int 类型的值转换为float类型以后调用了Math.round方法
IJU_ASSERT_METHOD_INVOKED_FROM_RUN_METHOD
在JUnit中的断言在run方法中不会被告知
IJU_BAD_SUITE_METHOD
在一个JUnit类中声明的一个suite()方法必须声明为
public static junit.framework.Test suite()
或者
public static junit.framework.TestSuite suite()的形式。
IL_CONTAINER_ADDED_TO_ITSELF
集合自己做为add方法的参数，这样会引发内容溢出。
IL_INFINITE_LOOP
方法的自调用引发的死循环
IM_MULTIPLYING_RESULT_OF_IREM
和整数余数进行乘法运算。例如：i % 60 * 1000 是进行(i % 60) * 1000运算而不是 i % (60 * 1000)
INT_BAD_COMPARISON_WITH_NONNEGATIVE_VALUE
保证非负数和负数进行比较
INT_BAD_COMPARISON_WITH_SIGNED_BYTE
比较有符合数，要先把有符号数转换为无符合数再进行比较
IO_APPENDING_TO_OBJECT_OUTPUT_STREAM
宣布试图在对象的输出流处添加元素，若是你但愿可以添加进一个对象的输出流中必须保证对象的输出流处于打开状态。
IP_PARAMETER_IS_DEAD_BUT_OVERWRITTEN
The initial value of this parameter is ignored, and the parameter is overwritten here. This often indicates a mistaken belief that the write to the parameter will be conveyed back to the caller.
传入参数的值被忽略，可是对传入值进行了修改，并返回给了调用者
MF_CLASS_MASKS_FIELD
子类中定义了和父类中同名的字段。在调用时会出错
MF_METHOD_MASKS_FIELD
在方法中定义的局部变量和类变量或者父类变量同名，从而引发字段混淆。
NP_ALWAYS_NULL
对象赋为null值后 没有被从新赋值
NP_ALWAYS_NULL_EXCEPTION
A pointer which is null on an exception path is dereferenced here. This will lead to a NullPointerException when the code is executed. Note that because FindBugs currently does not prune infeasible exception paths, this may be a false warning.
Also note that FindBugs considers the default case of a switch statement to be an exception path, since the default case is often infeasible.
空指针引用上调用去除引用方法，将发生空指针异常
NP_ARGUMENT_MIGHT_BE_NULL
方法没有判断参数是否为空
NP_CLOSING_NULL
一个为空的对象调用close方法
NP_GUARANTEED_DEREF
There is a statement or branch 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).
在正常的null判断分支上，对象去除引用操做是受保护的不容许的
NP_GUARANTEED_DEREF_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).
异常路径上有一个语句或分支，若是执行该语句或分支，则该语句或分支将确保此时值为空，而且该值将被取消引用(涉及运行时异常的正向路径除外)。
NP_NONNULL_PARAM_VIOLATION
方法中为null的参数没有被从新赋值 void test(){
String ss = null;
sya(ss); } public void sya(String ad){
ad.getBytes(); }
NP_NONNULL_RETURN_VIOLATION
方法声明了返回值不能为空，可是方法中有可能返回null
NP_NULL_INSTANCEOF
检查一个为null的值是不是想要的类型对象，而不是因为粗心或者逻辑错误引发的
NP_NULL_ON_SOME_PATH
对象可能没有从新赋值
NP_NULL_ON_SOME_PATH_EXCEPTION
A reference value which is null on some exception control path is dereferenced here. This may lead to a NullPointerException when the code is executed. Note that because FindBugs currently does not prune infeasible exception paths, this may be a false warning.
Also note that FindBugs considers the default case of a switch statement to be an exception path, since the default case is often infeasible.
在异常null值处理分支调用的方法上，可能存在对象去除引用操做
NP_NULL_PARAM_DEREF_ALL_TARGETS_DANGEROUS
方法参数中声明为nonnull类型的参数为null
void test(){
String ss = null;
sya(ss); } public void sya(@nonnull String ad){
ad.getBytes(); }
NP_STORE_INTO_NONNULL_FIELD
为一个已经声明为不能为null值的属性赋值为null。
NM_BAD_EQUAL
类中定义了一个equal方法可是却不是覆写的Object对象的equals方法
NM_LCASE_HASHCODE
类中定义了一个hashCode方法可是却不是覆写的Object中的hashCode方法
NM_LCASE_TOSTRING
类中定义了一个toString方法可是却不是覆写的Object中的toString方法
NM_METHOD_CONSTRUCTOR_CONFUSION
构造方法定义混乱，保证一个标准的构造函数。 例如： SA(){ } void SA(){ }
NM_VERY_CONFUSING
混乱的方法命名，如getName和getname方法同时出现的时候
NM_WRONG_PACKAGE
方法由于取了不一样包中的同名的对象而没有正确覆写父类中的同名方法
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; }
}
QBA_QUESTIONABLE_BOOLEAN_ASSIGNMENT
再if或者while表达式中使用boolean类型的值时应该使用==去判断，而不是采用=操做
RC_REF_COMPARISON
比较两个对象值是否相等时应该采用equals方法，而不是==方法
RE_BAD_SYNTAX_FOR_REGULAR_EXPRESSION
对正则表达式使用了错误的语法，会抛出未经检查的异常，代表正则表达式模式中的语法错误。
RE_CANT_USE_FILE_SEPARATOR_AS_REGULAR_EXPRESSION
使用正则表达式使用了错误的文件分隔符，在windows系统中正则表达式不会匹配’\’而应该使用'\\'
RV_01_TO_INT
从0到1随机值被强制为整数值0。在强制获得一个整数以前，你可能想获得多个随机值。或使用Random.nextInt（n）的方法。
RV_ABSOLUTE_VALUE_OF_HASHCODE
此代码生成一个哈希码，而后计算该哈希码的绝对值。若是哈希码是Integer.MIN_VALUE的，那么结果将是负数（由于Math.abs（Integer.MIN_VALUE的）== Integer.MIN_VALUE的）。
在2^ 32值以外字符串有一个Integer.MIN_VALUE的hashCode包括“polygenelubricants”，“GydZG_”和“，”DESIGNING WORKHOUSES “。
RV_ABSOLUTE_VALUE_OF_RANDOM_INT
此代码生成一个随机的符号整数，而后计算该随机整数的绝对值。若是随机数生成数绝对值为Integer.MIN_VALUE的，那么结果将是负数（由于Math.abs（Integer.MIN_VALUE的）== Integer.MIN_VALUE的）。
RV_EXCEPTION_NOT_THROWN
此代码建立一个异常（或错误）的对象，但不会用它作任何事情。例如：if (x < 0)
new IllegalArgumentException("x must be nonnegative");
这多是程序员的意图抛出建立的异常：
if (x < 0)
throw new IllegalArgumentException("x must be nonnegative");
86.RV: Method ignores return value (RV_RETURN_VALUE_IGNORED)
该方法的返回值应该进行检查。这种警告一般出如今调用一个不可变对象的方法，认为它更新了对象的值。例如：String dateString = getHeaderField(name);
dateString.trim();
程序员彷佛觉得trim（）方法将更新dateString引用的字符串。但因为字符串是不可改变的，trim（）函数返回一个新字符串值，在这里它是被忽略了。该代码应更正：
String dateString = getHeaderField(name);
dateString = dateString.trim();
RpC_REPEATED_CONDITIONAL_TEST
该代码包含对同一个条件试验了两次，两边彻底同样例如：（如X == 0 | | x == 0）。可能第二次出现是打算判断别的不一样条件（如X == 0 | | y== 0）。
SA_FIELD_DOUBLE_ASSIGNMENT
方法中的字段包含了双重任务，例如：
int x;
public void foo() {
x = x = 17;
}
这种为变量赋值是无用的，并可能代表一个逻辑错误或拼写错误。
SA_FIELD_SELF_ASSIGNMENT
方法中包含本身对本身赋值的字段。例如：
int x;
public void foo() {
x = x;
}
SA_FIELD_SELF_COMPARISON
字段本身进行自比较可能代表错误或逻辑错误。
SA_LOCAL_SELF_COMPARISON
方法中对一个局部变量自身进行比较运算，并可说明错误或逻辑错误。请确保您是比较正确的事情。
SA_LOCAL_SELF_COMPUTATION
此方法对同一变量执行了荒谬的计算（如x&x或x-x）操做。因为计算的性质，这一行动彷佛没有意义，并可能代表错误或逻辑错误。
SF_DEAD_STORE_DUE_TO_SWITCH_FALLTHROUGH
在swtich中先前的case值由于swtich执行失败而被覆写，这就像是忘记使用break推出或者没有使用return语句放回先前的值同样。
SF_DEAD_STORE_DUE_TO_SWITCH_FALLTHROUGH_TO_THROW
在swtich中由于出现异常而忽略了对case值的保存。
SIC_THREADLOCAL_DEADLY_EMBRACE
若是是一个静态内部类。实际上，在内部类和当前线程有死锁的可能。因为内部类不是静态的，它保留了对外部类的引用。若是线程包含对一个内部类实例的引用，那么内外实例的实例均可以被获取，这样就不具有垃圾会回收的资格。
SIO_SUPERFLUOUS_INSTANCEOF
在进行instanceof操做时进行没有必要的类型检查
STI_INTERRUPTED_ON_CURRENTTHREAD
此方法调用Thread.currentThread（）调用，只需调用interrupted（）方法。因为interrupted（）是一个静态方法， Thread.interrupted（）更简单易用。
STI_INTERRUPTED_ON_UNKNOWNTHREAD
调用不是当前线程对象的Thread.interrupted()方法，因为interrupted（）方法是静态的，interrupted方法将会调用一个和做者原计划不一样的对象。
SE_METHOD_MUST_BE_PRIVATE
这个类实现了Serializable接口，并定义自定义序列化的方法/反序列化。但因为这种方法不能声明为private，将被序列化/反序列化的API忽略掉。
SE_READ_RESOLVE_IS_STATIC
为使readResolve方法获得序列化机制的识别，不能做为一个静态方法来声明。
UMAC_UNCALLABLE_METHOD_OF_ANONYMOUS_CLASS
在匿名类中定义了一个既没有覆写超类中方法也不能直接调用的方法。由于在其余类的方法不能直接引用匿名类声明的方法，彷佛这种方法不能被调用，这种方法可能只是没有任何做用的代码，但也可能覆写超类中声明。
UR_UNINIT_READ
此构造方法中使用了一个还没有赋值的字段或属性。 String a; public SA() {
String abc = a;
System.out.println(abc); }
UR_UNINIT_READ_CALLED_FROM_SUPER_CONSTRUCTOR
方法被超类的构造函数调用时，在当前类中的字段或属性尚未被初始化。例如：
abstract class A {
int hashCode;
abstract Object getValue();
A() {
hashCode = getValue().hashCode();
}
}
class B extends A {
Object value;
B(Object v) {
this.value = v;
}
Object getValue() {
return value;
}
}
当B是建立时，A的构造函数将在B为value赋值以前触发，然而在A的初始化方法调用getValue方法时value这个变量尚未被初始化。
DMI_INVOKING_TOSTRING_ON_ANONYMOUS_ARRAY
该代码调用上匿名数组的toString（）方法，产生的结果形如[@ 16f0472并无实际的意义。考虑使用Arrays.toString方法来转换成可读的字符串，提供该数组的内容数组。例如：
String[] a = { "a" };
System.out.println(a.toString());
//正确的使用为
System.out.println(Arrays.toString(a));
DMI_INVOKING_TOSTRING_ON_ARRAY
该代码调用上数组的toString（）方法，产生的结果形如[@ 16f0472并不能显示数组的真实内容。考虑使用Arrays.toString方法来转换成可读的字符串，提供该数组的内容数组
UWF_NULL_FIELD
字段的值老是为null值，全部读取该字段的值都为null。检查错误，若是它确实没有用就删除掉。
107.UwF: Unwritten field (UWF_UNWRITTEN_FIELD)
此字段是永远不会写入值。全部读取将返回默认值。检查错误（若是它被初始化？），若是它确实没有用就删除掉。
五：Performance关于代码性能相关方面的
BX_UNBOXING_IMMEDIATELY_REBOXED
装箱的值被取消装箱，而后当即从新装箱
BX_BOXING_IMMEDIATELY_UNBOXED
对原始值进行装箱，而后当即取消装箱。这多是在一个未要求装箱的地方进行了手动装箱，从而迫使编译器进行当即撤消装箱的操做
BX_BOXING_IMMEDIATELY_UNBOXED_TO_PERFORM_COERCION
对原始值进行装箱而后当即把它强制转换为另一种原始类型。例如：
new Double(d).intValue()应该直接进行强制转换例如：(int) d
DM_BOXED_PRIMITIVE_TOSTRING
仅仅为了调用封装类的toString()而对原始类型进行封装操做。比这种方法更有效的是调用封装类的toString(…)方法例如：
new Integer(1).toString() 替换为 Integer.toString(1)
new Long(1).toString() 替换为 Long.toString(1)
new Float(1.0).toString() 替换为 Float.toString(1.0)
new Double(1.0).toString() 替换为 Double.toString(1.0)
new Byte(1).toString() 替换为 Byte.toString(1)
new Short(1).toString() 替换为 Short.toString(1)
new Boolean(true).toString() 替换为 Boolean.toString(true)
DM_FP_NUMBER_CTOR
使用new Double(double)方法老是会建立一个新的对象，然而使用Double.valueOf(double)方法能够把值保存在编辑器或者class library、JVM中。使用存储值的方式来避免对象的分配能够或得更好的代码性能
除非类必须符合Java 1.5之前的JVM，不然请使用自动装箱或valueOf（）方法建立Double和Float实例。
DM_NUMBER_CTOR
使用new Integer(int)方法老是会建立一个新的对象，然而使用Integer.valueOf(int)方法能够把值保存在编辑器或者class library、JVM中。使用存储值的方式来避免对象的分配能够或得更好的代码性能
除非类必须符合Java 1.5之前的JVM，不然请使用自动装箱或valueOf（）方法建立Long, Integer, Short, Character, Byte实例。
DMI_BLOCKING_METHODS_ON_URL
使用equals和hashCode方法来对url进行资源标识符解析时会引发堵塞。考虑使用java.net.URI来代替。
DMI_COLLECTION_OF_URLS
方法或者字段使用url的map/set集合。由于equals方法或者hashCode方法来进行资源标识符解析时都会引发堵塞。考虑使用java.net.URI来代替。
DM_BOOLEAN_CTOR
使用new方法建立一个java.lang.Boolean类型可以的实例对象是浪费空间的，由于Boolean对象是不可变的并且只有两个有用的值。使用Boolean.valueOf()或者Java1.5中的自动装箱功能来建立一个Boolean实例。
DM_GC
在代码中显式的调用垃圾回收命名，这样作并不能起做用。在过去，有人在关闭操做或者finalize方法中调用垃圾回收方法致使了不少的性能浪费。这样大规模回收对象时会形成处理器运行缓慢。
DM_NEXTINT_VIA_NEXTDOUBLE
若是r是一个java.util.Random对象，你可使r.nextInt(n)生成一个0到n-1以前的随机数，而不是使用(int)(r.nextDouble() * n)
DM_STRING_CTOR
使用java.lang.String(String)构造函数会浪费内存由于这种构造方式和String做为参数在功能上容易混乱。只是使用String直接做为参数的形式
DM_STRING_TOSTRING
调用String.toString()是多余的操做，只要使用String就能够了。
DM_STRING_VOID_CTOR
使用没有参数的构造方法去建立新的String对象是浪费内存空间的，由于这样建立会和空字符串“”混淆。Java中保证完成相同的构造方法会产生描绘相同的String对象。因此你只要使用空字符串来建立就能够了。
ITA_INEFFICIENT_TO_ARRAY
当使用集合的toArray()方法时使用数组长度为0的数组做为参数。比这更有效的一种方法是
myCollection.toArray(new Foo[myCollection.size()])，若是数组的长度足够大就能够直接把集合中的内容包装到数组中直接返回从而避免了第二次建立一个新的数组来存放集合中值。
LO_APPENDED_STRING_IN_FORMAT_STRING
此方法使用SLF4J记录器记录一个字符串，其中第一个（格式）字符串是使用串联建立的。您应该使用{}标记将动态内容注入到字符串中，以便延迟String的构建，直到须要实际的日志字符串为止。若是日志级别足够高，以至不使用此日志语句，则将永远不会执行附加操做。
NAB_NEEDLESS_BOXING_VALUEOF
此方法将String传递给包装的原始对象的parse方法，该方法又调用valueOf（）方法以转换为装箱的原始对象。当须要从String转换为装箱的原始对象时，使用BoxedPrimitive.valueOf（String）方法更简单。
而不是这样的：
Boolean bo = Boolean.valueOf(Boolean.parseBoolean("true"));
Float f = Float.valueOf(Float.parseFloat("1.234"));
只需作：
Boolean bo = Boolean.valueOf("true");
Float f = Float.valueOf("1.234");
NAB_NEEDLESS_BOXING_PARSE
该方法将String传递给包装的原始对象的valueOf方法，该方法进而调用boxedValue（）方法以转换为原始对象。当须要从String转换为原始值时，使用BoxedPrimitive.parseBoxedPrimitive（String）方法更简单。
而不是这样的：
public int someMethod(String data) {
long l = Long.valueOf(data).longValue();
float f = Float.valueOf(data).floatValue();
return Integer.valueOf(data); // There is an implicit .intValue() call
}
只需作：
public int someMethod(String data) {
long l = Long.parseLong(data);
float f = Float.parseFloat(data);
return Integer.parseInt(data);
}
NAB_NEEDLESS_BOOLEAN_CONSTANT_CONVERSION
此方法将一个装箱的布尔常量分配给一个原始布尔变量，或将一个装箱的布尔常量分配给一个装箱的布尔变量。对须要的变量使用正确的常数
PRMC_POSSIBLY_REDUNDANT_METHOD_CALLS
此方法在相同实例上使用相同的常量参数连续两次调用相同的方法，而无需对对象进行任何中间更改。若是此方法未对对象进行更改（看上去没有更改），则进行两次调用将很浪费。经过将结果分配给一个临时变量，而后第二次使用该变量，能够合并这些方法调用。
PSC_PRESIZE_COLLECTIONS
这个方法使用默认构造函数分配集合，即便它预先知道集合中将放置多少项(或者至少能够合理地猜想)，从而没必要要地致使集合的中间从新分配。
您可使用具备初始大小的构造函数，这样会好得多，可是因为映射和集合的加载因子，甚至这也不是一个正确的估计值。
若是您正在使用Guava，请使用它的方法来分配具备预先肯定大小的映射和集合，以得到不从新分配的最佳机会，例如:
Sets.newHashSetWithExpectedSize (int)
Maps.newHashMapWithExpectedSize (int)
若是没有，一个很好的估计值应该是expectedSize / {LOADING_FACTOR}默认值为0.75
SBSC_USE_STRINGBUFFER_CONCATENATION
在循环中构建一个String对象时从性能上讲使用StringBuffer来代替String对象
例如：
// This is bad
String s = "";
for (int i = 0; i < field.length; ++i) {
s = s + field[i];
}
// This is better
StringBuffer buf = new StringBuffer();
for (int i = 0; i < field.length; ++i) {
buf.append(field[i]);
}
String s = buf.toString();
SEO_SUBOPTIMAL_EXPRESSION_ORDER
例如，此方法在if或while语句中构建条件表达式，该表达式既包含简单的局部变量比较，又包含方法调用的比较。表达式对这些命令进行排序，以便在简单的局部变量比较以前进行方法调用。这致使方法调用在不须要的条件下执行，所以有可能致使大量代码无执行。经过对表达式进行排序，以便首先包含局部变量条件的简单条件，能够消除这种浪费。假定方法调用没有反作用。若是该方法确实有反作用，则最好将这些调用从条件中拉出并先执行，而后将值分配给局部变量。
例：
if ((calculateHaltingProbability() > 0) && shouldCalcHalting) { }
Better：
if (shouldCalcHalting && (calculateHaltingProbability() > 0) { }
SS_SHOULD_BE_STATIC
类中所包含的final属性字段在编译器中初始化为静态的值。考虑在定义时就把它定义为static类型的。
SPP_STRINGBUFFER_WITH_EMPTY_STRING
这个方法调用StringBuffer或StringBuilder构造函数，传入一个常量空字符串("")。这与调用默认构造函数相同，可是会使代码更加困难。考虑传入一个默认大小。
UCPM_USE_CHARACTER_PARAMETERIZED_METHOD
此方法将String长度为1 的常量文字做为参数传递给方法，该方法公开了一个相似的方法，该方法采用char。处理一个字符而不是一个字符串更简单方便。
而不是像这样：
String myString = ...
if (myString.indexOf("e") != -1) {
int i = myString.lastIndexOf("e");
System.out.println(myString + ":" + i); //the Java compiler will use a StringBuilder internally here [builder.append(":")]
...
return myString.replace("m","z");
}
将单字母Strings 替换为它们的char等价物，以下所示：
String myString = ...
if (myString.indexOf('e') != -1) {
int i = myString.lastIndexOf('e');
System.out.println(myString + ':' + i); //the Java compiler will use a StringBuilder internally here [builder.append(':')]
...
return myString.replace('m','z');
}
UM_UNNECESSARY_MATH
在方法中使用了java.lang.Math的静态方法代替常量来使用，使用常量速度和准确度会更好。 如下为Math中的方法产生的值。
Method Parameter
abs -any-
acos 0.0 or 1.0
asin 0.0 or 1.0
atan 0.0 or 1.0
atan2 0.0 cbrt 0.0 or 1.0
ceil -any-
cos 0.0
cosh 0.0
exp 0.0 or 1.0
expm1 0.0
floor -any-
log 0.0 or 1.0
log10 0.0 or 1.0
rint -any-
round -any-
sin 0.0
sinh 0.0
sqrt 0.0 or 1.0
tan 0.0
tanh 0.0
toDegrees 0.0 or 1.0
toRadians 0.0
UPM_UNCALLED_PRIVATE_METHOD
定义为Private类型方法从未被调用，应该被删除。
URF_UNREAD_FIELD
类中定义的属性从未被调用，建议删除。
UUF_UNUSED_FIELD
类中定义的属性从未被使用，建议删除。
WMI_WRONG_MAP_ITERATOR
当方法中接受一个Map类型的参数时，使用keySet的迭代器比使用entrySet的迭代器效率要高。
六：Internationalization关于代码国际化相关方面的
DM_CONVERT_CASE
使用平台默认的编码格式对字符串进行大小写转换，这可能致使国际字符的转换不当。使用如下方式对字符进行转换
String.toUpperCase( Locale l )
String.toLowerCase( Locale l )
七：Multithreaded correctness关于代码多线程正确性相关方面的
DL_SYNCHRONIZATION_ON_BOOLEAN
该代码同步一个封装的原始常量，例如一个Boolean类型。
private static Boolean inited = Boolean.FALSE;
...
synchronized(inited) {
if (!inited) {
init();
inited = Boolean.TRUE;
}
}
...
因为一般只存在两个布尔对象，此代码多是同步的其余无关的代码中相同的对象，这时会致使反应迟钝和可能死锁
DL_SYNCHRONIZATION_ON_BOXED_PRIMITIVE
该代码同步一个封装的原始常量，例如一个Integer类型。
private static Integer count = 0;
...
synchronized(count) {
count++;
}
...
因为Integer对象能够共享和保存，此代码多是同步的其余无关的代码中相同的对象，这时会致使反应迟钝和可能死锁
DL_SYNCHRONIZATION_ON_SHARED_CONSTANT
同步String类型的常量时，因为它被JVM中多个其余的对象所共有，这样在其余代码中会引发死锁。
DL_SYNCHRONIZATION_ON_UNSHARED_BOXED_PRIMITIVE
同步一个显然不是共有封装的原始值，例如一个Integer类型的对象。例如：
private static final Integer fileLock = new Integer(1);
...
synchronized(fileLock) {
.. do something ..
}
...
它最后被定义为如下方式来代替：private static final Object fileLock = new Object();
DM_MONITOR_WAIT_ON_CONDITION
方法中以java.util.concurrent.locks.Condition对象调用wait（）。等待一个条件发生时应该使用在Condition接口中定义的await()方法。
DM_USELESS_THREAD
这个方法没有经过run方法或者具体声明Thread类，也没有经过一个Runnable对象去定义一个线程，而这个线程出来浪费资源却什么也没有去作。
ESync_EMPTY_SYNC
该代码包含一个空的同步块：synchronized() {}
IS2_INCONSISTENT_SYNC
不合理的同步
IS_FIELD_NOT_GUARDED
域不是良好的同步访问---
此字段被标注为net.jcip.annotations.GuardedBy，但能够在某种程度上违反注释而去访问
JLM_JSR166_LOCK_MONITORENTER
实现java.util.concurrent.locks.Lock的对象调用了同步的方法。应该这样处理，对象被锁定/解锁时使用acquire（）/ release（）方法而不是使用同步的方法。
LI_LAZY_INIT_STATIC
静态域不正确的延迟初始化--
这种方法包含了一个不一样步延迟初始化的非volatile静态字段。由于编译器或处理器可能会从新排列指令，若是该方法能够被多个线程调用，线程不能保证看到一个彻底初始化的对象。你可让字段可变来解决此问题
LI_LAZY_INIT_UPDATE_STATIC
这种方法包含一个不一样步延迟初始化的静态字段。以后为字段赋值，对象存储到该位置后进一步更新或访问。字段后尽快让其余线程可以访问。若是该方法的进一步访问该字段为初始化对象提供服务，而后你有一个很是严重的多线程bug，除非别的东西阻止任何其余线程访问存储的对象，直到它彻底初始化。
即便你有信心，该方法是永远不会被多个线程调用时，在它的值尚未被充分初始化或移动，不把它设定为static字段时它可能会更好。
ML_SYNC_ON_UPDATED_FIELD
对象获取一个可变字段时进行同步。这是没有意义的，由于不一样的线程能够在不一样的对象同步。
MSF_MUTABLE_SERVLET_FIELD
一个web服务通常只能建立一个servlet或者jsp的实例（例如：treates是一个单利类），它会被多个线程调用这个实例的方法服务于多个同时的请求。所以使用易变的字段属性产生竞争的状况。
MWN_MISMATCHED_NOTIFY
此方法调用Object.notify（）或Object.notifyAll（）而没有获取到该对象的对象锁。调用notify（）或notifyAll（）而没有持有该对象的对象锁，将致使IllegalMonitorStateException异常。
MWN_MISMATCHED_WAIT
此方法调用Object.wait()而没有获取到该对象的对象锁。调用wait（）而没有持有该对象的对象锁，将致使IllegalMonitorStateException异常。
NP_SYNC_AND_NULL_CHECK_FIELD
若是代码块是同步的，那么久不可能为空。若是是空，同步时就会抛出NullPointerException异常。最好是在另外一个代码块中进行同步。
NO_NOTIFY_NOT_NOTIFYALL
调用notify（）而不是notifyAll（）方法。 Java的监控器一般用于多个条件。调用notify（）只唤醒一个线程，这意味着该线程被唤醒只是知足的当前的惟一条件。
RS_READOBJECT_SYNC
序列化类中定义了同步的readObject（）。经过定义，反序列化建立的对象只有一个线程能够访问，所以没有必要的readObject（）进行同步。若是的readObject（）方法自己形成对象对另外一个线程可见，那么这自己就是很差的编码方式。
RU_INVOKE_RUN
这种方法显式调用一个对象的run（）。通常来讲，类是实现Runnable接口的，由于在一个新的线程他们将有本身的run（）方法，在这种状况下Thread.start（）方法调用是正确的。
SC_START_IN_CTOR
在构造函数中启动一个线程。若是类曾经被子类扩展过，那么这极可能是错的，由于线程将在子类构造以前开始启动。
SP_SPIN_ON_FIELD
方法无限循环读取一个字段。编译器可合法悬挂宣读循环，变成一个无限循环的代码。这个类应该改变，因此使用适当的同步（包括等待和通知要求）
STCAL_INVOKE_ON_STATIC_CALENDAR_INSTANCE
即便JavaDoc对此不包含暗示，而Calendars自己在多线程中使用就是不安全的。探测器发现当调用Calendars的实例时将会得到一个静态对象。
Calendar rightNow = Calendar.getInstance();
STCAL_INVOKE_ON_STATIC_DATE_FORMAT_INSTANCE
在官方的JavaDoc，DateFormats多线程使用本事就是不安全的。探测器发现调用一个DateFormat的实例将会得到一个静态对象。
myString = DateFormat.getDateInstance().format(myDate);
STCAL_STATIC_CALENDAR_INSTANCE
Calendar在多线程中自己就是不安全的，若是在线程范围中共享一个Calendarde 实例而不使用一个同步的方法在应用中就会出现一些奇怪的行为。在sun.util.calendar.BaseCalendar.getCalendarDateFromFixedDate()中会抛出ArrayIndexOutOfBoundsExceptions or IndexOutOfBoundsExceptions异常。
STCAL_STATIC_SIMPLE_DATE_FORMAT_INSTANCE
DateFormat 在多线程中自己就是不安全的，若是在线程范围中共享一个DateFormat的实例而不使用一个同步的方法在应用中就会出现一些奇怪的行为。
SWL_SLEEP_WITH_LOCK_HELD
当持有对象时调用Thread.sleep（）。这可能会致使不好的性能和可扩展性，或陷入死锁，由于其余线程可能正在等待得到锁。调用wait（）是一个更好的主意，释放对象的持有以容许其余线程运行。
UG_SYNC_SET_UNSYNC_GET
这个类包含相似命名的get和set方法。在set方法是同步方法和get方法是非同步方法。这可能会致使在运行时的不正确行为，由于调用的get方法不必定返回对象一致状态。 GET方法应该同步。
UL_UNRELEASED_LOCK
方法得到了当前的对象所，可是在方法中始终没有释放它。一个正确的示例以下：
Lock l = ...;
l.lock();
try {
// do something
} finally {
l.unlock();
}
UL_UNRELEASED_LOCK_EXCEPTION_PATH
方法得到了当前的对象所，可是在全部的异常处理中始终没有释放它。一个正确的示例以下：
Lock l = ...;
l.lock();
try {
// do something
} finally {
l.unlock();
}
UW_UNCOND_WAIT)
方法中包含调用java.lang.Object.wait（），而却没有放到条件流程控制中。该代码应确认条件还没有知足以前等待;先前任何通知将被忽略。
VO_VOLATILE_REFERENCE_TO_ARRAY
声明一个变量引用数组，这可能不是你想要的。若是一个变量引用数组，那么对引用数组的读和写都是不安全的，可是数组元素不是变量。取得数组的变量值你可使用java.util.concurrent包中的数组的原子性特性
WL_USING_GETCLASS_RATHER_THAN_CLASS_LITERAL
实例的方法中同步this.getClass()，若是这个类有子类集合，那么子类集合中的对象将会在这个类的各个子类上进行同步，这不是咱们想要的效果，咱们只要同步当前的类对象而不包含它的全部子类，能够同步类名.getClass()。例如，java.awt.Label的代码：
private static final String base = "label";
private static int nameCounter = 0;
String constructComponentName() {
synchronized (getClass()) {
return base + nameCounter++;
}
}
Label中的子类集合不可能在同一个子对象上进行同步，替换上面的方法为：
private static final String base = "label";
private static int nameCounter = 0;
String constructComponentName() {
synchronized (Label.class) {
return base + nameCounter++;
}
}
WS_WRITEOBJECT_SYNC
这个类有一个writeObject（）方法是同步的，可是这个类中没有其余的同步方法。
WA_AWAIT_NOT_IN_LOOP
方法没有在循环中调用java.util.concurrent.await()。若是对象是用于多种条件，打算调用wait()方法的条件可能不是实际发生的。
WA_NOT_IN_LOOP
这种方法包含调用java.lang.Object.wait（），而这并非一个循环。若是监视器用于多个条件，打算调用wait()方法的条件可能不是实际发生的。
八：Malicious codevulnerability关于恶意破坏代码相关方面的
EI_EXPOSE_REP
返回一个易变对象引用并把它保存在对象字段中时会暴露对象内部的字段描述，若是接受不守信任的代码访问或者没有检查就去改变易变对象的会涉及对象的安全和其余重要属性的安全。返回一个对象的新副本，在不少状况下更好的办法。
EI_EXPOSE_REP2
此代码把外部可变对象引用存储到对象的内部表示。若是实例受到不信任的代码的访问和没有检查的变化危及对象和重要属性的安全。存储一个对象的副本，在不少状况下是更好的办法。
FI_PUBLIC_SHOULD_BE_PROTECTED
一个类中的finalize（）方法必须声明为protected，而不能为public类型
MS_EXPOSE_REP
一个public类型的静态方法返回一个数组，可能引用内部属性的暴露。任何代码调用此方法均可以自由修改底层数组。一个解决办法是返回一个数组的副本。
MS_FINAL_PKGPROTECT
一个静态字段可能被恶意代码或另一个包所改变的。字段能够放到protected包中也能够定义为final类型的以免此问题。
MS_MUTABLE_ARRAY
一个定义为final类型的静态字段引用一个数组时它能够被恶意代码或在另其余包中所使用。这些代码能够自由修改数组的内容。
MS_MUTABLE_HASHTABLE
一个定义为final类型的静态字段引用一个Hashtable时能够被恶意代码或者在其余包中被调用，这些方法能够修改Hashtable的值。
MS_OOI_PKGPROTECT
将域尽可能不要定义在接口中，并声明为包保护
在接口中定义了一个final类型的静态字段，如数组或哈希表等易变对象。这些对象能够被恶意代码或者在其余包中被调用，为了解决这个问题，须要把它定义到一个具体的实体类中而且声明为保护类型以免这种错误。
MS_PKGPROTECT
一个静态字段是能够改变的恶意代码或其余的包访问修改。能够把这种类型的字段声明为final类型的以防止这种错误。
九：Dodgy、style糟糕的代码
BC_BAD_CAST_TO_ABSTRACT_COLLECTION
在代码投把一个集合强制类型转换为一个抽象的集合（如list，set或map）。保证该对象类型和将要转换的类型是一致的。若是你只是想要便利一个集合，那么你就没必要将它转换为Set或List。
BC_BAD_CAST_TO_CONCRETE_COLLECTION
代码把抽象的集合（如List，Set，或Collection）强制转换为具体落实类型（如一个ArrayList或HashSet）。这可能不正确，也可能使您的代码很脆弱，由于它使得难以在从此的切换指向其余具体实现。除非你有特别理由这样作，不然只须要使用抽象的集合类。
BC_UNCONFIRMED_CAST
强制类型转换操做没有通过验证，并且不是全部的此种类型装换过的类均可以再强制类型转换为原类型。在代码中须要进行逻辑判断以保证能够进行这样的操做。
BC_VACUOUS_INSTANCEOF
instanceof测试将始终返回真（除非被测试的值为空）。虽然这是安全，确保它是否是说明一些误解或其余一些逻辑错误。若是你真的想测试是空的价值，也许会更清楚这样作的更好空试验，而不是一个instanceof测试。
CC_CYCLOMATIC_COMPLEXITY
该方法具备较高的圈复杂度，能够计算出分支点的个数。它极可能难以测试，而且很容易更改。考虑将此方法重构为多个方法以下降风险。
CFS_CONFUSING_FUNCTION_SEMANTICS
此方法将修改参数，而后将此参数做为方法的返回值返回。这将使这个方法的调用者感到困惑，由于传入参数的“原始”显然也不会更改。若是此方法的目的是更改参数，则将该方法更改成具备空返回值的a会更清楚。若是因为接口或超类契约须要返回类型，则可能应该复制该参数。
CI_CONFUSED_INHERITANCE
这个类被声明为final的，而是字段属性却声明为保护类型的。因为是final类，它不能再被继承，而再声明为保护类型的很容易形成混淆。为了从外部能正确的使用它应该把它们声明为private或者public类型。
DB_DUPLICATE_BRANCHES
此方法使用相同的代码，以实现两个有条件的分支。检查以确保这是否是一个编码错误。
DB_DUPLICATE_SWITCH_CLAUSES
他的方法使用相同的代码来实现两个switch的声明条款。这多是重复代码的状况，但可能也显示出编码的错误。
DLS_DEAD_LOCAL_STORE
该指令为局部变量赋值，但在其后的没有对她作任何使用。一般，这代表一个错误，由于值从未使用过。
DLS_DEAD_LOCAL_STORE_IN_RETURN
本声明把一个局部变量放到方法的返回语句中。这对于方法中局部变量来讲是没有意思的。
DLS_DEAD_LOCAL_STORE_OF_NULL
把一个本地变量赋值为null值，而且再也没有对这个变量作任何的操做。这样多是为了垃圾回收，而是Java SE 6.0，这已再也不须要。
DMI_HARDCODED_ABSOLUTE_FILENAME
此代码包含文件对象为一个绝对路径名（例如，新的文件（“/ home/dannyc/workspace/j2ee/src/share/com/sun/enterprise/deployment”）;
DMI_NONSERIALIZABLE_OBJECT_WRITTEN
代码中让一个非序列化的对象出如今ObjectOutput.writeObject()方法中，这样会引发一个错误。
DMI_USELESS_SUBSTRING
此代码调用了subString(0)方法，它将返回原来的值。
EXS_EXCEPTION_SOFTENING_HAS_CHECKED
此方法的异常签名受超类接口的约束，不抛出已捕获的已检查异常。所以，此异常被转换为未检查异常并引起。最好抛出最近的已检查异常，并使用初始缘由字段用原始异常注释新异常。
EQ_DOESNT_OVERRIDE_EQUALS
该类扩展了定义equals方法的类并添加字段，但自己不定义equals方法。所以，该类实例上的等式将忽略子类的标识和添加的字段。确保这是您想要的，而且您不须要覆盖equals方法。即便不须要重写equals方法，也能够考虑重写它，以记录这样一个事实:子类的equals方法只返回调用super.equals(o)的结果。
FE_FLOATING_POINT_EQUALITY
此操做比较两个浮点值是否相等。因为浮点运算可能会涉及到舍入，计算float和double值可能不许确。若是要求值必须准确，如货币值，能够考虑使用固定精度类型，如BigDecimal类型的值来比较
VA_FORMAT_STRING_BAD_CONVERSION_TO_BOOLEAN
使用%b去格式化Boolean类型的值不正确的可是它不会抛出异常，任何非空的值都会输出true，任何为空的值都会输出false
IC_INIT_CIRCULARITY
在引用两个相互调用为环状static方法去初始化一个实例时是错误的。
ICAST_IDIV_CAST_TO_DOUBLE
整形数除法强制转换为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;
ICAST_INTEGER_MULTIPLY_CAST_TO_LONG
整形数作乘法运算结果转换为long值时若是采用
long convertDaysToMilliseconds(int days) { return 1000*3600*24*days; } 结果会由于超出整形的范围而出错。
若是使用：
long convertDaysToMilliseconds(int days) { return 1000L*3600*24*days; }
或者：
static final long MILLISECONDS_PER_DAY = 24L*3600*1000; long convertDaysToMilliseconds(int days) { return days * MILLISECONDS_PER_DAY; }
均可以免此问题。
ICAST_QUESTIONABLE_UNSIGNED_RIGHT_SHIFT
无符号数右移后进行转换为short或者byte类型时可能会丢弃掉高位的值，这样的结果就是有符合数和无符号数没法区分（这取决于移位大小）
IM_AVERAGE_COMPUTATION_COULD_OVERFLOW
代码中使用x % 2 == 1的方法去验证运算是否存在余数的状况，可是若是出现负数的状况就不起做用了。使用x & 1 == 1, or x % 2 != 0来代替
IMC_IMMATURE_CLASS_PRINTSTACKTRACE
此方法将堆栈跟踪打印到控制台。这是不可配置的，并致使应用程序看起来不专业。切换到使用日志记录器，以便用户可以控制日志记录的内容和位置。
INT_VACUOUS_COMPARISON
整形数进行比较结果老是不变。例如：x <= Integer.MAX_VALUE
MOM_MISLEADING_OVERLOAD_MODEL
该类用实例和静态版本“重载”相同的方法。因为这两种模型的使用是不一样的，这将使这些方法的用户感到困惑。
MTIA_SUSPECT_SERVLET_INSTANCE_FIELD
这个类扩展从Servlet类，并使用实例的成员变量。因为只有一个Servlet类的实例，并在多线程方式使用，这种模式有可能存在问题。考虑只使用方法的局部变量。
MTIA_SUSPECT_STRUTS_INSTANCE_FIELD
类扩展自Struts的Action类并使用这个实例的成员变量，由于在Struts框架中只存在一个Action实例对象而且使用在多线程的状况下极可能会出现问题。
NP_DEREFERENCE_OF_READLINE_VALUE
对readLine()的结果值没有进行判空操做就去从新赋值，这样的操做能够会抛出空指针异常。
NP_IMMEDIATE_DEREFERENCE_OF_READLINE
对readLine()的结果当即赋值，这样的操做能够会抛出空指针异常。
NP_NULL_ON_SOME_PATH_FROM_RETURN_VALUE
方法的返回值没有进行是否为空的检查就从新赋值，这样可能会出现空指针异常。
NP_PARAMETER_MUST_BE_NONNULL_BUT_MARKED_AS_NULLABLE
参数值在任何状况下都不能为空，可是有明确的注释它能够为空。
NS_DANGEROUS_NON_SHORT_CIRCUIT
代码中使用（& or |）代替（&& or ||）操做，这会形成潜在的危险。
NS_NON_SHORT_CIRCUIT
代码中使用（& or |）代替（&& or ||）操做，会引发不安全的操做
PZLA_PREFER_ZERO_LENGTH_ARRAYS
考虑返回一个零长度的数组，而不是null值
QF_QUESTIONABLE_FOR_LOOP
肯定这个循环是正确的变量递增，看起来，另外一个变量被初始化，检查的循环。这是因为for循环中太复杂的定义形成的。
RCN_REDUNDANT_COMPARISON_OF_NULL_AND_NONNULL_VALUE
方法中包含一个不能为空的赋值还包含一个能够为空的赋值。冗余比较非空值为空。
RCN_REDUNDANT_COMPARISON_TWO_NULL_VALUES
方法中对两个null值进行比较
RCN_REDUNDANT_NULLCHECK_OF_NONNULL_VALUE
方法中对不为空的值进行为空的判断。
REC_CATCH_EXCEPTION
在try/catch块中捕获异常，可是异常没有在try语句中抛出而RuntimeException又没有明确的被捕获
RI_REDUNDANT_INTERFACES
子类和父类都实现了同一个接口，这种定义是多余的。
RV_DONT_JUST_NULL_CHECK_READLINE
readLine方法的结果不为空时被抛弃
RV_REM_OF_RANDOM_INT
此代码生成一个随机的符号整数，而后计算另外一个值的。因为随机数能够是负数，因此其他操做的结果也能够是负面的。考虑使用Random.nextInt（int）方法代替。
RV_RETURN_VALUE_IGNORED_NO_SIDE_EFFECT
这段代码调用一个方法并忽略返回值。然而，咱们的分析代表，该方法(若是有的话，包括它在子类中的实现)除了返回值以外不会产生任何效果。所以能够删除这个调用。
多是错误警告：-该方法旨在被覆盖，并在其余超出分析范围的项目中产生反作用。
-调用该方法来触发类加载，这可能会产生反作用。
-调用该方法只是为了得到一些异常。
可使用@CheckReturnValue注释来指示FindBugs忽略该方法的返回值
SA_LOCAL_DOUBLE_ASSIGNMENT
为一个局部变量两次赋值，这样是没有意义的。例如：
public void foo() {
int x,y;
x = x = 17;
}
SA_LOCAL_SELF_ASSIGNMENT
局部变量使用自身给本身赋值
public void foo() {
int x = 3;
x = x;
}
SF_SWITCH_FALLTHROUGH
Switch语句中一个分支执行后又执行了下一个分支。一般case后面要跟break 或者return语句来跳出。
SF_SWITCH_NO_DEFAULT
Switch没有默认状况下执行的case语句。
SE_PRIVATE_READ_RESOLVE_NOT_INHERITED
声明为private的序列化方法被子类继承
UCF_USELESS_CONTROL_FLOW
没有任何做用的条件语句。
if (argv.length == 0) { // TODO: handle this case }
UCF_USELESS_CONTROL_FLOW_NEXT_LINE
无效的条件控制语句，注意if (argv.length == 1);以“;”结尾，下面的语句不管是否知足都会运行。
if (argv.length == 1);
System.out.println("Hello, " + argv[0]);
UP_UNUSED_PARAMETER
此方法定义了从未使用过的参数。因为此方法是静态的或私有的，且不能派生，所以删除这些参数并简化方法是安全的。虽然不太可能，但您应该考虑能够反射性地使用此方法，所以您也但愿更改该调用。在这种状况下，极可能一旦删除了参数，就会有一系列方法调用花费时间建立该参数并将其传递下去。全部这些均可能被移除。
UWF_FIELD_NOT_INITIALIZED_IN_CONSTRUCTOR
字段历来没有在任何构造函数初始化，对象被建立后值为空。若是该字段未被定义就从新赋值会产生一个空指针异常。
USBR_UNNECESSARY_STORE_BEFORE_RETURN
该方法将返回结果存储在局部变量中，而后当即返回局部变量。直接返回分配给局部变量的值会更简单。
Instead of the following:
public float average(int[] arr) {
float sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
float ave = sum / arr.length;
return ave;
}
Simply change the method to return the result of the division:
public float average(int[] arr) {
float sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum / arr.length; //Change
}
XFB_XML_FACTORY_BYPASS
方法自定义了一种XML接口的实现类。最好是使用官方提供的工厂类来建立这些对象，以即可以在运行期中改变。例如：
javax.xml.parsers.DocumentBuilderFactory
javax.xml.parsers.SAXParserFactory
javax.xml.transform.TransformerFactory
org.w3c.dom.Document.createXXXX
XSS_REQUEST_PARAMETER_TO_SEND_ERROR
在代码中在Servlet输出中直接写入一个HTTP参数，这会形成一个跨站点的脚本漏洞。
XSS_REQUEST_PARAMETER_TO_SERVLET_WRITER
代码直接写入参数的HTTP服务器错误页（使用HttpServletResponse.sendError）。表达了相似的不受信任的输入会引发跨站点脚本漏洞。