等额本金，等额本息，随借随还，利随本清，按月付息到期还本，5种还款方式java计算方法

墨蓝 2022-04-15 03:06 890阅读 0赞

### 等额本金，等额本息，随借随还，利随本清，按月付息到期还本，5种还款方式java计算方法 ###

等额本息定义：本金逐月递增，利息逐月递减，月还款数不变。

等额本金定义：本金保持相同，利息逐月递减，月还款数递减。

随借随还定义：客户在获得授信额度后可以随时来支取，借出后就开始算利息；借出后可以随时还。还了之后在期限内又可以取。

利随本清(一次性还本付息)定义：借款人在贷款期内不是按月偿还本息，而是贷款到期后一次性归还本金和利息。

按月付息到期还本定义：借款人每月只交付利息，在贷款到期日时一次性归还贷款本金

//等额本息
    import java.math.BigDecimal;
    import java.util.HashMap;
    import java.util.Map;
    
    /** * 等额本息还款，也称定期付息，即借款人每月按相等的金额偿还贷款本息，其中每月贷款利息按月初剩余贷款本金计算并逐月结清。把按揭贷款的本金总额与利息总额相加， * 然后平均分摊到还款期限的每个月中。作为还款人，每个月还给银行固定金额，但每月还款额中的本金比重逐月递增、利息比重逐月递减。 */
     
    public class AverageCapitalPlusInterestUtils { 
     
        /** * 等额本息计算获取还款方式为等额本息的每月偿还本金和利息 * * 公式：每月偿还本息=〔贷款本金×月利率×(1＋月利率)＾还款月数〕÷〔(1＋月利率)＾还款月数-1〕 * * @param invest * 总借款额（贷款本金） * @param yearRate * 年利率 * @param totalmonth * 还款总月数 * @return 每月偿还本金和利息,不四舍五入，直接截取小数点最后两位 */
        public static double getPerMonthPrincipalInterest(double invest, double yearRate, int totalmonth) { 
            double monthRate = yearRate / 12;
            BigDecimal monthIncome = new BigDecimal(invest)
                    .multiply(new BigDecimal(monthRate * Math.pow(1 + monthRate, totalmonth)))
                    .divide(new BigDecimal(Math.pow(1 + monthRate, totalmonth) - 1), 2, BigDecimal.ROUND_DOWN);
            return monthIncome.doubleValue();
        }
     
        /** * 等额本息计算获取还款方式为等额本息的每月偿还利息 * * 公式：每月偿还利息=贷款本金×月利率×〔(1+月利率)^还款月数-(1+月利率)^(还款月序号-1)〕÷〔(1+月利率)^还款月数-1〕 * @param invest * 总借款额（贷款本金） * @param yearRate * 年利率 * @param totalmonth * 还款总月数 * @return 每月偿还利息 */
        public static Map<Integer, BigDecimal> getPerMonthInterest(double invest, double yearRate, int totalmonth) { 
            Map<Integer, BigDecimal> map = new HashMap<Integer, BigDecimal>();
            double monthRate = yearRate/12;
            BigDecimal monthInterest;
            for (int i = 1; i < totalmonth + 1; i++) { 
                BigDecimal multiply = new BigDecimal(invest).multiply(new BigDecimal(monthRate));
                BigDecimal sub  = new BigDecimal(Math.pow(1 + monthRate, totalmonth)).subtract(new BigDecimal(Math.pow(1 + monthRate, i-1)));
                monthInterest = multiply.multiply(sub).divide(new BigDecimal(Math.pow(1 + monthRate, totalmonth) - 1), 6, BigDecimal.ROUND_DOWN);
                monthInterest = monthInterest.setScale(2, BigDecimal.ROUND_DOWN);
                map.put(i, monthInterest);
            }
            return map;
        }
        /** * 等额本息计算获取还款方式为等额本息的每月偿还本金 * * @param invest * 总借款额（贷款本金） * @param yearRate * 年利率 * @param totalmonth * 还款总月数 * @return 每月偿还本金 */
        public static Map<Integer, BigDecimal> getPerMonthPrincipal(double invest, double yearRate, int totalmonth) { 
            double monthRate = yearRate / 12;
            BigDecimal monthIncome = new BigDecimal(invest)
                    .multiply(new BigDecimal(monthRate * Math.pow(1 + monthRate, totalmonth)))
                    .divide(new BigDecimal(Math.pow(1 + monthRate, totalmonth) - 1), 2, BigDecimal.ROUND_DOWN);
            Map<Integer, BigDecimal> mapInterest = getPerMonthInterest(invest, yearRate, totalmonth);
            Map<Integer, BigDecimal> mapPrincipal = new HashMap<Integer, BigDecimal>();
     
            for (Map.Entry<Integer, BigDecimal> entry : mapInterest.entrySet()) { 
                mapPrincipal.put(entry.getKey(), monthIncome.subtract(entry.getValue()));
            }
            return mapPrincipal;
        }
     
        /** * 等额本息计算获取还款方式为等额本息的总利息 * * @param invest * 总借款额（贷款本金） * @param yearRate * 年利率 * @param totalmonth * 还款总月数 * @return 总利息 */
        public static double getInterestCount(double invest, double yearRate, int totalmonth) { 
            BigDecimal count = new BigDecimal(0);
            Map<Integer, BigDecimal> mapInterest = getPerMonthInterest(invest, yearRate, totalmonth);
     
            for (Map.Entry<Integer, BigDecimal> entry : mapInterest.entrySet()) { 
                count = count.add(entry.getValue());
            }
            return count.doubleValue();
        }
     
        /** * 应还本金总和 * @param invest * 总借款额（贷款本金） * @param yearRate * 年利率 * @param totalmonth * 还款总月数 * @return 应还本金总和 */
        public static double getPrincipalInterestCount(double invest, double yearRate, int totalmonth) { 
            double monthRate = yearRate / 12;
            BigDecimal perMonthInterest = new BigDecimal(invest)
                    .multiply(new BigDecimal(monthRate * Math.pow(1 + monthRate, totalmonth)))
                    .divide(new BigDecimal(Math.pow(1 + monthRate, totalmonth) - 1), 2, BigDecimal.ROUND_DOWN);
            BigDecimal count = perMonthInterest.multiply(new BigDecimal(totalmonth));
            count = count.setScale(2, BigDecimal.ROUND_DOWN);
            return count.doubleValue();
        }

//等额本金
    import java.math.BigDecimal;
    import java.util.HashMap;
    import java.util.Map;
    
    /** * 等额本金是指一种贷款的还款方式，是在还款期内把贷款数总额等分，每月偿还同等数额的本金和剩余贷款在该月所产生的利息，这样由于每月的还款本金额固定， * 而利息越来越少，借款人起初还款压力较大，但是随时间的推移每月还款数也越来越少。 */
    public class AverageCapitalUtils { 
     
        /** * 等额本金计算获取还款方式为等额本金的每月偿还本金和利息 * * 公式：每月偿还本金=(贷款本金÷还款月数)+(贷款本金-已归还本金累计额)×月利率 * * @param invest * 总借款额（贷款本金） * @param yearRate * 年利率 * @param totalMonth * 还款总月数 * @return 每月偿还本金和利息,不四舍五入，直接截取小数点最后两位 */
        public static Map<Integer, Double> getPerMonthPrincipalInterest(double invest, double yearRate, int totalMonth) { 
            Map<Integer, Double> map = new HashMap<Integer, Double>();
            // 每月本金
            double monthPri = getPerMonthPrincipal(invest, totalMonth);
            // 获取月利率
            double monthRate = yearRate / 12;
            monthRate = new BigDecimal(monthRate).setScale(6, BigDecimal.ROUND_DOWN).doubleValue();
            for (int i = 1; i <= totalMonth; i++) { 
                double monthRes = monthPri + (invest - monthPri * (i - 1)) * monthRate;
                monthRes = new BigDecimal(monthRes).setScale(2, BigDecimal.ROUND_DOWN).doubleValue();
                map.put(i, monthRes);
            }
            return map;
        }
        /** * 等额本金计算获取还款方式为等额本金的每月偿还利息 * * 公式：每月应还利息=剩余本金×月利率=(贷款本金-已归还本金累计额)×月利率 * * @param invest * 总借款额（贷款本金） * @param yearRate * 年利率 * @param totalMonth * 还款总月数 * @return 每月偿还利息 */
        public static Map<Integer, Double> getPerMonthInterest(double invest, double yearRate, int totalMonth) { 
            Map<Integer, Double> inMap = new HashMap<Integer, Double>();
            double principal = getPerMonthPrincipal(invest, totalMonth);
            Map<Integer, Double> map = getPerMonthPrincipalInterest(invest, yearRate, totalMonth);
            for (Map.Entry<Integer, Double> entry : map.entrySet()) { 
                BigDecimal principalBigDecimal = new BigDecimal(principal);
                BigDecimal principalInterestBigDecimal = new BigDecimal(entry.getValue());
                BigDecimal interestBigDecimal = principalInterestBigDecimal.subtract(principalBigDecimal);
                interestBigDecimal = interestBigDecimal.setScale(2, BigDecimal.ROUND_DOWN);
                inMap.put(entry.getKey(), interestBigDecimal.doubleValue());
            }
            return inMap;
        }
     
        /** * 等额本金计算获取还款方式为等额本金的每月偿还本金 * * 公式：每月应还本金=贷款本金÷还款月数 * * @param invest * 总借款额（贷款本金） * @param totalMonth * 还款总月数 * @return 每月偿还本金 */
        public static double getPerMonthPrincipal(double invest, int totalMonth) { 
            BigDecimal monthIncome = new BigDecimal(invest).divide(new BigDecimal(totalMonth), 2, BigDecimal.ROUND_DOWN);
            return monthIncome.doubleValue();
        }
     
        /** * 等额本金计算获取还款方式为等额本金的总利息 * * @param invest * 总借款额（贷款本金） * @param yearRate * 年利率 * @param totalMonth * 还款总月数 * @return 总利息 */
        public static double getInterestCount(double invest, double yearRate, int totalMonth) { 
            BigDecimal count = new BigDecimal(0);
            Map<Integer, Double> mapInterest = getPerMonthInterest(invest, yearRate, totalMonth);
     
            for (Map.Entry<Integer, Double> entry : mapInterest.entrySet()) { 
                count = count.add(new BigDecimal(entry.getValue()));
            }
            return count.doubleValue();
        }

//随借随还
    	/** 随借随还 * @param amount 本金 * @param annualInterestRate 年利率 * @param termCount 还款期限（天数） * @return 还款金额 = 本金 + 本金*日利率*天数 * @throws Exception */
    	public static BigDecimal payOff(BigDecimal amount, BigDecimal annualInterestRate, int termCount) throws Exception { 
    		annualInterestRate = annualInterestRate.multiply(new BigDecimal(100));
    		BigDecimal dailyInterest = LoanUtil.getDayInterestByYear(annualInterestRate);
    		BigDecimal multiply = amount.multiply(dailyInterest).multiply(new BigDecimal(termCount));
    		return multiply.add(amount).setScale(2, BigDecimal.ROUND_HALF_EVEN);
    	}

//利随本清
    	/** * @Title: calculateInterest 利息总计 = 本金*利率*数 * @Description: TODO(利随本清利息计算) * @param @param amount 本金 * @param @param annualInterestRate 年利率 * @param @param termUnit 1为日利率 3为月利率 * @param @param termCount 日数，月数 * @param @return 利随本清方式利息总计 * @param @throws Exception参数 * @return BigDecimal 返回类型 * @throws * */
        public static BigDecimal calculateInterest(BigDecimal amount,
    			BigDecimal annualInterestRate, int termUnit, int termCount) throws Exception
    			 { 
    			annualInterestRate = annualInterestRate.multiply(new BigDecimal(100));
    		if (termUnit == 1) { 
    			BigDecimal dailyInterest = LoanUtil
    					.getDayInterestByYear(annualInterestRate);
    			return amount.multiply(dailyInterest)
    					.multiply(new BigDecimal(termCount))
    					.setScale(2,
    					BigDecimal.ROUND_HALF_EVEN);
    		} else if (termUnit == 3) { 
    			BigDecimal monthlyInterest = LoanUtil
    					.getMonthInterestByYear(annualInterestRate);
    			return amount.multiply(monthlyInterest)
    					.multiply(new BigDecimal(termCount))
    					.setScale(2, BigDecimal.ROUND_HALF_EVEN);
    		} else { 
    			throw new Exception("不支持的时间单位: " + termUnit);
    		}
    		
    			 }

//按月付息到期还本
        /** * 按月付息，到期还本-计算获取还款方式为按月付息，到期还本的每月偿还利息 * * 公式：每月应还利息=总借款额*年利率÷还款月数 * * * @param invest * 总借款额（贷款本金） * @param yearRate * 年利率 * @param totalMonth * 还款总月数 * @return 每月偿还利息 */
        public static double getPerMonthInterests(double invest,double yearRate, int totalMonth) { 
            BigDecimal monthIncome = new BigDecimal(invest).multiply(new BigDecimal(yearRate)).divide(new BigDecimal(totalMonth), 2, BigDecimal.ROUND_DOWN);
            return monthIncome.doubleValue();
        }
        /** * 按月付息，到期还本计算获取还款方式为按月付息，到期还本的每月偿还利息，最后一个月归还利息+本金 * * 公式：每月偿还利息=(总借款额*年利率÷还款月数) * * @param invest * 总借款额（贷款本金） * @param yearRate * 年利率 * @param totalMonth * 还款总月数 * @return 每月偿还利息,不四舍五入，直接截取小数点最后两位 */
        public static Map<Integer, Double> getPerMonthPrincipalInterests(double invest, double yearRate, int totalMonth) { 
            Map<Integer, Double> map = new HashMap<Integer, Double>();
            // 每月利息
            double monthPri = getPerMonthInterests(invest,yearRate, totalMonth);
            for (int i = 1; i <= totalMonth; i++) { 
            	if(i == totalMonth){ 
            		//最后一期 利息+ 本金
            		monthPri = monthPri + invest ;
            	}
                map.put(i, monthPri);
            }
            return map;
        }