java 等額本金與等額本息

本文轉載自查看原文 2017-01-18 16:32 3257 工具類/ spring工具碼

等額本金與等額本息

等本等息的意思是，每月的本金相等，利息也相等。

等額本息的意思是，每月的本金+利息之和相等（其實每個月本金和利息都有變化，並不相等）

等本等息的意思是，每月的本金相等，利息不等。

等額本金計算：

等額本金是指一種貸款的還款方式，是在還款期內把貸款數總額等分，每月償還同等數額的本金和剩余貸款在該月所產生的利息，這樣由於每月的還款本金額固定，
而利息越來越少，借款人起初還款壓力較大，但是隨時間的推移每月還款數也越來越少。

  1 package com.utils;
  2 
  3 import java.math.BigDecimal;
  4 import java.util.ArrayList;
  5 import java.util.HashMap;
  6 import java.util.List;
  7 import java.util.Map;
  8 import java.util.Map.Entry;
  9 
 10 /**
 11  * 等額本金是指一種貸款的還款方式，是在還款期內把貸款數總額等分，每月償還同等數額的本金和剩余貸款在該月所產生的利息，這樣由於每月的還款本金額固定，
 12  * 而利息越來越少，借款人起初還款壓力較大，但是隨時間的推移每月還款數也越來越少。
 13  */
 14 public class AverageCapitalUtils {
 15     
 16     private static final Integer month = 12;
 17 
 18     /**
 19      * 等額本金計算獲取還款方式為等額本金的每月償還本金和利息 (返回，期數，月總和。月利息，月本金)
 20      * 
 21      * 公式：每月償還本金=(貸款本金÷還款月數)+(貸款本金-已歸還本金累計額)×月利率
 22      * 
 23      * @param investMoney
 24      *            總借款額（貸款本金）
 25      * @param yearRate
 26      *            總年利率
 27      * @param otherRate
 28      *            加息年利率
 29      * @param unit
 30      *            單位：年，月
 31      * @param month
 32      *            還款總月數
 33      * @return 每月償還本金和利息,不四舍五入，直接截取小數點最后兩位
 34      */
 35     public static List<Map<String, Object>> getPerMonthPrincipalInterest(BigDecimal investMoney, BigDecimal yearRate,BigDecimal otherRate, int totalMonth) {
 36         
 37         yearRate = yearRate.divide(new BigDecimal("100"), 6, BigDecimal.ROUND_DOWN);//年利率
 38         
 39         List<Map<String, Object>> mapList = new ArrayList<>();
 40         Map<String, Object> map = null;
 41         BigDecimal totalAmount = BigDecimal.ZERO; //已還本息
 42         // 每月本金
 43         BigDecimal monthPri = getPerMonthPrincipal(investMoney, totalMonth);
 44         // 獲取總月利率
 45         BigDecimal monthRate = yearRate.divide(new BigDecimal(month),6, BigDecimal.ROUND_DOWN);//向下取6位
 46         
 47         // 獲取加息部分月利率
 48         BigDecimal monthOtherRate = otherRate.divide(new BigDecimal(month),6, BigDecimal.ROUND_DOWN);//向下取6位
 49         
 50         for (int i = 1; i <= totalMonth; i++) {
 51             if (i == totalMonth)  //最后一個月的本金= 總金額-已還總金額
 52                 monthPri = investMoney.subtract(totalAmount);
 53             totalAmount = totalAmount.add(monthPri);
 54             
 55             // (貸款本金-已歸還本金累計額)×月利率
 56             BigDecimal monthInvest = investMoney.subtract(monthPri.multiply(new BigDecimal(i-1))).multiply(monthRate); //每月回款的總利息
 57             BigDecimal monthOtherInvest = investMoney.subtract(monthPri.multiply(new BigDecimal(i-1))).multiply(monthOtherRate); //每月回款的財務支付利息
 58             
 59             //每月回款金額 = 月利息+月本金
 60             BigDecimal monthRes = monthInvest.add(monthPri).setScale(2, BigDecimal.ROUND_DOWN);
 61             map = new HashMap<>();
 62             map.put("periods", i);
 63             map.put("monthResAndPri", monthRes); //每月回款總額
 64             map.put("monthPri", monthPri); // 回款本金
 65             map.put("monthInvest", monthInvest.setScale(6, BigDecimal.ROUND_DOWN)); // 回款利息
 66             map.put("monthOtherInvest", monthOtherInvest.setScale(6, BigDecimal.ROUND_DOWN)); // 回款其他利息
 67             map.put("surplusMoney", investMoney.subtract(totalAmount)); // 剩余本金
 68             mapList.add(map);
 69         }
 70         return mapList;
 71     }
 72 
 73     /**
 74      * 等額本金計算獲取還款方式為等額本金的每月償還利息
 75      * 
 76      * 公式：每月應還利息=剩余本金×月利率=(貸款本金-已歸還本金累計額)×月利率
 77      * 
 78      * @param invest
 79      *            總借款額（貸款本金）
 80      * @param yearRate
 81      *            年利率
 82      * @param month
 83      *            還款總月數
 84      * @return 每月償還利息
 85      */
 86     public static Map<String, Object> getPerMonthInterest(BigDecimal invest, BigDecimal yearRate, int totalMonth) {
 87         Map<String, Object> inMap = new HashMap<String, Object>();
 88         List<Map<String, Object>> mapList = getPerMonthPrincipalInterest(invest, yearRate,BigDecimal.ZERO, totalMonth);
 89         for (Map<String, Object> map : mapList) {
 90             inMap.put(map.get("periods").toString(), map.get("monthInvest"));
 91         }
 92         return inMap;
 93     }
 94     
 95     /**
 96      * 等額本金計算獲取還款方式為等額本金的每天償還利息
 97      * 
 98      * 公式：每天應還利息 = 本金*月利率/起息當月天數
 99      * @param invest
100      *            總借款額（貸款本金）
101      * @param yearRate
102      *            年利率
103      * @param totalDay
104      *            起息當月天數
105      * @return 每天償還利息
106      */
107     public static BigDecimal getPerMonthInterestByDay(BigDecimal invest, BigDecimal yearRate, int totalDay) {
108 
109         yearRate = yearRate.divide(new BigDecimal("100"), 6, BigDecimal.ROUND_DOWN);//年利率
110         
111         BigDecimal monthRate = yearRate.divide(new BigDecimal(month),6, BigDecimal.ROUND_DOWN);//向下取6位,獲取月利率
112         
113         BigDecimal income = invest.multiply(monthRate).divide(new BigDecimal(totalDay),6, BigDecimal.ROUND_DOWN);
114         
115         return income.setScale(6, BigDecimal.ROUND_DOWN);
116     }
117 
118     /**
119      * 等額本金計算獲取還款方式為等額本金的每月償還本金(每月回款本金)
120      * 
121      * 公式：每月應還本金=貸款本金÷還款月數
122      * 
123      * @param invest
124      *            總借款額（貸款本金）
125      * @param yearRate
126      *            年利率
127      * @param month
128      *            還款總月數
129      * @return 每月償還本金
130      */
131     private static BigDecimal getPerMonthPrincipal(BigDecimal invest, int totalMonth) {
132         BigDecimal monthIncome = invest.divide(new BigDecimal(totalMonth), 2, BigDecimal.ROUND_DOWN);
133         return monthIncome;
134     }
135 
136     /**
137      * 等額本金計算獲取還款方式為等額本金的總利息
138      * 
139      * @param invest
140      *            總借款額（貸款本金）
141      * @param yearRate
142      *            年利率
143      * @param month
144      *            還款總月數
145      * @return 總利息
146      */
147     public static BigDecimal getInterestCount(BigDecimal invest, BigDecimal yearRate, int totalMonth) {
148         BigDecimal count = new BigDecimal(0);
149         Map<String, Object> mapInterest = getPerMonthInterest(invest, yearRate, totalMonth);
150 
151         for (Entry<String, Object> entry : mapInterest.entrySet()) {
152             count = count.add((BigDecimal) entry.getValue());
153         }
154         return count;
155     }
156 
157     /**
158      * @param args
159      */
160     public static void main(String[] args) {
161         BigDecimal invest = new BigDecimal(10000); // 本金
162         int month = 12;
163         BigDecimal yearRate = new BigDecimal("8"); // 年利率
164         List<Map<String, Object>> getPerMonthPrincipalInterest = getPerMonthPrincipalInterest(invest, yearRate,BigDecimal.ZERO, month);
165         System.out.println("等額本金---每月本息：" + getPerMonthPrincipalInterest);
166         BigDecimal benjin = getPerMonthPrincipal(invest, month);
167         System.out.println("等額本金---每月本金:" + benjin);
168         Map<String, Object> mapInterest = getPerMonthInterest(invest, yearRate, month);
169         System.out.println("等額本金---每月利息:" + mapInterest);
170 
171         BigDecimal count = getInterestCount(invest, yearRate, month);
172         System.out.println("等額本金---總利息：" + count);
173         
174         System.out.println(getPerMonthInterestByDay(invest, yearRate, 31));
175     }
176     
177 }

