反例：_name / __name / $name / name_ / name$ / name__

说明：正确的英文拼写和语法可以让阅读者易于理解，避免歧义。注意，纯拼音命名方式更要避免采用。
正例：ali / alibaba / taobao / cainiao/ aliyun/ youku / hangzhou 等国际通用的名称，可视同英文。
反例：DaZhePromotion [打折] / getPingfenByName() [评分] / int 某变量 = 3

正例：ForceCode / UserDO / HtmlDTO / XmlService / TcpUdpDeal / TaPromotion
反例：forcecode / UserDo / HTMLDto / XMLService / TCPUDPDeal / TAPromotion

正例： localValue / getHttpMessage() / inputUserId

正例：MAX_STOCK_COUNT / CACHE_EXPIRED_TIME
反例：MAX_COUNT / EXPIRED_TIME

反例：
//本例中同学A定义了缓存的key，然后缓存提取的同学B使用了Id#taobao来提取，少了下划线，导致故障。
String key = "Id#taobao_" + tradeId;
cache.put(key, value);

说明：Long a = 2l; 写的是数字的 21，还是 Long 型的 2。

正例："test".equals(object);
反例：object.equals("test");
说明：推荐使用 java.util.Objects#equals（JDK7 引入的工具类）。

说明：第 1 个不记录时间，getHours()抛出异常；第 2 个不记录日期，getYear()抛出异常；第 3 个在构造方法 super((time/1000)*1000)，fastTime 和 nanos 分开存储秒和纳秒信息。
反例：java.util.Date.after(Date)进行时间比较时，当入参是 java.sql.Timestamp 时，会触发 JDK BUG(JDK9 已修复)，可能导致比较时的意外结果。

正例：
	// 获取今年的天数
	int daysOfThisYear = LocalDate.now().lengthOfYear();
	// 获取指定某年的天数
	LocalDate.of(2011, 1, 1).lengthOfYear();
	反例：
	// 第一种情况：在闰年 366 天时，出现数组越界异常
	int[] dayArray = new int[365];
	// 第二种情况：一年有效期的会员制，今年1月26日注册，硬编码365返回的却是1月25日
	Calendar calendar = Calendar.getInstance();
	calendar.set(2020, 1, 26);
	calendar.add(Calendar.DATE, 365);

说明：参考 JDK 原生注释，Month value is 0-based. e.g., 0 for January.
正例：Calendar.JANUARY，Calendar.FEBRUARY，Calendar.MARCH 等来指代相应月份来进行传参或比较。

说明：前者的时间复杂度为 O(1)，而且可读性更好。
正例：
Map<String, Object> map = new HashMap<>();
if(map.isEmpty()) {
	System.out.println("no element in this map.");
}

说明：参数 mergeFunction 的作用是当出现 key 重复时，自定义对 value 的处理策略。
正例：
	List<Pair<String, Double>> pairArrayList = new ArrayList<>(3);
	pairArrayList.add(new Pair<>("version", 6.19));
	pairArrayList.add(new Pair<>("version", 10.24));
	pairArrayList.add(new Pair<>("version", 13.14));
	// 生成的 map 集合中只有一个键值对：{version=13.14}
	Map<String, Double> map = pairArrayList.stream().collect(Collectors.toMap(Pair::getKey, Pair::getValue, (v1, v2) -> v2));
反例：
	String[] departments = new String[] {"iERP", "iERP", "EIBU"};
	// 抛出 IllegalStateException 异常
	Map<Integer, String> map = Arrays.stream(departments).collect(Collectors.toMap(String::hashCode, str -> str));

说明：在 java.util.HashMap 的 merge 方法里会进行如下的判断：
	if (value == null || remappingFunction == null) {
		// ...
		throw new NullPointerException();
	}
