java高精度

⑴ 在java中如何实现较为精确的定时器

大部分人在遇到需要使用定时任务的时候首先会想到Timer类，
不过在JDK5.0之后就不建议使用这个Timer了，因为它有很多的缺陷。
在新的java.util.concurrent包中的ScheledExecutorService可以替代这个Timer：
使用方法举例：

Java代码
ScheledThreadPoolExecutor exec = new ScheledThreadPoolExecutor(1);
exec.scheleAtFixedRate(new Runnable() {
public void run() {
try{
throw new RuntimeException();
}catch (Exception e){
System.out.println("RuntimeException catched");
}
}
}, 1000, 5000, TimeUnit.MILLISECONDS);

⑵ JAVA中如何获取毫秒和微秒数

一、获取毫秒数的代码：

微秒使用System.nanoTime()方法：如果Java程序需要高精度的计时，如1毫秒或者更小，使用System.nanoTime()方法，可以满足需求。

(2)java高精度扩展阅读：

获取微秒函数System.nanoTime() 的隐患：

System.currentTimeMillis() 起始时间是基于 1970.1.1 0:00:00 这个确定的时间的,而System.nanoTime()是基于cpu核心的时钟周期来计时,它的开始时间是不确定的。

但是在多核处理器上，由于每个核心的开始时间不确定，那么

“long start = System.nanoTime();String ip = Utilities.getIpByUrl(url);long cost = System.nanoTime() - start;”

这段代码有可能会运行在两个不同的cpu核心上，从而导致得到的结果完全不符逻辑。

⑶ java写一个高精度计算器程序。

- -存储数据的变量类型 换下就好了

c语言下的代码 差不多的
#include<stdio.h>
#include<string.h>
char s[100001];
int a[100001],b[100001],c[100001];

int main(){
long i,j,k,m,n;
long alen,blen,clen;
gets(s);
alen=strlen(s);
for(i=alen-1;i>=0;i--)
a[alen-i]=s[i]-'0';
gets(s);
blen=strlen(s);
for(i=blen-1;i>=0;i--)
b[blen-i]=s[i]-'0';
if(alen>blen)
clen=alen;
else
clen=blen;
for(i=1;i<=clen;i++)
c[i]=a[i]+b[i];
for(i=1;i<=clen;i++)
if(c[i]>9){
c[i+1]++;
c[i]-=10;
if(i==clen)
clen++;
}
for(i=clen;i>=1;i--)
printf("%d",c[i]);

printf("\n");
return 0;
}

⑷ JAVA计算时实现数字计算结果高精度

这个程序满足你的要求吧

public class BigNumber {
public static int[] add(int[] a, int[] b) {
int carry = 0;
int[] c = new int[a.length];
for(int i = a.length - 1; i >= 0; i--) {
c[i] = a[i] + b[i] + carry;
if(c[i] < 10000)
carry = 0;
else { // 进位

c[i] = c[i] - 10000;
carry = 1;
}
}
return c;
}
public static int[] sub(int[] a, int[] b) {
int borrow = 0;
int[] c = new int[a.length];
for(int i = a.length - 1; i >= 0; i--) {
c[i] = a[i] - b[i] - borrow;
if(c[i] >= 0)
borrow = 0;
else { // 借位
c[i] = c[i] + 10000;
borrow = 1;
}
}
return c;
}
public static int[] mul(int[] a, int b) { // b 为乘数
int carry = 0;
int[] c = new int[a.length];
for(int i = a.length - 1; i >=0; i--) {
int tmp = a[i] * b + carry;
c[i] = tmp % 10000;
carry = tmp / 10000;
}
return c;
}
public static int[] div(int[] a, int b) { // b 为除数
int remain = 0;
int[] c = new int[a.length];
for(int i = 0; i < a.length; i++) {
int tmp = a[i] + remain;
c[i] = tmp / b;
remain = (tmp % b) * 10000;
}
return c;
}
public static void main(String[] args) {
int[] a = {1234, 5678, 9910, 1923, 1124};
int[] b = {1234, 5678, 9910, 1923, 1124};
int[] c = BigNumber.add(a, b);
for(int i = 0; i < c.length; i++) {
System.out.print(c[i]);
}
System.out.println();
}
}

