javamath.signum的简单介绍

今天给各位分享javamath.signum的知识，其中也会对进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

1、java中如何区分00与02、一道基础JAVA编程问题，跪求解……3、Java Math类中的新功能，第1 部分:实数4、JAVA 二分算法只能对数字进行查找吗5、设f(n)=1-(1/(2*2))+(1/(3*3))-(1/(4*4))…… +(-1)^(n-1) * (1/(n*n))，编写程序求f(10)。 用Java写6、java的math类怎么用三角函数

java中如何区分00与0

很高兴为您解答！

你接收键盘输入的时候不用用数值类型，用string；

这样就能够区分了

希望对您有用！

一道基础JAVA编程问题，跪求解……

import java.util.*;

class Student

{

String name;

double math;

double english;

double comp;

double ave;

public void setAve()

{

this.ave=(this.math+this.english+this.comp)/3;

}

}

public class Person

{

public static void main(String[] args)

{

Scanner sc=new Scanner(System.in);

ListStudent list=new ArrayListStudent();

for(int n=1;n=2;n++)

{

Student temp=new Student();

System.out.println(“请输入第”+n+”个学生的姓名：”);

temp.name=sc.nextLine();

System.out.println(“请输入第”+n+”个学生的数学成绩：”);

temp.math=sc.nextInt();

System.out.println(“请输入第”+n+”个学生的英语成绩：”);

temp.english=sc.nextInt();

System.out.println(“请输入第”+n+”个学生的计算机成绩：”);

temp.comp=sc.nextInt();

sc.nextLine();

temp.setAve();

list.add(temp);

System.out.println();

}

Collections.sort(list, new ComparatorStudent()//排序

{

public int compare(Student o1,Student o2)

{

if(o1.ave!=o2.ave)//平均成绩从高到低

{

return (int)(-Math.signum(o1.ave-o2.ave));

}

else if(o1.math!=o2.math)//平均成绩相同按数学从低到高

{

return (int)(Math.signum(o1.math-o2.math));

}

else if(o1.english!=o2.english)//平均成绩，数学成绩相同按英语从低到高

{

return (int)(Math.signum(o1.english-o2.english));

}

else

{

return (int)(Math.signum(o1.comp-o2.comp));

}

}

});

System.out.println(“姓名\t数学\t英语\t计算机\t平均成绩”);

IteratorStudent it=list.iterator();

while(it.hasNext())

{

Student temp=it.next();

System.out.println (temp.name+”\t”+temp.math+”\t”+temp.english+”\t”+temp.comp+”\t”+temp.ave);

}

}

}

Java Math类中的新功能，第1 部分:实数

摘要 在这篇由两部分组成的文章中 Elliotte Rusty Harold 与您一起探讨经典 java lang Math 类中的 新 功能 第 部分主要讨论比较单调的数学函数 第 部分将探讨专为操作浮点数而设计的函数

有时候您会对一个类熟悉到忘记了它的存在 如果您能够写出 java lang Foo 的文档 那么 Eclipse 将帮助您自动完成所需的函数 您无需阅读它的 Javadoc 例如 我使用 java lang Math（一个我自认为非常了解的类）时就是这样 但令我吃惊的是 我最近偶然读到它的 Javadoc —— 这可能是我近五年来第一次读到 我发现这个类的大小几乎翻了一倍 包含 种我从来没听说过的新方法 看来我要对它另眼相看了

Java# ;语言规范第 版向 java lang Math（以及它的姊妹版 java lang StrictMath）添加了 种新方法 Java 又添加了 种 在本文中 我重点讨论其中的比较单调的数学函数 如 log 和 cosh 在第 部分 我将探讨专为操作浮点数（与抽象实数相反）而设计的函数

抽象实数（如 π 或 ）与 Java double 之间的区别很明显 首先 数的理想状态是具有无限的精度 而 Java 表示法把数限制为固定位数 在处理非常大和非常小的数时 这点很重要 例如 （二十亿零一）可以精确表示为一个 int 而不是一个 float 最接近的浮点数表示形式是 E — 即两亿 使用 double 数会更好 因为它们的位数更多（这是应该总是使用 double 数而不是 float 数的理由之一） 但它们的精度仍然受到一定限制

