BigDecimal Classe

Référence

Définition

Espace de noms:: Java.Math

Assembly:: Mono.Android.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Nombres décimaux signés immuables et arbitraires.

[Android.Runtime.Register("java/math/BigDecimal", DoNotGenerateAcw=true)]
public class BigDecimal : Java.Lang.Number, IDisposable, Java.Interop.IJavaPeerable, Java.Lang.IComparable

[<Android.Runtime.Register("java/math/BigDecimal", DoNotGenerateAcw=true)>]
type BigDecimal = class
    inherit Number
    interface ISerializable
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable
    interface IComparable

Héritage: Object

Object

Number
BigDecimal

Attributs: RegisterAttribute

Implémente: IJavaObject IJavaPeerable ISerializable IComparable IDisposable

Remarques

Nombres décimaux signés immuables et arbitraires. Il BigDecimal se compose d’un entier de précision arbitraire #unscaledValue() non mis à l’échelle et d’une échelle d’entier 32 bits #scale(). Si zéro ou positif, l’échelle correspond au nombre de chiffres à droite de la virgule décimale. Si elle est négative, la valeur non mise à l’échelle du nombre est multipliée par dix à la puissance de la négation de l’échelle. La valeur du nombre représenté par le BigDecimal nombre est donc (unscaledValue × 10<sup>-scale</sup>).

La BigDecimal classe fournit des opérations pour l’arithmétique, la manipulation d’échelle, l’arrondi, la comparaison, le hachage et la conversion de format. La #toString méthode fournit une représentation canonique d’un BigDecimal.

