java中每月等额与先息后本计算

最新推荐文章于 2023-01-06 08:48:36 发布
最新推荐文章于 2023-01-06 08:48:36 发布
阅读量288 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/seekingway/p/6635260.html
版权

　　一般信用贷款会提供两种还款方式：每月等额或者先息后本。每月等额，就是每月归还等同的部分本金和利息，你手里在使用的本金其实是逐月减少的。先息后本就是先还利息，到期归还本金。

　　每月等额

 1 import java.math.BigDecimal;
 2 import java.util.Calendar;
 3 import java.util.Date;
 4 
 5 /**
 6  * <p>Title: 等额本息还款工具类</p>
 7  *
 8  */
 9 public class CPMUtils{
10 
11     /**
12      * <p>Description: 每月还款总额。〔贷款本金×月利率×（1＋月利率）＾还款月数〕÷〔（1＋月利率）＾还款月数－1〕</p>
13      * @param principal 贷款本金
14      * @param monthlyInterestRate 月利率
15      * @param amount 期数
16      * @return
17      */
18     public static BigDecimal monthlyRepayment(BigDecimal principal, BigDecimal monthlyInterestRate, int amount){
19         //（1＋月利率）＾还款月数
20         BigDecimal temp = monthlyInterestRate.add(MoneyUtils.ONE).pow(amount);
21         return principal.multiply(monthlyInterestRate)
22                         .multiply(temp)
23                         .divide(temp.subtract(MoneyUtils.ONE), MoneyUtils.MATHCONTEXT);
24     }
25     
26     /**
27      * <p>Description: 月还款利息。（贷款本金×月利率-月还款额）*（1+月利率)^（当前期数-1）+月还款额</p>
28      * @param principal 贷款本金
29      * @param monthlyInterestRate 月利率
30      * @param monthlyRepayment 月还款额
31      * @param number 当前期数
32      * @return
33      */
34     public static BigDecimal monthlyInterest(BigDecimal principal, BigDecimal monthlyInterestRate, BigDecimal monthlyRepayment, int number){
35         //（1+月利率)^（当前期数-1）
36         BigDecimal temp = monthlyInterestRate.add(MoneyUtils.ONE).pow(number - 1);
37         return principal.multiply(monthlyInterestRate)
38                         .subtract(monthlyRepayment)
39                         .multiply(temp).add(monthlyRepayment, MoneyUtils.MATHCONTEXT);
41     }
42     
43     /**
44      * <p>Description: 还款总利息。期数×贷款本金×月利率×（1＋月利率）^期数÷〔（1＋月利率）^期数－1〕－贷款本金 </p>
45      * @param principal 贷款本金
46      * @param monthlyInterestRate 月利率
47      * @param amount 还款期数
48      * @return
49      */
50     public static BigDecimal interest(BigDecimal principal, BigDecimal monthlyInterestRate, int amount){
51         //（1＋月利率）^期数
52         BigDecimal temp = monthlyInterestRate.add(MoneyUtils.ONE).pow(amount);
53         return new BigDecimal(amount)
54                    .multiply(principal)
55                    .multiply(monthlyInterestRate)
56                    .multiply(temp)
57                    .divide(temp.subtract(MoneyUtils.ONE), MoneyUtils.MATHCONTEXT)
58                    .subtract(principal, MoneyUtils.MATHCONTEXT);
59     }
60     
61     /**
62      * <p>Description: 月还款本金。已经精确到分位，未做单位换算</p>
63      * @param principal 贷款本金
64      * @param monthlyInterestRate 月利率
65      * @param monthlyRepayment 月还款额
66      * @param number 当前期数
67      * @return
68      */
69     public static BigDecimal monthlyPrincipal(BigDecimal principal, BigDecimal monthlyInterestRate, BigDecimal monthlyRepayment, int number){
70         BigDecimal monthInterest = monthlyInterest(principal, monthlyInterestRate, monthlyRepayment, number);
71         //月还款额-月还款利息
72         return monthlyRepayment.subtract(monthInterest).setScale(MoneyUtils.MONEYSHOWSCALE, MoneyUtils.SAVEROUNDINGMODE);
73     }
74     
75     /**
76      * <p>Description: 月还款本金。已经精确到分位，未做单位换算</p>
77      * @param monthRepayment 月还款总额
78      * @param monthInterest 月还款利息
79      * @return
80      */
81     public static BigDecimal monthPrincipal(BigDecimal monthRepayment, BigDecimal monthInterest){
82         //月还款总额-月还款利息
83         return monthRepayment.subtract(monthInterest).setScale(MoneyUtils.MONEYSHOWSCALE, MoneyUtils.SAVEROUNDINGMODE);
84     }
85 
86 }

 