等額本息計算：

等額本息是指一種貸款的還款方式，是在還款期內，每月償還同等數額的貸款(包括本金和利息)，和等額本金是不一樣的概念，雖然剛開始還款時每月還款額可能會低於等額本金還款方式，但是最終所還利息會高於等額本金還款方式，該方式經常被銀行使用。

每月還款數額計算公式如下：

[ 貸款本金× 月利率×（1+月利率）^還款月數]÷[（1+月利率）^還款月數－1]

下面舉例說明等額本息還款法，

假定借款人從銀行獲得一筆20萬元的個人住房貸款，貸款期限20年，貸款年利率4.2%，每月還本付息。按照上述公式計算，每月應償還本息和為1233.14元。

上述結果只給出了每月應付的本息和，因此需要對這個本息和進行分解。仍以上例為基礎，一個月為一期，第一期貸款余額20萬元，應支付利息700元（200000×4.2%/12），支付本金533.14元，仍欠銀行貸款199466.86元；第二期應支付利息（199466.86×4.2%/12)元。

 package com.util;

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

import com.LoanProductStageVo;
import com.TimeUnits;

/**
 * 本息計算器
 * @Description: 本息算法
 */
public class PrincipalAndInterestEquals {
    /**
     * 調試
     * @param args
     */
    public static void main(String[] args) {
        int periods = 4;
        TimeUnits unit = TimeUnits.day;
        RoundingMode roundingMode = RoundingMode.UP;
        BigDecimal rate = new BigDecimal("0.12");
        BigDecimal money = new BigDecimal("10000");
        
//        equalPI_stage(periods, rate, unit, money, roundingMode);
//        System.out.println("每月本息和（等額本息）："+equalPI_everyMonthPrincipalAddInterset(periods, rate, TimeUnits.month, money, RoundingMode.UP));
//        System.out.println("每月本息和："+pEqualI_stage(periods, rate,unit, money, RoundingMode.UP));
//        pEqualI_stageSumNum(15 ,periods, rate, unit, money, roundingMode);
//        equalP_stage(periods, rate, money, roundingMode);
        
//        List<LoanProductStageVo> stages = equalPI_stage(periods, rate, TimeUnits.month, money, RoundingMode.UP);
//        for(int i = 0; i < stages.size(); i++) {
//            System.out.println("------------" + (i+1) + "期");
//            System.out.println("本金：" + stages.get(i).getPrincipal());
//            System.out.println("利息：" + stages.get(i).getInterset());
//        }
    }
    