反例：
	List<Pair<String, Double>> pairArrayList = new ArrayList<>(2);
	pairArrayList.add(new Pair<>("version1", 4.22));
	pairArrayList.add(new Pair<>("version2", null));
	Map<String, Double> map = pairArrayList.stream().collect(
	// 抛出 NullPointerException 异常
	Collectors.toMap(Pair::getKey, Pair::getValue, (v1, v2) -> v2));

反例：直接使用 toArray 无参方法存在问题，此方法返回值只能是 Object[] 类，若强转其它类型数组将出现 ClassCastException 错误。
正例：
	List<String> list = new ArrayList<>(2);
	list.add("guan");
	list.add("bao");
	String[] array = list.toArray(new String[0]);
说明：使用 toArray 带参方法，数组空间大小的 length，
1） 等于 0，动态创建与 size 相同的数组，性能最好。
2） 大于 0 但小于 size，重新创建大小等于 size 的数组，增加 GC 负担。
3） 等于 size，在高并发情况下，数组创建完成之后，size 正在变大的情况下，负面影响与 2 相同。
4） 大于 size，空间浪费，且在 size 处插入 null 值，存在 NPE 隐患。

正例：
	List<String> list = new ArrayList<>();
	list.add("1");
	list.add("2");
	Iterator<String> iterator = list.iterator();
	while (iterator.hasNext()) {
		String item = iterator.next();
		if (删除元素的条件) {
			iterator.remove();
		}
	}
	反例：
	for (String item : list) {
		if ("1".equals(item)) {
			list.remove(item);
		}
	}
说明：以上代码的执行结果肯定会出乎大家的意料，那么试一下把“1”换成“2”，会是同样的结果吗？

说明：菱形泛型，即 diamond，直接使用<>来指代前边已经指定的类型。
正例：
	// diamond 方式，即<>
	HashMap<String, String> userCache = new HashMap<>(16);
	// 全省略方式
	ArrayList<User> users = new ArrayList(10);

正例：注意线程安全，使用 DateUtils。亦推荐如下处理：
private static final ThreadLocal<DateFormat> df = new ThreadLocal<DateFormat>() {
	@Override
	protected DateFormat initialValue() {
		return new SimpleDateFormat("yyyy-MM-dd");
	}
};
说明：如果是 JDK8 的应用，可以使用 Instant 代替 Date，LocalDateTime 代替 Calendar，
DateTimeFormatter 代替 SimpleDateFormat，官方给出的解释：simple beautiful strong immutable thread-safe。

正例：
	objectThreadLocal.set(userInfo);
	try {
	// ...
	} finally {
		objectThreadLocal.remove();
	}

说明一：如果在 lock 方法与 try 代码块之间的方法调用抛出异常，那么无法解锁，造成其它线程无法成功获取锁。
说明二：如果 lock 方法在 try 代码块之内，可能由于其它方法抛出异常，导致在 finally 代码块中，unlock 对未加锁的对象解锁，它会调用 AQS 的 tryRelease 方法（取决于具体实现类），抛出 IllegalMonitorStateException 异常。
说明三：在 Lock 对象的 lock 方法实现中可能抛出 unchecked 异常，产生的后果与说明二相同。
正例：
	Lock lock = new XxxLock();
	// ...
	lock.lock();
	try {
		doSomething();
		doOthers();
	} finally {
		lock.unlock();
	}
反例：
	Lock lock = new XxxLock();
	// ...
	try {
		// 如果此处抛出异常，则直接执行 finally 代码块
		doSomething();
		// 无论加锁是否成功，finally 代码块都会执行
		lock.lock();
		doOthers();
	} finally {
		lock.unlock();
	}

说明：Lock 对象的 unlock 方法在执行时，它会调用 AQS 的 tryRelease 方法（取决于具体实现类），如果当前线程不持有锁，则抛出 IllegalMonitorStateException 异常。
正例：
	Lock lock = new XxxLock();
	// ...
	boolean isLocked = lock.tryLock();
	if (isLocked) {
		try {
			doSomething();
			doOthers();
		} finally {
			lock.unlock();
		}
	}

