阶梯费用计算(配置化_最小demo)

已于 2023-08-14 08:37:23 修改
阅读量367 收藏 1
点赞数
文章标签： 开发语言 java
于 2023-08-13 07:50:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haohaounique/article/details/132256290
版权

本文旨在提供一种配置化思路计算阶梯费用，更高级的做法则是通过数据库配置，注册中心等；在表达式上可以采用自定义或者spel表达式等其他方式进行处理；(代码仅展示最小demo,部分不完善地方自行补充)

思路：N个区间对应N个费用模式(费用模式可以根据需要进行扩展)；

          先进行第一个区间的值，收集后续区间，然后按照最大区间差值加权

          

目录

一、核心代码

二、工具类DataCompareUtils

一、核心代码



import java.math.BigDecimal;
import java.math.MathContext;
import java.util.ArrayList;
import java.util.List;

/**
 * description:
 */
public class FeeT {
    public static void main(String[] args) {
        /**
         * 如果 value落在区间N,
         *     当前区间则为当前值减去最小值 加权计算
         *     剩余区间则按照区间最大值  加权计算，
         *   1  10 80 -1
         */
        String expression = "(0,10]#(10,20]#(20,100]#(100,";
        String model = "+1#*1#*1#-1";
        String value = "101";
        BigDecimal bigDecimal = getStepFeeItem(expression, model, value);
        System.out.println(bigDecimal.doubleValue());


    }

    private static BigDecimal getStepFeeItem(String expression, String model, String value) {
        BigDecimal bigDecimal = new BigDecimal(0);
        String[] expressionArr = expression.split("#");
        String[] modelArr = model.split("#");
        List<String> expressionA = new ArrayList<>();
        /**
         * 计算第一个区间的值
         */
        bigDecimal = computeFirst(value, bigDecimal, expressionArr, modelArr, expressionA);
        bigDecimal = computeLast(bigDecimal, expressionA);
        return bigDecimal;
    }

    private static BigDecimal computeLast(BigDecimal bigDecimal, List<String> expressionA) {
        for (String s : expressionA) {
            String[] split = s.split("#");
            BigDecimal computeValue = computeValue(BigDecimal.valueOf(Double.parseDouble(maxRange(split[1]))).subtract(BigDecimal.valueOf(Double.parseDouble(minRange(split[1])))), split[0], true);
            bigDecimal = bigDecimal.add(computeValue);
        }
        return bigDecimal;
    }

    private static BigDecimal computeFirst(String value, BigDecimal bigDecimal, String[] expressionArr, String[] modelArr, List<String> expressionA) {
        for (int i = expressionArr.length - 1; i >= 0; i--) {
            if (DataCompareUtils.checkValue(value, expressionArr[i])) {
                BigDecimal computeValue = computeValue(BigDecimal.valueOf(Double.parseDouble(value)).subtract(BigDecimal.valueOf(Double.parseDouble(minRange(expressionArr[i])))), modelArr[i], true);
                bigDecimal = bigDecimal.add(computeValue);
                //如果目标值在遍历区间，则剩余区间则放到另外一个队列中
                for (int j = i - 1; j >= 0; j--) {
                    expressionA.add(new StringBuilder().append(modelArr[j]).append("#").append(expressionArr[j]).toString());
                }
                break;
            }
        }
        return bigDecimal;
    }


    public static String minRange(String expression) {
        String all = expression.replaceAll("[^0-9.,]", "");
        String[] split = all.split(",");
        return split[0];
    }

    public static String maxRange(String expression) {
        String all = expression.replaceAll("[^0-9.,]", "");
        String[] split = all.split(",");
        return split[1];
    }