    /**
     * 月轉年，乘以12
     */
    private static final BigDecimal MONTH_YEAR = new BigDecimal("12");
    /**
     * 天轉月，乘以30，一月按30天算
     */
    private static final BigDecimal DAY_MONTH = new BigDecimal("30");
//    private static final BigDecimal DAY_YEWR = new BigDecimal("365");
    /**
     * 利率百分數轉換
     */
    private static final BigDecimal RATE_CONVERT_PERCENT = new BigDecimal("100");

    ///-------------------------------等額本息
    /**
     * 等額本息 —— 計算每期還款本息和
     * <p>設貸款額為a，月利率為i，年利率為I，還款月數為n，每月還款額為b，還款利息總和為Y<br/>
     * 月均還款:b＝a×i×（1＋i）^n÷〔（1＋i）^n－1〕</p>
     * @param periods 期數，單位：月
     * @param rate 年利率
     * @param unit 期數單位（目前僅支持年、月、日）
     * @param money 要分期的金額
     * @param roundingMode 小數位處理
     * @return 每期還款額，如單位年，則為每年還款額
     */
    public static BigDecimal equalPI_everyMonthPrincipalAddInterset(Integer periods, BigDecimal rate, TimeUnits unit, BigDecimal money, RoundingMode roundingMode) {
        rate = rate.divide(RATE_CONVERT_PERCENT, roundingMode).divide(MONTH_YEAR, roundingMode);//將年利率轉換成月利率
        /*
         * 設貸款額為a，月利率為i，年利率為I，還款月數為n，每月還款額為b，還款利息總和為Y
         * 月均還款:b＝a×i×（1＋i）^n÷〔（1＋i）^n－1〕
         */
        BigDecimal newrate = rate.add(new BigDecimal("1")).pow(periods);//1+月利率
        BigDecimal ch = newrate.subtract(new BigDecimal("1"));
        BigDecimal monthMoney = money.multiply(rate).multiply(newrate).divide(ch, 2, roundingMode);//每月還款本息和
        
//        System.out.println("每月還款本息："+monthMoney);
//        System.out.println("通過每月還款本息計算的還款總和："+monthMoney.multiply(new BigDecimal(stage.getPeriods())));
        if(TimeUnits.year == unit) {
            return money.multiply(MONTH_YEAR).setScale(2, roundingMode);
        } else if(TimeUnits.day == unit) {
            return money.divide(DAY_MONTH, 2, roundingMode);
        }
        return monthMoney;
    }

