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

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

每月等额

import java.math.BigDecimal;
import java.util.Calendar;
import java.util.Date;
/**
 * <p>Title: 等额本息还款工具类</p>
 *
 */
public class CPMUtils{
 /**
 * <p>Description: 每月还款总额。〔贷款本金×月利率×(1+月利率)^还款月数〕÷〔(1+月利率)^还款月数-1〕</p>
 * @param principal 贷款本金
 * @param monthlyInterestRate 月利率
 * @param amount 期数
 * @return
 */
 public static BigDecimal monthlyRepayment(BigDecimal principal, BigDecimal monthlyInterestRate, int amount){
 //(1+月利率)^还款月数
 BigDecimal temp = monthlyInterestRate.add(MoneyUtils.ONE).pow(amount);
 return principal.multiply(monthlyInterestRate)
   .multiply(temp)
   .divide(temp.subtract(MoneyUtils.ONE), MoneyUtils.MATHCONTEXT);
 }
 /**
 * <p>Description: 月还款利息。(贷款本金×月利率-月还款额)*(1+月利率)^(当前期数-1)+月还款额</p>
 * @param principal 贷款本金
 * @param monthlyInterestRate 月利率
 * @param monthlyRepayment 月还款额
 * @param number 当前期数
 * @return
 */
 public static BigDecimal monthlyInterest(BigDecimal principal, BigDecimal monthlyInterestRate, BigDecimal monthlyRepayment, int number){
 //(1+月利率)^(当前期数-1)
 BigDecimal temp = monthlyInterestRate.add(MoneyUtils.ONE).pow(number - 1);
 return principal.multiply(monthlyInterestRate)
   .subtract(monthlyRepayment)
   .multiply(temp).add(monthlyRepayment, MoneyUtils.MATHCONTEXT);
 }
 /**
 * <p>Description: 还款总利息。期数×贷款本金×月利率×(1+月利率)^期数÷〔(1+月利率)^期数-1〕-贷款本金 </p>
 * @param principal 贷款本金
 * @param monthlyInterestRate 月利率
 * @param amount 还款期数
 * @return
 */
 public static BigDecimal interest(BigDecimal principal, BigDecimal monthlyInterestRate, int amount){
 //(1+月利率)^期数
 BigDecimal temp = monthlyInterestRate.add(MoneyUtils.ONE).pow(amount);
 return new BigDecimal(amount)
   .multiply(principal)
   .multiply(monthlyInterestRate)
   .multiply(temp)
   .divide(temp.subtract(MoneyUtils.ONE), MoneyUtils.MATHCONTEXT)
   .subtract(principal, MoneyUtils.MATHCONTEXT);
 }
 /**
 * <p>Description: 月还款本金。已经精确到分位,未做单位换算</p>
 * @param principal 贷款本金
 * @param monthlyInterestRate 月利率
 * @param monthlyRepayment 月还款额
 * @param number 当前期数
 * @return
 */
 public static BigDecimal monthlyPrincipal(BigDecimal principal, BigDecimal monthlyInterestRate, BigDecimal monthlyRepayment, int number){
 BigDecimal monthInterest = monthlyInterest(principal, monthlyInterestRate, monthlyRepayment, number);
 //月还款额-月还款利息
 return monthlyRepayment.subtract(monthInterest).setScale(MoneyUtils.MONEYSHOWSCALE, MoneyUtils.SAVEROUNDINGMODE);
 }
 /**
 * <p>Description: 月还款本金。已经精确到分位,未做单位换算</p>
 * @param monthRepayment 月还款总额
 * @param monthInterest 月还款利息
 * @return
 */
 public static BigDecimal monthPrincipal(BigDecimal monthRepayment, BigDecimal monthInterest){
 //月还款总额-月还款利息
 return monthRepayment.subtract(monthInterest).setScale(MoneyUtils.MONEYSHOWSCALE, MoneyUtils.SAVEROUNDINGMODE);
 }
}

先息后本

