快捷導(dǎo)航

java 如何計算同比增長工具類

更新時間：2021年07月06日 14:30:58 作者：FanClys

這篇文章主要介紹了java 如何計算同比增長工具類的操作，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教

java 計算同比增長工具類

為了數(shù)據(jù)的嚴(yán)謹(jǐn)性，統(tǒng)一裝換為BigDecimal,話不多說，看代碼。

package com.pig4cloud.pigx.admin.api.util;
import java.math.BigDecimal;
public class PercentCount {
	public String percentBigDecimal(BigDecimal preNum,BigDecimal sufNum){
		double result = countDecimal(preNum,sufNum);
		if(result>0){
			return "+"+result+"%";
		}
		if(result<0){
			return result+"%";
		}
		if(result==0){
			return "+"+0+"%";
		}
		return null;
	}
	public  double countDecimal(BigDecimal preNum,BigDecimal sufNum){
		boolean preBoolean = verifyNum(preNum);
		boolean sufBoolean = verifyNum(sufNum);
		//同時為true計算
		if(preBoolean && sufBoolean){
			boolean b = verifyEqual(preNum, sufNum);
			if (b == false){
				return realCountDecimal(preNum,sufNum);
			}
			if (b){
				return 0;
			}
		}
		if(preBoolean == false && sufBoolean ==false){
			return 0;
		}
		if(sufBoolean ==false){
			return 100;
		}
		return  0;
	}
	//驗證數(shù)字是否為零和null
	public boolean verifyNum(BigDecimal num){
		if(null !=num && num.compareTo(BigDecimal.ZERO)!=0 ){
			return true;
		}
		return false;
	}
	//驗證兩個數(shù)字是否相等
	public boolean verifyEqual(BigDecimal preNum,BigDecimal sufNum){
		int n = preNum.compareTo(sufNum);
		//比較 -1 小于   0 等于    1 大于
		if(n==0){
			return true;
		}
		return false;
	}
	//真正計算
	public double realCountDecimal(BigDecimal preNum,BigDecimal sufNum){
		//(前面的數(shù)字-后面的數(shù)字)/后面的數(shù)字*100
		BigDecimal bigDecimal = (preNum.subtract(sufNum)).divide(sufNum).multiply(new BigDecimal("100")).setScale(2, BigDecimal.ROUND_UP);
		if (bigDecimal.compareTo(BigDecimal.ZERO) !=0){
			return  bigDecimal.doubleValue();
		}
		return 0;
	}
	public static void main(String[] args) {
		PercentCount p = new PercentCount();
		BigDecimal a = new BigDecimal("3");
		BigDecimal b = new BigDecimal("1");
		String percent = p.percentBigDecimal(a, b);
		System.out.println(percent);
	}
}

Java計算同比環(huán)比

同比環(huán)比計算基本概念和計算公式

同比率：本年數(shù)據(jù)比上一年數(shù)據(jù)增長或減少的比率

同比率計算公式：rate = (本年數(shù)據(jù) - 前一年數(shù)據(jù)) / 前一年數(shù)據(jù)

實例：2020年10月游客數(shù)量為80W，2019年10月游客數(shù)量為100W，2018年10月游客數(shù)量為90W

2020年同比率為：rate ：（80 - 100）/100 * 100%= -20%

2019年同比率為：rate ：（100 - 900）/900 * 100%= +11%

（“+” 為增長，“-”為降低）

環(huán)比率：本月（季度）數(shù)據(jù)比上個月（季度）數(shù)據(jù)增長或減少的比率

環(huán)比率計算公式：rate = (本月數(shù)據(jù) - 上個月數(shù)據(jù)) / 上個月數(shù)據(jù)

實例：2020年10月游客數(shù)量為100W，2020年9月游客數(shù)量為90W，2020年7月游客數(shù)量為80W

2020年10月同比率為：rate ：（100 - 90）/90 * 100%= +11%

2019年10月同比率為：rate ：（90- 80）/800 * 100%= +12.5%

注：同比環(huán)比計算公式是相同的，但計算數(shù)據(jù)對應(yīng)的時間是不同的

代碼實現(xiàn)邏輯

通過Calendar等時間函數(shù)和HashMap，[ hashmap（key,value) key為時間，value為該時間對應(yīng)的值]。將key和value一一對應(yīng)的存入集合中，通過對key進行操作，再用key獲取HashMap中相對應(yīng)的value，套公式計算（重點在于對時間（key）的操作,通過key可直接獲取value進行計算）