计算机算法（Java 语言和其他语言的算法）的第二个限制是它基于二进制而不是十进制 / 和 / 之类的分数可用十进制精确表示（分别是 和 ） 但用二进制表示时 就会出现重复的分数 如同 / 在用十进制表示时 就会变为 ……以 为基数 任何分母仅包含质数因子 和 的分数都可以精确表示 以 为基数 则只有分母是 的乘方的分数才可以精确表示 / / / / 等

这种不精确性是迫切需要一个 math 类的最主要的原因之一 当然 您可以只使用标准的 + 和 * 运算符以及一个简单的循环来定义三角函数和其他使用泰勒级数展开式的函数 如清单 所示

清单 使用泰勒级数计算正弦

public class SineTaylor {    public static void main(String[] args) {        for (double angle = ; angle = *Math PI; angle += Math PI/ ) {            System out println(degrees(angle) + \t + taylorSeriesSine(angle)                     + \t + Math sin(angle));        }    }        public static double degrees(double radians) {        return * radians/ Math PI;    }        public static double taylorSeriesSine(double radians) {               double sine = ;        int sign = ;        for (int i = ; i ; i+= ) {            sine += Math pow(radians i) * sign / factorial(i);            sign *= ;        }        return sine;    }    private static double factorial(int i) {        double result = ;        for (int j = ; j = i; j++)  {            result *= j;        }        return result;    }}

开始运行得不错 只有一点小的误差 如果存在误差的话 也只是最后一位小数不同

但是 随着角度的增加 误差开始变大 这种简单的方法就不是很适用了

这里使用泰勒级数得到的结果实际上比我想像的要精确 但是 随着角度增加到 度 度（ pi 弧度）以及更大时 泰勒级数就逐渐需要更多条件来进行准确计算 java lang Math 使用的更加完善的算法就避免了这一点

泰勒级数的效率也无法与现代桌面芯片的内置正弦函数相比 要准确快速地计算正弦函数和其他函数 需要非常仔细的算法 专门用于避免无意地将小的误差变成大的错误 这些算法一般内置在硬件中以更快地执行 例如 几乎每个在最近 年内组装的 X 芯片都具有正弦和余弦函的硬件实现 X VM 只需调用即可 不用基于较原始的运算缓慢地计算它们 HotSpot 利用这些指令显著加速了三角函数的运算

直角三角形和欧几里德范数

每个高中学生都学过勾股定理 在直角三角形中 斜边边长的平方等于两条直角边边长平方之和 即 c = a + b

学习过大学物理和高等数学的同学会发现 这个等式会在很多地方出现 不只是在直角三角形中 例如 R 的平方 二维向量的长度 三角不等式等都存在勾股定理 （事实上 这些只是看待同一件事情的不同方式 重点在于勾股定理比看上去要重要得多）

Java 添加了 Math hypot 函数来精确执行这种计算 这也是库很有用的一个出色的实例证明 原始的简单方法如下

public static double hypot(double x double y){  return x*x + y*y;}

实际代码更复杂一些 如清单 所示 首先应注意的一点是 这是以本机 C 代码编写的 以使性能最大化 要注意的第二点是 它尽力使本计算中出现的错误最少 事实上 应根据 x 和 y 的相对大小选择不同的算法

清单 实现 Math hypot