    /**
     * 等額本息 —— 計算各個月份的還款額（<font color='red'>僅支持月</font>）
     * <p>設貸款額為a，月利率為i，年利率為I，還款月數為n，每月還款額為b，還款利息總和為Y<br/>
     * 第n月還款利息為:（a×i－b）×（1＋i）^（n－1）＋b</p>
     * <p>未完成：單位為年和日的，間隔不是1的情況</p>
     * @param periods 分期數，單位：月
     * @param rate 年利率
     * @param unit 單位（<font color='red'>僅支持月</font>）
     * @param money 貸款總金額
     * @param roundingMode 小數位處理
     * @return
     */
    public static List<LoanProductStageVo> equalPI_stage(Integer periods, BigDecimal rate, TimeUnits unit, BigDecimal money, RoundingMode roundingMode) {
        rate = rate.divide(RATE_CONVERT_PERCENT, roundingMode).divide(MONTH_YEAR, roundingMode);//計算月利率
        /*
         * 設貸款額為a，月利率為i，年利率為I，還款月數為n，每月還款額為b，還款利息總和為Y
         * 第n月還款利息為:（a×i－b）×（1＋i）^（n－1）＋b
         */
        List<LoanProductStageVo> stageResult = new ArrayList<>();
        //BigDecimal principalAddInterset = equalPI_everyMonthPrincipalAddInterset(periods, rate, unit, money,roundingMode);
        BigDecimal principalAddInterset = equalPI_everyMonthPrincipalAddInterset(periods, rate, TimeUnits.month, money,roundingMode);
        
        BigDecimal totalLixi = new BigDecimal(0);//臨時：利息總額
        BigDecimal totalBenjin = new BigDecimal(0);//臨時：本金總額
        for(int i = 0; i < periods; i++) {
//            System.out.println("\n--------" + (i+1) + "期");
            LoanProductStageVo stageVo = new LoanProductStageVo();
            stageVo.setPrincipalAddInterset(principalAddInterset);
            if(i + 1 == periods) {
                //最后一期的計算，將計算中因小數位導致數據不對稱的補充回來
                stageVo.setInterset(principalAddInterset.multiply(new BigDecimal(periods)).subtract(money).subtract(totalLixi));
                stageVo.setPrincipal(money.subtract(totalBenjin));
            } else {
                BigDecimal currentMonthRate = rate.add(new BigDecimal(1)).pow(i);
                BigDecimal interset = money.multiply(rate).subtract(principalAddInterset).multiply(currentMonthRate).add(principalAddInterset).setScale(2, roundingMode);
                stageVo.setInterset(interset);
                stageVo.setPrincipal(principalAddInterset.subtract(interset));
            }
            
            totalLixi = totalLixi.add(stageVo.getInterset());
            totalBenjin = totalBenjin.add(stageVo.getPrincipal());
            stageResult.add(stageVo);
        }
//        System.out.println("還款利息總額：" + totalLixi);
//        System.out.println("還款本金總額：" + totalBenjin);
        return stageResult;
    }
    
