javamath類

A. 在java中什麼意思 Math.abs(x)及同類的的公式

該方法返回x的絕對值，x的取值可以是各種類型參數。

Math.abs(x)=|x|；如果參數是非負數，則返回該參數。如果參數是負數，則返回該參數的相反數。

特殊情況是：

如果參數是正零或負零，那麼結果是正零。

如果參數是無窮大，那麼結果是正無窮大。

如果參數是 NaN，那麼結果就是 NaN。

NAN:

NaN，是Not a Number的縮寫。

NaN 用於處理計算中出現的錯誤情況，比如 0.0 除以 0.0 或者求負數的平方根。對於單精度浮點數，NaN 表示為指數為 emax + 1 = 128（指數域全為 1），且尾數域不等於零的浮點數。

EEE 標准沒有要求具體的尾數域，所以 NaN 實際上不是一個，而是一族。不同的實現可以自由選擇尾數域的值來表達 NaN。

比如 Java 中的常量 Float.NaN 的浮點數可能表達為 011111111100000000000000，其中尾數域的第一位為 1，其餘均為 0（不計隱藏的一位）。

但這取決系統的硬體架構。Java 中甚至允許程序員自己構造具有特定位模式的 NaN 值（通過 Float.intBitsToFloat() 方法）。

比如，程序員可以利用這種定製的 NaN 值中的特定位模式來表達某些診斷信息。

(1)javamath類擴展閱讀

java中math提供用於執行任意精度整數演算法 和任意精度小數演算法 的類。

同類公式：

java Math類常用的方法：

圓周率：Math.PI

自然對數：Math.E

絕對值：Math.abs

向上取整數：Math.ceil；

向下取整數:Math.floor；

B. java中Math類中的random方法和Random類有什麼區別

random方法是java.lang.Math的方法，作用是返回帶正號的 double 值，該值搭逗大於等於 0.0 且小於 1.0。而Random類是一個類(java.util.Random)，裡面含有很多方法。
Math.random()返回的只是從0到1之間的小數，如果要50到100，就先知局賣放大50倍，即0到50之間，這里還是小數，如果要整數，就強制轉換int，然後再加上50即為50~100。最終代碼：(int)(Math.random()*50) + 50。
Random類產生的隨機數，在其最大值范圍內，按照概率均勻分布的。也就是說，兩個種子數相同的Random對象，第一次生成的臘棗隨機數字完全相同，第二次生成的隨機數字也完全相同。

C. JAVA倆類，用類的時候為什麼Math類不需要new 呢

1.StringBuffer為羨叢激什麼要new?

答：java是面向對象語言，簡單的來說，就是化執行者為指揮者。而類的對象就是通過new關鄭殲鍵字來創建對象的，再通過對象來引用成員變數和成員方法，這個深層的原因：和java在編譯期對new轉化的虛擬機指令有關系。這個不多說。

2.Math類為什麼不需要new?

答：Math是JDK提供的一個工具類，1.6版本的申明源碼如下：

兄襪publicfinalclassMath{
/**
*Don'.
*/
privateMath(){}

如上面源碼所示， 構造器私有化，所以無法創建對象，這就好比你使用單例模式，就需要私有化構造器來防止其他的人創建對象。再看方法：

publicstaticintabs(inta){
return(a<0)?-a:a;
}

源碼中的方法都是靜態方法，所以，這部分靜態的方法在類載入的時候已經在方法區中申明出來了，不回參與你的對象實例化的過程，和對象創建沒有關系。所以，靜態的方法都是通過類型直接引用的，和你創不創建對象沒有關系。這就是我為什麼在上面寫成員方法，為了和這里的靜態方法區分開。

D. Java中怎樣調用Math中的方法

Math類中的方法一般都為靜態方法，直接使用類名.方法名(實參列表)即可調用，如調用Math中的max函數的語句為Math.max(3, 5);其返回3,5中較大的值。
Math 類包含用於執行基本數學運算的方法，如初等指數、對數、平方根和三角函數等，Math類在包java.lang中，是默認導入的包，使用時不需要額外導入包。。

E. java Math類中的pow方法

Math.pow(64,1/3)等價於 Math.pow(64,0)所以結果是1.0

在程序中 1/3並不代表三分之一，因為這里是兩個int類型在做除法，結果也是int類型，會自動取整（向下取0了）, 所以是0，就可以說明為什麼結果是1。執行代碼如下

System.out.println(1/3)

運行結果

這里1.0/3.0近似等於0.3333333333所以，最後結果為上圖所示。

拓展知識

1.0做除數拋運行時異常；兩整數商會做取整運算，Float或Double與一個整數做除法運算，則商位Float或者Double類型

2.0可以做除數，得到的是一個分正負的無窮大；當兩個數的絕對值均為0.0時候，商等於NaN。當0.0/x，x不等0.0時候

F. Java中的Math函數

new Random()就是一個隨即數對象，然後nextInt為獲取當前隨機數對象的隨即產生的一個整數，%100就是用這個整數對100求模，獲得其餘（該余在－99 至 99之間）,Math.abs為取絕對值，再加1，則獲得[1, 100]之間的整數，包括1，100

G. java中的java.math包是什麼

是數學函數相關的方法，比如開平方，幾次方，求平均數等

H. 求解java中Math類中的取整方法

public static long round(double a)
返回最接近參數的 long 長整型。結果將四捨五入為整數，對結果調用 Math.floor函數, 並將所得結果強制轉換為 long 類型。
換句話說，結果等於以下表達式的值：
(long)Math.floor(a + 0.5d)
對於負數的四捨五入規則是 先把負數轉換為正數,四捨五入後,再轉換為負數
-2.6轉換為正數2.6,四捨五入2.6+0.5=3.1,然後再轉為負數-3.1
用Math.floor函數去掉小數部分為-3,然後強制轉換成長整型-3.
-2.4轉換為正數2.4,四捨五入2.4+0.5=2.9,然後再轉為負數-2.9
用Math.floor函數去掉小數部分為-2,然後強制轉換成長整型-2.
所以Math.round(-2.6)=-3,Math.round(-2.4)=-2.

I. java中Math提供的是哪個取整的方法

Math類中提供的三個與取整有關的方法:
第一個: ceil
ceil的意思就是: 天花板的意思;該方法表示的是向上取整Math.ceil(11.3)的值是12 ; Math.ceil.(-11.6)的結果是-11;
第二個是: floor
首先他的英文含義就是地板的含義,該方法就表示的是向下取整,
Math.floor(11.6)的結果就是11 ;
Math.floor(-11.4);的結果就是-12
第三個是: round
他表示的是四捨五入,演算法為 Math.floor(x+0.5);也就是在原來的數字上加上0.5之後再進行向下取整;
Math.round(11.5);也就是 Math.floor(11.5+0.5)= Math.floor(12)=12;
同理: Math.round(-11.5)= Math.floor(-11.5+0.5)=Math.floor(-11.0)= -11;

J. 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) + + taylorSeriesSine(angle) + + 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 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 (w>b) { 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 + + Math log (i) + + Math log(i) + + 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:Sign( d);}

public static double Sign(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 函數（新的和舊的）的代碼將更快 更有效 而且比您自己編寫的任何代碼都准確 所以請使用這些函數