如何写出让同事无法维护的代码？

我并不是要叫你写出无法维护的代码，而是根据以往自己写的代码，想要优化，简洁，提炼代码，因为业务问题，曾经的工具类写出了有名的千行foreach，平时也以此自我调侃，而此段代码不懂业务的情况下，很难维护，且复用度极高，但可读性，扩展性为0，除了必要的注释，我觉得我方法名很直白了，难道这都看不懂？其实自己过了一个月在看自己的代码，同样问号脸。

要想无法维护

1、无注释，除了顺序注释以外，当时很少写注释

2、千层蛋糕for循环，if else多层嵌套，且无跳出逻辑

此代码一出，保证接手代码的人倒吸一口凉气。

一般情况下不需要更改idea单个文件初始化加载大小的，而当时写的那个工具类当个文件2.5M，总代码行数8000行+，单个方法if+for，400行+

且在1万节点的解析上长达5分钟，没有SQL执行，单纯解析验证，

在这里说下解析节点的逻辑

1. 获取前台xml文件，解析成图片保存

2. 每个节点解析成JSON数据并在数组内保存到响应库中

3. 每个节点存在连接关系，需分析到对应连接，比如1–>2,是一种情况，2–>1是一种情况，两种连接不能复用数据

4. 每个节点内的数据需要校验，并不是普通的校验，除了非空的前后台校验，还要校验其有效性，这里的校验并不是说普通的是否电话号码有效，格式正确等，而是比如A节点的IP是否在B节点连接的IP网段内，是否是同一网段，MAC是否重复，是否是DHCP，是否是广播地址等，页面有两个节点就要把左右的判断都走一遍，所以万节点下极慢~

   5.结构我用的IdentityHashmap，因为你A连B是A–>B,B连A是B–>A，此时的节点Id是重复但源节点与目标节点不同的。

优化方法：

1.枚举

在需求变更之前，固定节点只有5个元素节点，但需求不断变更会增加节点，但节点内的数据格式是一致的，使用枚举只需要增加元素节点，不需要增加代码逻辑

public enum EnumTest {


    ONE("one") {
        @Override
        public void apply() {
            System.out.println("one");
        }
    },
    TWO("two") {
        @Override
        public void apply() {
            System.out.println("two");
        }
    }, THREE("three") {
        @Override
        public void apply() {
            System.out.println("three");
        }
    }, FOUR("four") {
        @Override
        public void apply() {
            System.out.println("four");
        }
    };

2.if(true)的条件判断，由多个条件生成Boolean再判断

boolean b = subnetIdList.contains(source)

&& wsubnetIdList.contains(target)

||subnetIdList.contains(target)

&& wsubnetIdList.contains(source);

3.for循环foreach效率要高于for(int ; ;),且预测当嵌套循环时不要超过三层，将循环次数小的放置外侧

4.java8 Lambada表达式

Map<String, Consumer<ReflectTest>> functionMap =Maps.newHashMap();
functionMap.put("one", ReflectTest::methodOne);

5.逻辑优化，尽量一次组合数据关系，避免多层循环

package com.gw.resource.utils;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import java.util.*;
public class MainDemo {

    static class Entity{
        //定义链式Map信息
        String id;
        String source;
        String type;
   public Entity(String id, String source, String type) {
            this.id = id;
            this.source = source;
            this.type = type;
        }

        public String getId() {
            return id;
        }

        public void setId(String id) {
            this.id = id;
        }

        public String getSource() {
            return source;
        }

        public void setSource(String source) {
            this.source = source;
        }

        public String getType() {
            return type;
        }

        public void setType(String type) {
            this.type = type;
        }
    }

public static void main(String[] args) {
        
Map<String,Map<String,Object>> result = new HashMap<>();
        //读取数据
List<Entity> entities = Arrays.asList(new Entity("1", null,"A"), new Entity("2", null, "B"),new Entity("3", null, "C"),new Entity("4", null, "A"));entities.forEach(entity -> {
            Map<String,Object> types = new HashMap<>();
            //放入本身
            types.put("this",entity);
            //允许放入的集合
            types.put("success", new ArrayList<>());
            //错误集合
            types.put("error", new ArrayList<>());
            //绑定id 与对应结果一致
            result.put(entity.id,types);
        });
System.out.println(JSONObject.toJSONString(result));
Arrays.asList("1-1","1-2","1-3","2-4","3-4","1-1","2-2").forEach(line ->{String[] split = line.split("-");
    String src = split[0],target = split[1];
Entity targetObj = (Entity) result.get(target).get("this");
Entity srcObj = (Entity) result.get(src).get("this");
//确定源对象
Map<String,Object> srcContent = (Map<String,Object>)result.get(src);
//确定目标对象
Map<String,Object> tarContent = (Map<String,Object>)result.get(target);
if(src.equals(target)){
//error 集合
((List<Entity>)srcContent.get("error")).add(targetObj);
  return;
            }
 //符合连接条件的放入K  下层集合
((List<Entity>)srcContent.get("success")).add(targetObj);
((List<Entity>)tarContent.get("success")).add(srcObj);
        });
//  fastjson的循环依赖
System.out.println(JSONObject.toJSONString(result,SerializerFeature.DisableCircularReferenceDetect));
}
}

公众号代码格式放入不了？？？真是服了

放入部分 运行结果

{
        "1": {
        "success": [{
        "id": "2",
        "type": "B"
        }, {
        "id": "3",
        "type": "C"
        }],
        "this": {
        "id": "1",
        "type": "A"
        },
        "error": [{
        "id": "1",
        "type": "A"
        },

}

代码逻辑已经优化，不需要我每次都要通过循环判断去获取节点相连的关系，但是当节点图源为10000个的时候就还是要验证下效率问题。

开发中需遵循代码规范，能避免逻辑重复的就尽可能避免，可在逻辑中筛掉不必要的循环且可以将liststream该为并行流

人生的意义在于承担人生无意义的勇气，如果你一直探寻人生的意义，你将…

对不起没有将，你永远不会生活~

                                                                        ------ 阿尔贝 • 加缪