的实际代码/** ====================================================* Copyright (C) by Sun Microsystems Inc All rights reserved ** Developed at SunSoft a Sun Microsystems Inc business * Permission to use copy modify and distribute this* sofare is freely granted provided that this notice * is preserved * ====================================================*/#include fdlibm h #ifdef __STDC__       double __ieee _hypot(double x double y)#else       double __ieee _hypot(x y)       double x y;#endif{       double a=x b=y t t y y w;       int j k ha hb;       ha = __HI(x) x fffffff;       /* high word of  x */       hb = __HI(y) x fffffff;       /* high word of  y */       if(hb ha) {a=y;b=x;j=ha; ha=hb;hb=j;} else {a=x;b=y;}       __HI(a) = ha;       /* a |a| */       __HI(b) = hb;       /* b |b| */       if((ha hb) x c ) {return a+b;} /* x/y ** */       k= ;       if(ha x f ) {       /* a ** */          if(ha = x ff ) {       /* Inf or NaN */              w = a+b;                     /* for sNaN */              if(((ha xfffff)|__LO(a))== ) w = a;              if(((hb^ x ff )|__LO(b))== ) w = b;              return w;          }          /* scale a and b by ** */          ha = x ; hb = x ;       k += ;          __HI(a) = ha;          __HI(b) = hb;       }       if(hb x b ) {       /* b ** */           if(hb = x fffff) {       /* subnormal b or */                     if((hb|(__LO(b)))== ) return a;              t = ;              __HI(t ) = x fd ;       /* t = ^ */              b *= t ;              a *= t ;              k = ;           } else {              /* scale a and b by ^ */               ha += x ;        /* a *= ^ */              hb += x ;       /* b *= ^ */              k = ;                 __HI(a) = ha;                 __HI(b) = hb;           }       }    /* medium size a and b */       w = a b;       if (wb) {           t = ;           __HI(t ) = ha;           t = a t ;           w  = sqrt(t *t (b*( b) t *(a+t )));       } else {           a  = a+a;           y = ;           __HI(y ) = hb;           y = b y ;           t = ;           __HI(t ) = ha+ x ;           t = a t ;           w  = sqrt(t *y (w*( w) (t *y +t *b)));       }       if(k!= ) {           t = ;           __HI(t ) += (k );           return t *w;       } else return w;}

实际上 是使用这种特定函数 还是几个其他类似函数中的一个取决于平台上的 JVM 细节 不过 这种代码很有可能在 Sun 的标准 JDK 中调用 （其他 JDK 实现可以在必要时改进它 ）

这段代码（以及 Sun Java 开发库中的大多数其他本机数学代码）来自 Sun 约 年前编写的开源 fdlibm 库 该库用于精确实现 IEE 浮点数 能进行非常准确的计算 不过会牺牲一些性能

以 为底的对数

对数说明一个底数的几次幂等于一个给定的值 也就是说 它是 Math pow（） 函数的反函数 以 为底的对数一般出现在工程应用程序中 以 e为底的对数（自然对数）出现在复合计算以及大量科学和数学应用程序中 以 为底的对数一般出现在算法分析中

从 Java 开始 Math 类有了一个自然对数 也就是给定一个参数 x 该自然对数返回 e 的几次幂等于给定的值 x 遗憾的是 Java 语言的（以及 C Fortran 和 Basic 的）自然对数函数错误命名为 log（） 在我读的每本数学教材中 log 都是以 为底的对数 而 ln 是以 e 为底的对数 lg 是以 为底的对数 现在已经来不及修复这个问题了 不过 Java 添加了一个 log （） 函数 它是以 为底而不是以 e 为底的对数

清单 是一个简单程序 它输出整数 到 的以 和 e 为底的对数

清单 到 的各种底数的对数

public static void main(String[] args) {        for (int i = ; i = ; i++) {            System out println(i + \t +                              Math log (i) + \t +                              Math log(i) + \t   +                              lg(i));        }    }

public static double lg(double x) {        return Math log(x)/Math log( );    }}

下面是前 行结果

Math log （） 能正常终止对数函数执行 或任何负数的对数返回 NaN

立方根

我不敢说我的生活中曾经需要过立方根 我也不是每天都要使用代数和几何的少数人士之一 更别提偶然涉足微积分 微分方程 甚至抽象代数 因此 下面这个函数对我毫无用处 尽管如此 如果意外需要计算立方根 现在就可以了 — 使用自 Java 开始引入的 Math cbrt（） 方法 清单 通过计算 到 之间的整数的立方根进行了演示

清单 到 的立方根

public class CubeRoots {    public static void main(String[] args) {        for (int i = ; i = ; i++) {            System out println(Math cbrt(i));        }    }}