import java.math.BigDecimal;

  /**
  * <p>Title: 先息后本还款方式工具类型</p>
  */
  public class BIAPPUtils extends RepaymentUtils {

    /**
    * <p>Description: 月还款利息 贷款本金×月利率 </p>
    * @param loan 贷款本金
    * @param monthlyInterestRate 月利率
    * @return
    */
    public static BigDecimal monthlyInterest(BigDecimal loan, BigDecimal monthlyInterestRate){
      return loan.multiply(monthlyInterestRate, MoneyUtils.MATHCONTEXT);
    }
    /**
    * <p>Description: 还款总利息 贷款本金×月利率×期数</p>
    * @param loan 贷款本金
    * @param monthlyInterestRate 月利率
    * @param number 期数
    * @return
    */
    public static BigDecimal interest(BigDecimal loan, BigDecimal monthlyInterestRate, int number){
      return loan.multiply(monthlyInterestRate).multiply(new BigDecimal(number), MoneyUtils.MATHCONTEXT);
    }
    /**
    * <p>Description: 月还款额</p>
    * @param loan 贷款本金
    * @param monthlyInterestRate 月利率
    * @param amount 期数
    * @param curNumber 当前期数
    * @return
    */
    public static BigDecimal monthlyRepayment(BigDecimal loan, BigDecimal monthlyInterestRate, int amount, int curNumber){
        BigDecimal monthlyInterest = monthlyInterest(loan, monthlyInterestRate);
        if(amount == curNumber){
          return monthlyInterest.add(loan, MoneyUtils.MATHCONTEXT);//最后月还款额
        }else{
          return monthlyInterest;
        }
    }
  }

*金额计算工具类

