大量的if-else优化（判断具有一定的规律）

已于 2023-03-13 09:57:41 修改
阅读量177 收藏
点赞数 1
文章标签： java 性能优化
于 2023-03-09 17:47:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46047841/article/details/129427088
版权

大概需求：希望对每个区间的数据量进行统计。

这是最初的写法

           List<String> oilRateList = new ArrayList<>();  //数据集合
            int[] spotDistributing = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
            oilRateList.forEach(s -> {
                double aDouble = Double.parseDouble(s) * 100;
                //包前不包后
                if (aDouble >= 0 && aDouble < 5) {
                    spotDistributing[0]++;
                } else if (aDouble >= 5 && aDouble < 10) {
                    spotDistributing[1]++;
                } else if (aDouble >= 10 && aDouble < 15) {
                    spotDistributing[2]++;
                } else if (aDouble >= 15 && aDouble < 20) {
                    spotDistributing[3]++;
                } else if (aDouble >= 20 && aDouble < 25) {
                    spotDistributing[4]++;
                } else if (aDouble >= 25 && aDouble < 30) {
                    spotDistributing[5]++;
                } else if (aDouble >= 30 && aDouble < 35) {
                    spotDistributing[6]++;
                } else if (aDouble >= 35 && aDouble < 40) {
                    spotDistributing[7]++;
                } else if (aDouble >= 40 && aDouble < 45) {
                    spotDistributing[8]++;
                } else {
                    spotDistributing[9]++;
                }
            });

性能并不差，但是很丑。所以需要优化

第一版本

大佬给一些思路，优化后的：

@Data
public class IntervalData {


    /**
     * 数据区间对象集合
     */
    private static List<Rule> rules;

    static {
        rules = new ArrayList<>();
        rules.add(new Rule(0D, 5D, DataRangeEnum.ZeroIsFive));
        rules.add(new Rule(5D, 10D, DataRangeEnum.FiveIsTen));
        rules.add(new Rule(10D, 15D, DataRangeEnum.TenIsFifteen));
        rules.add(new Rule(15D, 20D, DataRangeEnum.FifteenIsTwenty));
        rules.add(new Rule(20D, 25D, DataRangeEnum.TwentyIsTwentyFive));
        rules.add(new Rule(25D, 30D, DataRangeEnum.TwentyFiveIsThirty));
        rules.add(new Rule(30D, 35D, DataRangeEnum.ThirtyIsThirtyFive));
        rules.add(new Rule(35D, 40D, DataRangeEnum.ThirtyFiveIsForty));
        rules.add(new Rule(40D, 45D, DataRangeEnum.FortyIsFortyFive));
        rules.add(new Rule(45D, -1D, DataRangeEnum.FortyFiveIsAll));
    }

    /**
     * 生成数据
     */
    public static Map<DataRangeEnum, Integer> check(List<String> doubles) {
        Map<Rule, AtomicInteger> counts = new HashMap<>();
        doubles.forEach(v -> {
            Double doublev = Double.parseDouble(v) * 100;
            for (Rule rule : rules) {
                boolean aTrue = rule.isTrue(doublev);
                if (!aTrue) continue;
                if (counts.containsKey(rule)) {
                    counts.get(rule).addAndGet(1);
                } else {
                    counts.put(rule, new AtomicInteger(1));
                }
            }
        });
        Map<DataRangeEnum, Integer> data = new HashMap<>();
        counts.keySet().forEach(v -> data.put(v.dataRangeEnum, counts.get(v).get()));
        Map<DataRangeEnum, Integer> returnData = new LinkedHashMap<>();
        Arrays.stream(DataRangeEnum.values()).forEach(v -> {
            Integer integer = data.get(v);
            if (integer == null) {
                returnData.put(v, 0);
            } else {
                returnData.put(v, integer);
            }
        });
        return returnData;
    }

    /**
     * 数据区间对象
     */
    static class Rule {

        /**
         * 左侧
         */
        private Double left;

        /**
         * 右侧
         */
        private Double right;

        /**
         * 对应的枚举
         */
        private DataRangeEnum dataRangeEnum;

        public Rule(Double left, Double right, DataRangeEnum dataRangeEnum) {
            this.left = left;
            this.right = right;
            this.dataRangeEnum = dataRangeEnum;
        }

        public boolean isTrue(Double number) {
            if (this.right == -1D) {
                return number >= left;
            }
            return number >= left && number < right;
        }
    }
}

对应的枚举代码