下面是结果

结果显示 与平方根相比 立方根拥有一个不错的特性 每个实数只有一个实立方根 这个函数只在其参数为 NaN 时才返回 NaN

双曲三角函数

双曲三角函数就是对曲线应用三角函数 也就是说 想象将这些点放在笛卡尔平面上来得到 t 的所有可能值

x = r cos(t)y = r sin(t)

您会得到以 r 为半径的曲线 相反 假设改用双曲正弦和双曲余弦 如下所示

x = r cosh(t)y = r sinh(t)

则会得到一个正交双曲线 原点与它最接近的点之间的距离是 r

还可以这样思考 其中 sin（x） 可以写成 （ei x e i x）/ cos（x） 可以写成 （ei x + e i x）/ 从这些公式中删除虚数单位后即可得到双曲正弦和双曲余弦 即 sinh（x） = （e x e x）/ cosh（x） = （e x + e x）/

Java 添加了所有这三个函数 sh（） Math sinh（） 和 Math tanh（） 还没有包含反双曲三角函数 — 反双曲余弦 反双曲正弦和反双曲正切

实际上 cosh（z） 的结果相当于一根吊绳两端相连后得到的形状 即悬链线 清单 是一个简单的程序 它使用 sh 函数绘制一条悬链线

清单 使用 sh（） 绘制悬链线

import java awt *;

public class Catenary extends Frame {

private static final int WIDTH = ;    private static final int HEIGHT = ;    private static final double MIN_X = ;    private static final double MAX_X = ;    private static final double MAX_Y = ;

private Polygon catenary = new Polygon();

public Catenary(String title) {        super(title);        setSize(WIDTH HEIGHT);        for (double x = MIN_X; x = MAX_X; x += ) {            double y = sh(x);            int scaledX = (int) (x * WIDTH/(MAX_X MIN_X) + WIDTH/ );            int scaledY = (int) (y * HEIGHT/MAX_Y);            // in puter graphics y extends down rather than up as in            // Caretesian coordinates so we have to flip            scaledY = HEIGHT scaledY;            catenary addPoint(scaledX scaledY);        }    }

public static void main(String[] args) {        Frame f = new Catenary( Catenary );        f setVisible(true);    }

public void paint(Graphics g) {        g drawPolygon(catenary);    }

}

图 为绘制的曲线

图 笛卡尔平面中的一条悬链曲线

双曲正弦 双曲余弦和双曲正切函数也会以常见或特殊形式出现在各种计算中

符号

Math signum 函数将正数转换为 将负数转换为 仍然是 实际上 它只是提取一个数的符号 在实现 Comparable 接口时 这很有用

一个 float 和一个 double 版本可用来维护这种类型 这个函数的用途很明显 即处理浮点运算 NaN 以及正 和负 的特殊情况 NaN 也被当作 正 和负 应该返回正 和 负 例如 假设如清单 那样用简单的原始方法实现这个函数

清单 存在问题的 Math signum 实现

public static double signum(double x) {  if (x == ) return ;  else if (x ) return ;  else return ;}

首先 这个方法会将所有负 转换为正 （负 可能不好理解 但它确实是 IEEE 规范的必要组成部分） 其次 它会认为 NaN 是正的 实际实现如清单 所示 它更加复杂 而且会仔细处理这些特殊情况

清单 实际的 正确的 Math signum 实现

public static double signum(double d) {    return (d == || isNaN(d))?d:copySign( d);}

public static double copySign(double magnitude double sign) {    return rawCopySign(magnitude (isNaN(sign)? d:sign));}

public static double rawCopySign(double magnitude double sign) {    return Double longBitsToDouble((Double doubleToRawLongBits(sign)                                    (DoubleConsts SIGN_BIT_MASK)) |                                   (Double doubleToRawLongBits(magnitude)                                    (DoubleConsts EXP_BIT_MASK |                                    DoubleConsts SIGNIF_BIT_MASK)));}

事半功倍

最有效的代码是从您未编写过的代码 不要做专家们已经做过的事情 使用 java lang Math 函数（新的和旧的）的代码将更快 更有效 而且比您自己编写的任何代码都准确 所以请使用这些函数

JAVA 二分算法只能对数字进行查找吗

2分法查找，前提是要有序，要排序，必然要比较大小，所以只要一个类它实现了Comparable接口的compareTo(T o)方法（Comparable在java.lang包中）或是实现一个比较器对象接口Comparator(Comparator在java.util包)，都可以进行比较了。不管是String型,计本数据类型,还是其他什么的，都可以用2分发查找了。给你看看API

java．util．Collections中2分法的API

binarySearch

public static T int binarySearch(List? extends Comparable? super T list,

T key)使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据列表元素的自然顺序对列表进行升序排序（通过 sort(List) 方法）。如果没有对列表进行排序，则结果是不确定的。如果列表包含多个等于指定对象的元素，则无法保证找到的是哪一个。

此方法对“随机访问”列表运行 log(n) 次（它提供接近固定时间的位置访问）。如果指定列表没有实现 RandomAccess 接口并且是一个大型列表，则此方法将执行基于迭代器的二分搜索，执行 O(n) 次链接遍历和 O(log n) 次元素比较。

参数：

list – 要搜索的列表。

key – 要搜索的键。

返回：

如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) – 1)。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引；如果列表中的所有元素都小于指定的键，则为 list.size()。注意，这保证了当且仅当此键被找到时，返回的值将 = 0。