⑸ java怎么处理高精度 算 10

有个类叫BigInteger，还有BigDecimal，可以解决这个问题。不过不推荐用java解决高精度计算问题 /** * 你的采纳是我继续为大家解疑答惑的东西，如解决了你的问题，望接纳！ */

⑹ Java中在赋值运算中可以将高精度的数据转换为低精度吗

可以强制类型转换，但会丢失精度

⑺ 在java 中怎么理解高精度和低精度

高精度和低精度 就是针对小数位数 来说的，

高精度 存储和保留的小数位数多，经度就高。
低经度 存储和保留的小数位数相比高精度少 ，经度低。

⑻ java能精确到小数点的后多少位

java中double类型是双精度浮点数，占用8字节（Byte）即64位（bit），其精度是由32个bit的二进制尾数来确定的，因此准确精度是二进制精度而不是十进制精度，通常可以保证十进制小数点后15位有效精度和第16位的部分精度。其实这个不只是java存在，是由计算机二级制架构决定的。高精度浮点计算，最好是先转换为整数计算后再转为小数。相对精度比较好。

⑼ java 高精开方

做是做出来了 大半夜的 写的有点乱 效率很低 不知道能不能优化 仅供参考吧

import java.math.BigDecimal;

public class SqrtTest
{
public static void main(String[] args)
{
Double n=2.0;
BigDecimal num=new BigDecimal(n);

BigDecimal bef;
BigDecimal aft;

for(int i=0;;i++)
{
if(i*i>n)
{
bef=new BigDecimal(i-1);
aft=new BigDecimal(i);
break;
}
}

BigDecimal res=null;
BigDecimal resup=new BigDecimal(0);

BigDecimal temp=new BigDecimal(2);
while(true)
{
res=bef.add(aft).divide(temp);

String r1=resup.toString();

if(res.multiply(res).compareTo(num)>0)
{
aft=res;
}else
{
bef=res;
}

String r2=res.toString();

int count=0;

int start=r1.indexOf('.')+1;

resup=res.multiply(new BigDecimal(1));

while(count<r1.length()&&r1.charAt(count)==r2.charAt(count))
count++;

if(count==1000+start)//1000为保留位数
{
System.out.println(" ---"+res.toString().substring(0,count));
break;
}

System.out.println(res.toString());

}

}
}

计算器 1.
程序：
---1.82152128229518488472

⑽ java：写个Appeton高精度乘法

import java.util.*;
import java.lang.*;
import java.math.*;
import java.awt.*;
import java.awt.event.*;

public class ncifang
{
public static void main(String args[])
{
new AppFrame();
}
}

class AppFrame extends Frame
{
TextField injishu=new TextField(12);
TextField incishu=new TextField(3);
String strcifang=" ^ ";
Button btn=new Button("求n次方");
Label out=new Label("结果 ");
Label out1=new Label("n=");
Label out2=new Label("次方");
public AppFrame()
{
setLayout( new FlowLayout() );
add( injishu );
add( out1 );
add( incishu );
add( out2 );
add( btn );
add( out );
btn.addActionListener( new BtnActionAdapter() );
setSize( 1500,100 );
show();
}
class BtnActionAdapter implements ActionListener
{
public void actionPerformed( ActionEvent e )
{
BigDecimal doublejishu;
String strResult;
String getAstring;
getAstring = injishu.getText();
doublejishu = BigDecimal.valueOf( Double.parseDouble( getAstring ) );
getAstring = incishu.getText();
int intcishu =Integer.parseInt( getAstring );
strResult = doublejishu.pow( intcishu ).toPlainString();
out.setText( "=" + strResult );
}
}

}