借呗提前还款算法模拟

最新推荐文章于 2022-05-25 08:08:02 发布
最新推荐文章于 2022-05-25 08:08:02 发布
阅读量2.3k 收藏 1
点赞数
分类专栏： jeibai 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huluyisheng/article/details/84895842
版权 
/**
 * 阿里借呗计息还款规则说明实现
 * 
 * 测试阿里案例和韩哥案例通过
 * @return
 */
package jdongtech.jiebaiUtils;

import java.util.Arrays;
import java.util.Calendar;
import java.util.HashMap;
import java.util.Map;

import jdongtech.interestUtils.AverageCapitalPlusInterestUtils;

public class advanceRepayMore {
	public static void main(String[] args) {

		Calendar lendDay = Calendar.getInstance(); // 借款日期
		Calendar rebackDay = Calendar.getInstance();// 还款日期
		double rebackInvest = 0; // 还款金额
		double invest = 0; // 借款本金
		int month = 0; // 期数
		double yearRate = 0; // 年利率
		int acctOffsetDay = 15; // 平移日期
		int accountDay = 25; // 账单日，蚂蚁会把账单日设置成借款当日

		// 文件示例
		lendDay.set(Calendar.MONTH, 9);
		lendDay.set(Calendar.DAY_OF_MONTH, 13);
		rebackInvest = 100.24;
		// rebackInvest = 60.04;
		rebackDay.set(Calendar.MONTH, 9);
		rebackDay.set(Calendar.DAY_OF_MONTH, 14);
		invest = 1200; // 本金
		month = 12; // 期数
		yearRate = 7.2 / 100; // 年利率
		acctOffsetDay = 15;
		accountDay = 25;

		// 韩哥示例
		lendDay.set(Calendar.MONTH, 4);
		lendDay.set(Calendar.DAY_OF_MONTH, 13);
		rebackInvest = 60.04;
		rebackDay.set(Calendar.MONTH, 4);
		rebackDay.set(Calendar.DAY_OF_MONTH, 13);
		invest = 120; // 本金
		month = 6; // 期数
		yearRate = 14.4 / 100; // 年利率
		acctOffsetDay = 15;
		accountDay = 13; // 账单日，蚂蚁会把账单日设置成借款当日

		double dateRate = yearRate / 360;
		int[] daysCount = new int[month];
		int IncreaseFlag = 0;
		Calendar lendCalOffset = (Calendar) lendDay.clone();
		lendCalOffset.add(Calendar.DATE, acctOffsetDay);
		Calendar accCal = (Calendar) lendDay.clone();
		accCal.set(Calendar.DAY_OF_MONTH, accountDay);
		Calendar accCalBegin = (Calendar) accCal.clone();
		if (lendCalOffset.before(accCal)) {
		} else {
			accCalBegin.add(Calendar.MONTH, 1);
			IncreaseFlag = 1;
		}
		Calendar accCalEnd = (Calendar) accCal.clone();
		accCalEnd.add(Calendar.MONTH, month - 1);

		System.out.println(lendDay.getTime() + "借款日期");
		System.out.println(accCalBegin.getTime() + "开始");
		System.out.println(accCalEnd.getTime() + "结束");
		int daysLending = RepayUtils.daysOffset(lendDay, accCalEnd);
		System.out.println("借款经历" + daysLending + "天");

		Calendar accCalPerEnd = (Calendar) accCalBegin.clone();
		for (int i = 0; i < month; i++) {
			Calendar accCalPerBeg;
			if (i == 0) {
				accCalPerBeg = (Calendar) lendDay.clone();
			} else {
				accCalPerBeg = (Calendar) accCalPerEnd.clone();
				accCalPerBeg.add(Calendar.MONTH, -1);
			}

			int daysPer = RepayUtils.daysOffset(accCalPerBeg, accCalPerEnd);
			daysCount[i] = daysPer;
			accCalPerEnd.add(Calendar.MONTH, 1);
		}

		System.out.println("部分还款前计划:");
		normalRepay.getPerMonthPrincipalInterestBig(invest, dateRate, month, daysCount, IncreaseFlag);

		System.out.println("提前还款日期:" + rebackDay.getTime());
		int curPeriod = 0;
		int daysCurPeriod = RepayUtils.daysOffset(lendDay, rebackDay);
		for (int i = 0; i < daysCount.length; i++) {
			daysCurPeriod = daysCurPeriod - daysCount[i];
			if (daysCurPeriod <= 0) { // 账单日算当前期
				curPeriod = i;
				daysCurPeriod = daysCurPeriod + daysCount[i];
				i = daysCount.length;
			}
		}
		System.out.println("提前还款当期期数:" + curPeriod);
		System.out.println("提前还款当期天数:" + daysCurPeriod);
		System.out.println("部分还款后计划:");
		getPerMonthPrincipalInterestBigRebackSome(invest, dateRate, month, daysCount, IncreaseFlag, rebackInvest,
				curPeriod, daysCurPeriod);
	}