@Getter
public enum DataRangeEnum {

    /**
     * 0-5
     */
    ZeroIsFive,

    /**
     * 5-10
     */
    FiveIsTen,

    /**
     * 10-15
     */
    TenIsFifteen,

    /**
     * 15-20
     */
    FifteenIsTwenty,

    /**
     * 20-25
     */
    TwentyIsTwentyFive,

    /**
     * 25-30
     */
    TwentyFiveIsThirty,

    /**
     * 30-35
     */
    ThirtyIsThirtyFive,

    /**
     * 35-40
     */
    ThirtyFiveIsForty,

    /**
     * 40-45
     */
    FortyIsFortyFive,

    /**
     * 45-
     */
    FortyFiveIsAll;
}

这个解决方法是通过对象来优化那些if-else
获取数据只用调一句话就行

Map<DataRangeEnum, Integer> check = IntervalData.check(oilRateList);
xx.setData(check.values());

很简便，但是通过观察大家可以看出，这个的获取数据的规则其实是写死的，正好我这个项目里面有两套规则，一套是上面的0-5，5-10…，还有一套是0-10，10-20…，上面写死了，如果要加的话，很不好看，这样不好，需要优化

我这里个人的解决方式是把规则提取出来

第二版本

上代码，规则枚举

@Getter
public enum BigRangeEnum {


    /**
     * 0-50 以5为间隔 统计十次
     */
    OneSpace(0, -1, 5, 10),

    /**
     * 0-100 以10为间隔 统计十次
     */
    TwoSpace(0, -1, 10, 10);

    /**
     * 范围左侧
     */
    private Integer bigLeft;

    /**
     * 范围右侧 （-1的意思是 最有一个判断区间范围 仅使用>=即可）
     */
    private Integer bigRight;

    /**
     * 间隔
     */
    private Integer space;

    /**
     * 计算次数
     */
    private Integer count;


    BigRangeEnum(Integer bigLeft, Integer bigRight, Integer space, Integer count) {
        this.bigLeft = bigLeft;
        this.bigRight = bigRight;
        this.space = space;
        this.count = count;
    }
}

上上一个枚举的升级版本

@Getter
public enum DataRangeEnum {

    /**
     * 0-5
     */
    ZeroIsFive(BigRangeEnum.OneSpace, 1),

    /**
     * 5-10
     */
    FiveIsTen(BigRangeEnum.OneSpace, 2),

    /**
     * 10-15
     */
    TenIsFifteen(BigRangeEnum.OneSpace, 3),

    /**
     * 15-20
     */
    FifteenIsTwenty(BigRangeEnum.OneSpace, 4),

    /**
     * 20-25
     */
    TwentyIsTwentyFive(BigRangeEnum.OneSpace, 5),

    /**
     * 25-30
     */
    TwentyFiveIsThirty(BigRangeEnum.OneSpace, 6),

    /**
     * 30-35
     */
    ThirtyIsThirtyFive(BigRangeEnum.OneSpace, 7),

    /**
     * 35-40
     */
    ThirtyFiveIsForty(BigRangeEnum.OneSpace, 8),

    /**
     * 40-45
     */
    FortyIsFortyFive(BigRangeEnum.OneSpace, 9),

    /**
     * 45-
     */
    FortyFiveIsAll(BigRangeEnum.OneSpace, 10),


    /**
     * 0-10
     */
    ZeroIsTen(BigRangeEnum.TwoSpace, 1),

    /**
     * 10-20
     */
    TenIsTwenty(BigRangeEnum.TwoSpace, 2),

    /**
     * 20-30
     */
    TwentyIsThirty(BigRangeEnum.TwoSpace, 3),

    /**
     * 30-40
     */
    ThirtyIsForty(BigRangeEnum.TwoSpace, 4),

    /**
     * 40-50
     */
    FortyIsFifty(BigRangeEnum.TwoSpace, 5),

    /**
     * 50-60
     */
    FiftyIsSixty(BigRangeEnum.TwoSpace, 6),

    /**
     * 60-70
     */
    SixtyIsSeventy(BigRangeEnum.TwoSpace, 7),

    /**
     * 70-80
     */
    SeventyIsEighty(BigRangeEnum.TwoSpace, 8),

    /**
     * 80-90
     */
    EightyIsNinety(BigRangeEnum.TwoSpace, 9),

    /**
     * 90-
     */
    NinetyIsAll(BigRangeEnum.TwoSpace, 10);


    private BigRangeEnum belong;