反例：如下的代码输出是什么？(报：java.lang.NullPointerException)
public class SwitchString {

    public static void main(String[] args) {
        method(null);
    }

    public static void method(String param) {
        switch (param) {
            // 肯定不是进入这里
            case "sth":
                System.out.println("it's sth");
                break;
            // 也不是进入这里
            case "null":
                System.out.println("it's null");
                break;
            // 也不是进入这里
            default:
                System.out.println("default");
        }
    }
}

说明：以下两种场景会触发类型对齐的拆箱操作：
1） 表达式 1 或表达式 2 的值只要有一个是原始类型。
2） 表达式 1 或表达式 2 的值的类型不一致，会强制拆箱升级成表示范围更大的那个类型。
反例：
Integer a = 1;
Integer b = 2;
Integer c = null;
Boolean flag = false;
// a*b 的结果是 int 类型，那么 c 会强制拆箱成 int 类型，抛出 NPE 异常
Integer result=(flag ? a*b : c);

	if (condition) {
		...
		return obj;
	}
// 接着写 else 的业务逻辑代码;
说明：如果非使用 if()...else if()...else...方式表达逻辑，避免后续代码维护困难，请勿超过 3 层。
正例：超过 3 层的 if-else 的逻辑判断代码可以使用卫语句、策略模式、状态模式等来实现，其中卫语句。示例如下：
	public void findBoyfriend(Man man) {
        if (man.isUgly()) {
            System.out.println("本姑娘是外貌协会的资深会员");
            return;
        }
        if (man.isPoor()) {
            System.out.println("贫贱夫妻百事哀");
            return;
        }
        if (man.isBadTemper()) {
            System.out.println("银河有多远，你就给我滚多远");
            return;
        }
        System.out.println("可以先交往一段时间看看");
    }

说明：很多 if 语句内的逻辑表达式相当复杂，与、或、取反混合运算，甚至各种方法纵深调用，理解成本非常高。如果赋值一个非常好理解的布尔变量名字，则是件令人爽心悦目的事情。
正例：
	// 伪代码如下
	final boolean existed = (file.open(fileName, "w") != null) && (...) ||(...);
	if (existed) {
		//...
	}
反例：
	public final void acquire (long arg) {
	if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) {
		selfInterrupt();
	}

说明：对于垃圾代码或过时配置，坚决清理干净，避免程序过度臃肿，代码冗余。
正例：对于暂时被注释掉，后续可能恢复使用的代码片断，在注释代码上方，统一规定使用三个斜杠(///)来说明注释掉代码的理由。如：
public static void hello() {
	/// 业务方通知活动暂停
	// Business business = new Business();
	// business.active();
	System.out.println("it's finished");
}

说明：try 块中的 return 语句执行成功后，并不马上返回，而是继续执行 finally 块中的语句，如果此处存在 return 语句，则在此直接返回，无情丢弃掉 try 块中的返回点。
反例：
	private int x = 0;
	public int checkReturn() {
		try {
			// x 等于 1，此处不返回
			return ++x;
		} finally {
			// 返回的结果是 2
			return ++x;
		}
	}

1） 返回类型为基本数据类型，return 包装数据类型的对象时，自动拆箱有可能产生 NPE。
反例：public int f() { return Integer 对象}， 如果为 null，自动解箱抛 NPE。
2） 数据库的查询结果可能为 null。
3） 集合里的元素即使 isNotEmpty，取出的数据元素也可能为 null。
4） 远程调用返回对象时，一律要求进行空指针判断，防止 NPE。
5） 对于 Session 中获取的数据，建议进行 NPE 检查，避免空指针。
6） 级联调用 obj.getA().getB().getC()；一连串调用，易产生 NPE。
正例：使用 JDK8 的 Optional 类来防止 NPE 问题。