写代码和写作很像，好的文章和好的代码总是可以总结出来一些规律。
那么这里就说四个编程技巧，很基本但很重要，看了就能用(代码示例使用Java)。
这里我们以买菜这件小事为例。

技巧1.先注释后代码

通过注释理清思路时一种非常常见的编码方式。
那么买菜这件小事，需要哪些步骤呢？

1
2
3
4
5
6
7
public class CodingSkills {
    public static void main(String[] args) {
        //列出需要购买的菜单
        //去各个菜市场了解价格
        //确认在哪个超市买哪些菜品
    }
}

然后根据注释，我们会编写对应代码

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
public class CodingSkills {
    public static void main(String[] args) {
        //列出需要购买的菜单
        String[] toPurchase=new String[]{"青菜","胡萝卜","牛肉","玉米","排骨"};
        //去各个菜市场了解价格
        Map<String, Map<String,Double>> vegetableMarket = new HashMap<>();
        HashMap<String,Double> marketA=new HashMap<>();
        marketA.put("青菜",1.8);
        marketA.put("胡萝卜",2.0);
        marketA.put("玉米",2.0);
        marketA.put("牛肉",32.0);
        marketA.put("排骨",28.0);
        vegetableMarket.put("marketA",marketA);

        HashMap<String,Double> marketB=new HashMap<>();
        marketB.put("青菜",1.9);
        marketB.put("胡萝卜",1.5);
        marketB.put("玉米",4.0);
        marketB.put("牛肉",35.0);
        marketB.put("排骨",25.0);
        vegetableMarket.put("marketB",marketB);

        HashMap<String,Double> marketC=new HashMap<>();
        marketC.put("青菜",1.2);
        marketC.put("胡萝卜",1.5);
        marketC.put("玉米",5.0);
        marketC.put("牛肉",32.8);
        marketC.put("排骨",22.0);
        vegetableMarket.put("marketC",marketC);
        //确认在哪个超市买哪些菜品
        Map<String, Object[]> finallyPurchase = new HashMap<>();
        for (String market : vegetableMarket.keySet()) {
            Map<String,Double> cur=vegetableMarket.get(market);
            for (String vName : toPurchase) {
                //当前超市有这个菜
                if (cur.containsKey(vName)){
                    if (!finallyPurchase.containsKey(vName)){
                        finallyPurchase.put(vName,new Object[]{market,cur.get(vName)});
                    }else {
                        Object[] market2price = finallyPurchase.get(vName);
                        //取小
                        if ((double)market2price[1]>cur.get(vName)){
                            finallyPurchase.put(vName,new Object[]{market,cur.get(vName)});
                        }
                    }
                }
            }
        }
    }
}

技巧2.抽取方法

抽取方法也是一种比较直接的技巧，可以让我们代码的整体结构更加清晰。
如上的代码我们做方法抽取之后如下,可以看到处理后的代码理解成本就下降了很多，
结构也比较清晰。

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
67
68
69
70
71
public class CodingSkills {
    public static void main(String[] args) {
        //列出需要购买的菜单
        String[] toPurchase=new String[]{"青菜","胡萝卜","牛肉","玉米","排骨"};
        //去各个菜市场了解价格
        Map<String, Map<String, Double>> vegetableMarket = getMarketPrice();
        //确认在哪个超市买哪些菜品
        Map<String, Object[]> finallyPurchase = new HashMap<>();
        GetFinallyPurchase(vegetableMarket, toPurchase, finallyPurchase);
    }

    /**
     * 获取最终购买的地址和价格
     * @param vegetableMarket 市场
     * @param toPurchase 想购买的菜品
     * @param finallyPurchase 最终购买的市场及价格
     */
    private static void GetFinallyPurchase(Map<String, Map<String, Double>> vegetableMarket, 
        String[] toPurchase, 
        Map<String, Object[]> finallyPurchase) {
        for (String market : vegetableMarket.keySet()) {
            Map<String,Double> cur= vegetableMarket.get(market);
            for (String vName : toPurchase) {
                //当前超市有这个菜
                if (cur.containsKey(vName)){
                    if (!finallyPurchase.containsKey(vName)){
                        finallyPurchase.put(vName,new Object[]{market,cur.get(vName)});
                    }else {
                        Object[] market2price = finallyPurchase.get(vName);
                        //取小
                        if ((double)market2price[1]>cur.get(vName)){
                            finallyPurchase.put(vName,new Object[]{market,cur.get(vName)});
                        }
                    }
                }
            }
        }
    }

