long或者 Long初始赋值时,必须使用大写的 L,不能是小写的 l,小写容易跟数字1混淆,造成误解。
正例:
Long a = 2L;
反例:
Long a = 2l;
不要在foreach循环里进行元素的remove/add操作。remove元素请使用Iterator方式,如果并发操作,需要对Iterator对象加锁。
正例:
ArrayList list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");
System.out.println(list);//[A, B, C]
Iterator iterator = list.iterator();
while (iterator.hasNext()){
String next = iterator.next();
if(next.equals("B")){
iterator.remove();
}
}
System.out.println(list);//[A, C]
反例:
ArrayList list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("R");
list.add("T");
list.add("C");
System.out.println(list);//[A, B, C]
for (String str : list) {
if(str.equals("B")){
list.remove(str);
}
}
3.在iflelse/forlwhileldo语句中必须使用大括号,即使只有一行代码。
正例:
if (condition){
statements;
}
反例:
if (condition) statements;
4.在使用正则表达式时,利用好其预编译功能,可以有效加快正则匹配速度。
正例:
private static final Pattern pattern = Pattern.compile(".*:(.*)://.*/(.*)\\?.*$");
反例:
public void t(){
Pattern pattern = Pattern.compile(".*:(.*)://.*/(.*)\\?.*$");
}
5.多钱程并行处理定时任务时,Timer运行多个TimeTask时,只要其中之一没有捕获抛出的异常,其它任务便会自动终止运行,使用ScheduledExecutorService则没有这个问题。
解释:
Timer运行多个TimeTask时底层公用一个队列它会错误的认为整个 Timer 线程都会取消。
Timer 是内部是单一线程,而 ScheduledThreadPoolExecutor 内部是个线程池,所以可以支持多个任务并发执行。
正例:
private final ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(1, new ImprovedTimer.DaemonThreadFactory());
private ScheduledFuture improvedTimerFuture = null;
public void schedule(Runnable command, long initialDelay, long period){
// initialDelay 毫秒后开始执行任务,以后每隔 period 毫秒执行一次
// schedule方法被用来延迟指定时间来执行某个指定任务。
// 如果你需要周期性重复执行定时任务可以使用scheduleAtFixedRate或者scheduleWithFixedDelay方法,它们不同的是前者以固定频率执行,后者以相对固定频率执行。
// 不管任务执行耗时是否大于间隔时间,scheduleAtFixedRate和scheduleWithFixedDelay都不会导致同一个任务并发地被执行。
// 唯一不同的是scheduleWithFixedDelay是当前一个任务结束的时刻,开始结算间隔时间,如0秒开始执行第一次任务,任务耗时5秒,任务间隔时间3秒,那么第二次任务执行的时间是在第8秒开始。
improvedTimerFuture = executorService.scheduleAtFixedRate(command, initialDelay, period, TimeUnit.MILLISECONDS);
}
/**
* 守护线程工厂类,用于生产后台运行线程
*/
private static final class DaemonThreadFactory implements ThreadFactory {
private AtomicInteger atoInteger = new AtomicInteger(0);
@Override
public Thread newThread(Runnable runnable) {
Thread thread = new Thread(runnable);
thread.setName("schedule-pool-Thread-" + atoInteger.getAndIncrement());
thread.setDaemon(true);
return thread;
}
}
反例:
public static void main(String[] args) throws Exception {
Timer timer = new Timer();
Thread.sleep(10000);
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("haha");
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, 1000, 1000);
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("heihei");
}
}, 1000,1000);
}
6.所有的包装类对象之间值的比较,全部使用equals方法比较。
正例:
a.equals(b)
反例:
a==b
7.所有的覆写方法,必须加@Override注解。
8.线程池不允许使用Executors去创建,而是通过ThreadPoolExecutor的方式,这样的处理方式能更加明确线程池的运行规则,规避资源耗尽的风险。
解释:
Java通过Executors提供四种线程池,分别为∶
1)newFixedThreadPool创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。
2)newSingleThreadExecutor创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO,优先级)执行。
3)newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。
4)newScheduledThreadPool创建一个定长线程池,支持定时及周期性任务执行。
Executors各个方法的弊端:
1)newFixedThreadPool和newSingleThreadExecutor:
主要问题是堆积的请求处理队列可能会耗费非常大的内存,甚至OOM。
2)newCachedThreadPool和newScheduledThreadPool:
主要问题是线程数最大数是Integer.MAX_VALUE,可能会创建数量非常多的线程,甚至OOM。
正例:
@Bean
public Executor FileCopyExecutor() {
ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
//核心线程数,一次处理100个
taskExecutor.setCorePoolSize(fileCorePoolSize);
taskExecutor.setMaxPoolSize(2 *fileCorePoolSize);
taskExecutor.setQueueCapacity(fileQueueCapacity);
taskExecutor.setThreadNamePrefix("file-");
taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
taskExecutor.initialize();
return taskExecutor;
}
反例:
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
9.获取当前毫秒数:System.currentTimeMillis();而不是new Date().getTime();
解释:
new Date().getTime()其实最终还是调用了System.currentTimeMillis(),那还不如直接就使用System.currentTimeMillis()。
因为new Date()包含了非常多的时间信息,直接使用System.currentTimeMillis(),效率更高。
10.避免用Apache Beanutils进行属性的copy.
主要还是性能问题
1000次 |
10000次 |
100000次 |
1000000次 |
|
apache BeanUtils |
906毫秒 |
807毫秒 |
1892毫秒 |
11049毫秒 |
apache PropertyUtils |
17毫秒 |
96毫秒 |
648毫秒 |
5896毫秒 |
spring cglib BeanCopier |
0毫秒 |
1毫秒 |
3毫秒 |
10毫秒 |
spring copyProperties |
87毫秒 |
90毫秒 |
123毫秒 |
482毫秒 |
性能走势 --> spring cglib BeanCopier 优于 spring copyProperties 优于 apache PropertyUtils 优于 apache BeanUtils
11.避免通过一个类的对象引用访问此类的静态变量或静态方法,无谓增加编译器解析成本,直接用类名来访问即可。
解释:
增加jvm成本,增加无谓的内存消耗
通过对象支持调用静态变量和静态方法,最终都会在编译后转换为类直接调用静态变量或静态方法。
正例:
String str = TestConst.a;
反例:
TestConst tc = new TestConst();
String str = tc.a;
12.ArrayList的subList结果不可强转成ArrayList,否则会抛出ClassCastException异常。
解释:
1)SubList 继承 AbstractList ,所以具有List接口的所有方法。
2)SubList 是ArrayList 的一个内部类。SubList并没有重新创建一个List,而是直接引用原有的List,只不过对原来List做截取而已。
3)ArrayList 也是继承AbstractList,但是 SubList 和 ArrayList 没有继承关系,所以不能强转换。
正例:
List list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
List subList1 = list.subList(1, 3);
反例:
List list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
ArrayList subList1 = (ArrayList)list.subList(1, 3);
13.Map/Set的key为自定义对象时,必须重写hashCode和equals.
解释:
Map/Set首先将自定义对象的hashcode值与集合中已经存在的数据的hashcode值比较,不相等则直接添加,如果相等再进一步判断他们的equals是否相等,不相等则添加。
如果不重写自定义对象类的hashcode和equals方法,则他们的equals方法不相同;同样他们的hashcode值也大概率不相等
14.Object的equals方法容易抛空指针异常,应使用常量或确定有值的对象来调用equals。
15.POJO类中的任何布尔类型的变量,都不要加is,否则部分框架解析会引起序列化错误
解释:
类中的属性用is开头会导致对象序列化后产生意想不到的结果。所以在平时编码的过程中,我们不能在类变量中用is开头如: “isSuccess”,这样容易造成程序错误
16.SimpleDateFormat是线程不安全的类,一般不要定义为static变量,如果定义为static,必须加锁,或者使用DateUltis工具类.
17.不能使用过时的类或方法。
18.不能在finally块中使用return,finally块中的return返回后方法结束执行,不会再执行try块中的return语句。
解释:
try块中的return值会先保存起来,然后执行完finally中的代码后,才会把try块中的return值返回,所以finally中的代码逻辑是不会影响try块中的return值的。
但如果在finally中使用return了就会导致try块中的代码得不到执行而无法返回正确的结果
19.使用工具类Arays.asList()把数组转换成集合时,不能使用其修改集合相关的方法,它的add/removelclear方法会抛出Unsupported()
解释:
asList的返回对象是一个Arrays内部类,并没有实现集合的修改方法。Arrays.asList体现的是适配器模式,只是转换接口,后台的数据仍是数组。
反例:
String[] str = new String[]{"1","2"};
List strings = Arrays.asList(str);
strings.add("3");//java.lang.UnsupportedOperationException
--------------------------------------------------------------------------------
String[] str = new String[]{"1","2"};
List strings = Arrays.asList(str);
str[0]="3";//strings 内容会同步被改掉
20.使用集合转数组的方法,必须使用集合的toArray(Tarray),传入的是类型完全一样的数组,大小就是list size()
正例:
List list = new ArrayList();
list.add("guan");
list.add("bao");
String[] array = new String[list.size()];
array = list.toArray(array);
21.创建线程或线程池时请指定有意义的线程名称,方便出错时回溯。创建线程池的时候请使用带ThreadFactory的构造函数,并且提供自定义ThreadFactory实现或者使用第三方实现。
22.在subList场景中,高度注意对原列表的修改,会导致子列表的遍历、增加、删除均产生ConcurentModificationException异常。
反例:
List list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
List subList1 = list.subList(1, 3);
list.remove(2);
for (Integer integer : subList1) {
}
23.在一个switch块内,每个case要么通过break/return等来终止,要么注释说明程序将继续执行到哪一个case为止;在一个switch块内都必须包含一个default语句并且放在最后,即使它什么代码也没有。
24.对于Service和DAO类,基于SOA的理念,暴露出来的服务一定是接口,内部的实现类用Impl的后缀与接口区别
25.常量命名应该全部大写,单词间用下划线隔开,力求语义表达完整清楚,不要嫌名字长
26.异常类命名使用Exception结尾
27.必须回收自定义的ThreadLocal变量,尤其在线程池场景下,线程经常会被复用,如果不清理自定义的ThreadLocal变量,可能会影响后续业务逻辑和造成内存泄露等问题。尽量在代理中使用try-finally块进行回收。
正例:
ThreadLocal objectThreadLocal = new ThreadLocal();
objectThreadLocal.set(1);
try {
// 业务逻辑
} finally {
objectThreadLocal.remove();
}
28.所有的枚举类型字段必须要有注释,说明每个数据项的用途。
正例:
public enum AppExceptionEnum implements ExceptionInterface {
APP_CODE_OR_SECRET_ERROR("应用编码有误或密钥错误"),
APP_CODE_NOT_EXIST("应用编码不存在"),
;
private String message;
AppExceptionEnum(String message) {
this.message = message;
}
}
29.所有编程相关的命名均不能以下划线或美元符号开始
反例:
private void $test(){
System.out.println("命名不能以美元符号开始")
}
private void _test(){
System.out.println("命名不能以下划线开始")
}
30.抽象类命名使用Abstract或Base开头
31.方法名、参数名、成员变量、局部变量都统一使用lowerCamelCase,必须遵从驼峰形式
32.日期格式化字符串[%s]使用错误,应注意使用小写y'表示当天所在的年,大写Y代表week in which year。
解释:
日期格式化时,yyyy表示当天所在的年,而大写的YYYY代表是week in which year(JDK7之后引入的概念),
意思是当天所在的周属于的年份,一周从周日开始,周六结束,只要本周跨年,返回的YYYY就是下一年。
33.浮点数之间的等值判断,基本数据类型不能用==来比较,包装数据类型不能用equals来判断。
正例:
BigDecimal aa = new BigDecimal("1.0");
BigDecimal bb = new BigDecimal("0.9");
BigDecimal cc = new BigDecimal("0.8");
BigDecimal x = aa.subtract(bb);
BigDecimal y = bb.subtract(cc);
x.equals(y);
反例:
float a = 1.0f - 0.9f;
float b = 0.9f - 0.8f;
a==b
34.线程资源必须通过线程池提供,不允许在应用中自行显式创建线程
解释:
如果不使用线程池,有可能造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。
如有解释不当处,欢迎各位大佬指正