抛出：

ClassCastException – 如果列表中包含不可相互比较 的元素（例如，字符串和整数），或者搜索键无法与列表的元素进行相互比较。

——————————————————————————–

binarySearch

public static T int binarySearch(List? extends T list,

T key,

Comparator? super T c)使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据指定的比较器对列表进行升序排序（通过 sort(List, Comparator) 方法）。如果没有对列表进行排序，则结果是不确定的。如果列表包含多个等于指定对象的元素，则无法保证找到的是哪一个。

此方法对“随机访问”的列表运行 log(n) 次（它提供接近固定时间的位置访问）。如果指定列表没有实现 RandomAccess 接口并且是一个大型列表，则此方法将执行基于迭代器的二分搜索，执行 O(n) 次链接遍历和 O(log n) 次元素比较。

参数：

list – 要搜索的列表。

key – 要搜索的键。

c – 排序列表的比较器。null 值指示应该使用元素的自然顺序。

返回：

如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) – 1)。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引；如果列表中的所有元素都小于指定的键，则为 list.size()。注意，这保证了当且仅当此键被找到时，返回的值将 = 0。

抛出：

ClassCastException – 如果列表中包含使用指定的比较器不可相互比较 的元素，或者使用此比较器无法相互比较搜索键与列表元素。

java．util．Comparator接口。

A        int compare(T o1,T o2)比较用来排序的两个参数。根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。

在前面的描述中，符号 sgn(expression) 表示 signum 数学函数，根据 expression 的值为负数、0 还是正数，该函数分别返回 -1、0 或 1。

实现程序必须确保对于所有的 x 和 y 而言，都存在 sgn(compare(x, y)) == -sgn(compare(y, x))。（这意味着当且仅当 compare(y, x) 抛出异常时 compare(x, y) 才必须抛出异常。）

实现程序还必须确保关系是可传递的：((compare(x, y)0)  (compare(y, z)0)) 意味着 compare(x, z)0。

最后，实现程序必须确保 compare(x, y)==0 意味着对于所有的 z 而言，都存在 sgn(compare(x, z))==sgn(compare(y, z))。

虽然这种情况很普遍，但并不 严格要求 (compare(x, y)==0) == (x.equals(y))。一般说来，任何违背这个条件的 Comparator 都应该清楚地指出这一事实。推荐的语言是“注意：此 Comparator 强行进行与 equals 不一致的排序。”

参数：

o1 – 要比较的第一个对象。

o2 – 要比较的第二个对象。

返回：

根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。

抛出：

ClassCastException – 如果参数的类型不允许此 Comparator 对它们进行比较。