詳細(xì)邏輯步驟

首先通過SQL語句獲取數(shù)據(jù)庫中相應(yīng)的時間和該時間對應(yīng)的數(shù)據(jù)，按時間分組排序

SELECT
        DATAS.DATE AS NAME ,
        SUM( DATAS.VISITORSUM) AS VALUE,
        2 AS sfzj,
        '' AS bfb
        FROM
        (SELECT TOURIST.* ,CONCAT(YEAR,'年',QUARTER,'月') AS DATE
        FROM TOURISTFLOW TOURIST)DATAS
        GROUP BY DATAS.DATE
        ORDER BY DATAS.DATE

接著設(shè)置時間范圍，將最早的時間減去一年設(shè)為最小時間，最后的時間為最大時間，以此為范圍即可保證覆蓋所有數(shù)據(jù)

// 設(shè)置時間范圍
            // 獲取最前的時間的第一個列表
            analyzeBean firstTimeSubway = analyzeByYear.get(0);
            String startTime = firstTimeSubway.getTime();
            // 獲取最后時間的最后一個列表
            analyzeBean endTimeSubway = analyzeByYear.get(analyzeByYear.size() - 1);
            String endTime = endTimeSubway.getTime();
            // 時間格式轉(zhuǎn)換
            SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月");
            Date parse = format.parse(startTime);
            Date parse1 = format.parse(endTime);
            Calendar c = Calendar.getInstance();
            c.setTime(parse);
            c.add(Calendar.YEAR, -1);
            Date y = c.getTime();
            // 獲取最前的時間的前一年的時間作為查詢范圍
            String firstTime = format.format(y);
            analyzeRequestBean.setStartTime(firstTime);
            Calendar c1 = Calendar.getInstance();
            c1.setTime(parse1);
            Date y1 = c1.getTime();
            // 獲取最后一年的時間作為查詢范圍
            String lastTime = format.format(y1);
            analyzeRequestBean.setStartTime(lastTime);

在將所有數(shù)據(jù)的結(jié)果集存入HashMap中 hash(key,value) key為時間，value為數(shù)據(jù)值

hashMap.put(time, analyzeByYear.get(i).getValue());

最后通過for循環(huán)和CaleCndar函數(shù)和Date函數(shù)對時間（key）進行相應(yīng)的操作，再通過時間（key）到HashMap中找對應(yīng)的值進行計算

for (int i = 0; i < analyzeByYear.size(); i++) {
                AnalyzeBean analyzeBean = analyzeByYear.get(i);
                if (i == 0) {
                	// 是否增長（"0：降低 1：增加 2：既不增長也不降低"）
                    analyzeBean.setSfzj(2);
                    analyzeBean.setBfb(null);
                } else {
                    SimpleDateFormat format2 = new SimpleDateFormat("yyyy年MM月");
                    // 當(dāng)前數(shù)據(jù)
                    Date parse2 = format2.parse(analyzeBean.getTime());
                    Calendar c2 = Calendar.gaetInstance();
                    c2.setTime(parse2);
                    c2.add(Calendar.YEAR, 0);
                    Date t = c2.getTime();
                    String time = format2.format(t);
                    Integer value = hashMap.get(time);
                    // 往年數(shù)據(jù)
                    Date parse3 = format2.parse(time);
                    Calendar c3 = Calendar.getInstance();
                    c3.setTime(parse3);
                    c3.add(Calendar.YEAR, -1);
                    Date year = c3.getTime();
                    String time1 = format2.format(year);
                    Integer value1 = hashMap.get(time1);
                    if (null != value1 && null != value) {
                        if (value.equals(value1)) {
                            analyzeBean.setSfzj(2);
                            analyzeBean.setBfb(null);
                        } else {
                            if (value > value1) {
                                analyzeBean.setSfzj(1);
                            } else {
                                analyzeBean.setSfzj(0);
                            }
                            // 2個值減法 絕對值
                            int abs = Math.abs(value - value1);
                            float a = (float) (abs) / (float) value1 * 100;
                            analyzeBean.setBfb(a + "");
                        }
                    } else {
                        analyzeBean.setSfzj(2);
                        analyzeBean.setBfb(null);
                    }
                }
            }

