Javaのstrictfpキーワード

12128 ワード
java strictfp Java開発
strictfp
　　
Strictfp-Javaキーワード.
 
strictfp、すなわち
strict float point(正確な浮動小数点).
 
strictfpキーワードは、クラス、インタフェース、またはメソッドに適用できます.strictfpキーワードを使用してメソッドを宣言する場合、このメソッドのfloat式とdouble式はすべてFP-strictの制限を厳格に遵守し、IEEE-754の仕様に合致します.クラスまたはインタフェースにstrictfpキーワードを使用すると、ネストタイプの初期設定値とコードを含むクラス内のすべてのコードが厳密に計算されます.厳密な制約は、すべての式の結果が、操作数に対してIEEE 754アルゴリズムによって予想される結果であり、単精度および二精度フォーマットで表される必要があることを意味する.
 
浮動小数点演算をより正確にし、異なるハードウェアプラットフォームで実行された結果が一致しないようにしたい場合は、キーワードstrictfpを使用します.
 
　　
例1次の例では、strictfp修飾子を使用して宣言されるクラスを示します.
 
　　 
   
   
   
   
    
    
    
    
    
  1. // Example of precision control with strictfp   
    2. 
    
    
    
    
  2.  
    3. 
    
    
    
    
  3. 　　public strictfp class MyClass  
    4. 
    
    
    
    
  4.  
    5. 
    
    
    
    
  5. 　　{  
    6. 
    
    
    
    
  6.  
    7. 
    
    
    
    
  7. 　　public MyClass(){}  
    8. 
    
    
    
    
  8.  
    9. 
    
    
    
    
  9. 　　public static void main(String[] args)  
    10. 
    
    
    
    
  10.  
    11. 
    
    
    
    
  11. 　　{  
    12. 
    
    
    
    
  12.  
    13. 
    
    
    
    
  13. 　　float aFloat = 0.6710339f;  
    14. 
    
    
    
    
  14.  
    15. 
    
    
    
    
  15. 　　double aDouble = 0.04150553411984792d;  
    16. 
    
    
    
    
  16.  
    17. 
    
    
    
    
  17. 　　double sum = aFloat + aDouble;  
    18. 
    
    
    
    
  18.  
    19. 
    
    
    
    
  19. 　　float quotient = (float)(aFloat / aDouble);  
    20. 
    
    
    
    
  20.  
    21. 
    
    
    
    
  21. 　　System.out.println("float: " + aFloat);  
    22. 
    
    
    
    
  22.  
    23. 
    
    
    
    
  23. 　　System.out.println("double: " + aDouble);  
    24. 
    
    
    
    
  24.  
    25. 
    
    
    
    
  25. 　　System.out.println("sum: " + sum);  
    26. 
    
    
    
    
  26.  
    27. 
    
    
    
    
  27. 　　System.out.println("quotient: " + quotient);  
    28. 
    
    
    
    
  28.  
    29. 
    
    
    
    
  29. 　　}  
    30. 
    
    
    
    
  30.  
    31. 
    
    
    
    
  31. 　　}  
    32.

　 

// Example of precision control with strictfp 

　　public strictfp class MyClass

　　{

　　public MyClass(){}

　　public static void main(String[] args)

　　{

　　float aFloat = 0.6710339f;

　　double aDouble = 0.04150553411984792d;

　　double sum = aFloat + aDouble;

　　float quotient = (float)(aFloat / aDouble);

　　System.out.println("float: " + aFloat);

　　System.out.println("double: " + aDouble);

　　System.out.println("sum: " + sum);

　　System.out.println("quotient: " + quotient);

　　}

　　}

サンプル出力
  
   
   
   
   
    
    
    
    
    
  1.     float: 0.6710339 
    2. 
    
    
    
    
  2.  
    3. 
    
    
    
    
  3. 　　double: 0.04150553411984792 
    4. 
    
    
    
    
  4.  
    5. 
    
    
    
    
  5. 　　sum: 0.71253945297742238 
    6. 
    
    
    
    
  6.  
    7. 
    
    
    
    
  7. 　　quotient: 16.1673355 
    8.

　 

    float: 0.6710339

　　double: 0.04150553411984792

　　sum: 0.71253945297742238

　　quotient: 16.1673355

 
　　
例2
 