    /**
     * 等額本息 —— 按照公式計算第n期的信息
     * @param n 第n期
     * @param periods 分期數
     * @param rate 月利率
     * @param unit 單位（目前僅支持年、月）
     * @param money 總本金額
     * @param roundingMode 小數位取值方式
     * @return
     */
    public static LoanProductStageVo equalPI_stageAtNum(int n, int periods, BigDecimal rate, BigDecimal money, RoundingMode roundingMode) {
        if(n <= 0) {
            return null;
        }
        if(n > periods) {
            return null;
        }
        rate = rate.divide(RATE_CONVERT_PERCENT, roundingMode).divide(MONTH_YEAR, roundingMode);
        /*
         * 設貸款額為a，月利率為i，年利率為I，還款月數為n，每月還款額為b，還款利息總和為Y
         * 第n月還款利息為:（a×i－b）×（1＋i）^（n－1）＋b
         */
        LoanProductStageVo stageVo = new LoanProductStageVo();
        BigDecimal principalAddInterset = equalPI_everyMonthPrincipalAddInterset(periods, rate, TimeUnits.month, money,roundingMode);
        BigDecimal currentMonthRate = rate.add(new BigDecimal(1)).pow(n - 1);
        BigDecimal interset = money.multiply(rate).subtract(principalAddInterset).multiply(currentMonthRate).add(principalAddInterset).setScale(2, roundingMode);
        stageVo.setPrincipalAddInterset(principalAddInterset);
        stageVo.setInterset(interset);
        stageVo.setPrincipal(principalAddInterset.subtract(interset));
        return stageVo;
    }
    
    ///-------------------------------等額本金
    /**
     * 等額本息 —— 計算每期信息
     * <p>公式：每月還款金額 = （貸款本金 / 還款月數）+（本金 — 已歸還本金累計額）×每月利率</p>
     *
     * @param periods 分期數
     * @param rate 年利率
     * @param money 本金總額
     * @param roundingMode 小數位處理
     * @return
     */
    public static List<LoanProductStageVo> equalP_stage(int periods, BigDecimal rate, BigDecimal money, RoundingMode roundingMode) {
        final BigDecimal PERIODS = new BigDecimal(periods + "");
        rate = rate.divide(RATE_CONVERT_PERCENT, roundingMode).divide(MONTH_YEAR, roundingMode);
        List<LoanProductStageVo> stageResult = new ArrayList<>();
        
        //每月還款本金
        BigDecimal everyMonthPrincipal = money.divide(PERIODS, 2, roundingMode);
        
        BigDecimal totalBenjin = new BigDecimal("0");
        BigDecimal totalLixi = new BigDecimal("0");
        for(int i = 0; i < periods; i++) {
//            System.out.println("\n--------" + (i+1) + "期");
            LoanProductStageVo stageVo = new LoanProductStageVo();
            if(i+1 == periods) {
                stageVo.setPrincipal(money.subtract(totalBenjin));
                stageVo.setInterset(stageVo.getPrincipal().multiply(rate).setScale(2, roundingMode));
            } else {
                stageVo.setPrincipal(everyMonthPrincipal);
                stageVo.setInterset(money.subtract(totalBenjin).multiply(rate).setScale(2, roundingMode));
            }
            
//            System.out.println("本金："+stageVo.getPrincipal());
//            System.out.println("利息："+stageVo.getInterset());
            
            totalBenjin = totalBenjin.add(stageVo.getPrincipal());
            totalLixi = totalLixi.add(stageVo.getInterset());
            
            stageResult.add(stageVo);
        }
//        System.out.println("本金和："+totalBenjin);
//        System.out.println("利息和："+totalLixi);
        return stageResult;
    }
}

等本等息為民間借貸、分期購物、銀行分期中的一種還款方式。
月還款為：本金+利息。
舉例說明，假設借款額3萬元，借款期限12個月，預計年化借款利率12%，等本等息還款，每月月末歸還本金及利息，則公式如下：每月歸還本金＝貸款3萬÷12期＝2500元，預計年利息＝3萬×12%＝3600元，為月息300元，那就是每個月需還2500＋300＝2800元。

package com.zhonglian.jinju.pub.service.support;

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

import com.LoanProductStageVo;
import com.TimeUnits;

/**
 *等 本等息計算器
 * @Description: 本息算法
 */
