1.仅仅判断是否存在时，select count 比 select 具体的列，更好。
我们经常遇到类似的业务场景，如，判断某个用户userId是否是会员。
【反例】 一些小伙伴会这样实现，先查从用户信息表查出用户记录，然后去判断是否是会员：
<select id="selectUserByUserId" resultMap="BaseResultMap">
selct user_id , vip_flag from user_info where user_id =#{userId};
</select>
boolean isVip (String userId){
UserInfo userInfo = userInfoDAp.selectUserByUserId(userId);
return UserInfo!=null && "Y".equals(userInfo.getVipFlag())
}
[正例] 针对这种业务场景，其实更好的实现，是直接select count一下，或者select limit 1 如下：
<select id="countVipUserByUserId" resultType="java.lang.Integer">
selct count(1) from user_info where user_id =#{userId} and vip_flag ='Y';
</select>
boolean isVip (String userId){
int vipNum = userInfoDAp.countVipUserByUserId(userId);
return vipNum>0
}
2.复杂的if逻辑条件，可以调整顺序，让程序更高效
假设业务需求是这样：如果用户是会员，并且第一次登陆时，需要发一条通知的短信。假如没有经过思考，代码很可能直接这样写了。
if(isUserVip && isFirstLogin){
sendMsgNotify();
}
假设总共有5个请求进去，isUserVip通过的有3个请求，isFirstLogin通过的有1个请求。那么以上代码，isUserVip执行次数为5次，isFirstLogin执行的次数也3次，如下：
如果调整一下isUserVip和isFirstLogin的顺序呢？
if(isFirstLogin && isUserVip ){
sendMsg();
}
isFirstLogin执行的次数是5次，isUserVip执行的次数是1次，如下
如果你的isFirstLogin，判断逻辑只是select count 一下数据库表，isUserVip也是select count 一下数据库表的话，显然，把isFirstLogin放在前面更高效。
3.写查询Sql的时候，只查你需要用到的字段，还有通用的字段，拒绝反手select *
【反例】
select * from user_info where user_id =#{userId};
【正例】
select user_id , vip_flag from user_info where user_id =#{userId};
【理由】
- 节约资源，减少网络开销。
- 可能用到覆盖索引，减少回表，提高查询效率。
4.优化你的程序，拒绝创建不必要的对象
如果你的变量，后面的逻辑判断，一定会被赋值；或者说，只是一个字符串变量，直接初始化字符串常量就可以了，没必要楞是要 new String（）。
【反例】
String s = new String ("欢迎关注公众号：捡田螺的小男孩");
【正例】
String s= "欢迎关注公众号：捡田螺的小男孩 ”;
5.初始化集合时，指定容量
阿里的开发手册，也明确提到这个点：
假设你的map要存储的元素个数是15个左右，最优写法如下
//initialCapacity = 15/0.75+1=21
Map map = new HashMap(21);
又因为hashMap的容量跟2的幂有关，所以可以取32的容量
Map map = new HashMap(32);
6.catch了异常，需要打印出具体的exception，方便更好定位问题
【反例】
try{
// do something
}catch(Exception e){
log.info("捡田螺的小男孩，你的程序有异常啦");
}
【正例】
try{
// do something
}catch(Exception e){
log.info("捡田螺的小男孩，你的程序有异常啦：",e); //把exception打印出来
}
【理由】
- 反例中，并没有把exception出来，到时候排查问题就不好排查了啦，到底是SQL写错的异常还是IO异常，还是其他呢？所以应该把exception打印到日志中哦~
7.打印日志的时候，对象没有覆盖Object的toString的方法，直接把类名打印出来了。
我们在打印日志的时候，经常想看下一个请求参数对象request是什么。于是很容易有类似以下这些代码；
publick Response dealWithRequest(Request request){
log.info("请求参数是：".request.toString)
}
打印结果如下：
请求参数是：local.Request@49476842
这是因为对象的toString方法，默认的实现是“类名@散列码的无符号十六进制”。所以你看吧，这样子打印日志就没啥意思啦，你都不知道打印的是什么内容
所以一般对象(尤其作为传参的对象），「都覆盖重写toString()方法」：
class Request {
private String age;
private String name;
@Override
public String toString() {
return "Request{" +
"age='" + age + '\'' +
", name='" + name + '\'' +
'}';
}
}
publick Response dealWithRequest(Request request){
log.info("请求参数是：".request.toString)
}
打印结果如下：
请求参数是：Request{age='26', name='公众号：捡田螺的小男孩'
8.一个方法，拒绝过长的参数列表。
假设有这么一个公有方法，形参有四个。。。
public void getUserInfo（String name,String age,String sex,String mobile){
// do something ...
}
如果现在需要多传一个version参数进来，并且你的公有方法是类似dubbo这种对外提供的接口的话，那么你的接口是不是需要兼容老版本啦？
public void getUserInfo（String name,String age,String sex,String mobile){
// do something ...
}
/**
* 新接口调这里
*/
public void getNewUserInfo（String name,String age,String sex,String mobile，String version){
// do something ...
}
所以呢，一般一个方法的参数，一般不宜过长。过长的参数列表，不仅看起来不优雅，并且接口升级时，可能还要考虑新老版本兼容。如果参数实在是多怎么办呢？可以用个DTO对象包装一下这些参数呢~如下：
public void getUserInfo（UserInfoParamDTO userInfoParamDTO){
// do something ...
}
class UserInfoParamDTO{
private String name;
private String age;
private String sex;
private String mobile;
}
用个DTO对象包装一下，即使后面有参数变动，也可以不用动对外接口了，好处杠杠的。
9.使用缓冲流，减少IO操作
「反例：」
/**
* 公众号：捡田螺的小男孩
* @desc: 复制一张图片文件
*/
public class MainTest {
public static void main(String[] args) throws FileNotFoundException {
long begin = System.currentTimeMillis();
try (FileInputStream input = new FileInputStream("C:/456.png");
FileOutputStream output = new FileOutputStream("C:/789.png")) {
byte[] bytes = new byte[1024];
int i;
while ((i = input.read(bytes)) != -1) {
output.write(bytes,0,i);
}
} catch (IOException e) {
log.error("复制文件发生异常",e);
}
log.info("常规流读写，总共耗时ms："+(System.currentTimeMillis() - begin));
}
}
运行结果：
常规流读写，总共耗时ms:52
使用FileInputStream、FileOutputStream实现文件读写功能，是没有什么问题的。但是呢，可以使用缓冲流BufferedReader、BufferedWriter、BufferedInputStream、BufferedOutputStream等，减少IO次数，提高读写效率。
如果是不带缓冲的流，读取到一个字节或者字符的，就会直接输出数据了。而带缓冲的流，读取到一个字节或者字符时，先不输出，而是等达到缓冲区的最大容量，才一次性输出。
「正例：」
/**
* 公众号：捡田螺的小男孩
* @desc: 复制一张图片文件
*/
public class MainTest {
public static void main(String[] args) throws FileNotFoundException {
long begin = System.currentTimeMillis();
try (BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("C:/456.png"));
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("C:/789.png"))) {
byte[] bytes = new byte[1024];
int i;
while ((i = input.read(bytes)) != -1) {
output.write(bytes,0,i);
}
} catch (IOException e) {
log.error("复制文件发生异常",e);
}
log.info("总共耗时ms"+(System.currentTimeMillis() - begin));
}
}
运行结果：
缓冲流读写，总共耗时ms:12
10.优化你的程序逻辑，比如前面已经查到的数据，在后面也要用到的话，是可以把往下传参的，减少方法调用/查表
【反例】
public Response dealRequest(Request request){
UserInfo userInfo = userInfoDao.selectUserByUserId(request.getUserId);
if(Objects.isNull(userInfo)){
return ;
}
insertUserVip(userInfo.getUserId);
}
private int insertUserVip（String userId）{
//又查了一次
UserInfo userInfo = userInfoDao.selectUserByUserId(userId);
//插入用户vip流水
insertUserVipFlow(userInfo);
....
}
很显然，以上程序代码，已经查到 userInfo，然后又把userId传下去，又查多了一次。。。实际上，可以把userInfo传下去的，这样可以省去一次查表操作，程序更高效。
【正例：」
public Response dealRequest(Request request){
UserInfo userInfo = userInfoDao.selectUserByUserId(request.getUserId);
if(Objects.isNull(request)){
return ;
}
insertUserVip(userInfo);
}
private int insertUserVip（UserInfo userInfo）{
//插入用户vip流水
insertUserVipFlow(userInfo);
....
}
11.不要为了方便，直接在代码中使用0，1等魔法值，应该要用enum枚举代替。
【反例】
if("0".equals(userInfo.getVipFlag)){
//非会员，提示去开通会员
tipOpenVip(userInfo);
}else if("1".equals(userInfo.getVipFlag)){
//会员，加勋章返回
addMedal（userInfo）;
}
【正例】
if(UserVipEnum.NOT_VIP.getCode.equals(userInfo.getVipFlag)){
//非会员，提示去开通会员
tipOpenVip(userInfo);
}else if(UserVipEnum.VIP.getCode.equals(userInfo.getVipFlag)){
//会员，加勋章返回
addMedal（userInfo）;
}
public enum UserVipEnum {
NOT_VIP("0","非会员"),
VIP("1","会员"), ;
private String code;
private String desc;
UserVipEnum(String code, String desc) {
this.code = code;
this.desc = desc;
}
}
写代码的时候，不要一时兴起使用魔法值哈。使用魔法值，维护代码起来很难受。
12.当成员变量值不会改变时，优化定义为静态常量
【反例】
public class Task {
private final long timeout = 10L;
...
}
【正例】
public class Task {
private static final long TIMEOUT = 10L;
...
}
因为如果定义为static，即类静态常量，在每个实例对象中，它只有一份副本。如果是成员变量，每个实例对象中，都各有一份副本。显然，如果这个变量不会变的话，定义为静态常量更好一些。
13.注意检验空指针，不要轻易相信业务，说正常逻辑某个参数不可能为空。
NullPointerException 在我们日常开发中非常常见，我们代码开发过程中，一定要对空指针保持灵敏的嗅觉。
主要有这几类空指针问题:
- 包装类型的空指针问题
- 级联调用的空指针问题
- Equals方法左边的空指针问题
- ConcurrentHashMap 类似容器不支持k-v为null。
- 集合，数组直接获取元素
- 对象直接获取属性
【反例】
public class NullPointTest {
public static void main(String[] args) {
String s = null;
if (s.equals("666")) { //s可能为空，会导致空指针问题
System.out.println("公众号：捡田螺的小男孩，干货满满");
}
}
}
14.捕获到的异常，不能忽略它，至少打点日志。
【反例】
public static void testIgnoreException() throws Exception {
try {
// 搞事情
} catch (Exception e) {
//捕获了异常，啥事情不做，日志也不打？？
}
}
【正例】
public static void testIgnoreException() {
try {
// 搞事情
} catch (Exception e) {
log.error("异常了，联系开发小哥哥看看哈",e);
}
}
15.使用Lambda表达式替换内部匿名类，是代码更优雅
JDK8出现了新特性Lambda表达式。Lambda表达式不仅比匿名内部类更加优雅，并且在大多数虚拟机中，都是采用invokeDynamic指令实现，相对于匿名内部类，效率也更高
【反例】
public void sortUserInfoList(List<UserInfo> userInfoList){
userInfoList.sort(new Comparator<UserInfo>() {
@Override
public int compare(UserInfo user1, UserInfo user2) {
Long userId1 = user1.getUserId();
Long userId2 = user2.getUserId();
return userId1.compareTo(userId2);
}});
}
【正例】
public void sortUserInfoList(List<UserInfo> userInfoList){
userInfoList.sort((user1, user2) -> {
Long userId1 = user1.getUserId();
Long userId2 = user2.getUserId();
return userId1.compareTo(userId2);
});
}
16.通知类（如发邮件，有短信）的代码，建议异步处理。
假设业务流程这样：需要在用户登陆时，添加个短信通知它的粉丝。很容易想到的实现流程如下：
假设提供sendMsgNotify服务的系统挂了，或者调用sendMsgNotify失败了，那么用户登陆就失败了。。。一个通知功能导致了登陆主流程不可用，明显的捡了芝麻丢西瓜。那么有没有鱼熊掌兼得的方法呢？有的，给发短信接口捕获异常处理，或者另开线程异步处理，如下：
因此，添加通知类等不是非主要，可降级的接口时，应该静下心来考虑是否会影响主要流程，思考怎么处理最好。
17.处理Java日期时，当心YYYY格式设置的问题。
日常开发中，我们经常需要处理日期。我们要当时日期格式化的时候，年份大写YYYY的坑。
Calendar calendar = Calendar.getInstance();
calendar.set(2019, Calendar.DECEMBER, 31);
Date testDate = calendar.getTime();
SimpleDateFormat dtf = new SimpleDateFormat("YYYY-MM-dd");
System.out.println("2019-12-31 转 YYYY-MM-dd 格式后 " + dtf.format(testDate));
运行结果：
2019-12-31 转 YYYY-MM-dd 格式后 2020-12-31
为什么明明是2019年12月31号，就转了一下格式，就变成了2020年12月31号了？因为YYYY是基于周来计算年的，它指向当天所在周属于的年份，一周从周日开始算起，周六结束，只要本周跨年，那么这一周就算下一年的了。正确姿势是使用yyyy格式。
18.如果一个类确定不会被继承，不会拿来搞AOP骚操作，可以指定final修饰符，如用final修饰一个工具类。
【正例】
public final class Tools {
public static void testFinal(){
System.out.println("工具类方法");
}
}
一个类指定了final修饰符，它不会被继承了，并且其所有方法都是final的了。java编译器会找机会内联所有的final方法，提升了java运行效率。
19.static静态变量不要依赖spring实例化变量，可能会导致初始化出错
之前看到项目有类似的代码。静态变量依赖于spring容器的bean。
private static SmsService smsService = SpringContextUtils.getBean(SmsService.class);
这个静态的smsService有可能获取不到的，因为类加载顺序不是确定的，而以上的代码，静态的smsService初始化强制依赖spring容器的实例了。正确的写法可以这样，如下：
private static SmsService smsService =null;
//使用到的时候采取获取
public static SmsService getSmsService(){
if(smsService==null){
smsService = SpringContextUtils.getBean(SmsService.class);
}
return smsService;
}
20.与类成员变量无关的方法，应当生明成静态方法
有些方法，与实例成员变量无关，就可以声明为静态方法。这一点，工具类用得很多。
【反例】
/**
* BigDecimal的工具类
*/
public class BigDecimalUtils {
public BigDecimal ifNullSetZERO(BigDecimal in) {
return in != null ？ in : BigDecimal.ZERO;
}
public BigDecimal sum(BigDecimal ...in){
BigDecimal result = BigDecimal.ZERO;
for (int i = 0; i < in.length; i++){
result = result.add(ifNullSetZERO(in[i]));
}
return result;
}
因为BigDecimalUtils工具类得方法都没有static修饰，所以，你要使用得时候，每次都要new一下啦，那不就耗资源去
反复创建对象了嘛！！
BigDecimalUtils bigDecimalUtils = new BigDecimalUtils（）;
bigDecimalUtils.sum(a,b);
所有可以声明成静态变量，使用得时候，直接类名.方法调用即可，
【正例】
/**
* BigDecimal的工具类
*/
public class BigDecimalUtils {
public static BigDecimal ifNullSetZERO(BigDecimal in) {
return in != null ？ in : BigDecimal.ZERO;
}
public static BigDecimal sum(BigDecimal ...in){
BigDecimal result = BigDecimal.ZERO;
for (int i = 0; i < in.length; i++){
result = result.add(ifNullSetZERO(in[i]));
}
return result;
}
21.不要用一个Exception捕捉所有可能得异常
【反例】
public void test(){
try{
//…抛出 IOException 的代码调用
//…抛出 SQLException 的代码调用
}catch(Exception e){
//用基类 Exception 捕捉的所有可能的异常，如果多个层次都这样捕捉，会丢失原始异常的有效信息哦
log.info(“Exception in test,exception:{}”, e);
}
}
【正例】
public void test(){
try{
//…抛出 IOException 的代码调用
//…抛出 SQLException 的代码调用
}catch(IOException e){
//仅仅捕捉 IOException
log.info(“IOException in test,exception:{}”, e);
}catch(SQLException e){
//仅仅捕捉 SQLException
log.info(“SQLException in test,exception:{}”, e);
}
}
22.函数不要过度封装，言简意赅即可
【反例】
// 函数封装
public static boolean isUserVip(Boolean isVip) {
return Boolean.TRUE.equals(isVip);
}
// 使用代码
boolean isVip = isVip(user.getUserVip());
【正例】
boolean isVip = Boolean.TRUE.equals(user.getUserVip());
函数不要过度封装，把意思表达清楚即可。并且，方法调用会引起入栈和出栈，导致消耗更多的CPU和内存，过度封装，会损耗性能的！
23.如果变量的初值一定会被覆盖，就没必要给变量赋初值。
【反例】
List<UserInfo> userList = new ArrayList<>();
if (isAll) {
userList = userInfoDAO.queryAll();
} else {
userList = userInfoDAO.queryActive();
}
【正例】
List<UserInfo> userList ;
if (isAll) {
userList = userInfoDAO.queryAll();
} else {
userList = userInfoDAO.queryActive();
}
24.金额数值计算要使用BigDecimal
看下这个浮点数计算的例子吧：
public class DoubleTest {
public static void main(String[] args) {
System.out.println(0.1+0.2);
System.out.println(1.0-0.8);
System.out.println(4.015*100);
System.out.println(123.3/100);
double amount1 = 3.15;
double amount2 = 2.10;
if (amount1 - amount2 == 1.05){
System.out.println("OK");
}
}
}
运行结果：
0.30000000000000004
0.19999999999999996
401.49999999999994
1.2329999999999999
因为计算机是以二进制存储数值的，对于浮点数也是。对于计算机而言，0.1无法精确表达，这就是为什么浮点数会导致精确度缺失的。因此，金额计算，一般都是用BigDecimal 类型
System.out.println(new BigDecimal(0.1).add(new BigDecimal(0.2)));
//output:
0.3000000000000000166533453693773481063544750213623046875
其实，使用 BigDecimal 表示和计算浮点数，必须使用字符串的构造方法来初始化 BigDecimal，并且，还要关注BigDecimal的几位小数点，它有八种舍入模式等
25.注意Arrays.asList的几个坑
- 基本类型不能作为Arrays.asList方法的参数，否则会被当做一个参数。
public class ArrayAsListTest {
public static void main(String[] args) {
int[] array = {1, 2, 3};
List list = Arrays.asList(array);
System.out.println(list.size());
}
}
//运行结果
1
- Arrays.asList返回的List不支持增删操作。
public class ArrayAsListTest {
public static void main(String[] args) {
String[] array = {"1", "2", "3"};
List list = Arrays.asList(array);
list.add("5");
System.out.println(list.size());
}
}
// 运行结果
Exception in thread "main" java.lang.UnsupportedOperationException
at java.util.AbstractList.add(AbstractList.java:148)
at java.util.AbstractList.add(AbstractList.java:108)
at object.ArrayAsListTest.main(ArrayAsListTest.java:11)
Arrays.asList 返回的 List 并不是我们期望的 java.util.ArrayList，而是 Arrays 的内部类ArrayList。内部类的ArrayList没有实现add方法，而是父类的add方法的实现，是会抛出异常的呢。
- 使用Arrays.asList的时候，对原始数组的修改会影响到我们获得的那个List
public class ArrayAsListTest {
public static void main(String[] args) {
String[] arr = {"1", "2", "3"};
List list = Arrays.asList(arr);
arr[1] = "4";
System.out.println("原始数组"+Arrays.toString(arr));
System.out.println("list数组" + list);
}
}
//运行结果
原始数组[1, 4, 3]
list数组[1, 4, 3]
26.及时关闭IO资源流
应该大家都有过这样的经历，windows系统桌面如果打开太多文件或者系统软件，就会觉得电脑很卡。当然，我们linux服务器也一样，平时操作文件，或者数据库连接，IO资源流如果没关闭，那么这个IO资源就会被它占着，这样别人就没有办法用了，这就造成资源浪费。
所以使用完IO流，记得关闭哈。可以使用try-with-resource关闭的：
try (FileInputStream inputStream = new FileInputStream(new File("jay.txt")) {
// use resources
} catch (FileNotFoundException e) {
log.error(e);
} catch (IOException e) {
log.error(e);
}
27.尽量使用函数内的基本类型临时变量
- 在方法函数内，基本类型参数以及临时变量，都是保存在栈中的，访问速度比较快。
- 对象类型的参数和临时变量的引用都保存在栈中，内容都保存在堆中，访问速度较慢。
- 在类中，任何类型的成员变量都保存在堆（Heap）中，访问速度较慢。
public class AccumulatorUtil {
private double result = 0.0D;
//反例
public void addAllOne( double[] values) {
for(double value : values) {
result += value;
}
}
//正例，先在方法内声明一个局部临时变量，累加完后，再赋值给方法外的成员变量
public void addAl1Two(double[] values) {
double sum = 0.0D;
for(double value : values) {
sum += value;
}
result += sum;
}
}
28.如果数据库一次查询的数量过多，建议分页处理
如果你的Sql一次性查出来的数据量比较多，建议分页处理。
【反例】
select user_id,name,age from user_info ;
【正例】
select user_id,name,age from user_info limit #{offset},#{pageSize};
如果偏移量特别大的时候，查询效率就变得低下。可以这接种方式优化：
//方案一 ：返回上次查询的最大记录(偏移量)
select id，name from user_info where id>10000 limit #{pageSize}.
//方案二：order by + 索引
select id，name from user_info order by id limit #{offset},#{pageSize}
//方案三：在业务允许的情况下限制页数：
29.尽量减少对变量的重复计算
一般我们写代码的时候，会以以下的方式实现遍历：
for (int i = 0; i < list.size; i++){
}
如果list数据量比较小那还好。如果list比较大时，可以优化成这样：
for (int i = 0, length = list.size; i < length; i++){
}
理由：对方法的调用，即使是只有一个语句，也是有有消耗的，比如创建栈帧。如果list比较大时，多次调用list.size也是会有资源消耗的。
30.修改对外老接口的时候，思考接口的兼容性
很多bug都是因为修改了对外老接口，但是却不做兼容导致的。关键这个问题多数是比较严重的，可能直接导致系统发版失败的。新手程序员很容易就犯这个错误了哦~
所以，如果你的需求是在原来接口上修改，，尤其这个接口是对外提供服务的话，一定要考虑接口兼容。举个例子吧，比如dubbo接口，原本是只接收A，B参数，现在你加了一个参数C，就可以考虑这样处理。
//老接口
void oldService(A,B);{
//兼容新接口，传个null代替C
newService(A,B,null);
}
//新接口，暂时不能删掉老接口，需要做兼容。
void newService(A,B,C);
Q.E.D.