    public static BigDecimal computeValue(BigDecimal value, String expression, boolean flag) {
        String symbol = expression.replaceAll("[^\\+\\-\\*/]", ""); //+-*/
        String feeValue = expression.replaceAll("[\\+\\-\\*/]", "");// 1
        switch (symbol) {
            case "+":
                return flag ? BigDecimal.valueOf(Double.parseDouble(feeValue)).setScale(4, BigDecimal.ROUND_CEILING) : value.add(BigDecimal.valueOf(Double.parseDouble(feeValue))).setScale(4, BigDecimal.ROUND_CEILING);
            case "-":
                return flag ?BigDecimal.valueOf(Double.parseDouble(feeValue)).multiply(BigDecimal.valueOf(-1)).setScale(4, BigDecimal.ROUND_CEILING): value.subtract(BigDecimal.valueOf(Double.parseDouble(feeValue))).setScale(4, BigDecimal.ROUND_CEILING);
            case "*":
                return value.multiply(BigDecimal.valueOf(Double.parseDouble(feeValue))).setScale(4, BigDecimal.ROUND_CEILING);
            case "/":
                return value.divide(BigDecimal.valueOf(Double.parseDouble(feeValue)), MathContext.DECIMAL64).setScale(4, BigDecimal.ROUND_CEILING);
            default:
                return value;
        }
    }

}

二、工具类DataCompareUtils

数据比较工具，不同区间的值进行比较


import org.apache.commons.lang3.StringUtils;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;

/**
 * description: 数据比较工具类
 */
public class DataCompareUtils {
    private DataCompareUtils() {
    }


    public static final Map<String, String> SYMBOL_MAP = new HashMap<>();

    static {
        SYMBOL_MAP.put("(,)", "(,)");
        SYMBOL_MAP.put("[,)", "[,)");
        SYMBOL_MAP.put("(,]", "(,]");
        SYMBOL_MAP.put("[,]", "[,]");
        SYMBOL_MAP.put("[,", "[,");
        SYMBOL_MAP.put("(,", "(,");
        SYMBOL_MAP.put(",]", ",]");
        SYMBOL_MAP.put(",)", ",)");
    }

    public static final String SYMBOL_01 = "(,)";
    public static final String SYMBOL_02 = "[,)";
    public static final String SYMBOL_03 = "(,]";
    public static final String SYMBOL_04 = "[,]";
    public static final String SYMBOL_05 = "[,";
    public static final String SYMBOL_06 = "(,";
    public static final String SYMBOL_07 = ",]";
    public static final String SYMBOL_08 = ",)";

    private static final Pattern NUMBER_REG = Pattern.compile("^-?\\d+(\\.\\d+)?$");

    /**
     * 双边校验 返回true说明不符合
     * [4,5] (3,5)
     * 不符合返回false,符合区间返回true
     *
     * @param value
     * @return
     */

    public static boolean checkValue(String value, String config) {
        if (StringUtils.isEmpty(config)) {
            return false;
        }
        config = config.replace(" ", "").replace("，", ",").replace("（", "(").replace("【", "[").replace("】", "]").replace("）", ")").trim();
        config = config.replaceAll("[^0-9.()\\[\\],]", ""); //获取 [3,8]
        String s = config.replaceAll("[^\\[\\]\\(\\),]", "");//获取 []
        if (StringUtils.isEmpty(SYMBOL_MAP.get(s))) {
            return false;
        }
        /**
         * 第一个为值  第二个为配置表达式
         */

        boolean flag = false;
        switch (s) {
            case SYMBOL_01:
                flag = checkLeftNoAndRightNo(value, config);
                break;
            case SYMBOL_02:
                flag = checkLeftAndRightNo(value, config);
                break;
            case SYMBOL_03:
                flag = checkLeftNoAndRight(value, config);
                break;
            case SYMBOL_04:
                flag = checkLeftAndRight(value, config);
                break;
            case SYMBOL_05:
                flag = checkLeft(value, config);
                break;
            case SYMBOL_06:
                flag = checkLeftNo(value, config);
                break;
            case SYMBOL_07:
                flag = checkRight(value, config);
                break;
            case SYMBOL_08:
                flag = checkRightNo(value, config);
                break;
            default:
                break;
        }
        return flag;
    }

