在对数值做一些计算的时候，往往我们需要控制计算结果的精度，所以会使用到DecimalFormat类来将数值格式化成字符串。在最近测试中，突然注意到默认使用DecimalFormat进行格式化时，并非我们一般认识上的四舍五入，而是一种诡异的舍入——(1)5以下舍去(2)5以上舍入(3)若前一位是奇数，5就舍入(4)如前一位是偶数，5就舍去

遇到这样的统计结论，没有理论的支持，我们总是感到很迷茫，所以我仔细查阅了DecimalFormat相关API，终于找到了答案。

分析：

在DecimalFormat API中有这样一段：

这句话指出了舍入模式有多种类型，而DecimalFormat默认采用了RoundingMode.HALF_EVEN这种类型，接下来，我们就一起看看，到底存在哪些舍入类型吧

RoundingMode介绍：

RoundingMode是一个枚举类，有一下几个常量：UP，DOWN，CEILING，FLOOR，HALF_UP，HALF_DOWN，HALF_EVEN，UNNECESSARY

UP

public static final RoundingMode UP

远离零方向舍入的舍入模式。始终对非零舍弃部分前面的数字加 1。注意，此舍入模式始终不会减少计算值的绝对值。

示例：

输入数字	使用 UP 舍入模式 将输入数字舍入为一位数
5.5	6
2.5	3
1.6	2
1.1	2
1.0	1
-1.0	-1
-1.1	-2
-1.6	-2
-2.5	-3
-5.5	-6

 

DOWN

public static final RoundingMode DOWN

向零方向舍入的舍入模式。从不对舍弃部分前面的数字加 1（即截尾）。注意，此舍入模式始终不会增加计算值的绝对值。

示例：

输入数字	使用 DOWN 舍入模式 将输入数字舍入为一位数
5.5	5
2.5	2
1.6	1
1.1	1
1.0	1
-1.0	-1
-1.1	-1
-1.6	-1
-2.5	-2
-5.5	-5

 

CEILING

public static final RoundingMode CEILING

向正无限大方向舍入的舍入模式。如果结果为正，则舍入行为类似于 RoundingMode.UP；如果结果为负，则舍入行为类似于 RoundingMode.DOWN。注意，此舍入模式始终不会减少计算值。

示例：

输入数字	使用 CEILING 舍入模式 将输入数字舍入为一位数
5.5	6
2.5	3
1.6	2
1.1	2
1.0	1
-1.0	-1
-1.1	-1
-1.6	-1
-2.5	-2
-5.5	-5

 

FLOOR

public static final RoundingMode FLOOR

向负无限大方向舍入的舍入模式。如果结果为正，则舍入行为类似于 RoundingMode.DOWN；如果结果为负，则舍入行为类似于RoundingMode.UP。注意，此舍入模式始终不会增加计算值。

示例：

输入数字	使用 FLOOR 舍入模式 将输入数字舍入为一位数
5.5	5
2.5	2
1.6	1
1.1	1
1.0	1
-1.0	-1
-1.1	-2
-1.6	-2
-2.5	-3
-5.5	-6

 

HALF_UP

public static final RoundingMode HALF_UP

向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向上舍入。如果被舍弃部分 >= 0.5，则舍入行为同 RoundingMode.UP；否则舍入行为同RoundingMode.DOWN。注意，此舍入模式就是通常学校里讲的四舍五入。

示例：

输入数字	使用 HALF_UP 舍入模式 将输入数字舍入为一位数
5.5	6
2.5	3
1.6	2
1.1	1
1.0	1
-1.0	-1
-1.1	-1
-1.6	-2
-2.5	-3
-5.5	-6

 

HALF_DOWN

public static final RoundingMode HALF_DOWN

向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向下舍入。如果被舍弃部分 > 0.5，则舍入行为同 RoundingMode.UP；否则舍入行为同RoundingMode.DOWN。

示例：

输入数字	使用 HALF_DOWN 舍入模式 将输入数字舍入为一位数
5.5	5
2.5	2
1.6	2
1.1	1
1.0	1
-1.0	-1
-1.1	-1
-1.6	-2
-2.5	-2
-5.5	-5

 

HALF_EVEN

public static final RoundingMode HALF_EVEN

向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向相邻的偶数舍入。如果舍弃部分左边的数字为奇数，则舍入行为同RoundingMode.HALF_UP；如果为偶数，则舍入行为同RoundingMode.HALF_DOWN。注意，在重复进行一系列计算时，此舍入模式可以在统计上将累加错误减到最小。此舍入模式也称为“银行家舍入法”，主要在美国使用。此舍入模式类似于 Java 中对float 和double 算法使用的舍入策略。

示例：

输入数字	使用 HALF_EVEN 舍入模式 将输入数字舍入为一位数
5.5	6
2.5	2
1.6	2
1.1	1
1.0	1
-1.0	-1
-1.1	-1
-1.6	-2
-2.5	-2
-5.5	-6

 

UNNECESSARY

public static final RoundingMode UNNECESSARY

用于断言请求的操作具有精确结果的舍入模式，因此不需要舍入。如果对生成精确结果的操作指定此舍入模式，则抛出 ArithmeticException。

示例：

输入数字	使用 UNNECESSARY 舍入模式 将输入数字舍入为一位数
5.5	抛出 ArithmeticException
2.5	抛出 ArithmeticException
1.6	抛出 ArithmeticException
1.1	抛出 ArithmeticException
1.0	1
-1.0	-1
-1.1	抛出 ArithmeticException
-1.6	抛出 ArithmeticException
-2.5	抛出 ArithmeticException
-5.5	抛出 ArithmeticException

 