同比實例代碼：

 // 求同比
    @Override
    public Result getAnalyzeByYear(AnalyzeRequestBean analyzeRequestBean) {
        try {
            // 檢查參數(shù)
            if (null == analyzeRequestBean) {
                return ResultUtil.fail(ResultEnum.PARAMS_ERROR);
            }
a
            List<AnalyzeBean> analyzeByYear
                    = InfoMapper.getAnalyzeByYear(analyzeRequestBean);
            if (analyzeByYear == null || analyzeByYear.size() == 0) {
                return ResultUtil.ok(null);
            }
            // 設(shè)置時間范圍
            // 獲取最前的時間的第一個列表
            analyzeBean firstTimeSubway = analyzeByYear.get(0);
            String startTime = firstTimeSubway.getTime();
            // 獲取最后時間的最后一個列表
            analyzeBean endTimeSubway = analyzeByYear.get(analyzeByYear.size() - 1);
            String endTime = endTimeSubway.getTime();
            // 時間格式轉(zhuǎn)換
            SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月");
            Date parse = format.parse(startTime);
            Date parse1 = format.parse(endTime);
            Calendar c = Calendar.getInstance();
            c.setTime(parse);
            c.add(CaleCndar.YEAR, -1);
            Date y = c.getTime();
            // 獲取最前的時間的前一年的時間作為查詢范圍
            String firstTime = format.format(y);
            analyzeRequestBean.setStartTime(firstTime);
            Calendar c1 = Calendar.getInstance();
            c1.setTime(parse1);
            Date y1 = c1.getTime();
            // 獲取最后一年的時間作為查詢范圍
            String lastTime = format.format(y1);
            analyzeRequestBean.setStartTime(lastTime);
            // 把大范圍的結(jié)果集都放入hashMap中
            HashMap<String, Integer> hashMap = new HashMap<>();
            for (int i = 0; i < analyzeByYear.size(); i++) {
                analyzeBean analyzeBean = analyzeByYear.get(i);
                SimpleDateFormat format1 = new SimpleDateFormat("yyyy年MM月");
                Date parse2 = format1.parse(analyzeBean.getTime());
                Calendar c2 = Calendar.getInstance();
                c2.setTime(parse2);
                c2.add(Calendar.YEAR, 0);
                Date t = c2.getTime();
                String time = format1.format(t);
                hashMap.put(time, analyzeByYear.get(i).getValue());
            }
            for (int i = 0; i < analyzeByYear.size(); i++) {
                AnalyzeBean analyzeBean = analyzeByYear.get(i);
                if (i == 0) {
                	// 是否增長（"0：降低 1：增加 2：既不增長也不降低"）
                    analyzeBean.setSfzj(2);
                    analyzeBean.setBfb(null);
                } else {
                    SimpleDateFormat format2 = new SimpleDateFormat("yyyy年MM月");
                    // 當(dāng)前數(shù)據(jù)
                    Date parse2 = format2.parse(analyzeBean.getTime());
                    Calendar c2 = Calendar.gaetInstance();
                    c2.setTime(parse2);
                    c2.add(Calendar.YEAR, 0);
                    Date t = c2.getTime();
                    String time = format2.format(t);
                    Integer value = hashMap.get(time);
                    // 往年數(shù)據(jù)
                    Date parse3 = format2.parse(time);
                    Calendar c3 = Calendar.getInstance();
                    c3.setTime(parse3);
                    c3.add(Calendar.YEAR, -1);
                    Date year = c3.getTime();
                    String time1 = format2.format(year);
                    Integer value1 = hashMap.get(time1);
                    if (null != value1 && null != value) {
                        if (value.equals(value1)) {
                            analyzeBean.setSfzj(2);
                            analyzeBean.setBfb(null);
                        } else {
                            if (value > value1) {
                                analyzeBean.setSfzj(1);
                            } else {
                                analyzeBean.setSfzj(0);
                            }
                            // 2個值減法 絕對值
                            int abs = Math.abs(value - value1);
                            float a = (float) (abs) / (float) value1 * 100;
                            analyzeBean.setBfb(a + "");
                        }
                    } else {
                        analyzeBean.setSfzj(2);
                        analyzeBean.setBfb(null);
                    }
                }
            }
            return ResultUtil.ok(analyzeByYear);
        } catch (ParseException ex) {
            ex.printStackTrace();
        }
        return ResultUtil.ok(null);
    }