　  先息后本

　

 1 　import java.math.BigDecimal;
 2 
 3 　　/**
 4 　　* <p>Title: 先息后本还款方式工具类型</p>
 5 　　*/
 6 　　public class BIAPPUtils extends RepaymentUtils {
 7 
 8 　　　　/**
 9 　　　　* <p>Description: 月还款利息  贷款本金×月利率 </p>
10 　　　　* @param loan 贷款本金
11 　　　　* @param monthlyInterestRate 月利率
12 　　　　* @return
13 　　　　*/
14 　　　　public static BigDecimal monthlyInterest(BigDecimal loan, BigDecimal monthlyInterestRate){
15 　　　　　　return loan.multiply(monthlyInterestRate, MoneyUtils.MATHCONTEXT);
16 　　　　}
17 　　　　/**
18 　　　　* <p>Description: 还款总利息  贷款本金×月利率×期数</p>
19 　　　　* @param loan 贷款本金
20 　　　　* @param monthlyInterestRate 月利率
21 　　　　* @param number 期数
22 　　　　* @return
23 　　　　*/
24 　　　　public static BigDecimal interest(BigDecimal loan, BigDecimal monthlyInterestRate, int number){
25 　　　　　　return loan.multiply(monthlyInterestRate).multiply(new BigDecimal(number), MoneyUtils.MATHCONTEXT);
26 　　　　}
27 　　　　/**
28 　　　　* <p>Description: 月还款额</p>
29 　　　　* @param loan 贷款本金
30 　　　　* @param monthlyInterestRate 月利率
31 　　　　* @param amount 期数
32 　　　　* @param curNumber 当前期数
33 　　　　* @return
34 　　　　*/
35 　　　　public static BigDecimal monthlyRepayment(BigDecimal loan, BigDecimal monthlyInterestRate, int amount, int curNumber){
36 　　　　　　　　BigDecimal monthlyInterest = monthlyInterest(loan, monthlyInterestRate);
37 　　　　　　　　if(amount == curNumber){
38 　　　　　　　　　　return monthlyInterest.add(loan, MoneyUtils.MATHCONTEXT);//最后月还款额
39 　　　　　　　　}else{
40 　　　　　　　　　　return monthlyInterest;
41 　　　　　　　　}
42 　　　　}
43 　　}

 