    /**
     * 市场和菜品价格
     * @return 市场和菜品价格
     */
    private static Map<String, Map<String, Double>> getMarketPrice() {
        Map<String, Map<String,Double>> vegetableMarket = new HashMap<>();
        HashMap<String,Double> marketA=new HashMap<>();
        marketA.put("青菜",1.8);
        marketA.put("胡萝卜",2.0);
        marketA.put("玉米",2.0);
        marketA.put("牛肉",32.0);
        marketA.put("排骨",28.0);
        vegetableMarket.put("marketA",marketA);

        HashMap<String,Double> marketB=new HashMap<>();
        marketB.put("青菜",1.9);
        marketB.put("胡萝卜",1.5);
        marketB.put("玉米",4.0);
        marketB.put("牛肉",35.0);
        marketB.put("排骨",25.0);
        vegetableMarket.put("marketB",marketB);

        HashMap<String,Double> marketC=new HashMap<>();
        marketC.put("青菜",1.2);
        marketC.put("胡萝卜",1.5);
        marketC.put("玉米",5.0);
        marketC.put("牛肉",32.8);
        marketC.put("排骨",22.0);
        vegetableMarket.put("marketC",marketC);
        return vegetableMarket;
    }
}

技巧3.卫语句减少缩进

代码在编写过程中，如果判断比较多的话，就会产生一层套一层的情况。
这个问题一般有两种解决方案，一种就是我们上边说的提取方法，另一种就是使用卫语句。
比如我们优化一下之前的GetFinallyPurchase方法，结合continue减少嵌套

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
/**
* 获取最终购买的地址和价格
* @param vegetableMarket 市场
* @param toPurchase 想购买的菜品
* @param finallyPurchase 最终购买的市场及价格
*/
private static void GetFinallyPurchase(Map<String, Map<String, Double>> vegetableMarket, String[] toPurchase, Map<String, Object[]> finallyPurchase) {
    for (String market : vegetableMarket.keySet()) {
        Map<String,Double> cur= vegetableMarket.get(market);
        for (String vName : toPurchase) {
            //当前超市有这个菜
            if (!cur.containsKey(vName)){
                continue;
            }
            if (!finallyPurchase.containsKey(vName)){
                finallyPurchase.put(vName,new Object[]{market,cur.get(vName)});
            }else {
                Object[] market2price = finallyPurchase.get(vName);
                //取小
                if ((double)market2price[1]>cur.get(vName)){
                    finallyPurchase.put(vName,new Object[]{market,cur.get(vName)});
                }
            }
        }
    }
}

技巧4.变量提升

变量提升是一种很常用的减少内存占用，提高运行效率的一种方式。
具体来说又有两种操作手法，提升到循环外、提升到方法签名。
这里我们举例说明提升到循环外，这里把cur做了提升

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
/**
     * 获取最终购买的地址和价格
     * @param vegetableMarket 市场
     * @param toPurchase 想购买的菜品
     * @param finallyPurchase 最终购买的市场及价格
     */
    private static void GetFinallyPurchase(Map<String, Map<String, Double>> vegetableMarket, String[] toPurchase, Map<String, Object[]> finallyPurchase) {
        Map<String,Double> cur;
        for (String market : vegetableMarket.keySet()) {
            cur= vegetableMarket.get(market);
            for (String vName : toPurchase) {
                //当前超市有这个菜
                if (!cur.containsKey(vName)){
                    continue;
                }
                if (!finallyPurchase.containsKey(vName)){
                    finallyPurchase.put(vName,new Object[]{market,cur.get(vName)});
                }else {
                    Object[] market2price = finallyPurchase.get(vName);
                    //取小
                    if ((double)market2price[1]>cur.get(vName)){
                        finallyPurchase.put(vName,new Object[]{market,cur.get(vName)});
                    }
                }
            }
        }
    }

小结

通过掌握并使用 先注释后代码、抽取方法、卫语句减少缩进、变量提升四个技巧，我们就拿编写结构清晰且性能较高的代码了。
关注我，获取更多编程技巧和前沿AI信息。

许可协议

本文采用 署名-非商业性使用-相同方式共享 4.0 国际 许可协议，转载请注明出处。

快来参与讨论吧~