Java 中一些好的编码风格

最新推荐文章于 2024-02-19 15:05:05 发布
最新推荐文章于 2024-02-19 15:05:05 发布
阅读量686 收藏 2
点赞数
分类专栏： java web 文章标签： 编程 java 风格 艺术 编码

https://blog.csdn.net/YQS_Love/article/details/79432048?utm_source=copy

 

一、前言

  在实际工作中，我们所编写的代码主要是给我们自己看的，只是顺便让机器去执行。那么，可想而知，良好的代码编写风格，将给维护人员带来很大的便利之处。这篇文章是我工作中的一些总结，也许并不适合你，但值得参考，因为我的很多同事并没有良好的编码风格和习惯，每次我看他们代码时，说句实话，我想吐。如果你有更好的建议，欢迎留言告知。（注：本文以Java语言为例）

二、这是正文

编码方面

1） 方法名称的意义要明确。
  在提供方法时，一定要明确方法的用意，不然，他人在看到这个方法时会有歧义，以为用错了。

例如：
  我想根据no获取大于no的所有数据，而如下的方法其实是获取等于no的意思，而不是大于no的，因此会带来歧义。（我之前就犯过这样的错误 :(）

// 不友好的定义
public List<Book> getBookListByNo(int no);

// 友好的定义
public List<Book> getBookListByGtNo(int no);
  • 1
  • 2
  • 3
  • 4
  • 5

注意：
  Gt 是greater than 的缩写，因此不会带来歧义。在NoSQL数据库，比如MongoDB的条件查询中就是这样命名的，如下：

  • (>) 大于 ->$gt
  • (<) 小于 -> $lt
  • (>=) 大于等于 -> $gte
  • (<= ) 小于等于 -> $lte

2） 可根据参数顺序定义方法名。
  在给方法提供参数时，方法的命名最好根据参数列表进行命名，这样调用者通过方法即可看到参数的调用顺序，而不必进入方法内查看参数列表，但此规则仅仅适用于参数较少的方法。

例如：
  我想通过故事ID和用户ID去获取单个故事或者列表，给定故事ID和用户ID都是long型。

// 不友好的定义
public Story getStoryId(Long uid,Long storyId);
public Story getStoryBySidAndUid(Long uid,Long sid);

// 友好的定义
public Story getStoryByUidAndSid(Long uid,Long sid);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

解析：
  如果调用方法时没有注意参数的顺序，很容易导致用错，特别是对于参数类型都一样的参数列表，编译器不会报错，将造成严重的后果。如果程序员们都按照这个规则对短参数列表进行这样的命名，注释都省得写了，错误发生的概率也就小了。

3）不返回给客户端映射数据库的实体类。
  在给客户端做接口时，返回的数据字段一定要是一个自定义的类，如果返回的结果直接是映射数据库的类，那么这将是灾难。在客户端需要增加返回字段时，你不得不在重新开一个新的接口。虽然有注解可以忽略掉让dao层不识别扩展的字段，但对于客户端变化如此之快的业务，这样做也不是明智之举，也会使得原始类变得臃肿，难以维护。（这个只有做过api接口和客户端对接的业务才会有深深的体会）

4） 能用包装类型时坚决不用基本类型。
  在定义的bean时，基本类型最好使用包装类，而数组最好使用List，因为List可以使用Java的一些新特性，用起来更方便，也能给他人提供很好的调用，除此之外，对List的操作要比操作数组安全得多，当然，这么做有不好之处，出现空指针的概率变大了，编码时要时刻注意。同时，有时候数据库的查询结果可能是 null，因为自动拆箱，用基本数据类型接收有 NPE 风险。（好处还不止这些）

// 不友好的定义
public class TestClass{

    privete long id;

    private String name;

    private int age;

    private int[] hobbies;

    // 省略构造方法、getter、setter、toString方法
}

// 友好的定义
public class TestClass{

    privete Long id;

    private String name;

    private Int age;

    private List<Integer> hobbies;

    // 省略构造方法、getter、setter、toString方法
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

5）杜绝if else的层层嵌套。
  在编码过程中，如果能够使用反向条件过滤的逻辑，就先过滤掉，这样可以避免if else结构的层层嵌套，使得代码看起来层次结构非常的清晰易懂，也便于维护。如下代码块，你更喜欢看哪块代码呢？

// 不友好的代码
public StringBuilder testMethod(HttpServletRequest request, Long commentsId){

    StringBuilder rst;                
    if (commentsId == null || commentsId <= 0) {
        rst = ApiResBuilder.json(ActionStatus.PARAMAS_ERROR.inValue(), "invalid-comments_id");
    } else {
        CommentsBean comment = commentsService.get(commentsId);
        if (comment == null) {
            rst = ApiResBuilder.json(CommunityActionStatus.COMMENTS_NOT_EXISTS);
        } else {
            long uid = (Long) request.getAttribute(APIkey.uid);
            if (commentsService.praise(uid, commentsId, comment.getReply2thread())) {
                rst = ApiResBuilder.json(ActionStatus.NORMAL_RETURNED);
            } else {
                rst = ApiResBuilder.json(ActionStatus.UNKNOWN);
            }
        }
    }        
    return rst;
}

// 友好的代码
public StringBuilder testMethod(HttpServletRequest request, Long commentsId) {

    if (Objects.isNull(commentsId) || commentsId <= 0) {
        return ApiResBuilder.json(ActionStatus.PARAMAS_ERROR.inValue(), "invalid-comments_id");
    }

    CommentsBean comment = commentsService.get(commentsId);
    if (comment == null) {
        return ApiResBuilder.json(CommunityActionStatus.COMMENTS_NOT_EXISTS);
    }

    long uid = (Long) request.getAttribute(APIkey.uid);
    if (commentsService.praise(uid, commentsId, comment.getReply2thread())) {
        return ApiResBuilder.json(ActionStatus.NORMAL_RETURNED);
    } 

    return ApiResBuilder.json(ActionStatus.UNKNOWN);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41

6） 不要为了省事，编写较多的内部类。
  在编写代码时，如果你的类需要一些框架或者别人用无惨构造方法去构造对象的时候，尽量不要使用内部类的形式，如果非得要使用内部类，一定要将类定义为静态的，否则会导致这个内部类无法被构造。如果你忘记写这个static了（除非你非要这么做），那么将会给他人带来无数的“坑”。

7） 不要吝啬空行。
  编写代码时，可以根据业务将代码分行，用空行告知代码下一步是做什么的，在你觉得该留空行的地方的留上空行，而不是整个方法一行空行都没有，那样的代码真的很糟糕。（例子可能给得不恰当）

// 不友好的代码
public void testMethod(int day) {
    MoneyDayStatisticsBean moneyDayStatisticsBean = new MoneyDayStatisticsBean();
    DateTime time = DateTime.now().minusDays(day);
    String date = time.toString("yyyyMMdd");
    Long start = getMinMillis(time);
    Long end = getMaxMillis(time);
    StatsWithdrawCostResultDto statsWithdrawCostResultDto = withdrawStatsJob.statsWithdrawCost(start, end);
    moneyDayStatisticsBean.setId(redisIDService.generate(MoneyDayStatisticsBean.class));
    MoneyDayStatisticsBean lastMoneyDayStatisticsBean = moneyDayStatisticsDao.findLastBean();
    if (!Objects.isNull(lastMoneyDayStatisticsBean)) {
        moneyDayStatisticsBean.setTotalCost(lastMoneyDayStatisticsBean.getTotalCost().add(moneyDayStatisticsBean.getPlatformCost()));
    } else {
        moneyDayStatisticsBean.setTotalCost(moneyDayStatisticsBean.getPlatformCost());
    }
    moneyDayStatisticsBean.setCreateTime(DateTime.now().getMillis());
    WlTaskIncomePay incomePayByDate = businessStatService.getIncomePayByDate(date);
    long totalIncome = businessStatService.getTotalIncome(date);
    Double totalIncomeMoney = NumUtil.dividedBy100(totalIncome);
    moneyDayStatisticsBean.setTotalIncome(totalIncomeMoney);
    moneyDayStatisticsBean.setIncome(Objects.isNull(incomePayByDate) ?
            0 : NumUtil.dividedBy100(incomePayByDate.getIncomeTotal()));
    double totalCost = moneyDayStatisticsBean.getTotalCost().doubleValue();
    long res = totalIncome - NumUtil.multiplyBy100(totalCost);
    moneyDayStatisticsBean.setTotalSurplus(NumUtil.dividedBy100(res));
    moneyDayStatisticsDao.save(moneyDayStatisticsBean);
}

// 友好的代码

public void testMethod(int day) {

    MoneyDayStatisticsBean moneyDayStatisticsBean = new MoneyDayStatisticsBean();

    DateTime time = DateTime.now().minusDays(day);
    String date = time.toString("yyyyMMdd");
    Long start = getMinMillis(time);
    Long end = getMaxMillis(time);

    StatsWithdrawCostResultDto statsWithdrawCostResultDto = withdrawStatsJob.statsWithdrawCost(start, end);
    MoneyDayStatisticsBean lastMoneyDayStatisticsBean = moneyDayStatisticsDao.findLastBean();

    moneyDayStatisticsBean.setId(redisIDService.generate(MoneyDayStatisticsBean.class));
    if (!Objects.isNull(lastMoneyDayStatisticsBean)) {
        moneyDayStatisticsBean.setTotalCost(lastMoneyDayStatisticsBean.getTotalCost().add(moneyDayStatisticsBean.getPlatformCost()));
    } else {
        moneyDayStatisticsBean.setTotalCost(moneyDayStatisticsBean.getPlatformCost());
    }

    moneyDayStatisticsBean.setCreateTime(DateTime.now().getMillis());

    WlTaskIncomePay incomePayByDate = businessStatService.getIncomePayByDate(date);

    long totalIncome = businessStatService.getTotalIncome(date);
    Double totalIncomeMoney = NumUtil.dividedBy100(totalIncome);

    moneyDayStatisticsBean.setTotalIncome(totalIncomeMoney);
    moneyDayStatisticsBean.setIncome(Objects.isNull(incomePayByDate) ?
            0 : NumUtil.dividedBy100(incomePayByDate.getIncomeTotal()));

    double totalCost = moneyDayStatisticsBean.getTotalCost().doubleValue();
    long res = totalIncome - NumUtil.multiplyBy100(totalCost);
    moneyDayStatisticsBean.setTotalSurplus(NumUtil.dividedBy100(res));

    moneyDayStatisticsDao.save(moneyDayStatisticsBean);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66

8） 不让代码连火车。
  编写代码时，一行代码不要太长，如果太长，可在和合适的地方断行。我使用的工具是IDEA，我的建议是，代码的长度不要超过IDEA设定的两条竖线，多那么一丁点也是可以的。同时，方法的参数也应该在合适的地方断行，方便在查看方法时能够快速找到。
  如下图，超级长的代码，已经远远的超出IDEA设定的竖线。合适的做法是在appkey变量名后断行，这样更加优雅和美观。
超级长的代码

9） 定义API接口时，一个参数占据一行。
  定义接口时，最好的做法是一个参数占据一行，不要因为参数短，让几个参数占据一行，这使得在查看接口时，不能很好的识别参数的类型、名称等其他属性。

// 不友好的定义
@RequestMapping(value = "task/stats/golds", method = RequestMethod.GET, headers = "Accept=application/json")
@ApiOperation(value = "获取任务金币发放量", response = TaskGoldStat.class)
@ResponseBody
public JSONResult getUserMessage(@ApiParam("查询时间") @RequestParam(value = "start_time", required = false) Long startTime,@ApiParam("查询时间") @RequestParam(value = "end_time", required = false) Long endTime) {
    try {
        return JSONResult.okResult(userDataStatService.getTaskGoldFlow(startTime, endTime));
    } catch (Exception e) {
        SLogger.error(e, e);
        return JSONResult.failureResult(e.getMessage());
    }
}

// 友好的定义
@RequestMapping(value = "task/stats/golds", method = RequestMethod.GET, headers = "Accept=application/json")
@ApiOperation(value = "获取任务金币发放量", response = TaskGoldStat.class)
@ResponseBody
public JSONResult getUserMessage(@ApiParam("查询时间") @RequestParam(value = "start_time", required = false) Long startTime,
                                 @ApiParam("查询时间") @RequestParam(value = "end_time", required = false) Long endTime) {
    try {
        return JSONResult.okResult(userDataStatService.getTaskGoldFlow(startTime, endTime));
    } catch (Exception e) {
        SLogger.error(e, e);
        return JSONResult.failureResult(e.getMessage());
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

注意：
  这里有个问题，就是参数可能过长，导致超出了IDEA设定的竖线，这可能违背了上条规则。我的建议是，接口参数定义时，不管这一行代码多长，都要忽略上条规则，如果这个时候将代码断行，识别这个接口的参数就存在一定的障碍。接口一旦定义了，改变和查看的概率远小于业务层代码，因此，可忽略上条规则。

10） 定义枚举变量，以及一些常量时，名称使用大写。
  看过很多前辈代码，有大写的，有小写的，让人感觉很乱。我的建议是将这些变量定义成大写，借助开发工具，能够快速识别这些变量时说明类型。

11）利用IDEA的功能对代码按照一定的规则分块。
  有时候一个类中，代码可能比较多，业务也比较复杂，在他人查看代码时，如果这些业务方法没有进行分类排版，而是错中复杂的穿插在各行，这样的代码是很糟糕的。IDEA提供了如下命令：

//region 业务模块名称
//endregion 业务模块名称
  • 1
  • 2

在这个标签内的代码，可以灵活的展开和隐藏。这样，我们在编码时，就可以将相同业务的方法放入到此代码中，那么，在review代码时，就变得轻松多了。

12）一定要重载bean类的toString()方法。
  构建bean对象时， 一定要重载toString()方法，在方法执行抛出异常时，可以直接调用 类的 toString()方法打印其属性值，便于排查问题，而不是需要debug才能知道类的属性值。

13）Object的equals方法最正确的用法。
  Object 的 equals 方法容易抛空指针异常，如果明确的知道某个变量不可能为空指针，应使用常量或确定有值的对象来调用equals。
例如：

// 不友好的代码
object.equals("test");

// 友好的代码
"test".equals(object);
  • 1
  • 2
  • 3
  • 4
  • 5

14）使用private隐藏不想让外界访问的方法。
  现在开发项目都是基于IDE，IDE的代码提示功能方便了我们的开发。因此，在平时的开发中，如果某些方法不需要让外部所调用而引起错误，那么应该将其修饰为private的，这样可以减少错误调用导致的程序错误。编码时脑袋里不要理所当然的都是public。

15）利用集合运算提高程序的效率以及代码简洁度。
  做项目开发时会经常遇到这样的情况，从用户表得到了一批用户id集合，根据业务需求需要过滤掉一些不符合业务需求的用户id，将余下的用户id在进行别的也操作。那么，经常看到有同事是通过如下代码来处理的：

List<Long> uidList = new ArrayList<>();
uidList.add(2122346211L);
uidList.add(2126554121L);
uidList.add(2126562651L);
uidList.add(2265621171L);
uidList.add(4126216721L);

List<Long> removeList = new ArrayList<>();
removeList .add(2265621171L);
removeList .add(4126216721L);

uidList.removeAll(removeList);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

  还有一种方法是通过iterator去移除集合内的对象。基础好点的都知道，在对原集合边遍历边移除是会抛异常的，要想边遍历边移除只能用迭代器（iterator）才能够实现。而我推荐的做法是对两集合求差集，而不是调用集合的removeAll()方法，具体代码如下：

// 集合差集
List resultList = (ArrayList) CollectionUtils.subtract(listA, listB);

// 集合并集
List resultList = (ArrayList) CollectionUtils.union(listA, listB);

// 集合交集
List resultList = (ArrayList) CollectionUtils.intersection(listA, listB);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

可能有人会疑惑，将Collection强制转化为list会不会抛异常，其实不必担心，看看源码（源码如下）就是知道，CollectionUtils在做差集时将结果集保存到了ArrayList 中，所以不会出现强制转化异常。

 public static Collection subtract(Collection a, Collection b) {
        ArrayList list = new ArrayList(a);
        Iterator it = b.iterator();

        while(it.hasNext()) {
            list.remove(it.next());
        }

        return list;
   }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

  细心的人会发现，CollectionUtils.subtract()方法就是采用迭代器移除的方法实现的，那么你还有什么理由自己去写一遍这样的代码呢？

16）更优雅的写if的条件。
  在编码过程中，经常会对一个对象、集合、字符串判断是否是合法的参数，在没有第三方库的时候，我们的条件表达式可能是以下这样写的：

// 传统的条件表达式
Object object = null;
if(null == object){
    // TODO
}

String string = "";
if(null == string || string.length() <= 0){
    // TODO
}

List<Long> datas = new ArrayList<>();
if(null == datas || datas.size() <= 0){
    // TODO
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

  这么写，并没有什么不妥，只是，我们如果查看这个条件时，可能需要一点时间来解读这个if条件到底要做什么，这给我们解读代码带来了一定的障碍，特别是对于集合类或者字符串的判空时。而我建议的写法如下:

// 更优雅条件表达式
Object object = null;
if(Objects.isNull(object){
    // TODO
}

String string = "";
if(StringUtils.isBlank(string){
    // TODO
}

List<Long> datas = new ArrayList<>();
if(CollectionUtils.isEmpty(datas){
    // TODO
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

这些方法还有反向条件的方法：Objects.nonNull(obj),StringUtils.isNotBlank(obj),CollectionUtils.isNotEmpty(obj),这样的代码更加直观的表达了开发者的用意，且使得代码更加的优雅。

17）定义类的成员变量时，Boolean类型不要以is开头。
  定义为基本数据类型 boolean isSuccess； 的属性，它的方法也是 isSuccess()， 框架在反向解析的时候， “以为”对应的属性名称是 success，导致属性获取不到，进而抛出异常。

18）能不用else坚决不用。
  话不多说，直接上代码，你更喜欢哪块代码呢？

// 不优雅的代码
public void testMethod(){
    if(...){
        return obj;
    } else {
        return obj;
    }
}

// 优雅的代码
public void testMethod(){
    if(...){
        return obj;
    }
    return obj;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

19）创建类时一定要注明作者信息。
  在新建立类时，一定要标明这个类是谁创建的，最好连创建时间日期都带上，这么做的用意在于，在维护时能更好的找到责任人（嘻嘻），当然，作用可不止这些。如下给出我在工作中的类注释头。

/**
 * @Author: YaoQianShu
 * @Date: 2018/2/28
 * @Time: 15:27
 * Copyright © SSY All Rights Reserved.
 */
@Service
public class TestService {
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

20）使用Java8 lambda简化代码，使代码不仅优雅还高大上。
  一段普通的方法与Java8 lambda语法的示例。

// 普通的代码
List<Integer> datas = new ArrayList<>();
// 省略初始化
for（Integer num : datas）{
    System.out.println(num);
}

// Java8 lambda
List<Integer> datas = new ArrayList<>();
// 省略初始化
datas.stream().forEach(System.out::println);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

21）行注释不要放在代码之后。
  很多人在写代码是为了方便，在写完代码时，将注释直接写在代码之后，而不换行，当代码本身就比较长时，这样的注释可能就超出屏幕的可见范围，这么做是很不可取的。

// 不友好的行注释

if(....){ // 这是注释
}

boolean result = StringUtils.isBlank(varA) || Objects.isNull(varB); // 这是注释注释注释注释注释注释注释

// 友好的行注释

// 这是注释
if(....){ 
}

// 这是注释注释注释注释注释注释注释
boolean result = StringUtils.isBlank(varA) || Objects.isNull(varB);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

22）接口类中的方法和属性不要加任何修饰符号。

// 不友好的定义
public interface Test{

    /**
     * This is method describe!
     **/
    public void testMethod();
}

// 友好的定义
public interface Test{

    /**
     * This is method describe!
     **/
    void testMethod();
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

23）不吝啬“{}”。
  在 if/else/for/while/do 语句中必须使用大括号，即使只有一行代码。

// 不友好的代码
if(...) //TODO

// 友好的代码
if(...){
    // TODO
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

24）容易被遗忘的关键字 - switch。
  在某些控制语句中，如果能用switch解决的，推荐使用switch，例如条件表达式是枚举常量或者其他可使用switch完成的，应都用switch来控制，switch不仅可以使代码简洁，且分支跳转效率要比if else效率高。同时需要注意，即使default分支什么都不处理，我们也应该写上。

// 不友好的代码
if(var == ONE){
    // TODO
} else if(var == TWO){
    // TODO
} else if(....){
}else{
}

// 友好的代码
switch(var){
    case ONE:
        // TODO
    break;
    case TWO：
        // TODO
    break;
    .......
    default:
    break;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

25）集合初始化时尽量指定集合初始值。
  ArrayList 尽量使用 ArrayList( int initialCapacity) 初始化，Map等其他集合类类似。特别是对于一些明确知道集合大小的情况下最为妥当，可以防止集合扩容而牺牲不必要的空间和时间。

// 不友好的代码（例子为接收Redis的响应结果,外部传入taskKeyList）
Map<String, Response<String>> responseMap = new HashMap<>();
Pipeline pipeline = jedis.pipelined();

for (String taskKey : taskKeyList) {
    String key = createKey(currentTime, uid, taskKey);
    responseMap.put(taskKey, pipeline.get(key));
}

// 友好的代码（此处对HashMap进行了初始化）
Map<String, Response<String>> responseMap = new HashMap<>(taskKeyList.size());
Pipeline pipeline = jedis.pipelined();

for (String taskKey : taskKeyList) {
    String key = createKey(currentTime, uid, taskKey);
    responseMap.put(taskKey, pipeline.get(key));
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

26）获取系统时间戳用System. currentTimeMillis()。
  获取当前毫秒数 System. currentTimeMillis(); 而不是 new Date(). getTime()，或者JodaTime的 new DataTime()。如果想获取更加精确的纳秒级时间值，用 System. nanoTime()。
  Reason:System. currentTimeMillis()是一个native方法，并且被static修饰，效率更高，而new开辟的对象不仅消耗空间，还浪费时间。

27）循环体中的语句要考量try-catch性能。
  循环体中的语句要考量性能，以下操作尽量移至循环体外处理，如定义对象、变量、
获取数据库连接，进行不必要的 try-catch 操作（这个 try-catch 是否可以移至循环体外） ，并且，将try-catch移至外部后，代码看起来会更优雅。

// 不友好的代码
public void tryCatchTest1() {

    int divider = 100;

    List<Integer> list = new ArrayList<>(3);
    list.add(12);
    list.add(13);
    list.add(0);

    List<Double> result = new ArrayList<>(3);

    list.stream().forEach(var -> {
        try {
            result.add((double) (divider / var));
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }
    });

    result.stream().forEach(System.out::println);
}

// 友好的代码
public void tryCatchTest() {

    int divider = 100;

    List<Integer> list = new ArrayList<>(3);
    list.add(12);
    list.add(11);
    list.add(0);

    List<Double> result = new ArrayList<>(3);
    try {
        list.stream().forEach(var -> result.add((double) (divider / var)));
    } catch (ArithmeticException e) {
        e.printStackTrace();
    }

    result.stream().forEach(System.out::println);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43

别踩坑

1） 使用Redis的有序集合时，一定要注意如果想要实现分页时，Redis不会将分页的大小减1，而是从0到分页大小的下标取数据，所有如果分页取20，那么最终结果是21个。因为它是按照数组的下标取值的。如果想要取第二页，那么，如果按照mysql的分页规则，那么，redis的size需要加上offset的值，否则分页将不正确。（以上仅限Redis的集合类）

2）在从数据库中获取带状态的数据时，一定要加上状态。比如，现在要获取一个任务，这个任务的状态类型有下线、删除和有效状态，那么，在获取某个任务时，一定要带状态，否则当有相同数据但状态不同时，就会产生错误。

3） 在使用Map时，一定要注意数据类型要一致。
例如：

Map<String,String> datas = new HashMap<>();
datas.put("10001","haha");
datas.put("10002","oo");

Long testKey = 10001L;
String res = datas.get(testKey);

//不要以为res的值为“haha”，那你就错了，res的值为null.
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

  查看源码变可以知道，Map的方法：V get(Object key); 其实是将key键当做对象来处理的，因此，会导致取不到结果，正确的做法是将Long类型的key转化为String型或者存储和取值保存一样的方式，如下：

String res = datas.get(String.valueOf(testKey));
  • 1

这样就可以得到正确的结果。

注意

1） 自定义对象比较记得重载hashCode和equals方法。
  在使用CollectionUtils时，一定要小心用户自定义对象类集合的比较，因为这些自定义类如果没有重载hashCode和equals方法时，将得不到你想要的结果。

2）编写MySQL语句时，对每个字段都加‘`field_name`’。
  MySQL环境对sql语句中出现关键字时，如果没有加“` `”的话，会报语法错误，导致项目出现Server Error，因此，以后项目编码过程中最好都带“` `”，防止不必要的bug，增加不必要的Bug修复操作。

3） 小心整形数相除得不到小数部分。
  两个整形相除会得不到小数部分，因此需要转化除数。
例如：
double res = 10 / 3.0;
必须将3写成3.0，否则结果将是3.0，而不是3.333

4）基本数据类型的包装类对象之间值的比较，全部都用equals方法比较。
  对于 Integer var=?在-128 至 127 之间的赋值， Integer 对象是在
IntegerCache. cache 产生，会复用已有对象，这个区间内的 Integer 值可以直接使用==进行
判断，但是这个区间之外的所有数据，都会在堆上产生，并不会复用已有对象，这是一个大坑，
推荐使用 equals 方法进行判断。

未完，待续…..

由于小编能力有限，如果更好的建议，欢迎告知，谢谢！

 

ArthurKingYs
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
codingame:Java 和 Scala 中编码游戏难题的一些“解决方案”
06-22
编码名可能不是“最佳”，但至少所有测试都通过了并且他们赢得了所有“挑战”。 :-) 我是 Scala 的初学者，所以不要太相信我的 Scala 编码风格。 :-))
让编码成为一种艺术
YQS_Love的博客
03-05 1340
一、前言   在实际工作中，我们所编写的代码主要是给我们自己看的，只是顺便让机器去执行。那么，可想而知，良好的代码编写风格，将给维护人员带来很大的便利之处。这篇文章是我工作中的一些总结，也许并不适合你，但值得参考，因为我的很多同事并没有良好的编码风格和习惯，每次我看他们代码时，说句实话，我想吐。如果你有更好的建议，欢迎留言告知。（注：本文以Java语言为例） 二、这是正文 编码方面 ...
编码风格总结
weixin_61145649的博客
05-19 1299
软件工程（编码风格）： 提示：5月19日学习记录，良好的代码风格 学习内容： 源程序代码的逻辑简明清晰、易读易懂是好程序的一个重要标准，为了做到这一点，应该从以下几个方面遵循相应的规则： 程序内部的文档 数据说明 语句构造 输入输出 效率 学习产出： 程序内部的文档包括： 标识符 即符号名，包括模块名、变量名、常量名等。这些名字应能反映它所代表的实际东西，应有一定实际意义。 ​ 例如，表示次数的量用Times，表示总量的用Total，表示平均值的用Average，表示和的量用Sum等。
java编码风格和规范
最新发布
抓饭不吃皮牙子
02-19 948
本文介绍了一些常见的Java编码风格和规范，包括命名规范、缩进和空格、注释规范、类和方法设计、异常处理、格式化和代码布局，以及代码复用和继承。遵循这些规范将有助于提高代码的可读性、可维护性和一致性，并促进团队合作和代码质量的提升。
一些养成良好代码风格的方法
zhanlongsiqu的博客
01-10 555
以下为大家介绍一些养成良好代码风格的方法，内容来源于《高质量C++/C编程指南》。 1、空行 【规则1】每个函数定义结束之后都要加空行。参见示例2-1（a）
谈谈良好的编码风格
lanyuxinkong的专栏
08-27 4105
能写出结构精巧的代码是一件令人羡慕的事情，能写出解决复杂问题模型的算法是一件令人羡慕而又佩服事情。虽然未必所有人能做到这些，但是每一个对代码有信仰的人至少要做到语法使用合理、代码简洁、逻辑清晰、变量的命名是见名知义的、注释是恰当可读的、会合理使用常量......总的来说是要有良好的编码风格。 一、说说为什么要使用常量 在编码过程中，常常会遇到一些表示状态的情况。很多时候为了方便我们直接使用了字
Java | 编码的艺术
wongbynn的博客
12-05 218
思考 在《调香术》这本书里面有这样一句话，<font color= “#660066" >“人所共知，调香是科学技术和艺术的结合，在调配高级香水、空气清新剂、化妆品香精时。“艺术”二字占有更大的分量，同艺术家、画家一样，调香师的艺术修养决定了他的作品到达的境界。” 如果对这句话引深一下，我觉得编程也是如此，<font color= “#660066" >开发人员对编码理解和领悟的水平高低，决定了其编码艺术水平到达的境界，越是优雅、简洁的代码，其艺术水平就越高，更容易让人产生心理共
程序编码规范(java).doc
03-25
好的代码风格不仅会提高可读性，而且会使代码更健壮，更为重要的是在修改时不容易出错。现代软件开发中，维护工作会占用80%的时间，而且开发者和维护者通常不是同一个程序员。这意味着程序员经常要阅读和修改别人...
Java零基础 - Java中的注释.md
08-15
本文档详细介绍了Java中的注释类型，包括单行...阅读相关的Java编码规范，了解注释的最佳实践； 查阅Java文档生成工具的使用方法，尝试为自己的项目生成API文档； 参与开源项目或团队合作，学习他人的注释风格和技巧。
Java编码规范终极版
05-16
通过建立编码规范，以使每个开发人员养成良好的编码风格和习惯；并以此形成开发小组编码约定，提高程序的可靠性、可读性、可修改性、可维护性和一致性等，增进团队间的交流，并保证软件产品的质量。 1. 1.1 为什么要...
Java By Comparison - Become a Java Craftsman in 70 Examples
07-11
本书通过70个代码例子说明了如何编写好代码。虽然代码是用Java写的，但是其思想适合于所有开发人员。
Java编程风格
qq_30326403的博客
05-23 2457
在用一种语言编辑时遵守该语言的编程风格是非常重要的，否则编写的代码将难以阅读，给后期的维护带来诸多不便。例如，一个程序员将许多代码都写在一行，尽管程序可以正确的编译和运行，但是这样的代码几乎无法阅读，其他程序员无法容忍这样的代码，本次将为大家介绍一些最基本的编程风格。 在编写java程序时，许多地方都会涉及使用一对大括号，例如类的类体、方法的方法体、循环语句的循环体以及分支语句的分支体等都使用一对大括号括起若干内容，即俗称的“代码块”都是用一对大括号括起的若干内容。“代码块...
编码的艺术
华章IT官方博客
07-02 157
《编写可读代码的艺术》是一本关注编码细节的书。或许你会认为本书所讲皆为小道，诸如方法命名、变量定义、语句组织、任务分解等内容，俱是细枝末节，微不足道。然而，对于一个整体的软件系统而言，既需要宏观的架构决策、设计与指导原则，也必须重视微观的代码细节。正如作文，提纲主旨是文章的根与枝，但一词一句，也需精雕细作，才能立起文章的精气神。 所谓“细节决定成败”，在软件历史中，有许多影响深远的重大失败，其根...
深入分析 Java 中的中文编码问题
yij1986916的博客
07-09 4560
  深入分析 Java 中的中文编码问题 几种常见的编码格式 为什么要编码 不知道大家有没有想过一个问题，那就是为什么要编码？我们能不能不编码？要回答这个问题必须要回到计算机是如何表示我们人类能够理解的符号的，这些符号也就是我们人类使用的语言。由于人类的语言有太多，因而表示这些语言的符号太多，无法用计算机中一个基本的存储单元—— byte 来表示，因而必须要经过...
【JAVA编码规范】JAVA编码规范，超级详细的JAVA编码规范，太棒了，值得你通读一遍
xzb5566的专栏
07-07 7282
【JAVA编码规范】JAVA编码规范，超级详细的JAVA编码规范，太棒了，值得你通读一遍 编码规范对于程序员而言尤为重要，有以下几个原因： 一个软件的生命周期中，80%的花费在于维护 几乎没有任何一个软件，在其整个生命周期中，均由最初的开发人员来维护 规范可以改善软件的可读性，可以让程序员尽快而彻底地理解新的设计和代码 良好的编码规范可以有效避免一些低级错误
java的编码风格_Java良好的编码风格（一）
weixin_34827430的博客
02-26 656
编程规约：(一)命名规约【强制】 代码中的命名均不能以下划线或美元符号开始，也不能以下划线或美元符号结束。反例：_name / _name / $Object / name / name$ / Object$【强制】类名使用 UpperCamelCase 风格，必须遵从驼峰形式，但以下情形例外：(领域模型 的相关命名)DO / BO / DTO / VO 等。正例：MarcoPolo / User...
好的编码风格和不好的
GhostHouse
01-05 1583
再去粗粗阅读，对好的程序员还是差的程序员就会更有把握。好的程序员写的代码，有一种精心雕琢而成的一致性。好的程序员一致会遵守统一的命名方式，如camelCase，而差的程序员的变量命名时不时的就会偏离统一规范。好的程序员的代码中拼写错误几乎不可见，而差的程序员的拼写错误要多得多。好的程序员对于同一类动作，不会忽而用这个动词，忽而又用那个同义词，如add/insert混用。好的程序员采用一致的简写规则
一份比较优雅的代码风格注意点
qq_24884955的博客
02-27 335
以下是我个人从工作经验中引发的问题和前辈指导的途径中理解的一些基本点    规范这个问题要放在第一个说明，正所谓国有国法 家有家规，没有规矩，不成方圆，遵循编码规则定义好的规范，是作为一个程序员最基本的素养和要求 向不同的语言都有着各自自己的语言规范规范描述或者想使用git github这种协同工作的规范。一般在公司的商业项目里技术团队里都有自己定义的规范说明 在写代码开始前，时刻提醒要遵循...
如何写好Java代码
02-07
写好Java代码的方法有很多，下面列举一些常见的建议： 1. 遵循Java的编码规范：Java有自己的编码规范，比如命名规则、缩进规则、注释规则等。遵循这些规范可以让你的代码更易读、更易维护。 2. 使用良好的编码风格...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值