|
|
Yayınlandı 7.04.2015 14:53:05
|
|
|
Büyük sayılar için işlem sınıfları java'da sağlanır; yani java.math.BinInteger sınıfı ve java.math.BigDecimal sınıfı. Bu iki sınıf, yüksek hassasiyetli hesaplamalar için kullanılır; BigInteger sınıfı büyük tam sayılar için işleme sınıfıdır, BigDecimal sınıfı ise büyük ve küçük sayılar için işleme sınıfıdır. Aşağıda BigDecimal sınıfını tanıtıyoruz:
BigDecimal'ın uygulanması BigInteger'den faydalanır, ancak BigDecimal ondalık kavramını ekler. Genel float ve çift tip verileri yalnızca bilimsel hesaplamalar veya mühendislik hesaplamaları için kullanılabilir, çünkü ticari hesaplamada gerekli sayısal doğruluk nispeten yüksektir, bu nedenle java.math.BigDecimal sınıfı kullanılır; bu sınıf sabit noktaların herhangi bir hassasiyetini destekler ve para birimi değerlerini doğru hesaplamak için kullanılabilir. Aşağıda kullanımını örneklerle kısaca tanıtacağız
java.math.BigDecimal
Bugün, ders kitabına atıfta bulunarak ikili ve ondalık dönüşüm hakkında bir program yazdım ve program algoritması zor değil, ancak yazdıktan sonra, 2'den 10'a ya da 10'dan 2'ye kadar olsun, 2,1 milyardan büyük sayılar için iyi bir dönüşüm olmadığını gördüm, yani tam sayı aralığından fazla. 0 olacak.
Referans kitaplar, BigInteger kullanmanın bu sorunu çözdüğünü bulmuştur.
JDK'yı araştırdım, sonra birkaç kez test ettim ve sonunda başarılı bir şekilde yazdım!
Kullanım deneyimi aşağıdaki gibidir:
1. BigInteger java.math.BigInteger'a aittir, bu yüzden her kullanımdan önce bu sınıfı içe aktarın. Bazen başta içe aktarmayı unutuyorum, bu yüzden prompt sürekli istemde bulunamıyor.
2. Birçok yapım yöntemi vardır, ancak şimdi ara sıra kullanılıyorlar:
BigInteger(String val)
BigInteger'ın ondalık dizi temsilini BigInteger'a dönüştürün.
BigInteger(Dizi val, int radix)
Belirtilen kardinalite için BigInteger dize temsilini BigInteger'a dönüştürür.
Int tipinden 2'yi BigInteger türüne dönüştürmek için BigInteger two=new BigInteger("2") yazın; Not 2: çift tırnak işareti çıkarılamaz
3. BigInteger sınıfı, add()=="+", divide()=="-" gibi tüm int-tip matematiksel işlemleri simüle eder, ancak içeriğinin matematiksel işlemler sırasında doğrudan matematiksel işlemler için kullanılamayacağını ve dahili yöntemlerini kullanması gerektiğini unutmayın. Ve onun operandı da BigInteger tipinde olmalıdır.
Örneğin: two.add(2) yanlış bir işlemdir çünkü 2 BigInteger türüne dönüşmez.
4. Hesaplama sonuçlarını çıkarmak istediğinizde, .toString yöntemini kullanarak aşağıdaki gibi ondalık bir diziye dönüştürmelisiniz:
String toString()
Bu BigInteger'ın ondalık dizim temsilini döndürür.
Çıkış yöntemi: System.out.print(two.toString());
5. Kullanılan üç fonksiyonu açıklayın.
BigInteger kalanı (BigInteger val)
(bu % val) değeri olan bir BigIntsayı döndürür.
BigInteger negate()
BigInteger (-this) değerini döndürür.
int compareTo(BigInteger val)
Bu BigInteger ile belirtilen BigInteger'ı karşılaştırın.
kalanları bulmak için kullanılan kalıntılar.
negate, operandı tam tersine dönüştürür.
Karşılaştırma ayrıntılı olarak şu şekilde açıklanır:
karşılaştırmak
public int compareTo(BigInteger val)
Bu BigInteger ile belirtilen BigInteger'ı karşılaştırın. Bu yöntem, altı Boolean karşılaştırma operatörünün her biri için tercih edilir (<, ==, >, >=, !=, <=). Bu karşılaştırmaları yapmak için önerilen ifade şudur: (x.compareTo(y <op> ) 0), burada <op> altı karşılaştırma operatöründen biridir.
Belirti:
<BigInteger> Arayüz Karşılaştırılabilir
Parametreler:
val - Bu BigInteger ile karşılaştıran BigIntse.
Geri:
Başlık: Java'da On Nokta Sayılarının Hassas Hesaplamalarını Uygulama AYellow (Orijinal) Modifikasiyonu
Anahtar kelimeler: Java kayan nokta sayı kesin hesaplama
Sorulan soru:
Aşağıdaki programı derleyip çalıştırsak ne görürdük?
public class Test{
public static void main(String args[]){
System.out.println(0.05+0.01);
System.out.println(1.0-0.42);
System.out.println(4.015*100);
System.out.println(123.3/100);
}
};
Doğru okudun! Sonuç gerçekten
0.060000000000000005
0.5800000000000001
401.49999999999994
1.2329999999999999
Java'da basit float ve double tipleri işlenemez. Bu sorun sadece Java'da değil, birçok diğer programlama dilinde de görülür. Çoğu durumda hesaplamalar doğrudur, ancak yukarıdaki gibi hataları denemek için birkaç kez daha deneyebilirsiniz (döngü yapabilirsiniz). Şimdi nihayet neden BCD kodu olduğunu anladım.
Bu sorun oldukça ciddi, eğer 9.99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
Bazı programlama dilleri bu durumu yönetmek için özel para birimi türleri sunarken, Java bunu yapmaz. Şimdi bunu nasıl düzelteceğimize bakalım.
Yuvarlama
İlk tepkimiz yuvarlamak olur. Matematik dersinde tur yöntemi birkaç ondalık basamayı tutacak şekilde ayarlanamaz, sadece bunu yapabiliriz (iki yer tutuyoruz):
Public double round(double value){
Math.round(value*100)/100.0 döndür;
}
Ne yazık ki, yukarıdaki kod çalışmaz, 4.015'i bu yönteme aktarırsak, yukarıda gördüğümüz gibi 4.02 yerine 4.01 döndürür
4.015*100=401.49999999999999
Bu nedenle, doğru yuvarlama yapmak istiyorsak, basit tiplerle herhangi bir işlem yapamıyoruz
java.text.DecimalFormat bu sorunu da çözmez:
System.out.println(new java.text.DecimalFormat("0.00").format(4.025));
Çıkış 4.02
BigDecimal
Bu ilke "Effective Java" kitabında da belirtilmiştir; float ve double yalnızca bilimsel veya mühendislik hesaplamaları için kullanılabilir ve iş bilişiminde java.math.BigDecimal kullanmamız gerekir. BigDecimal oluşturmanın 4 yolu var, BigInteger ile yapılan iki yöntemi umursamıyor, yani iki tane daha var, bunlar şunlardır:
BigDecimal (çift val)
Çifti BigDecimal'a çevirir.
BigDecimal (String val)
Bir Büyük Ondalık'ın String repre göndermesini BigDecimal'e çevirir.
API kısaca tanımlanır ve genellikle kullanımı daha kolaydır. Düşünmeden kullanabiliriz, sorun ne olur? Bir şeyler ters gittiğinde, yukarıdaki yöntemlerden hangisinin yeterli olduğuna dair ayrıntılı açıklamada böyle bir paragraf olduğunu öğrendim:
Not: Bu yapıcının sonuçları biraz öngörülemez olabilir. Yeni BigDecimal(.1)'nin tam olarak .1'e eşit olduğu varsayılabilir, ancak aslında .1000000000000000055511151231257827021181583404541015625'e eşittir. Bunun nedeni, .1'in tam olarak bir çift olarak (veya herhangi bir sonlu uzunlukta ikili bir kesim olarak) temsil edilememesi. Dolayısıyla, yapıcıya verilen uzun değer, görünüşlere rağmen tam olarak 0.1'e eşit değildir.
(String) yapıcısı ise tamamen tahmin edilebilir: yeni BigDecimal(".1") tam olarak .1'e eşittir, beklenildiği gibi. Bu nedenle, genellikle (String) yapıcısının bu yapıya tercih edilmesi önerilir.
Doğru hesaplamamız gerekiyorsa, BigDecimal oluşturmak için String kullanmamız gerekiyor! Effective Java adlı kitaptaki örnek, BigDecimal oluşturmak için String kullanıyor, ancak kitap bunu vurgulamıyor, ki bu küçük bir hata olabilir.
Çözüm
Şimdi bu problemi çözdüğümüze göre, prensip BigDecimal kullanmak ve String kullandığınızdan emin olmak.
Ama bir toplama işlemi yapmak istiyorsak, önce iki kayan nokta sayısını String'e dönüştürmemiz, sonra bir BigDecimal oluşturmamız, birinde toplama yöntemini çağırmamız, diğerini argüman olarak vermemiz ve ardından işlemin sonucunu (BigDecimal) bir kayan noktalı sayıya dönüştürmemiz gerekiyor. Böylesine sıkıcı bir sürece dayanabilir misiniz? Aşağıda, işlemi basitleştirmek için Arith adlı bir araç sınıfı sunuyoruz. Toplama, çıkarma, çarpma ve bölme ile yuvarlama gibi aşağıdaki statik yöntemleri sunar:
Public static double add (double v1, double v2)
Kamu statik çift alt alt (çift v1, çift v2)
Public Static Double Mul(Double V1, Double V2)
Public Static Double Div (Double V1, Double V2)
Public Static Double Div (Double V1, Double V2, INT Scale)
Kamu statik çift tur (çift V, INT ölçeği)
Ek
Kaynak dosya Arith.java:
java.math.BigDecimal içe aktar;
/**
* Java'nın basit tipleri kayan nokta işlemlerini doğru şekilde gerçekleştiremediğinden, bu araç sınıfı cezalar sağlar
* Tam kayan nokta işlemleri; toplama, çıkarma, çarpma, bölme ve yuvarlama dahil.
*/
public class Arith{
Varsayılan bölme operasyon doğruluğu
özel statik final int DEF_DIV_SCALE = 10;
Bu sınıf oluşturulamaz
private Arith(){
}
/**
* Kesin toplama işlemleri sağlar.
* @param v1 eklendi
* @param v2 eklemesi
* @return İki parametrin toplamı
*/
public static double add(double v1,double v2){
BigDecimal b1 = yeni BigDecimal (Double.toString(v1));
BigDecimal b2 = yeni BigDecimal(Double.toString(v2));
return b1.add(b2).doubleValue();
}
/**
* Hassas çıkarma işlemleri sağlar.
* @param v1 çıkarılır
* @param v2 eksi
* @return İki parametre arasındaki fark
*/
Public static double sub(double v1,double v2){
BigDecimal b1 = yeni BigDecimal (Double.toString(v1));
BigDecimal b2 = yeni BigDecimal(Double.toString(v2));
geri döner: b1.al(b2).doubleValue();
}
/**
* Kesin çarpma işlemleri sağlar.
* @param v1 çarpılır
* @param v2 çarpanı
* @return İki parametrin çarpımı
*/
public static double mul(double v1,double v2){
BigDecimal b1 = yeni BigDecimal (Double.toString(v1));
BigDecimal b2 = yeni BigDecimal(Double.toString(v2));
return b1.multiply(b2).doubleValue();
}
/**
* Tükenmez bölünme gerçekleştiğinde (göreceli) doğru bölme işlemleri sağlar
* 10 ondalık basamak ve aşağıdaki rakamlar yuvarlanmıştır.
* @param v1 bölünmüş
* @param v2 bölücü
* @return İki parametrin bölümü
*/
public static double div(double v1,double v2){
return div(v1,v2,DEF_DIV_SCALE);
}
/**
* (Göreceli) doğru tümen operasyonları sağlar. Tükenmez bir durum meydana geldiğinde, bu ölçek parametresiyle belirtilir
* Doğruluğu belirleyin ve yuvarlandıktan sonra sayılar belirlenir.
* @param v1 bölünmüş
* @param v2 bölücü
* @param ölçeği, birkaç ondalık basacama kadar doğru olması gerektiğini gösterir.
* @return İki parametrin bölümü
*/
public static double div(double v1,double v2,int scale){
if(scale<0){
yeni IllegalArgumentException(
"Ölçeg pozitif tam sayı veya sıfır olmalıdır");
}
BigDecimal b1 = yeni BigDecimal (Double.toString(v1));
BigDecimal b2 = yeni BigDecimal(Double.toString(v2));
return b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
}
/**
* Hassas ondalık yuvarlama sağlar.
* @param v için sayıların yuvarlanması gerekir
* @param ölçeği ondalık noktadan sonra ayrılır
* @return Yuvarlak sonuçlar
*/
Public static double round(double v,int scale){
if(scale<0){
yeni IllegalArgumentException(
"Ölçeg pozitif tam sayı veya sıfır olmalıdır");
}
BigDecimal b = yeni BigDecimal(Double.toString(v));
BigDecimal bir = yeni BigDecimal ("1");
b.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue() döndür;
}
}; |
Önceki:Anlamlı bir telin birincil anahtar olarak ayarlanmaması en iyisidirÖnümüzdeki:JDK, JRE, JVM farklılıkları ve bağlantıları
|