    //(5,8)
    public static boolean checkLeftNoAndRightNo(String value, String config) {
        String range = config.replace("(", "").replace(")", "");
        String[] split = range.split(",");
        return checkNoIncludeMin(value, split[0]) && checkNoIncludeMax(value, split[1]);
    }

    //(5,8]
    public static boolean checkLeftNoAndRight(String value, String config) {
        String range = config.replace("(", "").replace("]", "");
        String[] split = range.split(",");
        return checkNoIncludeMin(value, split[0]) && checkIncludeMax(value, split[1]);
    }

    //[5,8)
    public static boolean checkLeftAndRightNo(String value, String config) {
        String range = config.replace("[", "").replace(")", "");
        String[] split = range.split(",");
        return checkIncludeMin(value, split[0]) && checkNoIncludeMax(value, split[1]);
    }

    //[5,8]
    public static boolean checkLeftAndRight(String value, String config) {
        String range = config.replace("[", "").replace("]", "");
        String[] split = range.split(",");
        return checkIncludeMin(value, split[0]) && checkIncludeMax(value, split[1]);
    }

    //(5,
    public static boolean checkLeftNo(String value, String config) {
        String range = config.replace("(", "").replace(",", "");
        return checkNoIncludeMin(value, range);
    }

    //[5,
    public static boolean checkLeft(String value, String config) {
        String range = config.replace("[", "").replace(",", "");
        return checkIncludeMin(value, range);
    }

    //,8)
    public static boolean checkRightNo(String value, String config) {
        String range = config.replace(")", "").replace(",", "");
        return checkNoIncludeMax(value, range);
    }

    //,8]
    public static boolean checkRight(String value, String config) {
        String range = config.replace("]", "").replace(",", "");
        return checkIncludeMax(value, range);
    }


    /**
     * 校验下限 不含 （6,
     *
     * @param value
     * @param target
     * @return
     */
    public static boolean checkNoIncludeMin(String value, String target) {
        if (StringUtils.isEmpty(value) || StringUtils.isEmpty(target)) {
            return false;
        }
        if (BigDecimal.valueOf(Double.parseDouble(value)).compareTo(BigDecimal.valueOf(Double.parseDouble(target))) > 0) {
            return true;
        }
        return false;
    }

    /**
     * 含最小 [6,
     *
     * @param value
     * @param target
     * @return
     */
    public static boolean checkIncludeMin(String value, String target) {
        if (StringUtils.isEmpty(value) || StringUtils.isEmpty(target)) {
            return false;
        }
        if (BigDecimal.valueOf(Double.parseDouble(value)).compareTo(BigDecimal.valueOf(Double.parseDouble(target))) >= 0) {
            return true;
        }
        return false;
    }

    /**
     * 最大包含  ,6]
     *
     * @param value
     * @param target
     * @return
     */
    public static boolean checkIncludeMax(String value, String target) {
        if (StringUtils.isEmpty(value) || StringUtils.isEmpty(target)) {
            return false;
        }
        if (BigDecimal.valueOf(Double.parseDouble(value)).compareTo(BigDecimal.valueOf(Double.parseDouble(target))) <= 0) {
            return true;
        }
        return false;
    }

    /**
     * 不含最大校验    ,6)
     *
     * @param value
     * @param target
     * @return
     */
    public static boolean checkNoIncludeMax(String value, String target) {
        if (StringUtils.isEmpty(value) || StringUtils.isEmpty(target)) {
            return false;
        }
        if (BigDecimal.valueOf(Double.parseDouble(value)).compareTo(BigDecimal.valueOf(Double.parseDouble(target))) < 0) {
            return true;
        }
        return false;
    }

    /**
     * 判断是否为数字
     *
     * @param value
     * @return
     */
    public static boolean checkIsNumber(String value) {
        return NUMBER_REG.matcher(value).matches();
    }

