哪些代码让大家入了坑？

java 就是这么一门神奇的语言，任何水平的人都能写出可以运行的代码，但是一看代码便知水平高低。作为一个程序员，你看过哪些坑爹代码，你又写过多少坑爹代码，还有多少你不知道的坑爹代码？

有意思的是码云上建了一个代码仓库：bullshit-codes，仓库的目的就是为了收集这些坑爹代码，可以让别人不掉坑或者少掉坑，可以避免自己掉坑，或许哈哈一乐！

上边汇聚了各种编程语言的，仓库地址如下：

本文小编给大家整理了几个比较坑爹的代码，整理了几个之后，实在整理不下去了，仅供大家参考，看看能不能崩溃掉！

一、几个坑爹代码的目录

1、这样使用 StringBuffer 的方法有什么坑？

2、你写过的最长的一行代码有多长？？？

3、循环+条件判断，你最多能嵌套几层？

4、为了后期优化查询速度 ~ 颇有商业头脑！

5、你是如何被异常玩然后变成玩异常的？

6、Stream 玩得最 6 的代码，看过的人都惊呆了！

二、坑爹代码 | 这样使用 StringBuffer 的方法有什么坑？

你是否曾经这样使用过 Java 的 StringBuffer 类？

1. /**  
2.  * Create Time 2019/5/24  
3.  * StringBuffer追加 如痴如醉的写法  
4.  * @author cailong  
5.  **/  
6. public class Append {  
7.     public static void main(String[] ares){  
8.         StringBuffer sb = new StringBuffer();  
9.         //这里都能理解  
10.         sb.append("xml version=\\"1.0\\" encoding=\\"UTF-8\\"?><ROOT>");  
11.         for (int i = 0; i < 10; i++) {  
12.             //为什么到这里就要这样写？？？既然都用StringBuffer了    （这里省略集合遍历用i代替 意思能懂就行）  
13.             sb.append("<NSRXX>" +  
14.                     "<NSRSBH>"+i+"NSRSBH>" +  
15.                     "<NSRMC>"+i+"NSRMC>" +  
16.                     "<DJXH>"+i+"DJXH>" +  
17.                     "<ZGSWJ_DM>"+i+"ZGSWJ_DM>" +  
18.                     "<ZGSWJ_MC>"+i+"ZGSWJ_MC>" +  
19.                     "<SJLY>sjzsSJLY>" +  
20.                     "<YWSX_DM>"+i+"YWSX_DM>" +  
21.                     "NSRXX>");  
22.         }  
23.         sb.append("ROOT>");  
24.         System.out.println(sb.toString());  
25.     }  
26. } 

三、坑爹代码 | 你写过的最长的一行代码有多长？？？

你写过的最长的一行代码有多长吗？你为什么要写这么长？是看着帅呢，还是想减少代码行数？

1. List<OperationPurchaseInfo> purchaseInfoList  
2.                 = sheet.getPurchaseInfoList()  
3.                 .stream()  
4.                 .filter(purchaseInfo -> purchaseInfo.getExteriorOperation()  
5.                         .getExteriorPart()  
6.                         .getExteriorOperationList()  
7.                         .stream()  
8.                         .filter(exteriorOperation -> exteriorOperation  
9.                                 .getProcessState()  
10.                                 .equals(ExteriorOperation.ProcessState.PROCESSING))  
11.                         .count() != 0  
12.                         // 订单明细中工序对应的工件下的其他工序存在加工中，  
13.                         // 且已发给供应商且供应商不是当前订单供应商时，需要判断  
14.                         && (purchaseInfo.getExteriorOperation()  
15.                         .getExteriorPart()  
16.                         .getTeamwork() == null || !purchaseInfo.getExteriorOperation()  
17.                         .getExteriorPart().getTeamwork().equals(sheet.getTeamwork()))  
18.                 ).collect(Collectors.toList()); 

上面这段代码虽然被拆开多行显示，但本质上是一行，一个极其复杂的赋值语句！

这种代码是不是为了让别人看不懂来彰显自己的编码水平呢？

小编觉得 Java Stream API 以及各种函数式编程方法，以及各种语法糖在某种程度让这种糟糕代码越来越多！

那么一起来批判一下这个代码，或者你有什么好的解决方案呢？

四、坑爹代码 | 循环+条件判断，你最多能嵌套几层？

for 循环和 if 条件判断语句，必不可少吧。但是你见过最多嵌套的循环和条件判断有几层呢？或者说，你最多能容忍多少层的嵌套呢？