　　*金额计算工具类

　

  1 　import java.math.BigDecimal;
  2 　　import java.math.MathContext;
  3 　　import java.math.RoundingMode;
  4 　　import java.text.NumberFormat;
  5 
  6 　　public class MoneyUtils {
  7 　　　　/**
  8 　　　　* 标度（小数位数）
  9 　　　　*/
 10 　　　　public static final int SCALE = 10;
 11 
 12 　　　　/**
 13 　　　　* 金钱显示标度（小数位数）
 14 　　　　*/
 15 　　　　public static final int MONEYSHOWSCALE = 2;
 16 
 17 　　　　/**
 18 　　　　* 利率显示标度（小数位数）
 19 　　　　*/
 20 　　　　public static final int INTERESTRATESHOWSCALE = 4;
 21 
 22 　　　　/**
 23 　　　　* 精度
 24 　　　　*/
 25 　　　　public static final int PRECISION = 30;
 26 
 27 　　　　/**
 28 　　　　* 保存舍入规则
 29 　　　　*/
 30 　　　　public static final RoundingMode SAVEROUNDINGMODE = RoundingMode.HALF_UP;
 31 
 32 　　　　/**
 33 　　　　* 是否舍去小数点最后的零
 34 　　　　*/
 35 　　　　public static boolean STRIPTRAILINGZEROS = true;
 36 
 37 　　　　/**
 38 　　　　* 运算上下文（设置精度、舍入规则）
 39 　　　　*/
 40 　　　　public static final MathContext MATHCONTEXT = new MathContext(PRECISION, SAVEROUNDINGMODE);
 41 
 42 　　　　/**
 43 　　　　* 每年天数
 44 　　　　*/
 45 　　　　public static final String YEARDAYS = "360";
 46 
 47 　　　　/**
 48 　　　　* 每年月数
 49 　　　　*/
 50 　　　　public static final String YEARMOTHS = "12";
 51 
 52 　　　　/**
 53 　　　　* 每月天数
 54 　　　　*/
 55 　　　　public static final String MOTHDAYS = "30";
 56 
 57 　　　　/**
 58 　　　　* 数字“1”
 59 　　　　*/
 60 　　　　public static final BigDecimal ONE = new BigDecimal(1);
 61 
 62 　　　　/**
 63 　　　　* 数字“100”
 64 　　　　*/
 65 　　　　public static final BigDecimal HUNDRED = new BigDecimal(100);
 66 
 67 　　　　/**
 68 　　　　* 数字“0.01”
 69 　　　　*/
 70 　　　　public static final BigDecimal ONEHUNDREDTH = new BigDecimal(0.01);
 71 
 72 　　　　public static BigDecimal newBigDecimal(String str){
 73 　　　　　　return (str == null || str.trim().isEmpty()) ? BigDecimal.ZERO : new BigDecimal(str);
 74 　　　　}
 75 
 76 　　　　/**
 77 　　　　* <p>Description: 加法返回格式化结果数字</p>
 78 　　　　* @param addend
 79 　　　　* @param augend
 80 　　　　* @return
 81 　　　　*/
 82 　　　　public static BigDecimal add(BigDecimal addend, BigDecimal augend){
 83 　　　　　　return formatMoney(addend.add(augend, MATHCONTEXT));
 84 　　　　}
 85 
 86     　　/**
 87 　　　　* <p>Description: 加法返回格式化结果数字</p>
 88 　　　　* @param addend
 89 　　　　* @param augend
 90 　　　　* @return
 91 　　　　*/
 92 　　　　public static BigDecimal add(String addend, String augend){
 93 　　　　　　BigDecimal decimalAddend = newBigDecimal(addend);
 94 　　　　　　BigDecimal decimalAugend = newBigDecimal(augend);
 95 　　　　　　return formatMoney(decimalAddend.add(decimalAugend, MATHCONTEXT));
 96 　　　　}
 97 
 98 　　　　/**
 99 　　　　* <p>Description: 加法返回格式化结果字符串</p>
100 　　　　* @param addend
101 　　　　* @param augend
102 　　　　* @return
103 　　　　*/
104 　　　　public static String addToString(BigDecimal addend, BigDecimal augend){
105 　　　　　　return formatToString(addend.add(augend, MATHCONTEXT));
106 　　　　}
107 
108 　　　　/**
109 　　　　* <p>Description: 加法返回格式化结果字符串</p>
110 　　　　* @param addend
111 　　　　* @param augend
112 　　　　* @return
113 　　　　*/
114 　　　　public static String addToString(String addend, String augend){
115 　　　　　　BigDecimal decimalAddend = newBigDecimal(addend);
116 　　　　　　BigDecimal decimalAugend = newBigDecimal(augend);
117 　　　　　　return formatToString(decimalAddend.add(decimalAugend, MATHCONTEXT));
118 　　　　}
119 
120 　　　　/**
121 　　　　* <p>Description: 减法返回格式化结果数字</p>
122 　　　　* @param minuend
123 　　　　* @param subtrahend
124 　　　　* @return
125 　　　　*/
126 　　　　public static BigDecimal subtract(BigDecimal minuend, BigDecimal subtrahend){
127 　　　　　　return formatMoney(minuend.subtract(subtrahend, MATHCONTEXT));
128 　　　　}
129 
130 
131 　　　　/**
132 　　　　* <p>Description: 减法返回格式化结果数字</p>
133 　　　　* @param minuend
134 　　　　* @param subtrahend
135 　　　　* @return
136 　　　　*/
137 　　　　public static BigDecimal subtract(String minuend, String subtrahend){
138 　　　　　　BigDecimal decimalMinuend = newBigDecimal(minuend);
139 　　　　　　BigDecimal decimalSubtrahend = newBigDecimal(subtrahend);
140 　　　　　　return formatMoney(decimalMinuend.subtract(decimalSubtrahend, MATHCONTEXT));
141 　　　　}
142 
143 　　　　/**
144 　　　　* <p>Description: 减法返回格式化结果字符串</p>
145 　　　　* @param minuend
146 　　　　* @param subtrahend
147 　　　　* @return
148 　　　　*/
149 　　　　public static String subtractToString(BigDecimal minuend, BigDecimal subtrahend){
150 　　　　　　return formatToString(minuend.subtract(subtrahend, MATHCONTEXT));
151 　　　　}
152 　　　　/**
153 　　　　* <p>Description: 减法返回格式化结果字符串</p>
154 　　　　* @param minuend
155 　　　　* @param subtrahend
156 　　　　* @return
157 　　　　*/
158 　　　　public static String subtractToString(String minuend, String subtrahend){
159 　　　　　　BigDecimal decimalMinuend = newBigDecimal(minuend);
160 　　　　　　BigDecimal decimalSubtrahend = newBigDecimal(subtrahend);
161 　　　　　　return formatToString(decimalMinuend.subtract(decimalSubtrahend, MATHCONTEXT));
162 　　　　}
163 
164 　　　　/**
165 　　　　* <p>Description: 乘法返回格式化结果数字</p>
166 　　　　* @param multiplier
167 　　　　* @param multiplicand
168 　　　　* @return
169 　　　　*/
170 　　　　public static BigDecimal multiply(BigDecimal multiplier, BigDecimal multiplicand){
171 　　　　　　return formatMoney(multiplier.multiply(multiplicand, MATHCONTEXT));
172 　　　　}
173 
174 
175 　　　　/**
176 　　　　* <p>Description: 乘法返回格式化结果数字</p>
177 　　　　* @param multiplier
178 　　　　* @param multiplicand
179 　　　　* @return
180 　　　　*/
181 　　　　public static BigDecimal multiply(String multiplier, String multiplicand){
182 　　　　　　BigDecimal decimalMultiplier = newBigDecimal(multiplier);
183 　　　　　　BigDecimal decimalMultiplicand = newBigDecimal(multiplicand);
184 　　　　　　return formatMoney(decimalMultiplier.multiply(decimalMultiplicand, MATHCONTEXT));
185 　　　　}
186 
187 　　　　/**
188 　　　　* <p>Description: 乘法返回格式化结果字符串</p>
189 　　　　* @param multiplier
190 　　　　* @param multiplicand
191 　　　　* @return
192 　　　　*/
193 　　　　public static String multiplyToString(BigDecimal multiplier, BigDecimal multiplicand){
194 　　　　　　return formatToString(multiplier.multiply(multiplicand, MATHCONTEXT));
195 　　　　}
196 　　　　/**
197 　　　　* <p>Description: 乘法返回格式化结果字符串</p>
198 　　　　* @param multiplier
199 　　　　* @param multiplicand
200 　　　　* @return
201 　　　　*/
202 　　　　public static String multiplyToString(String multiplier, String multiplicand){
203 　　　　　　BigDecimal decimalMultiplier = newBigDecimal(multiplier);
204 　　　　　　BigDecimal decimalMultiplicand = newBigDecimal(multiplicand);
205 　　　　　　return formatToString(decimalMultiplier.multiply(decimalMultiplicand, MATHCONTEXT));
206 　　　　}
207 
208 　　　　/**
209 　　　　* <p>Description: 除法返回格式化结果数字</p>
210 　　　　* @param dividend
211 　　　　* @param divisor
212 　　　　* @return
213 　　　　*/
214 　　　　public static BigDecimal divide(BigDecimal dividend, BigDecimal divisor){
215 　　　　　　return formatMoney(dividend.divide(divisor, MATHCONTEXT));
216 　　　　}
217 　　　　/**
218 　　　　* <p>Description: 除法返回格式化结果数字</p>
219 　　　　* @param dividend
220 　　　　* @param divisor
221 　　　　* @return
222 　　　　*/
223 　　　　public static BigDecimal divide(String dividend, String divisor){
224 　　　　　　BigDecimal decimalDividend = newBigDecimal(dividend);
225 　　　　　　BigDecimal decimalDivisor = newBigDecimal(divisor);
226 　　　　　　return formatMoney(decimalDividend.divide(decimalDivisor, MATHCONTEXT));
227 　　　　}
228 
229 　　　　/**
230 　　　　* <p>Description: 除法返回格式化结果字符串</p>
231 　　　　* @param dividend
232 　　　　* @param divisor
233 　　　　* @return
234 　　　　*/
235 　　　　public static String divideToString(BigDecimal dividend, BigDecimal divisor){
236 　　　　　　return formatToString(dividend.divide(divisor, MATHCONTEXT));
237 　　　　}
238 
239 　　　　/**
240 　　　　* <p>Description: 除法返回格式化结果字符串</p>
241 　　　　* @param dividend
242 　　　　* @param divisor
243 　　　　* @return
244 　　　　*/
245 　　　　public static String divideToString(String dividend, String divisor){
246 　　　　　　BigDecimal decimalDividend = newBigDecimal(dividend);
247 　　　　　　BigDecimal decimalDivisor = newBigDecimal(divisor);
248 　　　　　　return formatToString(decimalDividend.divide(decimalDivisor, MATHCONTEXT));
249 　　　　}
250 　　　　/**
251 　　　　* <p>Description: 月利率计算</p>
252 　　　　* @param yearInterestRate
253 　　　　* @return
254 　　　　*/
255 　　　　public static BigDecimal monthInterestRate(BigDecimal yearInterestRate){
256 　　　　　　BigDecimal dayInterestRate = MoneyUtils.divide(yearInterestRate, YEARDAYS).setScale(5, RoundingMode.CEILING);
257 　　　　　　System.err.println(dayInterestRate);
258 　　　　　　BigDecimal monthInterestRate = dayInterestRate.multiply(newBigDecimal(MOTHDAYS));
259 　　　　　　System.err.println(monthInterestRate);
260 　　　　　　return monthInterestRate;
261 　　　　}
262 
263 　　　　/**
264 　　　　* <p>Description: 按既定小数位数格式化金额保存</p>
265 　　　　* @param result
266 　　　　* @return
267 　　　　*/
268 　　　　public static BigDecimal formatMoney(BigDecimal result){
269 　　　　　　return result.setScale(SCALE, SAVEROUNDINGMODE);
270 　　　　}
271 
272 　　　　/**
273 　　　　* <p>Description: 按既定小数位数格式化金额显示</p>
274 　　　　* @param resultStr 要格式化的数
275 　　　　* @param multiple 乘以的倍数
276 　　　　* @return
277 　　　　*/
278 　　　　public static String formatMoneyToShow(String resultStr, BigDecimal multiple){
279 　　　　　　BigDecimal result = newBigDecimal(resultStr);
280 　　　　　　return MoneyUtils.formatToString(MoneyUtils.formatMoneyToShow(result, multiple));
281 　　　　}
282 
283 　　　　/**
284 　　　　* <p>Description: 按既定小数位数格式化金额显示</p>
285 　　　　* @param result 要格式化的数
286 　　　　* @param multiple 乘以的倍数
287 　　　　* @return
288 　　　　*/
289 　　　　public static BigDecimal formatMoneyToShow(BigDecimal result, BigDecimal multiple){
290 　　　　　　return result.multiply(multiple).setScale(MONEYSHOWSCALE, SAVEROUNDINGMODE);
291 　　　　}
292 
293 　　　　/**
294 　　　　* <p>Description: 按既定小数位数格式化利率显示</p>
295 　　　　* @param result 要格式化的数
296 　　　　* @param multiple 乘以的倍数
297 　　　　* @return
298 　　　　*/
299 　　　　public static BigDecimal formatInterestRateToShow(BigDecimal result, BigDecimal multiple){
300 　　　　　　return result.multiply(multiple).setScale(INTERESTRATESHOWSCALE, SAVEROUNDINGMODE);
301 　　　　}
302 
303 　　　　/**
304 　　　　* <p>Description: 按既定小数位数格式化显示</p>
305 　　　　* @param result 要格式化的数
306 　　　　* @param scale 显示标度（小数位数）
307 　　　　* @return
308 　　　　*/
309 　　　　public static BigDecimal formatToShow(BigDecimal result, int scale){
310 　　　　　　return result.setScale(scale, SAVEROUNDINGMODE);
311 　　　　}
312 
313 　　　　/**
314 　　　　* <p>Description: 格式化为字符串，进行去零不去零操作</p>
315 　　　　* @param result
316 　　　　* @return
317 　　　　*/
318 　　　　public static String formatToString(BigDecimal result){
319 　　　　　　if(result == null){
320 　　　　　　　　return "";
321 　　　　　　}else{
322 　　　　　　　　return STRIPTRAILINGZEROS ? result.stripTrailingZeros().toPlainString() : result.toPlainString();
323 　　　　　　}
324 　　　　}
325 
326 　　　　/**
327 　　　　* <p>Description: 按既定小数位数格式化为货币格式</p>
328 　　　　* @param result
329 　　　　* @return
330 　　　　*/
331 　　　　public static String formatToCurrency(BigDecimal result){
332 　　　　　　BigDecimal temp = result.divide(HUNDRED, SAVEROUNDINGMODE);
333 　　　　　　NumberFormat numberFormat = NumberFormat.getCurrencyInstance();
334 　　　　　　return numberFormat.format(STRIPTRAILINGZEROS ? temp.stripTrailingZeros() : temp);
335 　　　　}
336 
337 　　　　public static String formatToPercent(BigDecimal result){
338 　　　　　　BigDecimal temp = result.divide(HUNDRED, SAVEROUNDINGMODE);
339 　　　　　　NumberFormat numberFormat = NumberFormat.getPercentInstance();
340 　　　　　　return numberFormat.format(STRIPTRAILINGZEROS ? temp.stripTrailingZeros() : temp);
341 　　　　}
342 
343 　　　　/** 
344 　　　　* <p>Description:格式化数字为千分位显示； </p>
345 　　　　* @param text 
346 　　　　* @return 
347 　　　　*/ 
348 　　　　public static String fmtMicrometer(String text){ 
349 　　　　　　DecimalFormat df = null; 
350 　　　　　　if(text.indexOf(".") > 0) { 
351 　　　　　　　　if(text.length() - text.indexOf(".")-1 == 0){ 
352 　　　　　　　　　　df = new DecimalFormat("###,##0."); 
353 　　　　　　　　}else if(text.length() - text.indexOf(".")-1 == 1){ 
354 　　　　　　　　　　df = new DecimalFormat("###,##0.0"); 
355 　　　　　　　　}else { 
356 　　　　　　　　　　df = new DecimalFormat("###,##0.00"); 
357 　　　　　　　　} 
358 　　　　　　}else{ 
359 　　　　　　　　df = new DecimalFormat("###,##0.00"); 
360 　　　　　　} 
361 　　　　　　double number = 0.0; 
362 　　　　　　try { 
363 　　　　　　　　number = Double.parseDouble(text); 
364 　　　　　　} catch (Exception e) { 
365 　　　　　　　　number = 0.0; 
366 　　　　　　} 
367 　　　　　　return df.format(number); 
368 　　　　}
369 
370 　　}

 