    private Integer sort;

    DataRangeEnum(BigRangeEnum belong, Integer sort) {
        this.belong = belong;
        this.sort = sort;
    }


    /**
     * 根据归属和排序 获取枚举
     */
    public static DataRangeEnum getDataRangeEnumByBelongAndSort(BigRangeEnum belong, Integer sort) {
        DataRangeEnum[] dataRangeEnums = DataRangeEnum.values();
        Optional<DataRangeEnum> first = Arrays.stream(dataRangeEnums).filter(v -> v.getBelong().equals(belong) && v.getSort().equals(sort)).findFirst();
        return first.orElse(null);
    }

    /**
     * 根据归属，获取枚举集合
     */
    public static List<DataRangeEnum> getListByBelong(BigRangeEnum belong) {
        DataRangeEnum[] dataRangeEnums = DataRangeEnum.values();
        return Arrays.stream(dataRangeEnums).filter(v -> v.getBelong().equals(belong)).collect(Collectors.toList());
    }
}

核心计算代码

@Data
public class IntervalData {


    /**
     * 数据区间对象集合
     */
    private static List<Rule> rules;

    /**
     * 计算入口
     */
    public static Map<DataRangeEnum, Integer> CalculateEntrance(BigRangeEnum bigRangeEnum, List<String> doubles) {
        rules = new ArrayList<>();
        for (int i = 1; i <= bigRangeEnum.getCount(); i++) {
            Rule rule;
            if (i == bigRangeEnum.getCount()) {
                rule = new Rule(bigRangeEnum.getSpace() * (i - 1) * 1.0, bigRangeEnum.getBigRight() * 1.0, DataRangeEnum.getDataRangeEnumByBelongAndSort(bigRangeEnum, i));
            } else {
                rule = new Rule(bigRangeEnum.getSpace() * (i - 1) * 1.0, bigRangeEnum.getSpace() * i * 1.0, DataRangeEnum.getDataRangeEnumByBelongAndSort(bigRangeEnum, i));
            }
            rules.add(rule);
        }
        return check(bigRangeEnum, doubles);
    }


    /**
     * 生成数据
     */
    private static Map<DataRangeEnum, Integer> check(BigRangeEnum bigRangeEnum, List<String> doubles) {
        Map<DataRangeEnum, AtomicInteger> counts = new HashMap<>();
        doubles.forEach(v -> {
            Double doublev = Double.parseDouble(v) * 100;
            for (Rule rule : rules) {
                boolean aTrue = rule.isTrue(doublev);
                if (!aTrue) continue;
                if (counts.containsKey(rule.dataRangeEnum)) {
                    counts.get(rule.dataRangeEnum).addAndGet(1);
                } else {
                    counts.put(rule.dataRangeEnum, new AtomicInteger(1));
                }
            }
        });
        Map<DataRangeEnum, Integer> returnData = new LinkedHashMap<>();
        DataRangeEnum.getListByBelong(bigRangeEnum).forEach(v -> {
            AtomicInteger integer = counts.get(v);
            if (integer == null) {
                returnData.put(v, 0);
            } else {
                returnData.put(v, integer.get());
            }
        });
        return returnData;
    }

    /**
     * 数据区间对象
     */
    static class Rule {

        /**
         * 左侧
         */
        private Double left;

        /**
         * 右侧
         */
        private Double right;

        /**
         * 对应的枚举
         */
        private DataRangeEnum dataRangeEnum;

        public Rule(Double left, Double right, DataRangeEnum dataRangeEnum) {
            this.left = left;
            this.right = right;
            this.dataRangeEnum = dataRangeEnum;
        }

        public boolean isTrue(Double number) {
            if (this.right == -1D) {
                return number >= left;
            }
            return number >= left && number < right;
        }
    }
}

这里其实就是通过指定的规则，去生成rules然后沿用上一版本的计算方法。

看到这，大家可能心里会有一个疑问，这样的处理，好看是好看了，代码性能怎么样。经过我的测试，在数据量小于10w条的时候，第二版本的运行时间是小于大量的if-else的，但是数据量一旦超过10w条，第二版本的性能就大打折扣，测试中1000w条数据，大量的if-else的执行时间平均为600ms，但是第二版本的执行时间平均达到了1200ms，性能太差了，需要优化。