import java.math.BigDecimal;
  import java.math.MathContext;
  import java.math.RoundingMode;
  import java.text.NumberFormat;

  public class MoneyUtils {
    /**
    * 标度(小数位数)
    */
    public static final int SCALE = 10;

    /**
    * 金钱显示标度(小数位数)
    */
    public static final int MONEYSHOWSCALE = 2;

    /**
    * 利率显示标度(小数位数)
    */
    public static final int INTERESTRATESHOWSCALE = 4;

    /**
    * 精度
    */
    public static final int PRECISION = 30;

    /**
    * 保存舍入规则
    */
    public static final RoundingMode SAVEROUNDINGMODE = RoundingMode.HALF_UP;

    /**
    * 是否舍去小数点最后的零
    */
    public static boolean STRIPTRAILINGZEROS = true;

    /**
    * 运算上下文(设置精度、舍入规则)
    */
    public static final MathContext MATHCONTEXT = new MathContext(PRECISION, SAVEROUNDINGMODE);

    /**
    * 每年天数
    */
    public static final String YEARDAYS = "360";

    /**
    * 每年月数
    */
    public static final String YEARMOTHS = "12";

    /**
    * 每月天数
    */
    public static final String MOTHDAYS = "30";

    /**
    * 数字“1”
    */
    public static final BigDecimal ONE = new BigDecimal(1);

    /**
    * 数字“100”
    */
    public static final BigDecimal HUNDRED = new BigDecimal(100);

    /**
    * 数字“0.01”
    */
    public static final BigDecimal ONEHUNDREDTH = new BigDecimal(0.01);

    public static BigDecimal newBigDecimal(String str){
      return (str == null || str.trim().isEmpty()) ? BigDecimal.ZERO : new BigDecimal(str);
    }

    /**
    * <p>Description: 加法返回格式化结果数字</p>
    * @param addend
    * @param augend
    * @return
    */
    public static BigDecimal add(BigDecimal addend, BigDecimal augend){
      return formatMoney(addend.add(augend, MATHCONTEXT));
    }

   /**
    * <p>Description: 加法返回格式化结果数字</p>
    * @param addend
    * @param augend
    * @return
    */
    public static BigDecimal add(String addend, String augend){
      BigDecimal decimalAddend = newBigDecimal(addend);
      BigDecimal decimalAugend = newBigDecimal(augend);
      return formatMoney(decimalAddend.add(decimalAugend, MATHCONTEXT));
    }

    /**
    * <p>Description: 加法返回格式化结果字符串</p>
    * @param addend
    * @param augend
    * @return
    */
    public static String addToString(BigDecimal addend, BigDecimal augend){
      return formatToString(addend.add(augend, MATHCONTEXT));
    }

    /**
    * <p>Description: 加法返回格式化结果字符串</p>
    * @param addend
    * @param augend
    * @return
    */
    public static String addToString(String addend, String augend){
      BigDecimal decimalAddend = newBigDecimal(addend);
      BigDecimal decimalAugend = newBigDecimal(augend);
      return formatToString(decimalAddend.add(decimalAugend, MATHCONTEXT));
    }

    /**
    * <p>Description: 减法返回格式化结果数字</p>
    * @param minuend
    * @param subtrahend
    * @return
    */
    public static BigDecimal subtract(BigDecimal minuend, BigDecimal subtrahend){
      return formatMoney(minuend.subtract(subtrahend, MATHCONTEXT));
    }

    /**
    * <p>Description: 减法返回格式化结果数字</p>
    * @param minuend
    * @param subtrahend
    * @return
    */
    public static BigDecimal subtract(String minuend, String subtrahend){
      BigDecimal decimalMinuend = newBigDecimal(minuend);
      BigDecimal decimalSubtrahend = newBigDecimal(subtrahend);
      return formatMoney(decimalMinuend.subtract(decimalSubtrahend, MATHCONTEXT));
    }

    /**
    * <p>Description: 减法返回格式化结果字符串</p>
    * @param minuend
    * @param subtrahend
    * @return
    */
    public static String subtractToString(BigDecimal minuend, BigDecimal subtrahend){
      return formatToString(minuend.subtract(subtrahend, MATHCONTEXT));
    }
    /**
    * <p>Description: 减法返回格式化结果字符串</p>
    * @param minuend
    * @param subtrahend
    * @return
    */
    public static String subtractToString(String minuend, String subtrahend){
      BigDecimal decimalMinuend = newBigDecimal(minuend);
      BigDecimal decimalSubtrahend = newBigDecimal(subtrahend);
      return formatToString(decimalMinuend.subtract(decimalSubtrahend, MATHCONTEXT));
    }

    /**
    * <p>Description: 乘法返回格式化结果数字</p>
    * @param multiplier
    * @param multiplicand
    * @return
    */
    public static BigDecimal multiply(BigDecimal multiplier, BigDecimal multiplicand){
      return formatMoney(multiplier.multiply(multiplicand, MATHCONTEXT));
    }

    /**
    * <p>Description: 乘法返回格式化结果数字</p>
    * @param multiplier
    * @param multiplicand
    * @return
    */
    public static BigDecimal multiply(String multiplier, String multiplicand){
      BigDecimal decimalMultiplier = newBigDecimal(multiplier);
      BigDecimal decimalMultiplicand = newBigDecimal(multiplicand);
      return formatMoney(decimalMultiplier.multiply(decimalMultiplicand, MATHCONTEXT));
    }

    /**
    * <p>Description: 乘法返回格式化结果字符串</p>
    * @param multiplier
    * @param multiplicand
    * @return
    */
    public static String multiplyToString(BigDecimal multiplier, BigDecimal multiplicand){
      return formatToString(multiplier.multiply(multiplicand, MATHCONTEXT));
    }
    /**
    * <p>Description: 乘法返回格式化结果字符串</p>
    * @param multiplier
    * @param multiplicand
    * @return
    */
    public static String multiplyToString(String multiplier, String multiplicand){
      BigDecimal decimalMultiplier = newBigDecimal(multiplier);
      BigDecimal decimalMultiplicand = newBigDecimal(multiplicand);
      return formatToString(decimalMultiplier.multiply(decimalMultiplicand, MATHCONTEXT));
    }

    /**
    * <p>Description: 除法返回格式化结果数字</p>
    * @param dividend
    * @param divisor
    * @return
    */
    public static BigDecimal divide(BigDecimal dividend, BigDecimal divisor){
      return formatMoney(dividend.divide(divisor, MATHCONTEXT));
    }
    /**
    * <p>Description: 除法返回格式化结果数字</p>
    * @param dividend
    * @param divisor
    * @return
    */
    public static BigDecimal divide(String dividend, String divisor){
      BigDecimal decimalDividend = newBigDecimal(dividend);
      BigDecimal decimalDivisor = newBigDecimal(divisor);
      return formatMoney(decimalDividend.divide(decimalDivisor, MATHCONTEXT));
    }

    /**
    * <p>Description: 除法返回格式化结果字符串</p>
    * @param dividend
    * @param divisor
    * @return
    */
    public static String divideToString(BigDecimal dividend, BigDecimal divisor){
      return formatToString(dividend.divide(divisor, MATHCONTEXT));
    }

    /**
    * <p>Description: 除法返回格式化结果字符串</p>
    * @param dividend
    * @param divisor
    * @return
    */
    public static String divideToString(String dividend, String divisor){
      BigDecimal decimalDividend = newBigDecimal(dividend);
      BigDecimal decimalDivisor = newBigDecimal(divisor);
      return formatToString(decimalDividend.divide(decimalDivisor, MATHCONTEXT));
    }
    /**
    * <p>Description: 月利率计算</p>
    * @param yearInterestRate
    * @return
    */
    public static BigDecimal monthInterestRate(BigDecimal yearInterestRate){
      BigDecimal dayInterestRate = MoneyUtils.divide(yearInterestRate, YEARDAYS).setScale(5, RoundingMode.CEILING);
      System.err.println(dayInterestRate);
      BigDecimal monthInterestRate = dayInterestRate.multiply(newBigDecimal(MOTHDAYS));
      System.err.println(monthInterestRate);
      return monthInterestRate;
    }

    /**
    * <p>Description: 按既定小数位数格式化金额保存</p>
    * @param result
    * @return
    */
    public static BigDecimal formatMoney(BigDecimal result){
      return result.setScale(SCALE, SAVEROUNDINGMODE);
    }

    /**
    * <p>Description: 按既定小数位数格式化金额显示</p>
    * @param resultStr 要格式化的数
    * @param multiple 乘以的倍数
    * @return
    */
    public static String formatMoneyToShow(String resultStr, BigDecimal multiple){
      BigDecimal result = newBigDecimal(resultStr);
      return MoneyUtils.formatToString(MoneyUtils.formatMoneyToShow(result, multiple));
    }

    /**
    * <p>Description: 按既定小数位数格式化金额显示</p>
    * @param result 要格式化的数
    * @param multiple 乘以的倍数
    * @return
    */
    public static BigDecimal formatMoneyToShow(BigDecimal result, BigDecimal multiple){
      return result.multiply(multiple).setScale(MONEYSHOWSCALE, SAVEROUNDINGMODE);
    }

    /**
    * <p>Description: 按既定小数位数格式化利率显示</p>
    * @param result 要格式化的数
    * @param multiple 乘以的倍数
    * @return
    */
    public static BigDecimal formatInterestRateToShow(BigDecimal result, BigDecimal multiple){
      return result.multiply(multiple).setScale(INTERESTRATESHOWSCALE, SAVEROUNDINGMODE);
    }

    /**
    * <p>Description: 按既定小数位数格式化显示</p>
    * @param result 要格式化的数
    * @param scale 显示标度(小数位数)
    * @return
    */
    public static BigDecimal formatToShow(BigDecimal result, int scale){
      return result.setScale(scale, SAVEROUNDINGMODE);
    }

    /**
    * <p>Description: 格式化为字符串,进行去零不去零操作</p>
    * @param result
    * @return
    */
    public static String formatToString(BigDecimal result){
      if(result == null){
        return "";
      }else{
        return STRIPTRAILINGZEROS ? result.stripTrailingZeros().toPlainString() : result.toPlainString();
      }
    }

    /**
    * <p>Description: 按既定小数位数格式化为货币格式</p>
    * @param result
    * @return
    */
    public static String formatToCurrency(BigDecimal result){
      BigDecimal temp = result.divide(HUNDRED, SAVEROUNDINGMODE);
      NumberFormat numberFormat = NumberFormat.getCurrencyInstance();
      return numberFormat.format(STRIPTRAILINGZEROS ? temp.stripTrailingZeros() : temp);
    }

    public static String formatToPercent(BigDecimal result){
      BigDecimal temp = result.divide(HUNDRED, SAVEROUNDINGMODE);
      NumberFormat numberFormat = NumberFormat.getPercentInstance();
      return numberFormat.format(STRIPTRAILINGZEROS ? temp.stripTrailingZeros() : temp);
    }

    /**
    * <p>Description:格式化数字为千分位显示; </p>
    * @param text
    * @return
    */
    public static String fmtMicrometer(String text){
      DecimalFormat df = null;
      if(text.indexOf(".") > 0) {
        if(text.length() - text.indexOf(".")-1 == 0){
          df = new DecimalFormat("###,##0.");
        }else if(text.length() - text.indexOf(".")-1 == 1){
          df = new DecimalFormat("###,##0.0");
        }else {
          df = new DecimalFormat("###,##0.00");
        }
      }else{
        df = new DecimalFormat("###,##0.00");
      }
      double number = 0.0;
      try {
        number = Double.parseDouble(text);
      } catch (Exception e) {
        number = 0.0;
      }
      return df.format(number);
    }
  }