B                 boolean equals(Object obj)指示某个其他对象是否“等于”此 Comparator。此方法必须遵守 Object.equals(Object) 的常规协定。此外，仅当 指定的对象也是一个 Comparator，并且强行实施与此 Comparator 相同的排序时，此方法才返回 true。因此，comp1.equals(comp2) 意味着对于每个对象引用 o1 和 o2 而言，都存在 sgn(comp1.compare(o1, o2))==sgn(comp2.compare(o1, o2))。

注意，不 重写 Object.equals(Object) 方法总是 安全的。然而，在某些情况下，重写此方法可以允许程序确定两个不同的 Comparator 是否强行实施了相同的排序，从而提高性能。

覆盖：

类 Object 中的 equals

参数：

obj – 要进行比较的引用对象。

返回：

仅当指定的对象也是一个 Comparator，并且强行实施与此 Comparator 相同的排序时才返回 true。

以及java.lang.Comparable

public interface ComparableT此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。

实现此接口的对象列表（和数组）可以通过 Collections.sort（和 Arrays.sort）进行自动排序。实现此接口的对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

对于类 C 的每一个 e1 和 e2 来说，当且仅当 e1.compareTo(e2) == 0 与 e1.equals(e2) 具有相同的 boolean 值时，类 C 的自然排序才叫做与 equals 一致。注意，null 不是任何类的实例，即使 e.equals(null) 返回 false，e.compareTo(null) 也将抛出 NullPointerException。

建议（虽然不是必需的）最好使自然排序与 equals 一致。这是因为在使用自然排序与 equals 不一致的元素（或键）时，没有显式比较器的有序集合（和有序映射表）行为表现“怪异”。尤其是，这样的有序集合（或有序映射表）违背了根据 equals 方法定义的集合（或映射表）的常规协定。

例如，如果将两个键 a 和 b 添加到没有使用显式比较器的有序集合中，使 (!a.equals(b)  a.compareTo(b) == 0)，那么第二个 add 操作将返回 false（有序集合的大小没有增加），因为从有序集合的角度来看，a 和 b 是相等的。

实际上，所有实现 Comparable 的 Java 核心类都具有与 equals 一致的自然排序。java.math.BigDecimal 是个例外，它的自然排序将值相等但精确度不同的 BigDecimal 对象（比如 4.0 和 4.00）视为相等。

从数学上讲，定义给定类 C 上自然排序的关系式 如下：

{(x, y)|x.compareTo(y) = 0}。

整体排序的商 是：

{(x, y)|x.compareTo(y) == 0}。

它直接遵循 compareTo 的协定，商是 C 的等价关系，自然排序是 C 的整体排序。当说到类的自然排序与 equals 一致 时，是指自然排序的商是由类的 equals(Object) 方法定义的等价关系。

{(x, y)|x.equals(y)}。

compareTo

int compareTo(T o)比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

实现类必须确保对于所有的 x 和 y 都存在 sgn(x.compareTo(y)) == -sgn(y.compareTo(x)) 的关系。（这意味着如果 y.compareTo(x) 抛出一个异常，则 x.compareTo(y) 也要抛出一个异常。）

实现类还必须确保关系是可传递的：(x.compareTo(y)0  y.compareTo(z)0) 意味着 x.compareTo(z)0。

最后，实现者必须确保 x.compareTo(y)==0 意味着对于所有的 z，都存在 sgn(x.compareTo(z)) == sgn(y.compareTo(z))。 强烈推荐 (x.compareTo(y)==0) == (x.equals(y)) 这种做法，但并不是 严格要求这样做。一般来说，任何实现 Comparable 接口和违背此条件的类都应该清楚地指出这一事实。推荐如此阐述：“注意：此类具有与 equals 不一致的自然排序。”

在前面的描述中，符号 sgn(expression) 指定 signum 数学函数，该函数根据 expression 的值是负数、零还是正数，分别返回 -1、0 或 1 中的一个值。

参数：

o – 要比较的对象。

返回：

负整数、零或正整数，根据此对象是小于、等于还是大于指定对象。

抛出：

ClassCastException – 如果指定对象的类型不允许它与此对象进行比较。