La BigDecimal classe donne à son utilisateur un contrôle complet sur le comportement d’arrondi. Si aucun mode d’arrondi n’est spécifié et que le résultat exact ne peut pas être représenté, il ArithmeticException est levée ; sinon, les calculs peuvent être effectués en mode de précision et d’arrondi choisis en fournissant un objet approprié MathContext à l’opération. Dans les deux cas, huit <modes< d’arrondi d’em>> sont fournis pour le contrôle de l’arrondi. L’utilisation des champs entiers de cette classe (par exemple#ROUND_HALF_UP) pour représenter le mode arrondi est déconseillée ; les valeurs d’énumération du , (par exempleRoundingMode#HALF_UP) doivent être utilisées à la RoundingModeenumplace.

Lorsqu’un MathContext objet est fourni avec un paramètre de précision de 0 (par exemple), MathContext#UNLIMITEDles opérations arithmétiques sont exactes, comme les méthodes arithmétiques qui ne prennent aucun MathContext objet. En tant que corollaire de calcul du résultat exact, le paramètre de mode arrondi d’un MathContext objet avec un paramètre de précision de 0 n’est pas utilisé et donc non pertinent. Dans le cas de la division, le quotient exact pourrait avoir une expansion décimale infiniment longue ; par exemple, 1 divisé par 3. Si le quotient a une expansion décimale non déterminante et que l’opération est spécifiée pour retourner un résultat exact, une ArithmeticException valeur est levée. Sinon, le résultat exact de la division est retourné, comme pour d’autres opérations.

Lorsque le paramètre de précision n’est pas 0, les règles d’arithmétique BigDecimal sont largement compatibles avec les modes d’opération sélectionnés de l’arithmétique défini dans ANSI X3.274-1996 et ANSI X3.274-1996/AM 1-2000 (section 7.4). Contrairement à ces normes, BigDecimal inclut de nombreux modes d’arrondi. Tout conflit entre ces normes ANSI et la BigDecimal spécification sont résolus en faveur de BigDecimal.

Étant donné que la même valeur numérique peut avoir différentes représentations (avec différentes échelles), les règles d’arithmétique et d’arrondi doivent spécifier à la fois le résultat numérique et l’échelle utilisée dans la représentation du résultat.

Les différentes représentations de la même valeur numérique sont appelées membres de la même cohorte. L’ordre naturel #compareTo(BigDecimal) de BigDecimal considérer que les membres de la même cohorte sont égaux les uns aux autres. En revanche, la #equals(Object) equals méthode exige que la valeur numérique et la représentation soient identiques pour que l’égalité soit conservée. Les résultats des méthodes comme #scale() et #unscaledValue() diffèrent pour les valeurs numériques égales avec différentes représentations.

En général, les modes d’arrondi et le paramètre de précision déterminent comment les opérations retournent des résultats avec un nombre limité de chiffres lorsque le résultat exact a plus de chiffres (peut-être infiniment nombreux dans le cas de la division et de la racine carrée) que le nombre de chiffres retournés.

Tout d’abord, le nombre total de chiffres à retourner est spécifié par le MathContextparamètre « precision ; cela détermine la précision du résultat. Le nombre de chiffres commence par le chiffre le plus à gauche du résultat exact. Le mode d’arrondi détermine la façon dont les chiffres de fin ignorés affectent le résultat retourné.

Pour tous les opérateurs arithmétiques, l’opération est effectuée comme si un résultat intermédiaire exact était d’abord calculé, puis arrondi au nombre de chiffres spécifié par le paramètre de précision (si nécessaire), à l’aide du mode d’arrondi sélectionné. Si le résultat exact n’est pas retourné, certaines positions de chiffres du résultat exact sont ignorées. Lorsque l’arrondi augmente l’ampleur du résultat retourné, il est possible qu’une nouvelle position de chiffre soit créée par un transport propagé à un chiffre « 9 » de début. Par exemple, arrondir la valeur 999,9 à trois chiffres arrondis serait numériquement égal à un millier, représenté comme 100&fois ; 10<sup>1</sup>. Dans ce cas, le nouveau « 1 » est la position du chiffre de début du résultat retourné.

Pour les méthodes et les constructeurs avec un MathContext paramètre, si le résultat est incorrect, mais que le mode d’arrondi est RoundingMode#UNNECESSARY UNNECESSARY, il ArithmeticException est levée.

Outre un résultat exact logique, chaque opération arithmétique a une échelle préférée pour représenter un résultat. L’échelle par défaut pour chaque opération est répertoriée dans le tableau ci-dessous.

<table class="striped » style="text-align :left">caption Preferred Scales for Results of Arithmetic Operations </caption<>thead><tr><th scope="col">Operation</th th><scope="col">Preferred Scale of Result</th></tr/thead<>tbody<>tr><>< th scope="row">Add</th><td>max(addend.scale(), augend.scale())</td<>tr><th scope="row">Soustraction><</th><td>max(minuend.scale(), subtrahend.scale())</td<>tr><th scope="row">multiplie/th><td>multiplier.scale<() + multiplicand.scale()</td<>tr><th scope="row">Divide</th><td>dividend.scale() - divisor.scale()</td<>tr><th scope="row">Square root</th><td>radicand.scale()/2</td/tbody><></table>

Ces échelles sont celles utilisées par les méthodes qui retournent des résultats arithmétiques exacts ; sauf qu’une division exacte peut avoir à utiliser une plus grande échelle, car le résultat exact peut avoir plus de chiffres. Par exemple, 1/32 est 0.03125.

Avant l’arrondi, l’échelle du résultat intermédiaire exact logique est l’échelle préférée pour cette opération. Si le résultat numérique exact ne peut pas être représenté dans precision des chiffres, l’arrondi sélectionne l’ensemble de chiffres à retourner et l’échelle du résultat est réduite de l’échelle du résultat intermédiaire à la moins grande échelle qui peut représenter les precision chiffres réellement retournés. Si le résultat exact peut être représenté avec au maximum precision des chiffres, la représentation du résultat avec l’échelle la plus proche de l’échelle préférée est retournée. En particulier, un quotient pouvant être représenté exactement peut être représenté en moins de precision chiffres en supprimant les zéros de fin et en réduisant l’échelle. Par exemple, arrondi à trois chiffres à l’aide du mode <arrondi roundingMode#FLOOR, br>

19/100 = 0.19 // integer=19, scale=2<br>

mais<br>

21/110 = 0.190 // integer=190, scale=3<br>

Notez que pour ajouter, soustraire et multiplier, la réduction de l’échelle correspond au nombre de positions de chiffres du résultat exact qui sont ignorés. Si l’arrondi entraîne la propagation d’un transport pour créer une position de chiffre à ordre élevé, un chiffre supplémentaire du résultat est ignoré que lorsqu’aucune nouvelle position de chiffre n’est créée.

D’autres méthodes peuvent avoir une sémantique d’arrondi légèrement différente. Par exemple, le résultat de la pow méthode à l’aide de l’algorithme spécifié #pow(int, MathContext) peut parfois différer du résultat mathématique arrondi par plusieurs unités au dernier endroit, un ulp #ulp().

Deux types d’opérations sont fournis pour manipuler l’échelle d’une BigDecimalopération de mise à l’échelle/arrondi et d’opérations de mouvement de virgule décimale. Les opérations de mise à l’échelle/arrondi (#setScale setScale et #round round) retournent une BigDecimal valeur dont la valeur est approximativement (ou exactement) égale à celle de l’opérande, mais dont l’échelle ou la précision est la valeur spécifiée ; autrement dit, elles augmentent ou diminuent la précision du nombre stocké avec un effet minimal sur sa valeur. Les opérations de mouvement de virgule décimale (#movePointLeft movePointLeft et #movePointRight movePointRight) retournent une BigDecimal valeur créée à partir de l’opérande en déplaçant le point décimal une distance spécifiée dans la direction spécifiée.

En tant qu’entier 32 bits, l’ensemble de valeurs pour l’échelle est volumineux, mais limité. Si l’échelle d’un résultat dépasse la plage d’un entier 32 bits, soit par dépassement de capacité, soit par sous-flux, l’opération peut lever un ArithmeticException.

Par souci de concision et de clarté, le pseudo-code est utilisé dans les descriptions des BigDecimal méthodes. L’expression (i + j) pseudo-code est abrégée pour « une BigDecimal valeur dont laiBigDecimalvaleur est celle ajoutée à celle du BigDecimalj». L’expression (i == j) pseudo-code est abrégée pour «true si et seulement si le BigDecimali représente la même valeur que le BigDecimalj». D’autres expressions pseudo-code sont interprétées de la même façon. Les crochets sont utilisés pour représenter la paire particulière BigInteger et identique définissant une BigDecimal valeur ; par exemple [19, 2] est numériquement BigDecimal égal à 0,19 ayant une échelle de 2.

Toutes les méthodes et constructeurs de cette classe lèvent NullPointerException une référence d’objet null pour n’importe quel paramètre d’entrée.

Ajouté dans la version 1.1.

Documentation Java pour java.math.BigDecimal.

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

Constructeurs

BigDecimal(BigInteger)	Traduit un `BigInteger` en un `BigDecimal`.
BigDecimal(BigInteger, Int32)	Traduit une `BigInteger` valeur non mise à l’échelle et une `int` échelle en un `BigDecimal`.
BigDecimal(BigInteger, Int32, MathContext)	Traduit une `BigInteger` valeur non mise à l’échelle et une `int` échelle en un `BigDecimal`, avec arrondi en fonction des paramètres de contexte.
BigDecimal(BigInteger, MathContext)	Traduit un `BigIntegerBigDecimal` arrondi en fonction des paramètres de contexte.
BigDecimal(Char[])	Traduit une représentation de tableau de caractères d’un `BigDecimal` en un `BigDecimal`, acceptant la même séquence de caractères que le `#BigDecimal(String)` constructeur.
BigDecimal(Char[], Int32, Int32)	Traduit une représentation de tableau de caractères d’un `BigDecimal` en un `BigDecimal`, acceptant la même séquence de caractères que le `#BigDecimal(String)` constructeur, tout en permettant à un sous-tableau d’être spécifié.
BigDecimal(Char[], Int32, Int32, MathContext)	Traduit une représentation de tableau de caractères d’un `BigDecimal` en un `BigDecimal`, acceptant la même séquence de caractères que le `#BigDecimal(String)` constructeur, tout en permettant à un sous-tableau d’être spécifié et avec arrondi en fonction des paramètres de contexte.
BigDecimal(Char[], MathContext)	Traduit une représentation de tableau de caractères d’un `BigDecimal` en un `BigDecimal`, acceptant la même séquence de caractères que le `#BigDecimal(String)` constructeur et avec arrondi en fonction des paramètres de contexte.
BigDecimal(Double)	Traduit une `doubleBigDecimal` valeur qui correspond à la représentation décimale exacte de la `double`valeur à virgule flottante binaire.
BigDecimal(Double, MathContext)	Traduit un `double` en un `BigDecimal`, avec arrondi en fonction des paramètres de contexte.
BigDecimal(Int32)	Traduit un `int` en un `BigDecimal`.
BigDecimal(Int32, MathContext)	Traduit un `int` en un `BigDecimal`, avec arrondi en fonction des paramètres de contexte.
BigDecimal(Int64)	Traduit un `long` en un `BigDecimal`.
BigDecimal(Int64, MathContext)	Traduit un `long` en un `BigDecimal`, avec arrondi en fonction des paramètres de contexte.
BigDecimal(IntPtr, JniHandleOwnership)	Constructeur utilisé lors de la création de représentations managées d’objets JNI ; appelée par le runtime.
BigDecimal(String)	Convertit la représentation sous forme de chaîne d’un `BigDecimalBigDecimal`.
BigDecimal(String, MathContext)	Traduit la représentation sous forme de chaîne d’un `BigDecimal` en un `BigDecimal`, acceptant les mêmes chaînes que le `#BigDecimal(String)` constructeur, avec arrondi en fonction des paramètres de contexte.

Champs

RoundCeiling	Mode arrondi pour arrondir vers l’infini positif.
RoundDown	Mode arrondi pour arrondir vers zéro.
RoundFloor	Mode arrondi pour arrondir vers l’infini négatif.
RoundHalfDown	Arrondir le mode à arrondir vers le « voisin le plus proche », sauf si les deux voisins sont équidistants, auquel cas arrondir.
RoundHalfEven	Arrondir le mode pour arrondir vers le « voisin le plus proche », sauf si les deux voisins sont équidistants, auquel cas, arrondis vers le voisin pair.
RoundHalfUp	Arrondir le mode à arrondir vers le « voisin le plus proche », sauf si les deux voisins sont équidistants, auquel cas arrondir.
RoundUnnecessary	Mode arrondi pour affirmer que l’opération demandée a un résultat exact, donc aucune arrondi n’est nécessaire.
RoundUp	Mode arrondi pour arrondir à zéro.

Propriétés

Class	Retourne la classe runtime de ce `Object`. (Hérité de Object)
Handle	Handle de l’instance Android sous-jacente. (Hérité de Object)
JniIdentityHashCode	Nombres décimaux signés immuables et arbitraires. (Hérité de Object)
JniPeerMembers	Nombres décimaux signés immuables et arbitraires.
One	Valeur 1, avec une échelle de 0.
PeerReference	Nombres décimaux signés immuables et arbitraires. (Hérité de Object)
Ten	Valeur 10, avec une échelle de 0.
ThresholdClass	Cette API prend en charge l’infrastructure Mono pour Android et n’est pas destinée à être utilisée directement à partir de votre code.
ThresholdType	Cette API prend en charge l’infrastructure Mono pour Android et n’est pas destinée à être utilisée directement à partir de votre code.
Zero	Valeur 0, avec une échelle de 0.

Méthodes

Abs()	Retourne une `BigDecimal` valeur dont la valeur est la valeur absolue de ce `BigDecimal`, et dont l’échelle est `this.scale()`.
Abs(MathContext)	Retourne une `BigDecimal` valeur dont la valeur est la valeur absolue de ce `BigDecimal`, avec arrondi en fonction des paramètres de contexte.
Add(BigDecimal)	Retourne une `BigDecimal` valeur dont la valeur est `(this + augend)`, et dont l’échelle est `max(this.scale(), augend.scale())`.
Add(BigDecimal, MathContext)	Retourne une `BigDecimal` valeur dont la valeur est `(this + augend)`, avec arrondi en fonction des paramètres de contexte.
ByteValue()	Retourne la valeur du nombre spécifié en tant que `byte`. (Hérité de Number)
ByteValueExact()	Convertit cela `BigDecimal` en un `byte`, en vérifiant les informations perdues.
Clone()	Crée et retourne une copie de cet objet. (Hérité de Object)
CompareTo(BigDecimal)	Compare cela `BigDecimal` avec le fichier spécifié `BigDecimal`.
Dispose()	Nombres décimaux signés immuables et arbitraires. (Hérité de Object)
Dispose(Boolean)	Nombres décimaux signés immuables et arbitraires. (Hérité de Object)
Divide(BigDecimal)	Retourne une `BigDecimal` valeur dont la valeur est `(this / divisor)`, et dont l’échelle préférée est `(this.scale() - divisor.scale())`; si le quotient exact ne peut pas être représenté (car il a une expansion décimale sans fin) une `ArithmeticException` valeur levée.
Divide(BigDecimal, Int32, RoundingMode)	Retourne une `BigDecimal` valeur dont la valeur est `(this / divisor)`, et dont l’échelle est spécifiée.
Divide(BigDecimal, Int32, RoundOptions)	Retourne une `BigDecimal` valeur dont la valeur est `(this / divisor)`, et dont l’échelle est spécifiée.
Divide(BigDecimal, MathContext)	Retourne une `BigDecimal` valeur dont la valeur est `(this / divisor)`, avec arrondi en fonction des paramètres de contexte.
Divide(BigDecimal, RoundingMode)	Retourne une `BigDecimal` valeur dont la valeur est `(this / divisor)`, et dont l’échelle est `this.scale()`.
Divide(BigDecimal, RoundOptions)	Retourne une `BigDecimal` valeur dont la valeur est `(this / divisor)`, et dont l’échelle est `this.scale()`.
DivideAndRemainder(BigDecimal)	Retourne un tableau à deux éléments `BigDecimal` contenant le résultat de `divideToIntegralValue` suivi du résultat des `remainder` deux opérandes.
DivideAndRemainder(BigDecimal, MathContext)	Retourne un tableau à deux éléments `BigDecimal` contenant le résultat de `divideToIntegralValue` suivi du résultat des `remainder` deux opérandes calculés avec arrondi en fonction des paramètres de contexte.
DivideToIntegralValue(BigDecimal)	Retourne une `BigDecimal` valeur dont la valeur est la partie entière du quotient `(this / divisor)` arrondi vers le bas.
DivideToIntegralValue(BigDecimal, MathContext)	Retourne une `BigDecimal` valeur dont la valeur est la partie entière de `(this / divisor)`.
DoubleValue()	Convertit cette `BigDecimal` en une `double`.
Equals(Object)	Indique si un autre objet est « égal à » celui-ci. (Hérité de Object)
FloatValue()	Convertit cette `BigDecimal` en une `float`.
GetHashCode()	Retourne une valeur de code de hachage pour l'objet. (Hérité de Object)
IntValue()	Convertit cela `BigDecimal` en `int`.
IntValueExact()	Convertit ce paramètre `BigDecimal` en une `int`recherche d’informations perdues.
JavaFinalize()	Appelé par le garbage collector sur un objet lorsque le garbage collection détermine qu’il n’y a plus de références à l’objet. (Hérité de Object)
LongValue()	Convertit cette `BigDecimal` en une `long`.
LongValueExact()	Convertit cela `BigDecimal` en un `long`, en vérifiant les informations perdues.
Max(BigDecimal)	Retourne le maximum de ceci `BigDecimal` et `val`.
Min(BigDecimal)	Retourne le minimum de ceci `BigDecimal` et `val`.
MovePointLeft(Int32)	Retourne une `BigDecimal` valeur équivalente à celle-ci avec le point décimal déplacé `n` vers la gauche.
MovePointRight(Int32)	Retourne une `BigDecimal` valeur équivalente à celle-ci avec le point décimal déplacé `n` vers la droite.
Multiply(BigDecimal)	Retourne une `BigDecimal` valeur dont la valeur est `(this × multiplicand)`, et dont l’échelle est `(this.scale() + multiplicand.scale())`.
Multiply(BigDecimal, MathContext)	Retourne une `BigDecimal` valeur dont la valeur est `(this × multiplicand)`, avec arrondi en fonction des paramètres de contexte.
Negate()	Retourne une `BigDecimal` valeur dont la valeur est `(-this)`, et dont l’échelle est `this.scale()`.
Negate(MathContext)	Retourne une `BigDecimal` valeur dont la valeur est `(-this)`, avec arrondi en fonction des paramètres de contexte.
Notify()	Réveille un thread unique qui attend le moniteur de cet objet. (Hérité de Object)
NotifyAll()	Réveille tous les threads qui attendent le moniteur de cet objet. (Hérité de Object)
Plus()	Retourne une `BigDecimal` valeur dont la valeur est `(+this)`, et dont l’échelle est `this.scale()`.
Plus(MathContext)	Retourne une `BigDecimal` valeur dont la valeur est `(+this)`, avec arrondi en fonction des paramètres de contexte.
Pow(Int32)	Retourne une `BigDecimal` valeur dont la valeur est `(this<sup>n</sup>)`, la puissance est calculée exactement, à une précision illimitée.
Pow(Int32, MathContext)	Retourne une `BigDecimal` valeur dont la valeur est `(this<sup>n</sup>)`.
Precision()	Retourne la précision de ce `BigDecimal`.
Remainder(BigDecimal)	Retourne une `BigDecimal` valeur dont la valeur est `(this % divisor)`.
Remainder(BigDecimal, MathContext)	Retourne une `BigDecimal` valeur dont la valeur est `(this % divisor)`, avec arrondi en fonction des paramètres de contexte.
Round(MathContext)	Retourne un `BigDecimal` arrondi en fonction des `MathContext` paramètres.
Scale()	Retourne l’échelle de ce `BigDecimal`.
ScaleByPowerOfTen(Int32)	Retourne un BigDecimal dont la valeur numérique est égale à (`this` * 10<sup>n</sup>).
SetHandle(IntPtr, JniHandleOwnership)	Définit la propriété Handle. (Hérité de Object)
SetScale(Int32)	Retourne une `BigDecimal` valeur dont l’échelle est la valeur spécifiée et dont la valeur est numériquement égale à celle-ci `BigDecimal`.
SetScale(Int32, RoundingMode)	Retourne une `BigDecimal` valeur dont l’échelle est la valeur spécifiée et dont la valeur non mise à l’échelle est déterminée en multipliant ou en divisant cette `BigDecimal`valeur non mise à l’échelle par la puissance appropriée de dix pour conserver sa valeur globale.
SetScale(Int32, RoundOptions)	Retourne une `BigDecimal` valeur dont l’échelle est la valeur spécifiée et dont la valeur non mise à l’échelle est déterminée en multipliant ou en divisant cette `BigDecimal`valeur non mise à l’échelle par la puissance appropriée de dix pour conserver sa valeur globale.
ShortValue()	Retourne la valeur du nombre spécifié en tant que `short`. (Hérité de Number)
ShortValueExact()	Convertit cela `BigDecimal` en un `short`, en vérifiant les informations perdues.
Signum()	Retourne la fonction signum de ce `BigDecimal`.
Sqrt(MathContext)	Retourne une approximation à la racine carrée de l’arrondi `this` en fonction des paramètres de contexte.
StripTrailingZeros()	Retourne une `BigDecimal` valeur numériquement égale à celle-ci, mais avec les zéros de fin supprimés de la représentation.
Subtract(BigDecimal)	Retourne une `BigDecimal` valeur dont la valeur est `(this - subtrahend)`, et dont l’échelle est `max(this.scale(), subtrahend.scale())`.
Subtract(BigDecimal, MathContext)	Retourne une `BigDecimal` valeur dont la valeur est `(this - subtrahend)`, avec arrondi en fonction des paramètres de contexte.
ToArray<T>()	Nombres décimaux signés immuables et arbitraires. (Hérité de Object)
ToBigInteger()	Convertit cette `BigDecimal` en une `BigInteger`.
ToBigIntegerExact()	Convertit cela `BigDecimal` en un `BigInteger`, en vérifiant les informations perdues.
ToEngineeringString()	Retourne une représentation sous forme de chaîne de ce `BigDecimal`, en utilisant la notation d’ingénierie si un exposant est nécessaire.
ToPlainString()	Retourne une représentation sous forme de chaîne de ce `BigDecimal` champ sans champ d’exposant.
ToString()	Retourne une représentation de chaîne de l'objet. (Hérité de Object)
Ulp()	Retourne la taille d’un ulp, une unité à la dernière place, de ce `BigDecimal`.
UnregisterFromRuntime()	Nombres décimaux signés immuables et arbitraires. (Hérité de Object)
UnscaledValue()	Retourne une `BigInteger` valeur dont la valeur est la valeur non mise à l’échelle de ce `BigDecimal`.
ValueOf(Double)	Traduit un `double` en `BigDecimal`un , à l’aide de la `double`représentation sous forme de chaîne canonique fournie par la `Double#toString(double)` méthode.
ValueOf(Int64)	Traduit une `long` valeur en une `BigDecimal` échelle de zéro.
ValueOf(Int64, Int32)	Traduit une `long` valeur non mise à l’échelle et une `int` échelle en un `BigDecimal`.
Wait()	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti par em ou><em>interrompu</em>.<> (Hérité de Object)
Wait(Int64)	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti< par> em>ou <em>interrompu/em>,< ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée. (Hérité de Object)
Wait(Int64, Int32)	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti< par> em>ou <em>interrompu/em>,< ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée. (Hérité de Object)

Implémentations d’interfaces explicites

IComparable.CompareTo(Object)	Nombres décimaux signés immuables et arbitraires.
IJavaPeerable.Disposed()	Nombres décimaux signés immuables et arbitraires. (Hérité de Object)
IJavaPeerable.DisposeUnlessReferenced()	Nombres décimaux signés immuables et arbitraires. (Hérité de Object)
IJavaPeerable.Finalized()	Nombres décimaux signés immuables et arbitraires. (Hérité de Object)
IJavaPeerable.JniManagedPeerState	Nombres décimaux signés immuables et arbitraires. (Hérité de Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Nombres décimaux signés immuables et arbitraires. (Hérité de Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Nombres décimaux signés immuables et arbitraires. (Hérité de Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Nombres décimaux signés immuables et arbitraires. (Hérité de Object)

Méthodes d’extension

JavaCast<TResult>(IJavaObject)	Effectue une conversion de type vérifiée par le runtime Android.
JavaCast<TResult>(IJavaObject)	Nombres décimaux signés immuables et arbitraires.
GetJniTypeName(IJavaPeerable)	Nombres décimaux signés immuables et arbitraires.

S’applique à

Partager via