通过观察第二版本的核心计算代码其实可以看出来doubles为数据总量，rules是每一个范围的抽象对象
——大量的if-else的循环次数就=doubles个数
——第二版本的总循环次数=doubles个数 * rules个数
当数据量较小的时候，看不出来，一旦数据量足够多，比如1000w条，那么此时大量的if-else的循环次数为1000w次，但是第二版本的循环次数达到了1000w*10，一亿次，也怪不得性能差了。需要优化

第三版本

核心计算代码

@Data
public class IntervalData {
    

    /**
     * 数据区间对象集合
     */
    private static List<Rule> rules;

    /**
     * 计算入口
     */
    public static Map<DataRangeEnum, Integer> CalculateEntrance(BigRangeEnum bigRangeEnum, List<String> doubles) {
        rules = new ArrayList<>();
        for (int i = 1; i <= bigRangeEnum.getCount(); i++) {
            Rule rule;
            if (i == bigRangeEnum.getCount()) {
                rule = new Rule(bigRangeEnum.getSpace() * (i - 1) * 1.0, bigRangeEnum.getBigRight() * 1.0, DataRangeEnum.getDataRangeEnumByBelongAndSort(bigRangeEnum, i));
            } else {
                rule = new Rule(bigRangeEnum.getSpace() * (i - 1) * 1.0, bigRangeEnum.getSpace() * i * 1.0, DataRangeEnum.getDataRangeEnumByBelongAndSort(bigRangeEnum, i));
            }
            rules.add(rule);
        }
        return check(bigRangeEnum, doubles);
    }


    /**
     * 生成数据
     */
    private static Map<DataRangeEnum, Integer> check(BigRangeEnum bigRangeEnum, List<String> doubles) {
        Map<DataRangeEnum, AtomicInteger> counts = new HashMap<>();
        doubles.forEach(v -> {
            Double doublev = Double.parseDouble(v) * 100;
            int i = (int) (doublev / bigRangeEnum.getSpace());
            Rule rule = (i >= rules.size()) ? rules.get(rules.size() - 1) : rules.get(i);
            if (counts.containsKey(rule.dataRangeEnum)) {
                counts.get(rule.dataRangeEnum).addAndGet(1);
            } else {
                counts.put(rule.dataRangeEnum, new AtomicInteger(1));
            }

        });
        Map<DataRangeEnum, Integer> returnData = new LinkedHashMap<>();
        DataRangeEnum.getListByBelong(bigRangeEnum).forEach(v -> {
            AtomicInteger integer = counts.get(v);
            if (integer == null) {
                returnData.put(v, 0);
            } else {
                returnData.put(v, integer.get());
            }
        });
        return returnData;
    }

    /**
     * 数据区间对象
     */
    static class Rule {

        /**
         * 左侧
         */
        private Double left;

        /**
         * 右侧
         */
        private Double right;

        /**
         * 对应的枚举
         */
        private DataRangeEnum dataRangeEnum;

        public Rule(Double left, Double right, DataRangeEnum dataRangeEnum) {
            this.left = left;
            this.right = right;
            this.dataRangeEnum = dataRangeEnum;
        }
    }
}

通过观察第二版本的代码可以发现rules的顺序一直都是一个好的顺序，是一个按照0-5，5-10…的一个顺序，那么此时，我们就可以用数据值/规则间距得出来的值，就是rules对应的区间的数据位置，当然，需要考虑超过rules范围的值，超过范围的就去最后一个即可

这样处理，第二版本的循环数量直接减少了rules个数倍。
那么最后的结果是多少呢
跑一个1000w条数据试试
在这里插入图片描述
上面是大量的if-else的结果，下面是第三版本的结果，相差无几！！！（if-else的性能不差）

这个设计的话，还有一个好处，后续有任何需要添加规则，修改规则，去规则枚举里改就行。

到此，撒花，完美解决。

2023-03-13 补

其实再再仔细观察一下可以发现Rule 对象是没有什么用的，最初的版本需要通过它来判断区间，但是现在区间的判断不需要他了，在这个对象里面，只会用到DataRangeEnum这个枚举，每次创建对象，都需要开辟内存空间，所以，就把Rule对象给优化掉吧

上代码

@Data
public class IntervalData {


    /**
     * 数据范围枚举集合
     */
    private static List<DataRangeEnum> rangeEnumList;

    /**
     * 计算入口
     */
    public static Map<DataRangeEnum, Integer> CalculateEntrance(BigRangeEnum bigRangeEnum, List<String> doubles) {
        rangeEnumList = new ArrayList<>();
        for (int i = 1; i <= bigRangeEnum.getCount(); i++) {
            rangeEnumList.add(DataRangeEnum.getDataRangeEnumByBelongAndSort(bigRangeEnum, i));
        }
        return check(bigRangeEnum, doubles);
    }