    //\u00A0,\u0020,\u3000
//    1.不间断空格\u00A0,主要用在office中,让一个单词在结尾处不会换行显示,快捷键ctrl+shift+space ;
//2.半角空格(英文符号)\u0020,代码中常用的;
//3.全角空格(中文符号)\u3000,中文文章中使用;
    public static String replaceSpecialEmpty(String value) {
        if (StringUtils.isEmpty(value)) {
            return value;
        }
        return value.replace("\\u00A0", "").replace("\\u0020", "").replace("\\u3000", "");
    }


    public static void main(String[] args) {

        List<String> arrayList = new ArrayList<>();
        arrayList.add("(5,8)");
        arrayList.add("[5,8)");
        arrayList.add("(5,8]");
        arrayList.add("[5,8]");
        arrayList.add("[5,");
        arrayList.add("(5,");
        arrayList.add(",8]");
        arrayList.add(",8)");
        String target = "8.01";
        for (String s : arrayList) {
            boolean checked = checkValue(target, s);
            System.out.printf("s:%s ,%s, %s", s, target, checked);
            System.out.println();
        }

    }

}

三、效果

String expression = "(0,10]#(10,20]#(20,100]#(100,";
String model = "*1#*2#*2#+1";
String value = "101";

1+80*2+10*2+10

1+160+20+10=191