	/**
	 * 计算实际等额本息每月额度
	 * 
	 * @return
	 */
	public static double getPerMonthPrincipalInterestBigRebackSome(double invest, double dateRate, int totalmonth,
			int[] daysCount, int IncreaseFlag, double rebackInvest, int curPeriod, int daysCurPeriod) {
		IncreaseFlag = 1;
		if (daysCurPeriod == 0) {
			daysCurPeriod = 1;
		}
		double perMonthStandard = AverageCapitalPlusInterestUtils.getPerMonthPrincipalInterest(invest, dateRate * 360,
				totalmonth);

		double perMonthMax = perMonthStandard * 1.01;
		double[] PRperMonth = new double[totalmonth];
		double[] PperMonth = new double[totalmonth];
		double[] RperMonth = new double[totalmonth];
		double[] PLeftperMonth = new double[totalmonth];
		Map<Double, Double> lastCheckMap = new HashMap<Double, Double>();
		Map<Double, double[]> PLeftperMonthMap = new HashMap<Double, double[]>();
		Map<Double, double[]> PRperMonthMap = new HashMap<Double, double[]>();
		Map<Double, double[]> PperMonthMap = new HashMap<Double, double[]>();
		Map<Double, double[]> RperMonthMap = new HashMap<Double, double[]>();
		Map<Double, Double> sumPRMap = new HashMap<Double, Double>();
		Map<Double, Double> sumPMap = new HashMap<Double, Double>();
		Map<Double, Double> sumRMap = new HashMap<Double, Double>();

		if (IncreaseFlag == 1) {
			while (perMonthStandard < perMonthMax) {
				PRperMonth = new double[totalmonth];
				PperMonth = new double[totalmonth];
				RperMonth = new double[totalmonth];
				PLeftperMonth = new double[totalmonth];

				PRperMonth[0] = RepayUtils.num2second(perMonthStandard);
				PLeftperMonth[0] = RepayUtils.num2second(invest);
				RperMonth[0] = RepayUtils.num2secondDown(PLeftperMonth[0] * daysCount[0] * dateRate);
				PperMonth[0] = RepayUtils.num2second(PRperMonth[0] - RperMonth[0]);
				for (int j = 1; j < totalmonth; j++) {
					PRperMonth[j] = RepayUtils.num2second(perMonthStandard);
					PLeftperMonth[j] = RepayUtils.num2second(PLeftperMonth[j - 1] - PperMonth[j - 1]);
					RperMonth[j] = RepayUtils.num2secondDown(PLeftperMonth[j] * dateRate * daysCount[j]);
					PperMonth[j] = RepayUtils.num2second(PRperMonth[j] - RperMonth[j]);
					if (j == totalmonth - 1) {
						PperMonth[j] = RepayUtils.num2second(PLeftperMonth[j]);
						PRperMonth[j] = RepayUtils.num2second(PperMonth[j] + RperMonth[j]);
					}
				}
				double sumP = 0;
				double sumR = 0;
				double sumPR = 0;
				for (int i = 0; i < PLeftperMonth.length; i++) {
					sumP = sumP + PperMonth[i];
					sumR = sumR + RperMonth[i];
					sumPR = sumPR + PRperMonth[i];
				}
				lastCheckMap.put(RepayUtils.num2second(perMonthStandard),
						Math.abs(PRperMonth[totalmonth - 1] - PRperMonth[totalmonth - 2]));
				PLeftperMonthMap.put(RepayUtils.num2second(perMonthStandard), PLeftperMonth);
				PRperMonthMap.put(RepayUtils.num2second(perMonthStandard), PRperMonth);
				PperMonthMap.put(RepayUtils.num2second(perMonthStandard), PperMonth);
				RperMonthMap.put(RepayUtils.num2second(perMonthStandard), RperMonth);
				sumPRMap.put(RepayUtils.num2second(perMonthStandard), RepayUtils.num2second(sumPR));
				sumPMap.put(RepayUtils.num2second(perMonthStandard), RepayUtils.num2second(sumP));
				sumRMap.put(RepayUtils.num2second(perMonthStandard), RepayUtils.num2second(sumR));

				perMonthStandard = perMonthStandard + 0.01;
			}
		}

		Double resultKey = RepayUtils.getKeyByMinValue(lastCheckMap);
		// 当期剩余天数
		int remainDaysCurPeriod = daysCount[curPeriod] - daysCurPeriod;
		double rebackPCurPeriod = RepayUtils.num2second(
				rebackInvest - RepayUtils.num2secondDown(PLeftperMonth[curPeriod] * dateRate * daysCurPeriod));

		if (rebackPCurPeriod < PperMonthMap.get(resultKey)[curPeriod]) { // 还款小于当前期本金
			PLeftperMonthMap.get(resultKey)[curPeriod] = RepayUtils
					.num2second(PLeftperMonthMap.get(resultKey)[curPeriod] - rebackPCurPeriod);
			PperMonthMap.get(resultKey)[curPeriod] = RepayUtils
					.num2second(PperMonthMap.get(resultKey)[curPeriod] - rebackPCurPeriod);
			RperMonthMap.get(resultKey)[curPeriod] = RepayUtils
					.num2secondDown(PLeftperMonthMap.get(resultKey)[curPeriod] * dateRate * remainDaysCurPeriod);
			PRperMonthMap.get(resultKey)[curPeriod] = RepayUtils
					.num2second(RperMonthMap.get(resultKey)[curPeriod] + PperMonthMap.get(resultKey)[curPeriod]);

			System.out.println("等额本息每月还款额：" + resultKey);
			System.out.println("每期经历" + Arrays.toString(daysCount));
			System.out.println("每月余本金:" + Arrays.toString(PLeftperMonthMap.get(resultKey)));
			System.out.println("每月还款额:" + Arrays.toString(PRperMonthMap.get(resultKey)));
			System.out.println("每月还本金:" + Arrays.toString(PperMonthMap.get(resultKey)));
			System.out.println("每月还利息:" + Arrays.toString(RperMonthMap.get(resultKey)));
			double sumP = 0;
			double sumR = 0;
			double sumPR = 0;
			for (int i = 0; i < PLeftperMonth.length; i++) {
				sumP = sumP + PperMonthMap.get(resultKey)[i];
				sumR = sumR + RperMonthMap.get(resultKey)[i];
				sumPR = sumPR + PRperMonthMap.get(resultKey)[i];
			}
			sumPRMap.put(RepayUtils.num2second(resultKey), RepayUtils.num2second(sumPR));
			sumPMap.put(RepayUtils.num2second(resultKey), RepayUtils.num2second(sumP));
			sumRMap.put(RepayUtils.num2second(resultKey), RepayUtils.num2second(sumR));

			System.out.println("总还款额:" + sumPRMap.get(resultKey));
			System.out.println("总还本金:" + sumPMap.get(resultKey));
			System.out.println("总还利息:" + sumRMap.get(resultKey));

		} else { // 还款本金大于当期本金
			int[] dayCountsAfter = new int[totalmonth - curPeriod];
			double[] PRperMonthAfter = new double[totalmonth - curPeriod];
			double[] PperMonthAfter = new double[totalmonth - curPeriod];
			double[] RperMonthAfter = new double[totalmonth - curPeriod];
			double[] PLeftperMonthAfter = new double[totalmonth - curPeriod];

			// P本金0的阶段 第一个月
			double remainInvest = RepayUtils.num2second(PLeftperMonthMap.get(resultKey)[curPeriod] - rebackPCurPeriod);
			PperMonthAfter[0] = RepayUtils.num2second(0);
			PLeftperMonthAfter[0] = remainInvest;
			RperMonthAfter[0] = RepayUtils.num2secondDown(PLeftperMonthAfter[0] * dateRate * remainDaysCurPeriod);
			PRperMonthAfter[0] = RperMonthAfter[0];

			// P本金非0的再平衡阶段
			int remainMonth = totalmonth - curPeriod - 1;
			double perMonthStandardRec = AverageCapitalPlusInterestUtils.getPerMonthPrincipalInterest(remainInvest,
					dateRate * 360, remainMonth);
			int[] daysCountRec = Arrays.copyOfRange(daysCount, curPeriod + 1, totalmonth); // 剩余天数数组
			for (int i = 0; i < remainMonth; i++) {
				dayCountsAfter[i + 1] = daysCountRec[i];
				dayCountsAfter[0] = remainDaysCurPeriod;
			}

			double perMonthMaxRec = perMonthStandardRec * 1.1;
			double[] PRperMonthRec = new double[remainMonth];
			double[] PperMonthRec = new double[remainMonth];
			double[] RperMonthRec = new double[remainMonth];
			double[] PLeftperMonthRec = new double[remainMonth];
			Map<Double, Double> lastCheckMapRec = new HashMap<Double, Double>();
			Map<Double, double[]> PLeftperMonthMapRec = new HashMap<Double, double[]>();
			Map<Double, double[]> PRperMonthMapRec = new HashMap<Double, double[]>();
			Map<Double, double[]> PperMonthMapRec = new HashMap<Double, double[]>();
			Map<Double, double[]> RperMonthMapRec = new HashMap<Double, double[]>();
			while (perMonthStandardRec < perMonthMaxRec) {
				PRperMonthRec = new double[remainMonth];
				PperMonthRec = new double[remainMonth];
				RperMonthRec = new double[remainMonth];
				PLeftperMonthRec = new double[remainMonth];

				PRperMonthRec[0] = RepayUtils.num2second(perMonthStandardRec);
				PLeftperMonthRec[0] = RepayUtils.num2second(remainInvest);
				RperMonthRec[0] = RepayUtils.num2secondDown(PLeftperMonthRec[0] * daysCountRec[0] * dateRate);
				PperMonthRec[0] = RepayUtils.num2second(PRperMonthRec[0] - RperMonthRec[0]);
				for (int j = 1; j < remainMonth; j++) {
					PRperMonthRec[j] = RepayUtils.num2second(perMonthStandardRec);
					PLeftperMonthRec[j] = RepayUtils.num2second(PLeftperMonthRec[j - 1] - PperMonthRec[j - 1]);
					RperMonthRec[j] = RepayUtils.num2secondDown(PLeftperMonthRec[j] * dateRate * daysCountRec[j]);
					PperMonthRec[j] = RepayUtils.num2second(PRperMonthRec[j] - RperMonthRec[j]);
					if (j == remainMonth - 1) {
						PperMonthRec[j] = RepayUtils.num2second(PLeftperMonthRec[j]);
						PRperMonthRec[j] = RepayUtils.num2second(PperMonthRec[j] + RperMonthRec[j]);
					}
				}

				lastCheckMapRec.put(RepayUtils.num2second(perMonthStandardRec),
						Math.abs(PRperMonthRec[remainMonth - 1] - PRperMonthRec[remainMonth - 2]));

				PLeftperMonthMapRec.put(RepayUtils.num2second(perMonthStandardRec), PLeftperMonthRec);
				PRperMonthMapRec.put(RepayUtils.num2second(perMonthStandardRec), PRperMonthRec);
				PperMonthMapRec.put(RepayUtils.num2second(perMonthStandardRec), PperMonthRec);
				RperMonthMapRec.put(RepayUtils.num2secondDown(perMonthStandardRec), RperMonthRec);
				perMonthStandardRec = perMonthStandardRec + 0.01;
			}

			Double resultKeyRec = RepayUtils.getKeyByMinValue(lastCheckMapRec);

			for (int i = 1; i < totalmonth; i++) {
				PperMonthAfter[i] = RepayUtils.num2second(PperMonthMapRec.get(resultKeyRec)[i - 1]);
				PLeftperMonthAfter[i] = RepayUtils.num2second(PLeftperMonthMapRec.get(resultKeyRec)[i - 1]);
				RperMonthAfter[i] = RepayUtils.num2second(RperMonthMapRec.get(resultKeyRec)[i - 1]);
				PRperMonthAfter[i] = RepayUtils.num2second(PRperMonthMapRec.get(resultKeyRec)[i - 1]);
			}

			System.out.println("重新等额本息每月还款额：" + resultKeyRec);
			System.out.println("重新每期经历" + Arrays.toString(dayCountsAfter));
			System.out.println("重新每月余本金:" + Arrays.toString(PLeftperMonthAfter));
			System.out.println("重新每月还款额:" + Arrays.toString(PRperMonthAfter));
			System.out.println("重新每月还本金:" + Arrays.toString(PperMonthAfter));
			System.out.println("重新每月还利息:" + Arrays.toString(RperMonthAfter));

			double sumP = 0;
			double sumR = 0;
			double sumPR = 0;
			for (int i = 0; i < PLeftperMonth.length; i++) {
				sumP = sumP + PperMonthAfter[i];
				sumR = sumR + RperMonthAfter[i];
				sumPR = sumPR + PRperMonthAfter[i];
			}
			sumPRMap.put(RepayUtils.num2second(resultKey), RepayUtils.num2second(sumPR));
			sumPMap.put(RepayUtils.num2second(resultKey), RepayUtils.num2second(sumP));
			sumRMap.put(RepayUtils.num2second(resultKey), RepayUtils.num2second(sumR));

			System.out.println("总还款额:" + sumPRMap.get(resultKey));
			System.out.println("总还本金:" + sumPMap.get(resultKey));
			System.out.println("总还利息:" + sumRMap.get(resultKey));
		}
		return resultKey;
	}

}
huluyisheng
关注
专栏目录
个人贷款提前还款计算器
12-02
本计算器支持等额本息、等额本金还贷方式下提前还款前后的支出对比，支持一次还本付息、缩短还款期限或降低月供等三种提前还款类型。 http://api.money.rj.91.com/91Money_root/91MoneyPlugins/AdvanceRePay_V0.1.0.0.Beta.131705.rar
借呗分期还款模拟
weixin_30273501的博客
05-17 1933
Java代码 /** *阿里借呗计息还款规则说明实现 * *@return */ packagejdongtech.jiebaiUtils; importjava.util.Arrays; importjava.util.Calendar; importjava.util.HashMap; importj...
还款功能怎么测试？
m0_46446002的博客
12-29 2341
还款功能怎么测试？ 功能测试 正常还款，还款成功 还款失败，还款账户余额不足 逾期还款，的利息 提前还款，能节省多少利息 弱网状态下，连续点击是否连续还款 弱网状态，或系统不稳定，支付服务方未把支付结果返回给下单发起方(如果发生这种问题，结果是，钱扣了，还款状态未发生变化) 是否支持他人帮还 是否支持查看扣款顺序 性能测试 还款的响应时间是否过长 用户体检 系统提示是否容易理解界面是否友好， 输入框是否对齐， 按钮大小是否适中， 是否有错别字等 安全性 是否能防止SQL注入，
1、模拟蚂蚁借呗—利息计算
weixin_30444105的博客
06-07 1673
模拟蚂蚁借呗—利息计算 程序的源代码如下： /* 2017年6月11日10:15:49 功能：计算蚂蚁借呗的利息 缺点：本程序没有判断年份是否为闰年 借款当日的时间需要手动输入，年份不能以特定的格式显示 没有还款功能 */ #include "stdio.h" #define M 0.0004 //符号之间都只有一个空...
提前还了一部分房贷！
Java和Android架构
05-25 234
终于提前还了一部分房贷！40W！经过深思熟虑，结合现在的大环境，还是决定了提前还掉一部分房贷 —— 40W。昨天终于扣款成功。剩下的部分也希望能早点还掉。年底希望能再还40W。这也算是在这立的Flag，希望能达成，到时候再在这里给大家汇报。现在提前还款很方便，在银行app上就可以操作预约提前还款。不像以前还需要到网点预约，提前还款有些银行可能还需要你支付违约金。我就是全程...
最全房贷计算器 java 代码 含算法
05-06
提前还款涉及到的算法则更为复杂，因为需要重新计算剩余贷款的利息和还款计划。通常，提前还款可以减少总的利息支出，但可能需要支付一定的手续费。具体计算涉及剩余本金、剩余期限、提前还款金额以及银行对于提前...
房贷利率计算源代码.rar
06-11
5. **提前还款功能**：在代码中，可能会有允许用户预付部分或全部贷款的函数，这会影响到总的利息支出和还款期限。 6. **还款计划生成**：这部分代码将生成详细的还款计划，显示每月的还款额、利息和剩余本金，帮助...
商业银行模拟经营沙盘实验报告.doc
10-07
实验报告详细记录了三年内的各项战略决策，包括贷款、土地分配、建筑、价格设定、广告投放、景观费用、个人消费贷款、存款、提前还款、股票发行和国债购买等，通过对这些决策的分析和评价，评估企业经营效果。...
住房与房屋贷款的问题
08-30
通过对各种可能的提前还款时间和金额进行计算，可以找到最经济的提前还款策略。 此外，文章还探讨了投资股票和基金的收益模型，以模拟投资风险和收益的不确定性。通过计算机模拟，可以预测不同投资组合可能带来的...
復利計算器
04-08
4. **提前还款分析**：对于贷款，用户可以查看提前还款对总利息支出的影响。 在实际应用中，"復利計算器"可能还会包含以下特性： - **多种货币选择**：支持不同国家的货币计算，适应全球化投资需求。 - **税率计算*...
计算器（等额本息，等额本金）
08-15
等额本息，等额本金的计算域统计页面的代码
花呗分期计算器
01-04
输入商品总金额，自动计算花呗分期金额，3、6、9、12期
java贷款计算器
02-07
java代码实现了商贷，公积金贷款，提前还贷。等额本金等额本息等功能。亲测可用
蚂蚁借呗总利息计算——每月等额（等额本息）
cheetahlover的博客
05-24 1万+
注：花了半天研究了一下蚂蚁借呗的利息计算，起因是因为一次简单的计算发现比借呗上实际利息要少好几块钱，这就有点疑惑了。 说明： 特别说明的只有两点 1. 利息分两部分：第一部分，距最近一个还款日期（即分期起息日，每个人不同，如27日）前的利息按日利率算，如今天24日，每月的还款日为27日，则24日到27日的三天累计日利息为第一部分利息；第二部分为分期起息日到最后一个还款日的分期总利息，按等额...
贷款计算公式——java实现
热门推荐
flueky的专栏
08-12 1万+
废话说在前头，本人公司做银行APP，每次写到贷款计算器总是一遍又一遍研究计算公式。N次过后，还是决定写一篇blog分享给大家。注：利率一律按照4.9计算。所有计算结果参照在线贷款计算公式等额本息每月还款本金+利息一样。 贷款本金100万，贷款期限30年，贷
蚂蚁借呗每月等额计算方式
清风的博客
02-22 4685
在网上找蚂蚁借呗的计算方式，全是一堆计算不准确的算法，都是按整月来算的（每个月的天数还一样），但是蚂蚁借呗是按天算的，而且还是固定还款日，如我2月22日借款到3月10日还第一期，使用时间只有17天，所以每期的使用时间又不相同，但是又要求每期还款(本金+利息)尽量平均 以下是我自己琢磨的方法，唯一缺点是：在有一些数字是比借呗多一个0.01的平均数(误差)或少一个0.01的平均数(误差) java ...
等额本金，等额本息，随借随还，利随本清，按月付息到期还本，5种还款方式java计算方法
小馒头味的博客
11-20 1万+
等额本金，等额本息，随借随还，利随本清，按月付息到期还本，5种还款方式java计算方法 等额本息定义：本金逐月递增，利息逐月递减，月还款数不变。 等额本金定义：本金保持相同，利息逐月递减，月还款数递减。 随借随还定义：客户在获得授信额度后可以随时来支取，借出后就开始算利息；借出后可以随时还。还了之后在期限内又可以取。 利随本清(一次性还本付息)定义：借款人在贷款期内不是按月偿还本息，而是贷款到期后...
蚂蚁借呗的利息计算方式？
02-17 5843
https://www.zhihu.com/question/36710827 作者：间隔年 链接：https://www.zhihu.com/question/36710827/answer/90176173 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 是利用等额本金还款法计算的 计算公式为 1：每月月供额＝(贷款本金÷还款月数)＋
Java根据日利率计算等额本息每月还款
yulianpeng的博客
06-19 3131
问题描述 等额本息分期贷款，大多数时候借款日和还款日不一定相同（例如支付宝借呗），并且每期（每月）天数不同，比如二月份是28天，29天，其他月份有31天或者30天，此时产生的一个问题就是每期的还款日相同但是每期的天数不一定相同，用常规的等额本息还款公式计算就会有误差（因为公式中每个月的月利率是相同的），而用日利率去计算每期的利率（等额本息相当于月利率）则能达到非常精确的计算结果，并且能一并解决借...
房贷提前还款python
最新发布
09-12
对于房贷提前还款的计算，你可以使用Python编程语言来实现。下面是一个示例代码，可以帮助你计算房贷提前还款的情况。 ```python def calculate_repayment(principal, interest_rate, years): monthly_interest_...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值