http://blog.csdn.net/alanzyy/article/details/8465098

       在多线程并发编程中，有时候会遇到将大任务分解成小任务再并发执行的场景。Java 8新增的ForkJoinPool很好的支持了这个问题。

       ForkJoinPool是一种支持任务分解的线程池，当提交给他的任务“过大”，他就会按照预先定义的规则将大任务分解成小任务，多线程并发执行。

      一般要配合可分解任务接口ForkJoinTask来使用，ForkJoinTask有两个实现它的抽象类：RecursiveAction和RecursiveTask，其区别是前者没有返回值，后者有返回值。

          下面通过具体代码，来示范两个问题：（1）怎么定义可分解的任务类 （2）如何使用ForkJoinPool

package demo.thread.fork;

import java.util.Random;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ForkJoinPool;

import java.util.concurrent.Future;

import java.util.concurrent.RecursiveTask;

public class ForkJoinPoolDemo {

public static void main(String[] args) throws InterruptedException, ExecutionException {

int arr[] = new int[100];

Random random = new Random();

int total = 0;

// 初始化100个数字元素

for (int i = 0; i < arr.length; i++) {

int temp = random.nextInt(100);

// 对数组元素赋值,并将数组元素的值添加到total总和中

total += (arr[i] = temp);

}

System.out.println("初始化时的总和=" + total);

// 创建包含Runtime.getRuntime().availableProcessors()返回值作为个数的并行线程的ForkJoinPool

ForkJoinPool forkJoinPool = new ForkJoinPool();

// 提交可分解的PrintTask任务

Future<Integer> future = forkJoinPool.submit(new SumTaskDemo(arr, 0,

arr.length));

System.out.println("计算出来的总和=" + future.get());

// 关闭线程池

forkJoinPool.shutdown();

}

}

// RecursiveTask为ForkJoinTask的抽象子类，有返回值的任务

class SumTaskDemo extends RecursiveTask<Integer> {

private static final long serialVersionUID = 4033241174438751063L;

// 每个"小任务"最多只打印20个数

private static final int MAX = 20;

private int arr[];

private int start;

private int end;

SumTaskDemo(int arr[], int start, int end) {

this.arr = arr;

this.start = start;

this.end = end;

}

@Override

protected Integer compute() {

int sum = 0;

// 当end-start的值小于MAX时候，开始打印

if ((end - start) <= MAX) {

for (int i = start; i < end; i++) {

sum += arr[i];

}

return sum;

} else {

System.err.println("=====任务分解======");

// 将大任务分解成两个小任务

int middle = (start + end) >>>1;

SumTaskDemo left = new SumTaskDemo(arr, start, middle);

SumTaskDemo right = new SumTaskDemo(arr, middle, end);

// 并行执行两个小任务

left.fork();

right.fork();

// 把两个小任务累加的结果合并起来

return left.join() + right.join();

}

}

}
例子二：

package demo.thread.fork;

import java.util.Random;

import java.util.concurrent.ForkJoinPool;

import java.util.concurrent.RecursiveAction;

import java.util.concurrent.TimeUnit;

/**

 * @author lin

 *

 */

public class ForkJoinPoolDemo2 {

public static void main(String[] args) throws Exception {

// 创建一个支持分解任务的线程池ForkJoinPool

ForkJoinPool pool = new ForkJoinPool(4);

myTask task = new myTask(60);

pool.submit(task);

pool.awaitTermination(10, TimeUnit.SECONDS);// 等待20s，观察结果

pool.shutdown();

}

}

/**

 * 定义一个可分解的的任务类，继承了RecursiveAction抽象类 必须实现它的compute方法

 */

class myTask extends RecursiveAction {

private static final long serialVersionUID = 1L;

// 定义一个分解任务的阈值——50,即一个任务最多承担50个工作量

int THRESHOLD = 20;

// 任务量

int task_Num = 0;

myTask(int Num) {

this.task_Num = Num;

}

@Override

protected void compute() {

if (task_Num <= THRESHOLD) {

System.out.println(Thread.currentThread().getName() + "承担了"

+ task_Num + "份工作");

/*try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}*/

} else {

// 随机解成两个任务

Random m = new Random();

int x = m.nextInt(50);

myTask left = new myTask(x);

myTask right = new myTask(task_Num - x);

left.fork();

right.fork();

}

}

}

公式：

上面的太复杂，来个简单的：

使用JAVA求实际利率

Java代码  

1. /** 
2.  * 实际利率法 
3.  * @author Bean(mailto:mailxbs@126.com) 
4.  * @param a 现值 
5.  * @param b 年金 
6.  * @param c 期数 
7.  * @param cnt 运算次数 
8.  * @param ina 误差位数 
9.  * @return 利率 
10.  */  
11. public static double rate(double a,double b,double c,int cnt,int ina){  
12.     double rate = 1,x,jd = 0.1,side = 0.1,i = 1;  
13.     do{  
14.         x = a/b - (Math.pow(1+rate, c)-1)/(Math.pow(rate+1, c)*rate);  
15.         if(x*side>0){side = -side;jd *=10;}  
16.         rate += side/jd;  
17.     }while(i++<cnt&&Math.abs(x)>=1/Math.pow(10, ina));  
18.     if(i>cnt)return Double.NaN;  
19.     return rate;  
20. }  
21. public static void main(String agrs[]) {  
22.     {  
23.     Double 现值 = 7944760.00d;  
24.     Double 年金 = 186627.21d;  
25.     Double 期数 = 48d;  
26.        
27.     //计算200次，比Excel20次要精确，误差精确到小数点后10位  
28.     System.out.println(rate(现值,年金,期数,200,10));  
29.     }  
30. }