次の例では、strictfp修飾子を使用して宣言する方法を示します.
 
　　
  
     
     
     
     
    
      
      
      
      
  1. // Example of precision control with strictfp:   
    2. 
      
      
      
      
  2.  
    3. 
      
      
      
      
  3. 　　public class MyClass2  
    4. 
      
      
      
      
  4.  
    5. 
      
      
      
      
  5. 　　{  
    6. 
      
      
      
      
  6.  
    7. 
      
      
      
      
  7. 　　public float aFloat;  
    8. 
      
      
      
      
  8.  
    9. 
      
      
      
      
  9. 　　public double aDouble;  
    10. 
      
      
      
      
  10.  
    11. 
      
      
      
      
  11. 　　public MyClass2(){}  
    12. 
      
      
      
      
  12.  
    13. 
      
      
      
      
  13. 　　public strictfp double add(float a, double b)  
    14. 
      
      
      
      
  14.  
    15. 
      
      
      
      
  15. 　　{  
    16. 
      
      
      
      
  16.  
    17. 
      
      
      
      
  17. 　　return (a + b);  
    18. 
      
      
      
      
  18.  
    19. 
      
      
      
      
  19. 　　}  
    20. 
      
      
      
      
  20.  
    21. 
      
      
      
      
  21. 　　public static void main(String[] args)  
    22. 
      
      
      
      
  22.  
    23. 
      
      
      
      
  23. 　　{  
    24. 
      
      
      
      
  24.  
    25. 
      
      
      
      
  25. 　　MyClass2 myClass2 = new MyClass2();  
    26. 
      
      
      
      
  26.  
    27. 
      
      
      
      
  27. 　　myClass2.aFloat = 0.6710339f;  
    28. 
      
      
      
      
  28.  
    29. 
      
      
      
      
  29. 　　myClass2.aDouble = 0.04150553411984792d;  
    30. 
      
      
      
      
  30.  
    31. 
      
      
      
      
  31. 　　double sum = myClass2.add(myClass2.aFloat, myClass2.aDouble);  
    32. 
      
      
      
      
  32.  
    33. 
      
      
      
      
  33. 　　System.out.println("float: " + myClass2.aFloat);  
    34. 
      
      
      
      
  34.  
    35. 
      
      
      
      
  35. 　　System.out.println("double: " + myClass2.aDouble);  
    36. 
      
      
      
      
  36.  
    37. 
      
      
      
      
  37. 　　System.out.println("sum: " + sum);  
    38. 
      
      
      
      
  38.  
    39. 
      
      
      
      
  39. 　　}  
    40. 
      
      
      
      
  40.  
    41. 
      
      
      
      
  41. 　　}  
    42. 
     
     
     
     

// Example of precision control with strictfp: 

　　public class MyClass2

　　{

　　public float aFloat;

　　public double aDouble;

　　public MyClass2(){}

　　public strictfp double add(float a, double b)

　　{

　　return (a + b);

　　}

　　public static void main(String[] args)

　　{

　　MyClass2 myClass2 = new MyClass2();

　　myClass2.aFloat = 0.6710339f;

　　myClass2.aDouble = 0.04150553411984792d;

　　double sum = myClass2.add(myClass2.aFloat, myClass2.aDouble);

　　System.out.println("float: " + myClass2.aFloat);

　　System.out.println("double: " + myClass2.aDouble);

　　System.out.println("sum: " + sum);

　　}

　　}

サンプル出力
 
　　
  
     
     
     
     
    
      
      
      
      
  1.     float: 0.6710339 
    2. 
      
      
      
      
  2.  
    3. 
      
      
      
      
  3. 　　double: 0.04150553411984792 
    4. 
      
      
      
      
  4.  
    5. 
      
      
      
      
  5. 　　sum: 0.71253945297742238 
    6. 
     
     
     
     

    float: 0.6710339

　　double: 0.04150553411984792

　　sum: 0.71253945297742238

==============================================================
Java 2以降、Java言語にキーワードstrictfpが追加されました.strictfpとはFP-strict、すなわち正確な浮動小数点を意味する.Java仮想マシンで浮動小数点演算を行う場合、strictfpキーワードが指定されていない場合、Javaのコンパイラおよび実行環境は、浮動小数点演算の式がマイペースに近い動作を取ってこれらの操作を完了し、結果が満足できないことが多い.一方、strictfpを使用してクラス、インタフェース、またはメソッドを宣言すると、宣言された範囲内のJavaのコンパイラおよび実行環境は、浮動小数点仕様IEEE-754に完全に従って実行されます.したがって、浮動小数点演算をより正確にし、異なるハードウェアプラットフォームで実行された結果が一致しないようにしたい場合は、キーワードstrictfpを使用します.
クラス、インタフェース、およびメソッドをstrictfpとして宣言できますが、インタフェース内のメソッドおよびコンストラクション関数に対してstrictfpキーワードを宣言することはできません.たとえば、次のコードです.
1.適法なキーワードstrictfpの使用
strictfp
interface
A
...
{}
public
strictfp
class
FpDemo1
...
{ strictfp void f() ...{} }
2.誤った使い方
interface
A
...
{ strictfp void f(); }
public
class
FpDemo2
...
{ strictfp FpDemo2() ...{} }
クラス、インタフェース、またはメソッドを宣言するためにキーワードstrictfpが使用されると、このキーワードが宣言した範囲内のすべての浮動小数点演算はIEEE-754仕様に合致する正確である.例えば、クラスがstrictfpとして宣言されると、クラス内のすべての方法はstrictfpである.
生産環境でSwaggerを無効にする方法
leetcode 151. Reverse Words in a String