    /**
     * 生成数据
     */
    private static Map<DataRangeEnum, Integer> check(BigRangeEnum bigRangeEnum, List<String> doubles) {
        Map<DataRangeEnum, AtomicInteger> counts = new HashMap<>();
        doubles.forEach(v -> {
            Double doublev = Double.parseDouble(v) * 100;
            int i = (int) (doublev / bigRangeEnum.getSpace());
            DataRangeEnum dataRangeEnum = (i >= rangeEnumList.size()) ? rangeEnumList.get(rangeEnumList.size() - 1) : rangeEnumList.get(i);
            if (counts.containsKey(dataRangeEnum)) {
                counts.get(dataRangeEnum).addAndGet(1);
            } else {
                counts.put(dataRangeEnum, new AtomicInteger(1));
            }

        });
        Map<DataRangeEnum, Integer> returnData = new LinkedHashMap<>();
        DataRangeEnum.getListByBelong(bigRangeEnum).forEach(v -> {
            AtomicInteger integer = counts.get(v);
            if (integer == null) {
                returnData.put(v, 0);
            } else {
                returnData.put(v, integer.get());
            }
        });
        return returnData;
    }
}

最后，再跑一次1000w数据瞅瞅
在这里插入图片描述
嗯，很完美

孟沇沇
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
代码中大量的 if else如何优化.doc
08-24
代码中大量的 if else如何优化.doc
学会这些代码优化通用技巧，提升程序执行效率不止一个Level（c/c++）
KingsMan666的博客
10-24 1082
扩展的K&R布局 目的是让较小的屏幕显示较多的信息 int extended(){ int a=0,b=0; while(a!=10) { b++; a++; } return b; } 函数内的左大括号不是紧跟上一行而是自己起一行，方便对应。 编写可读性强的代码 好的编程风格，布局，清晰的逻辑流，避免过多嵌套 好的命名 不要用过多复杂的函数，这里有一个经验，如果一个函数的代码总量超过了100行，那么它必可以本分解成更短的子函数，子函数长度以一屏的高度为宜 采用合适的数据类型，co
深度阅读：C语言中如何高效编程及代码优化
miaozenn的博客
10-27 446
在本篇文章中，我收集了很多经验和方法。应用这些经验和方法，可以帮助我们从执行速度和内存使用等方面来优化C语言代码。 简介 在最近的一个项目中，我们需要开发一个运行在移动设备上但不保证图像高质量的轻量级JPEG库。期间，我总结了一些让程序运行更快的方法。 在本篇文章中，我收集了一些经验和方法。应用这些经验和方法，可以帮助我们从执行速度和内存使用等方面来优化C语言代码。 尽管在C代码优化方面有很多的指南，但是关于编译和你使用的编程机器方面的优化知识却很少。 通常，为了让你的程序运行的更快，程序的代..
优化代码（ if-else篇）
hjklnmyuiop的博客
09-26 158
为什么我们写的代码都是 if-else？ 程序员想必都经历过这样的场景：刚开始自己写的代码很简洁，逻辑清晰，函数精简，没有一个 if-else，可随着代码逻辑不断完善和业务的瞬息万变:比如需要对入参进行类型和值进行判断；这里要判断下对象是否为 null；不同类型执行不同的流程。 落地到具体实现只能不停地加 if-else 来处理，渐渐地，代码变得越来越庞大，函数越来越长，文件行数也迅速突破上千行，维护难度也越来越大，到后期基本达到一种难以维护的状态。 虽然我们都很不情愿写出满屏 if-else 的代码，可逻
2020年哈尔滨工业大学C语言程序设计精髓 第四周练兵编程题
右丞的学习之路
02-24 4990
1 检测用户错误输入（4分） 题目内容： 根据scanf()的返回值判断scanf()是否成功读入了指定的数据项数，使程序在用户输入123a时，能输出如下运行结果： 123a↙ Input error! 输入格式: “%d %d” 输出格式： 如果成功读入指定的数据项数，输出格式为：“a = %d, b = %d\n” （注意：等号的两边各有一个空格） 输入非法数据，输出格式为：“Input er...
多个if与多个else if详解
lvmengmeng
01-12 1万+
下面两句代码，执行结果 形式如下 if ……if……if……else  if ……else if …… else if……else…… 通过观看下面的代码与结果截图可以明白多个if与多个else if 及else执行的情况，简单说就是如果是多个else if的话，只要第一个if条件成立，即使满足else if的条件也不会执行else if及else的内容，如果是多个if的话，最后的else
多层if else优化方案
About_zero的博客
06-29 2661
在 JavaScript 中，多层的 if-else 结构可能会导致代码的可读性和可维护性降低。
如何优化代码中大量的if/else
Evan's Blog ٩(๑❛ᴗ❛๑)۶
09-14 4784
日常我们在写代码或者读代码时，有时会发现代码中存在大量的if/else。甚至会嵌套多层，这样会大大降低代码的可读性，使得代码维护起来费时费力。那么有什么方案可以优化代码中大量的if/else呢，下面就给大家简单的介绍几种方法。 1. 提前return 在写判断条件时，选择取反判断，这样的话代码在逻辑表达上会更清晰，看下面代码： if (condition) { // do somet...
震惊！！！用了这些方法，他的代码里再也没有if-else了
weixin_43120613的博客
11-25 1559
前言 代码中如果if-else比较多，阅读起来比较困难，维护起来也比较困难，很容易出bug，接下来，本文将介绍优化if-else代码的八种方案。 优化方案一：提前return，去除不必要的else 如果if-else代码块包含return语句，可以考虑通过提前return，把多余else干掉，使代码更加优雅。 优化前： if(condition){ //doSomething }else{ return; } 优化后： if(!condition){ return; } //doSomethin
代码太多 if else，如何优化？
前端达人
02-02 868
作者：海底烧烤店https://juejin.cn/post/7172147708914827300???? 前言最近在网上冲浪时看到了这样一段代码：functiongetUserDescribe(name){if(name==="小刘"){console.log("刘哥哥");}elseif(name==="小红"){consol...
Windows Powershell IF-ELSEIF-ELSE 语句
01-20
Where-Object 进行条件判断很方便，如果在判断后执行很多代码可以使用IF-ELSEIF-ELSE语句。语句模板： 代码如下: If（条件满足）{ 如果条件满足就执行代码 } Else { 如果条件不满足 } 条件判断必须放在圆括号中，...
java基础知识-if-else的使用
06-14
在Java中，if-else是一种条件语句，它...首先，判断if后面的条件表达式是否为true。如果为true，则执行if代码块中的代码；如果为false，则执行else代码块中的代码。只会执行if或else其中一个代码块，永远不会同时执行。
策略模式消除if-else分支判断.zip
01-07
使用策略模式和工厂模式彻底消除if-else分支
ifelse_java_if-else_
10-01
岳小鹏参加Java考试，他和父亲岳不群达成承诺：如果：成绩为100分时，奖励一辆BMW；成绩为(80，99]时，奖励一台iphone xs max；当成绩为[6080]时，奖励一个 iPad；...请从键盘输入岳小鹏的期末成绩，并加以判断
大量if else的优化方案
qq_33521663的博客
09-02 2127
关于代码中大量ifelse的解决方案，优雅的处理代码中大量的判断的屎代码！
优化ifelse ifelse优化
weixin_44200656的博客
04-22 634
优化ifelse ifelse优化 以面向对象的思维方式来优化你的代码
if过多，if--else过多 ，if--else嵌套过多，优化代码质量
qq_36255346的博客
01-30 4612
常用优化if -else系列 优化代码质量
Java 中如何优化大量的 if...else...
m0_73311735的博客
03-20 1027
这种方法可以将大量的if else语句转换为数据结构的处理过程，从而提高代码的可扩展性和可维护性。将每个条件分支的实现作为一个独立的策略类，然后使用一个上下文对象来选择要执行的策略。这种方法可以将大量的if else语句转换为对象之间的交互，从而提高代码的可维护性和可扩展性。将每个条件分支的实现作为一个独立的产品类，然后使用一个工厂类来创建具体的产品对象。这种方法可以将大量的if else语句转换为对象的创建过程，从而提高代码的可读性和可维护性。使用一个映射表来将条件分支的实现映射到对应的函数或方法上。
Java如何优化大量的if else
热门推荐
zhaoyang10的专栏
01-11 3万+
用if-else if-else写判断季节的代码
最新发布
07-13
以下是用 if-else if-else 语句来判断季节的示例代码： ```csharp int month = 10; string season; if (month >= 3 && month ) { season = "春季"; } else if (month >= 6 && month ) { season = "夏季"; } else...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值