我们还是先来看看极端的坑爹代码吧：

1. // 这个无限循环嵌套，只是总循环的一部分。。。我已经绕晕在黄桷湾立交  
2.         if (recordList.size() > start) {  
3.             for (int i = start; i < end; i++) {  
4.                 Map<String, Object> map = recordList.get(i);  
5.                 Map<String, Object> field11 = (Map<String, Object>) map.get("field"); //name -> code  
6.                 Map<String, Object> record11 = (Map<String, Object>) map.get("record"); // code -> value  
7.                 String catagory1 = map.get("categoryId").toString();  
8.                 //  查询第一种类型对应的其他类型  
9.                 SalaryDataVo ss = JSON.parseObject(JSON.toJSONString(map), SalaryDataVo.class);  
10.                 Page page3 = salaryManagerService.getAllRecordsByCondition(ss);  
11.                 if (page3.getRecords().size() > 0) {  
12.                     List<Map<String, Object>> salaryDataVos = page3.getRecords();  
13.                     salaryDataVos = this.reSetMap(salaryDataVos, null, null);  
14.                     for (Map<String, Object> map2 : salaryDataVos) {  
15.                         Map<String, Object> field2 = (Map<String, Object>) map2.get("field");  
16.                         Map<String, Object> record2 = (Map<String, Object>) map2.get("record");  
17.                         String catagory2 = map2.get("categoryId").toString();  
18.                         List<SalaryGroupVO> groupList2 = salaryGroupService.getSalaryGroupsItems(this.getUserCorpId(), catagory2);  
19.                         for (SalaryGroupVO cc : groupList2) {  
20.                             cc.setCode(cc.getParentId() + cc.getCode());  
21.                         }  
22.                         //计算  
23.                         for (Map.Entry<String, Object> entity : field2.entrySet()) {  
24.                             String keyName = entity.getKey();  
25.                             for (SalaryGroupVO s2 : groupList2) {  
26.                                 if ("bigDecimal".equals(s2.getItemType()) && s2.getCode().equals(field2.get(keyName).toString()) && ("部门" != keyName) && ("姓名" != keyName) && StringUtils.isNotEmpty(s2.getItemType())) { 
27.                                      if (field11.containsKey(keyName)) {  
28.                                         if (field11.containsKey(keyName)) {  
29.                                             String code1 = field11.get(keyName).toString();  
30.                                             Double newValue = 0.0;  
31.                                             Double oldValue = 0.0;  
32.                                             if (!record11.get(code1).toString().matches("^[0-9]*$")) {  
33.                                                 oldValue = Double.parseDouble(record11.get(code1).toString());  
34.                                                 if (record2.containsKey(entity.getValue().toString()) && (!record2.get(entity.getValue().toString()).toString().matches("^[0-9]*$"))) { 
35.                                                      String value2 = record2.get(entity.getValue().toString()).toString();  
36.                                                     newValue = Double.parseDouble(value2);  
37.                                                 }  
38.                                                 record11.remove(field11.get(keyName).toString());  
39.                                             }  
40.                                             if (code1.startsWith(catagory1) || code1.startsWith(catagory2)) {  
41.                                                 String co = code1.replace(catagory1, "hz");  
42.                                                 field11.put(keyName, co);  
43.                                                 record11.put(co, oldValue + newValue);  
44.                                             }  
45.                                         }  
46.                                     } else {  
47.                                         String code = entity.getValue().toString();  
48.                                         String str = entity.getValue().toString();  
49.                                         Object value2 = record2.get(entity.getValue().toString());  
50.                                         if (str.startsWith(catagory1) && str.replace(catagory1, "").startsWith("hz")) {  
51.                                             code = str.replace(catagory1, "");  
52.                                         } else if (str.startsWith(catagory2) && str.replace(catagory2, "").startsWith("hz")) {  
53.                                             code = str.replace(catagory2, "");  
54.                                         }  
55.                                         field11.put(keyName, code);  
56.                                         record11.put(code, value2);  
57.                                     }  
58.                                 }  
59.                             }  
60.                         }  
61.                     }  
62.                 }  
63.                 List<SalaryGroupVO> sList = salaryGroupService.getSalaryGroupItemsByParentId(catagory1);  
64.                 for (SalaryGroupVO s : sList) {  
65.                     if (field11.containsKey(s.getName()) && s.getCode().startsWith("hz")) {  
66.                         String k = field11.get(s.getName()).toString();  
67.                         field11.put(s.getName(), s.getCode());  
68.                         String value = null;  
69.                         if (record11.containsKey(k)) {  
70.                             value = record11.get(k).toString();  
71.                         }  
72.                         record11.put(s.getCode(), value);  
73.                     }  
74.                 }  
75.                 resultList.add(map);  
76.                 pageInfo.setRecords(resultList);  
77.             }  
78.         } 