转载于:https://www.cnblogs.com/seekingway/p/6635260.html

XV5851
关注
Java等额本息实现
xiao___tao的博客
11-27 1179
工具类 import java.math.BigDecimal; import java.util.HashMap; import java.util.Map; /** * 等额本息计算工具类 * * <p> * 等额本息还款，也称定期付息，即借款人每月按相等的金额偿还贷款本息，其中每月贷款利息按月初剩余贷款本金计算并逐月结清。把按揭贷款的本金总额与利息总额相加， * 然后平均分摊到还款期限的每个月中。作为还款人，每个月还给银行固定金额，但每月还款额中的本金比重逐月递增、利息比重逐月
等额本息java计算
最新发布
hcks37的博客
10-15 883
等同于 每月应还利息=贷款本金×月利率×〔(1+月利率)^还款月数-(1+月利率)^(还款月序号-1)〕÷〔(1+月利率)^还款月数-1〕* 每月应还本金=贷款本金×月利率×(1 +月利率)^(还款月序号-1)÷〔(1 +月利率)^还款月数-1〕。* 每月应还利息=贷款本金×月利率×〔(1+月利率)^还款月数-(1+月利率)^(还款月序号-1)〕÷〔(1+月利率)^还款月数-1〕* 每月还款总额= ---------------------------------------------
Java中利息的计算--->1.等额本息2.先息后本
dutaotaosmlie的博客
05-07 2124
整理了两种关于利息的计算（可以写成一个专门的工具类，当然小编我是入门级的选手，按照自己的思路写了一下，仅供和我 一样入门级的朋友参考）： public class MathAboutBorrow { public static Double borrowMoney; public static Integer month; public static Double prate; priv
先息后本的计算方法
pengzhisen123的博客
03-30 1万+
先息后本的本义是：先还利息再还本金。但因为在等额本息法中，每月还款额中的本金比重逐月递增、利息比重逐月递减，再加上等额本息法比较普遍，所以现在的先息后本通常都是指“等额本息法”还贷，从节省的角度讲，等额本金法还贷要比等额本息法还贷更节省利息。但是，等额本金法还贷开始几年可能月供额要比等额本息法还贷稍微大些，所以对月收入较紧的家庭来说开始时会感觉压力较大，但它有个好处是每月还贷额是逐步减少的，将少的
java moneyutils_java中每月等额与先息后本计算
weixin_30937427的博客
02-13 242
1 　importjava.math.BigDecimal;2 　　importjava.math.MathContext;3 　　importjava.math.RoundingMode;4 　　importjava.text.NumberFormat;56 　　public classMoneyUtils {7 　　　　/**8 * 标度(小数位数)9 　　　　*/10 　　　　public ...
java计算利息_求JAVA编写的银行利息计算器代码？
weixin_36179941的博客
02-21 633
import java.util.ListIterator;import java.util.Stack;public class CalStr {private String src;/*** constructor** @param srcthe string(expression) to calculate*/public CalStr(String src) {this.src = src...
java等额本金本息
12-12
4. **每月还款**：等额本金中每月还款包含本金和利息，等额本息中每月还款是本金和利息的固定组合。 以下是一个简单的Java代码示例，用于计算等额本金和等额本息的月还款额： ```java public class LoanCalculator...
等额本金&等额本息_等额本息_等额本金_
09-30
在等额本息方式下，借款人每月偿还的金额将保持不变，而整个贷款期内支付的总利息相对较高，但每月负担稳定。在等额本金方式下，虽然初期还款压力较大，但长期来看，总利息支出会比等额本息低，因为后期利息减少，...
java实现的银行利息结算
02-03
java实现的等额本息的算法，能计算出每月还款，和每月需换利息
等额本息贷款计算Java代码
12-08
等额本息算法的java实现 输入本金、期数、年利率 输出每期本息合计、每期本金、每期利息 及总利息、本息总合计
等额本息逆推利率java算法
11-07
等额本息逆推利率java算法，可以逆推出利率 * @param Principal 本金 * @param MonthlyPayments 月还款额 * @param Period 期数 * @param Iterations 运算次数 * @param Digit 保留位数 * @return 利率
根据贷款还款方式（等额本金，等额本息，等本等息，先息后本），计算本息
qq_30942697的博客
01-06 660
根据贷款还款方式（等额本金，等额本息，等本等息，先息后本），计算本息
java版 银行还款计算
程序员
11-29 839
原型图是这样的(下图)，要求算出每个月不同的还款方式的明细 废话不多说，代码 package org.com.rsmall.wx.vo; import org.com.rsmall.db.vo.RepaymentDetailVo; import java.math.BigDecimal; import java.util.List; /** * 银行还款计算 */ public class BankRefund { /** * 先息后本 * @param m
js计算器（等额本息、先息后本算法）
qm19900331的博客
09-08 1万+
js计算器 $(function getPerRepayment() {     var money = $("#inside .box_money").val();     var rate = $("#inside .box_rate").val();     var deadline = $("#inside .box_deadline").val();     var f
等额本金、等额本息工具类(Java版)
关于代码的那些事
07-02 1万+
等额本息： /** * Description:等额本息工具类 * Copyright: Copyright (corporation)2015 * Company: Corporation * @author: 凯文加内特 * @version: 1.0 * Created at: 2015年11月30日 下午3:45:46 * Modification History: *
等额本金，等额本息，随借随还，利随本清，按月付息到期还本，5种还款方式java计算方法
热门推荐
小馒头味的博客
11-20 1万+
等额本金，等额本息，随借随还，利随本清，按月付息到期还本，5种还款方式java计算方法 等额本息定义：本金逐月递增，利息逐月递减，月还款数不变。 等额本金定义：本金保持相同，利息逐月递减，月还款数递减。 随借随还定义：客户在获得授信额度后可以随时来支取，借出后就开始算利息；借出后可以随时还。还了之后在期限内又可以取。 利随本清(一次性还本付息)定义：借款人在贷款期内不是按月偿还本息，而是贷款到期后...
java等额本息、等额本金计算 记录一下
Memento
03-26 4403
public static void main(String[] args) {double invest = 280000;double yearRate = 0.0655;double monthRate = yearRate/12;int year = 15;int month = year * 12;...
Java实现的精确等额本息还款算法详解
Java等额本息算法是一种常见的贷款还款计划计算方法，在金融领域中广泛应用于个人或企业贷款的还款规划。这个特定的Java实现用于计算贷款的每月还款额以及利息分摊，它接受四个关键参数：贷款金额（loanAmount）、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值