设f(n)=1-(1/(2*2))+(1/(3*3))-(1/(4*4))…… +(-1)^(n-1) * (1/(n*n))，编写程序求f(10)。 用Java写

public class F {

public static void main(String[] args) {

System.out.println(f(10));

}

public static float f(int n){

float d=0.0f;

for(int i=1;i=n;i++){

d=(float) (d+Math.pow(-1, i-1)*(1.0f/(i*i)));

}

return d;

}

}

运行结果：

0.81796217

java的math类怎么用三角函数

就用Math+’.’+Math中的方法名即可

如：

Math.abs(-1),Math.acos(0)等，Math中常用的方法有：

static double abs(double a)

返回 double 值的绝对值。

static float abs(float a)

返回 float 值的绝对值。

static int abs(int a)

返回 int 值的绝对值。

static long abs(long a)

返回 long 值的绝对值。

static double acos(double a)

返回角的反余弦，范围在 0.0 到 pi 之间。

static double asin(double a)

返回角的反正弦，范围在 -pi/2 到 pi/2 之间。

static double atan(double a)

返回角的反正切，范围在 -pi/2 到 pi/2 之间。

static double atan2(double y, double x)

将矩形坐标 (x, y) 转换成极坐标 (r, theta)。

static double cbrt(double a)

返回 double 值的立方根。

static double ceil(double a)

返回最小的（最接近负无穷大）double 值，该值大于或等于参数，并且等于某个整数。

static double cos(double a)

返回角的三角余弦。

static double cosh(double x)

返回 double 值的双曲线余弦。

static double exp(double a)

返回欧拉数 e 的 double 次幂的值。

static double expm1(double x)

返回 ex -1。

static double floor(double a)

返回最大的（最接近正无穷大）double 值，该值小于或等于参数，并且等于某个整数。

static double hypot(double x, double y)

返回 sqrt(x2 +y2)，没有中间溢出或下溢。

static double IEEEremainder(double f1, double f2)

按照 IEEE 754 标准的规定，对两个参数进行余数运算。

static double log(double a)

返回（底数是 e）double 值的自然对数。

static double log10(double a)

返回 double 值的底数为 10 的对数。

static double log1p(double x)

返回参数与 1 的和的自然对数。

static double max(double a, double b)

返回两个 double 值中较大的一个。

static float max(float a, float b)

返回两个 float 值中较大的一个。

static int max(int a, int b)

返回两个 int 值中较大的一个。

static long max(long a, long b)

返回两个 long 值中较大的一个。

static double min(double a, double b)

返回两个 double 值中较小的一个。

static float min(float a, float b)

返回两个 float 值中较小的一个。

static int min(int a, int b)

返回两个 int 值中较小的一个。

static long min(long a, long b)

返回两个 long 值中较小的一个。

static double pow(double a, double b)

返回第一个参数的第二个参数次幂的值。

static double random()

返回带正号的 double 值，大于或等于 0.0，小于 1.0。

static double rint(double a)

返回其值最接近参数并且是整数的 double 值。

static long round(double a)

返回最接近参数的 long。

static int round(float a)

返回最接近参数的 int。

static double signum(double d)

返回参数的符号函数；如果参数是零，则返回零；如果参数大于零，则返回 1.0；如果参数小于零，则返回 -1.0。

static float signum(float f)

返回参数的符号函数；如果参数是零，则返回零；如果参数大于零，则返回 1.0；如果参数小于零，则返回 -1.0。

static double sin(double a)

返回角的三角正弦。

static double sinh(double x)

返回 double 值的双曲线正弦。

static double sqrt(double a)

返回正确舍入的 double 值的正平方根。

static double tan(double a)

返回角的三角正切。

static double tanh(double x)

返回 double 值的双曲线余弦。

static double toDegrees(double angrad)

将用弧度测量的角转换为近似相等的用度数测量的角。

static double toRadians(double angdeg)

将用度数测量的角转换为近似相等的用弧度测量的角。

javamath.signum的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于、javamath.signum的信息别忘了在本站进行查找喔。