我数了数，一共有 11 层的嵌套！！！

吐槽归吐槽，这样的代码逻辑有什么重构的好方法吗？

五、坑爹代码 | 为了后期优化查询速度 ~ 颇有商业头脑！

什么样的程序员是一个好程序员呢？当我们在给客户开发系统时候，为了后期的优化，预留一些埋点。

通过对这些埋点的优化，可以让客户瞬间感觉系统在运行速度上有质的飞跃，让公司顺利的签署二期开发合同，收取巨额开发费用。

从公司角度来看，这样的程序员就是一个好程序员。 —— 这句话不是红薯说的！

比如：

我想说的是：凶碟，你下手能否不那么狠啊，建议对代码进行优化，改成 Thread.sleep(1000);  —— 这句话也不是红薯说的。

或者你有什么更好的建议呢？不要觉得骇人听闻，真有这样的人，这样的代码！！！

六、坑爹代码 | 你是如何被异常玩然后变成玩异常的？

玩 Java 的人，刚开始会被各种异常虐，空指针应该是最常见的。多玩两年就开始玩异常，各种奇葩异常玩法层出不穷。

你觉得下面这种异常的定义妥吗？

1. /**  
2.  * 处理业务的异常  
3.  * 居然有一堆静态异常，准备好了随时可以抛？？  
4.  * 错误码是字符串  
5.  */  
6. public class CommandException extends BaseException {  
7.   private static final long serialVersionUID = -6354513454371927970L;  
8.   public static CommandException PARAM_NULL= new CommandException("Command_assemble_01", "Parameter is Needed But Empty");  
9.   public static CommandException DEVID_NULL = new CommandException("Command_assemble_02", "DevId Cannot Be Null");  
10.   public static CommandException MDCODE_NULL = new CommandException("Command_assemble_03", "Model Code Cannot Be Empty");  
11.   public static CommandException ORDER_NULL = new CommandException("Command_assemble_04", "Order Cannot Be Empty");  
12.   public static CommandException TYPE_NULL = new CommandException("Command_assemble_05", "Upstream / Downstream Type Cannot Be Empty");  
13.   public static CommandException MENUID_NULL = new CommandException("Command_assemble_06", "Menu Id Cannot Be Null");  
14.   public static CommandException CTRLTYPE_NOT_RANGE= new CommandException("Command_assemble_07", "Ctrltype Cannot Be Recognized, Which is not in Range");  
15.   public static CommandException CMD_NULL = new CommandException("Command_analyze_01", "CMD Cannot Be Null");  
16.   public static CommandException PAYLOAD_NULL = new CommandException("Command_analyze_02", "Payload Cannot Be Null");  
17.   public static CommandException FRAMEWORK_FAILED= new CommandException("Command_analyze_03", "Framework Failed to be Checked");  
18.   public static CommandException CHECK_FAILED= new CommandException("Command_analyze_04", "Command Failed to be Checked");  
19.   public static CommandException CONFIGURE_NOT_EXIST = new CommandException("Command_error_1001", "Configure is not Exist");  
20.   public static CommandException REDIS_ERROR = new CommandException("Command_error_1002", "Cache Command in Redis Error", true);  
21.   //省略构造函数、get/set方法  
22. } 

如果不妥，有什么问题呢？

七、坑爹代码 | Stream 玩得最 6 的代码，看过的人都惊呆了！

Stream 作为 Java 8 的一大亮点，它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念。Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作 (bulk data operation)。Stream API 借助于同样新出现的 Lambda 表达式，极大的提高编程效率和程序可读性。

那么 Java 8 的 Stream 到底是王者，还是个巨坑，这完全取决于你是怎么玩的？

我不得不说，下面代码是我从业 20 年（说谁呢，谁从业 20 年，我今年 19  岁！！！）看过最牛逼的 Stream 的用法：