public class PrincipalAndInterestEquals2 {
    /**
     * 調試
     * @param args
     */
    public static void main(String[] args) {
        int periods = 4;
        TimeUnits unit = TimeUnits.day;
        RoundingMode roundingMode = RoundingMode.UP;
        BigDecimal rate = new BigDecimal("0.12");
        BigDecimal money = new BigDecimal("10000");
        
    pEqualI_stageSumNum(15 ,periods, rate, unit, money, roundingMode);
//        equalP_stage(periods, rate, money, roundingMode);
        
//        List<LoanProductStageVo> stages = equalPI_stage(periods, rate, TimeUnits.month, money, RoundingMode.UP);
//        for(int i = 0; i < stages.size(); i++) {
//            System.out.println("------------" + (i+1) + "期");
//            System.out.println("本金：" + stages.get(i).getPrincipal());
//            System.out.println("利息：" + stages.get(i).getInterset());
//        }
    }
    
    /**
     * 月轉年，乘以12
     */
    private static final BigDecimal MONTH_YEAR = new BigDecimal("12");
    /**
     * 天轉月，乘以30，一月按30天算
     */
    private static final BigDecimal DAY_MONTH = new BigDecimal("30");
//    private static final BigDecimal DAY_YEWR = new BigDecimal("365");
    /**
     * 利率百分數轉換
     */
    private static final BigDecimal RATE_CONVERT_PERCENT = new BigDecimal("100");

    ///-------------------------------等本等息
    
    /**
     * 等本等息 —— 計算每期信息
     * <p>算法：第n月還款利息為:貸款總額 * 年利率 / 分期數</p>
     * @param periods 分期數，單位月
     * @param rate 利率
     * @param money 貸款總額
     * @param roundingMode 小數位處理
     * @return
     */
    public static List<LoanProductStageVo> pEqualI_stage(int periods, BigDecimal rate, BigDecimal money, RoundingMode roundingMode) {
        rate = rate.divide(RATE_CONVERT_PERCENT, roundingMode);
        List<LoanProductStageVo> result = new ArrayList<>();
        BigDecimal everyMonthPrincipal = money.divide(new BigDecimal(periods+""), 2, roundingMode);
        BigDecimal everyMonthInterset = money.multiply(rate).divide(MONTH_YEAR, roundingMode);
        BigDecimal totalInterset = everyMonthInterset.multiply(new BigDecimal(periods+""));
        BigDecimal principalAddInterset = everyMonthPrincipal.add(everyMonthInterset);
        
        BigDecimal totalBenjin = new BigDecimal("0");
        BigDecimal totalLixi = new BigDecimal("0");
        for(int i = 0; i < periods; i++) {
//            System.out.println("\n--------" + (i+1) + "期");
            LoanProductStageVo stageVo = new LoanProductStageVo();
            if(i + 1 == periods) {
                //TODO 算法疑問：最后一期會與前面的不一樣
//                System.out.println("最后");
                stageVo.setPrincipal(money.subtract(totalBenjin));
                stageVo.setInterset(totalInterset.subtract(totalLixi).setScale(2, roundingMode));
                stageVo.setPrincipalAddInterset(principalAddInterset);
            } else {
                stageVo.setInterset(everyMonthInterset);
                stageVo.setPrincipal(everyMonthPrincipal);
                stageVo.setPrincipalAddInterset(principalAddInterset);
            }
            result.add(stageVo);
            
            totalBenjin = totalBenjin.add(stageVo.getPrincipal());
            totalLixi = totalLixi.add(stageVo.getInterset());
            
//            System.out.println("本金："+stageVo.getPrincipal());
//            System.out.println("利息："+stageVo.getInterset());
//            System.out.println("月本息和："+stageVo.getPrincipalAddInterset());
        }
//        System.out.println("本金和："+totalBenjin);
//        System.out.println("利息和："+totalLixi);
        
        return result;
    }