以上就是本文的全部内容,希望本文的内容对大家的学习或者工作能带来一定的帮助,同时也希望多多支持我们!

(0)

相关推荐

  • java计算两个日期中间的时间

    java计算两个日期中间的时间 其中在数据库中有一个字段为datetime类型,想要计算两个日期之间过了多少天 多少小时 多少分钟. 思路为把时间换算为毫秒(与协调世界时 1970 年 1 月 1 日午夜之间的时间差(以毫秒为单位测量).然后利用毫秒的加减计算. 计算如下: public static String getDays(Date date){ Calendar cal=Calendar.getInstance(); cal.setTime(date); long oldTime=ca

  • Java小程序计算圆周率代码

    下面我们来介绍两种Java编程中实现计算圆周率的方法. 方法一:割圆法 计算公式为: π≈3*2^n*y_n 其中,n代表割圆次数,y_n代表圆中内嵌正6*n边形的边长 package 计算π的近似值; import java.util.Scanner; public class Example { public static void main(String[] args) { Scanner scan=new Scanner(System.in); System.out.println("请

  • Java计算一个数加上100是完全平方数,加上168还是完全平方数

    题目:一个整数,它加上100后是一个完全平方数,加上168又是一个完全平方数,请问该数是多少? 程序分析:在10万以内判断,先将该数加上100后再开方,再将该数加上268后再开方,如果开方后的结果满足如下条件,即是结果.请看具体分析: 程序设计: public class test { public static void main (String[]args){ long k=0; for(k=1;k<=100000l;k++) if(Math.floor(Math.sqrt(k+100))=

  • java计算两个日期之前的天数实例(排除节假日和周末)

    如题所说,计算两个日期之前的天数,排除节假日和周末.这里天数的类型为double,因为该功能实现的是请假天数的计算,有请一上午假的为0.5天. 不够很坑的是每个日期都要查询数据库,感觉很浪费时间. 原则: 1.节假日存放在数据库中 实现步骤: 1.循环每个日期 2.判断每个日期是否为节假日或者为周末 3.若不是节假日和周末,天数+1 代码: public double calLeaveDays(Date startTime,Date endTime){ double leaveDays = 0;

  • Java基于余弦方法实现的计算相似度算法示例

    本文实例讲述了Java基于余弦方法实现的计算相似度算法.分享给大家供大家参考,具体如下: (1)余弦相似性 通过测量两个向量之间的角的余弦值来度量它们之间的相似性.0度角的余弦值是1,而其他任何角度的余弦值都不大于1;并且其最小值是-1.从而两个向量之间的角度的余弦值确定两个向量是否大致指向相同的方向.所以,它通常用于文件比较. 相关介绍可参考百度百科:余弦相似性 (2)算法实现的中未使用权重(IDF ---逆文档频率),使用词项的出现次数作为向量空间的值. import java.util.H

  • Java简单计算两个日期月数差的方法

    本文实例讲述了Java简单计算两个日期月数差的方法.分享给大家供大家参考,具体如下: /** * 获取两个日期相差的月数 * @param d1 较大的日期 * @param d2 较小的日期 * @return 如果d1>d2返回 月数差 否则返回0 */ public static int getMonthDiff(Date d1, Date d2) { Calendar c1 = Calendar.getInstance(); Calendar c2 = Calendar.getInsta

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

    一般信用贷款会提供两种还款方式:每月等额或者先息后本.每月等额,就是每月归还等同的部分本金和利息,你手里在使用的本金其实是逐月减少的.先息后本就是先还利息,到期归还本金. 每月等额 import java.math.BigDecimal; import java.util.Calendar; import java.util.Date; /** * <p>Title: 等额本息还款工具类</p> * */ public class CPMUtils{ /** * <p>

  • Java中线程的等待与唤醒_动力节点Java学院整理

    wait(), notify(), notifyAll()等方法介绍 在Object.java中,定义了wait(), notify()和notifyAll()等接口.wait()的作用是让当前线程进入等待状态,同时,wait()也会让当前线程释放它所持有的锁.而notify()和notifyAll()的作用,则是唤醒当前对象上的等待线程:notify()是唤醒单个线程,而notifyAll()是唤醒所有的线程. Object类中关于等待/唤醒的API详细信息如下: notify()      

  • java 中Spring task定时任务的深入理解

    java 中Spring task定时任务的深入理解 在工作中有用到spring task作为定时任务的处理,spring通过接口TaskExecutor和TaskScheduler这两个接口的方式为异步定时任务提供了一种抽象.这就意味着spring容许你使用其他的定时任务框架,当然spring自身也提供了一种定时任务的实现:spring task.spring task支持线程池,可以高效处理许多不同的定时任务.同时,spring还支持使用Java自带的Timer定时器和Quartz定时框架.

  • 学习Java中的日期和时间处理及Java日历小程序的编写

    Java 在 java.util 包中提供了 Date 类,这个类封装了当前的日期和时间. Date 类支持两种构造函数.第一个构造函数初始化对象的当前日期和时间. Date( ) 下面的构造函数接收一个参数等于自1970年1月1日午夜起已经过的毫秒数 Date(long millisec) 一旦有一个可用的日期对象,可以调用以下任何一种支持的方法使用时间: SN 方法和描述 1 boolean after(Date date) 如果调用Date对象包含或晚于指定的日期则返回true,否则,返回

  • Java 中jasperReport实现动态列打印的实现代码

    Java 中jasperReport实现动态列打印的实现代码 以下代码中注释说明很清楚,希望能帮助到大家,大家参考下. 示例代码: public ActionResult projectPrint() { String[] printValue = null; // 从页面中获得要查询的字段 String reqPrintValue = getRequest().getParameter("printValue"); // 没有选择则默认全打印 if (null == reqPrint

  • 详解Java中String类型与默认字符编码

    为什么写这个 至于为什么要写这个,主要是一句mmp一定要讲,绕了一上午,晕死 Java程序中的中文乱码问题一直是一个困扰程序员的难题,自己也不例外,早在做项目时就遇到过很多编码方式的坑,当时想填来着,但是嫌麻烦.这次终于忍不住了,一定要弄个明白 String类型的编码方式 从网上查的资料都说,Java默认的字符编码是Unicode,而String类型的编码方式是与JVM编码方式和本机操作系统默认字符集有关的.于是我做出了测试 在Java中可以这样显示查看本地编码方式(JVM还是OS呢?) //

  • Java中Jedis基本使用

    在前面我们已经学习了Redis命令行客户端redis-cli的使用,接下来我们了解一下Redis基于Java编程语言的客户端. 在Java语言体系下,有三个常用的Redis客户端Jedis.Redisson.Lettuce.三者各有特点,各有适用的场景. Jedis:Redis的Java实现的客户端,其API提供了比较全面的Redis命令的支持: Jedis中的方法调用是比较底层的暴露的Redis的API,也即Jedis中的Java方法基本和Redis的API保持着一致,了解Redis的API,

  • java中并发Queue种类与各自API特点以及使用场景说明

    一 先说下队列 队列是一种数据结构.它有两个基本操作:在队列尾部加入一个元素,和从队列头部移除一个元素(注意不要弄混队列的头部和尾部) 就是说,队列以一种先进先出的方式管理数据,如果你试图向一个 已经满了的阻塞队列中添加一个元素或者是从一个空的阻塞队列中移除一个元索,将导致线程阻塞. 在多线程进行合作时,阻塞队列是很有用的工具.工作者线程可以定期地把中间结果存到阻塞队列中而其他工作者线程把中间结果取出并在将来修改它们.队列会自动平衡负载. 如果第一个线程集运行得比第二个慢,则第二个 线程集在等待

  • Java中数组的定义与使用

    目录 一.数组的基本用法 1.什么是数组 2.创建数组 3.数组的使用 二.数据作为方法参数 1.基本用法 2.理解引用类型 3.认识null 4.JVM内存区域划分 5.数组作为方法的返回值 6.关于数组的地址 四.数组练习 1.数组转字符串 2.数组拷贝 五.二维数组 1.二维数组的语法 2.二维数组的结构 3.用for-each遍历二维数组 总结 一.数组的基本用法 1.什么是数组 数组本质上就是让我们能 "批量" 创建相同类型的变量. 如果我们需要创建多个同一个类型的变量,则不

  • GC参考手册二java中垃圾回收原理解析

    内存碎片整理 每次执行清除(sweeping), JVM 都必须保证不可达对象占用的内存能被回收重用.但这(最终)有可能会产生内存碎片(类似于磁盘碎片), 进而引发两个问题: 写入操作越来越耗时, 因为寻找一块足够大的空闲内存会变得非常麻烦. 在创建新对象时, JVM在连续的块中分配内存.如果碎片问题很严重, 直至没有空闲片段能存放下新创建的对象,就会发生内存分配错误(allocation error). 要避免这类问题,JVM 必须确保碎片问题不失控.因此在垃圾收集过程中, 不仅仅是标记和清除

随机推荐