haohaounique
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c语言编程进行阶梯电价计算.c
04-07
大学生
东西阶梯教室多媒体信息化设备建设改造方案.pdf
11-18
东西阶梯教室多媒体信息化设备建设改造方案.pdf
java电费计算
03-20
简单的电费计算程序，java编写，每个用电取值范围费用不同！
关于阶梯价格计算费用
08-27 1986
很多场景，我们会遇到阶梯价格的计算问题，网上有比较多的文章，但是都写得比较复杂，很难看到核心的算法思想。 以下用很简单的伪代码说明一下三阶价格的计算方法。 //按阶梯价计算价格 int jsJiage(int total){ num3 = total - jie2; //计算最高阶用量 if(num3 < 0) num3=0; //如果为负数说明没有这一阶的 if(0 == num3) { //计算第二阶用量 num2 =...
java 阶梯价格计算_【java】求阶梯型的服务费总和
weixin_36041020的博客
02-28 1469
在一次面试php开发工程师中我遇到这道题目，是笔试中最后一道题目有一个服务平台，提供服务需要收取用户使用的服务费，但是服务费的收取跟订单数量是有个阶梯关系的，请根据以下这个收费标准计算一个指定订单数量的平台服务费总和，假如用户下了8个订单该用户需要支付多少服务费？示列给定:订单数服务费1-5316-103011-502751-20024201-1000181001-5000155001-10000...
java阶梯电价计算方法
WWW994531的博客
01-16 722
/*阶梯电价计算方法为：月用电量在50度以下按基本电价计费为0.538元/度, 阶梯电价的第一档为月用电量不超过200度的，阶梯电价加收0.03元/度， 阶梯电价的第二档为月用电量超过200度的，阶梯电价加收0.1元/度。 要求输入用户姓名及用电量，计算应收电费，输出结果保留两位小数。
编程之梯度计算价格
a_jie_2016_05的博客
03-23 269
梯度算法计算
java实现爬楼梯的最小费用（动态规划）
Erictr的博客
01-17 510
解题思路 我们爬上第n级台阶所花费的最小费用即为从第n-1级台阶所花的费用加上cost[n-1],或者从第n-2级台阶所花费的最小费用加上cost[n-2],因此我们只需要一个长度为3的数组即可完成计算，有一点需要注意的地方是爬上最后一级台阶之后还要再爬一次才能到顶部，因此，在遍历cost数组时，最后一级台阶的费用也要使用，刚开始用了一个dp[n]的数组，后来经过优化，使用长度为3的数组即可解决问题，代码如下： 代码 class Solution { public int minCostClimbi
责任链模式--阶梯计费
weixin_37981618的博客
04-06 426
责任链模式-chain of responsibility 前言：最近在学习设计模式，每天晚上九点吹着寒风，走在回去的路上我就会想，今天写的代码可以用什么设计模式呢？真正的使用过一次，我发现印象就特别的深刻，下面是我真实的运用的案例。 故事： 帅哥：“今天家里开通了燃气，据说是阶梯收费分。第一阶梯的总气量是300，单价收费1.89；第二阶梯的总气量是600，单价是2.89；第三阶梯总气量无限大，单价是3.89。燃气公司可真是赚钱啊，天天煲汤，那这燃气费都得好几百一个月了。” 类图： 伪代码： /** *
JTH.zip_曲线阶梯化出力
07-15
该MATLAB源码详细介绍了如何实现阶梯化曲线
ms_阶梯_阶梯波电路_
10-03
输出阶梯波电路，以及一些三角波方波电路图
阶梯图_阶梯图；螺旋；matlab_
10-02
能够用来画螺旋阶梯图，亲测好用，欢迎下载
Java 必实验一：基本类型应用
qq_62215764的博客
03-28 1478
一、 实验目的与要求 1.在掌握JAVA数组基本概念及应用的基础上，变换数组的内容，完成主类创建，查找等功能的实现； 2.熟练掌握数据类型、运算符、表达式和语句。 二、实验内容 1. 运行一个关于二维数组的例子程序，代码如下，截图给出其运行结果，并简单解释说明程序功能。(15分) 2. 某省居民电价分三个“阶梯”： 月用电量50度以内的部分，电价为0.538元/度； 用电量在51度至220度之间的部分，电价为0.568元/度； 用电量超过220度的部分，电价为0.638元/度。 编写程
《前端面试题》- TypeScript - TypeScript的优/缺点
小张微说的博客
04-22 1499
问题 简述TypeScript的优/缺点 答案 优点 增强了代码的可读性和可维护性 包容性，js可以直接改成ts，ts编译报错也可以生成js文件，兼容第三方库，即使不是ts编写的 社区活跃，完全支持es6 缺点 增加学习成本 增加开发成本，因为增加了类型定义 需要编译，类型检查会增加编译时长，语法和类型系统复杂的话时间特别特别长 eval和new Function()这种操作类型系统管不到 ...
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 784
都是符合我们的预期的。
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 854
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
string模拟实现
m0_73969414的博客
04-23 1784
c++中string的模拟实现，面试必会知识点
Day25-Java基础之常用类1
最新发布
m0_46053885的博客
04-27 852
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 1047
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
求java 阶梯算法 计算计件工资
01-23
阶梯算法是一种计算计件工资的方法，根据完成的任务数量来确定工资的不同阶梯。以下是一个用Java实现的阶梯算法计算计件工资的示例： ```java public class LadderAlgorithm { public static void main(String[] args) { int numberOfTasks = 105; // 完成的任务数量 double basePay = 2000.0; // 基础工资 double payPerTask = calculatePayPerTask(numberOfTasks); // 根据任务数量计算每个任务的工资 double totalPay = basePay + numberOfTasks * payPerTask; // 计算总工资 System.out.println("工资总额： " + totalPay); } // 根据任务数量计算每个任务的工资 public static double calculatePayPerTask(int numberOfTasks) { double payPerTask = 0.0; if (numberOfTasks <= 100) { payPerTask = 10.0; } else if (numberOfTasks <= 200) { payPerTask = 12.0; } else if (numberOfTasks <= 300) { payPerTask = 15.0; } else { payPerTask = 20.0; } return payPerTask; } } ``` 在上述代码中，我们假设完成的任务数量为105个，基础工资为2000元。根据阶梯算法，前100个任务的工资为10元/个，接下来的100个任务为12元/个，再接下来的100个任务为15元/个，超过300个任务的工资为20元/个。根据任务数量和每个任务的工资，我们可以计算出总工资。 当我们运行上述代码时，将会输出 "工资总额：3100.0"，即这个员工的总工资为3100元。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值