    /**
     * 等本等息 —— 計算前n期之和，時間單位支持年、月、日（按照公式計算）
     * <br/>但對最后一期本金或利息不會“多退少補”計算，本方法完全按照公式走
     * @param n 要計算的期數，單位：月
     * @param periods 分期數
     * @param rate 年利率
     * @param unit 時間單位
     * @param money 總金額
     * @param roundingMode 小數位取值方式
     * @return 如果要獲取的期數超過分期期數，則返回總本息信息
     */
    public static LoanProductStageVo pEqualI_stageSumNum(int n, int periods, BigDecimal rate, TimeUnits unit, BigDecimal money, RoundingMode roundingMode) {
        rate = rate.divide(RATE_CONVERT_PERCENT, roundingMode);
        LoanProductStageVo stageVo = new LoanProductStageVo();
        if(n <= 0) {
            stageVo.setInterset(new BigDecimal("0"));
            stageVo.setPrincipal(new BigDecimal("0"));
            return stageVo;
        }
        final BigDecimal PERIODS = new BigDecimal(periods+"");
        final BigDecimal N = new BigDecimal(n + "");
        BigDecimal monthPrincipal = money.divide(PERIODS, 2, roundingMode);//月本金
        BigDecimal monthInterset = money.multiply(rate).divide(MONTH_YEAR, 2, roundingMode);//月利息
        BigDecimal nSumPrincipal = null, nSumInterset = null;
        boolean nEp = true;//期數校驗
        if(TimeUnits.year == unit) {
            if(n * 12 <= periods) {
                nSumPrincipal = monthPrincipal.multiply(N).multiply(MONTH_YEAR);
                nSumInterset = monthInterset.multiply(N).multiply(MONTH_YEAR);
                nEp = false;
            }
        } else if(TimeUnits.month == unit) {
            if(n <= periods) {
                nSumPrincipal = monthPrincipal.multiply(N);
                nSumInterset = monthInterset.multiply(N);
                nEp = false;
            }
        } else if(TimeUnits.day == unit) {
            if(n / 30 <= periods) {
                nSumPrincipal = monthPrincipal.multiply(N).divide(DAY_MONTH, 2, roundingMode);
                nSumInterset = monthInterset.multiply(N).divide(DAY_MONTH, 2, roundingMode);
                nEp = false;
            }
        } else {
            return null;
        }
        //n的時間大於分期數情況，計算總和
        if(nEp) {
            nSumPrincipal = monthPrincipal.multiply(PERIODS);
            nSumInterset = monthInterset.multiply(PERIODS);
        }
        stageVo.setPrincipal(nSumPrincipal);
        stageVo.setInterset(nSumInterset);
        
//        System.out.println("等本等息：前"+n+unit.getText()+"信息");
//        System.out.println("本金和："+stageVo.getPrincipal());
//        System.out.println("利息和："+stageVo.getInterset());
        
        return stageVo;
    }
    
    
}

TimeUnits類

package com.enums;

import com.fasterxml.jackson.databind.annotation.JsonSerialize;

@JsonSerialize(as = StringValueTextEnum.class)
public enum TimeUnits implements StringValueTextEnum {

    /** 分 */
    minute("minute", "分"),

    /** 時 */
    hour("hour", "時"),

    /** 天 */
    day("day", "天"),

    /** 周 */
    week("week", "周"),

    /** 月 */
    month("month", "月"),

    /** 年 */
    year("year", "年");

    private String value;
    private String text;

    private TimeUnits(String value, String text) {
        this.value = value;
        this.text = text;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    public String getText() {
        return text;
    }

    public void setText(String text) {
        this.text = text;
    }

}

LoanProductStageVo公共類

package com.bo;

import java.math.BigDecimal;

/**
 * 分期計算結果類
 *
 */
public class LoanProductStageVo {
    //本息和
    private BigDecimal principalAddInterset;
    //本金
    private BigDecimal principal;
    //利息
    private BigDecimal interset;
    
    /**
     * 本息和（單獨的公式計算，每月相同）
     * @return
     */
    public BigDecimal getPrincipalAddInterset() {
        if(principalAddInterset == null && principal != null && interset != null) {
            principalAddInterset = principal.add(interset);
        }
        return principalAddInterset;
    }
    /**
     * 本息和（單獨的公式計算，每月相同）
     * @param principalAddInterset
     */
    public void setPrincipalAddInterset(BigDecimal principalAddInterset) {
        this.principalAddInterset = principalAddInterset;
    }
    /**
     * 本金
     * @return
     */
    public BigDecimal getPrincipal() {
        return principal;
    }
    /**
     * 本金
     * @param principal
     */
    public void setPrincipal(BigDecimal principal) {
        this.principal = principal;
    }
    /**
     * 利息
     * @return
     */
    public BigDecimal getInterset() {
        return interset;
    }
    /**
     * 利息
     * @param interset
     */
    public void setInterset(BigDecimal interset) {
        this.interset = interset;
    }
}

完

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 等額本息和等額本金計算等額本息計算公式推導 [Python]等額本息房貸計算器等額本息PMT和PPMT推導計算公式【Java例題】2.3 計算銀行存款本息 java 什么是Java java 一、java為什么叫java? [Java]-Java的版本演化