1. //Stream 用的66的  
2. final EventAction eventAction = redisObj(  
3.                 EventActionKey + distributionEventId,  
4.                 () -> Optional  
5.                         .of(distributionEventId)  
6.                         .map(eventId -> {  
7.                             final EventActionExample example = new EventActionExample();  
8.                             example.createCriteria()  
9.                                     .andEventIdEqualTo(eventId)  
10.                                     .andTriggerTypeEqualTo(EnumEventTriggerType.DISTRIBUTION_PURCHASE.getCode().byteValue());  
11.                             return example;  
12.                         })  
13.                         .map(eventActionMapper::selectByExample)  
14.                         .filter(StringUtil::isNotEmpty)  
15.                         .map(e -> e.get(0)).orElseThrow(() -> ExceptionUtil.createParamException("事件触发信息不存在"))  
16.                 , EventAction.class);  
17.         final AwardConfig awardConfig = redisObj(EventConfigKey + eventAction.getId(),  
18.                 () -> Optional.ofNullable(eventAction.getId())  
19.                         .map(actionId -> {  
20.                             final AwardConfigExample example = new AwardConfigExample();  
21.                             example.createCriteria()  
22.                                     .andActionIdEqualTo(actionId);  
23.                             return example;  
24.                         })  
25.                         .map(awardConfigMapper::selectByExample)  
26.                         .filter(StringUtil::isNotEmpty)  
27.                         .map(e -> e.get(0)).orElseThrow(() -> ExceptionUtil.createParamException("xxx")),  
28.                 AwardConfig.class  
29.         );  
30.         Optional.of(req)  
31.                 .map(e -> e.clueUid)  
32.                 .map(id -> {  
33.                     final ClueExample example = new ClueExample();  
34.                     example.createCriteria()  
35.                             .andClueUidEqualTo(id)  
36.                             .andDeletedEqualTo(false)  
37.                             .andReceivedEqualTo(false)  
38.                             .andCreateTimeGreaterThan(now - cluetime);  
39.                     example.setOrderByClause("create_time asc");  
40.                     return example;  
41.                 })  // 获取该被邀请人所有未过期且未被领取的线索的线索  
42.                 .map(clueMapper::selectByExample)  
43.                 .filter(StringUtil::isNotEmpty)  
44.                 .ifPresent(clues -> {  
45.                             final ClueResp clueResp = Optional.of(req)  
46.                                     .filter(c -> {  
47.                                         c.count = clues.size();  
48.                                         return true;  
49.                                     })  
50.                                     .map(this::awardValue)  
51.                                     .orElseThrow(() -> ExceptionUtil.createParamException("参数错误"));  
52.                             final Integer specialId = req.getIsHead()  
53.                                     ? clues.get(0).getId()  
54.                                     : clues.get(clues.size() - 1).getId();  
55.                             clues.stream()  
56.                                     .peek(clue -> {  
57.                                         final AwardConfig awardConfigclone = Optional.of(awardConfig)  
58.                                                 .map(JSONUtil::obj2Json)  
59.                                                 .map(json -> JSONUtil.json2Obj(json, AwardConfig.class))  
60.                                                 .orElseGet(AwardConfig::new);  
61.                                         awardConfigclone.setMoney(  
62.                                                 Optional.of(clue.getId())  
63.                                                         .filter(specialId::equals)  
64.                                                         .map(e -> clueResp.specialReward.longValue())  
65.                                                         .orElse(clueResp.otherAverageReward.longValue())  
66.                                         );  
67.                                         eventActionService.assembleAward(  
68.                                                 awardConfigclone,  
69.                                                 clue.getAdviserUid(),  
70.                                                 clue.getAdviserUid(),  
71.                                                 clue.getClueUid(),  
72.                                                 eventAction,  
73.                                                 new PasMessageParam(),  
74.                                                 clue.getId(),  
75.                                                 AwardRelationType.Clud.code()  
76.                                         );  
77.                                     })  
78.                                     .forEach(clue -> {  
79.                                         clue.setOrderNo(req.orderNo);  
80.                                         clue.setCommodityName(req.commodityName);  
81.                                         clue.setOrderAmount(req.orderAmount);  
82.                                         clue.setReceived(true);  
83.                                         clue.setModifyTime(now);  
84.                                         clueMapper.updateByPrimaryKeySelective(clue);  
85.                                     });  
86.                         }  
87.                 ); 

Java 就是这么一门神奇的语言，任何水平的人都能写出可以运行的代码，但是一看代码便知水平高低。但是这样的 Stream 代码你一定一口老谈不吐不快！

八、小编已阵亡

好了，小编实在整理不下去了，大家有兴趣的可以去：

https://gitee.com/oschina/bullshit-codes

更进一步的吐槽！

很多编程语言需要用指令方式说明计算的程序，而有些编程语言则属于声明式编程，说明需要的结果，而不说明如何计算。