Les huit types de données de base de Java et BigDecimal

Type de données de base

8 types de données de base

Elles sont:

1. 6 types de nombres: byte, short, int, long, float, double
2. 1 type de caractère: char
3. 1 type booléen: booléen

 

Octets occupés par huit types de données de base

type de base	Bit	Octet	Par défaut
booléen	1		faux
octet	8	1	0
carboniser	16	2	«u0000»
court	16	2	0
int	32	4	0
longue	64	8	0L
flotte	32	4	0f
double	64	8	0j

 
3. Méthode de conversion de base et de chaîne

Prenons l'exemple de la chirurgie plastique

3.1. Conversion d'entiers en chaîne

String str = String.valueOf(int i);

String str = Integer.toString(int i);

String str = “ ” + i ;

3.2. Convertir une chaîne en entier

int i = Integer.parseIn(String str)

int i = Integer.valueOf().intValue()
//说明：
//Integer.parseIn和Integer.valueOf 不同，
//前者生成的是整型，而后者是一个对象，所以要通过intValue()来获得对象的值

 
 

genre d'emballage

Types de packaging correspondant à huit types de données de base

booléen -> Boolean
byte -> Byte
char -> Character
short -> Short
int -> Integer
long -> Long
float -> Float
double -> Double

 

Conversion du type de données de base et du type d'emballage

 

1. Conversion des types de données de base en types d'emballage (boxing)
 

Integer a = new Integer (1);
Integer b = 1;//jdk1.5 之后可以通过这种方式自动装箱
Integer c = Integer.valueOf(1);

 
2. Conversion du type d'emballage en type de données de base (déballage)
 

int a1 = a.intValue();
int b1 = b;//自动拆箱

Double c1;
double c2= double(c1);//通过强制转换

 

8 types de base de classes d'emballage et de pools constants

La plupart des classes wrapper des types de base Java implémentent la technologie de pool constant, à savoir Byte, Short, Integer, Long, Character, Boolean; les quatre premières classes wrapper créent le type correspondant de données de cache de la valeur [-128, 127] par défaut , Character crée des données de cache avec une valeur comprise entre [0,127] et Boolean renvoie directement Vrai ou Faux. S'il dépasse la plage correspondante, il créera toujours un nouvel objet.

Les deux classes de conditionnement de type nombre à virgule flottante Float et Double n'implémentent pas la technologie de pool constant.

Integer i1 = 33;
Integer i2 = 33;
System.out.println(i1 == i2);// 输出 true

Integer i11 = 333;
Integer i22 = 333;
System.out.println(i11 == i22);// 输出 false

Double i3 = 1.2;
Double i4 = 1.2;
System.out.println(i3 == i4);// 输出 false

 
Scénarios d'application:

1. Integer i1=40；Java encapsulera directement le code lors de la compilation Integer i1=Integer.valueOf(40);, utilisant ainsi les objets du pool de constantes.
2. Integer i1 = new Integer(40);Dans ce cas, un nouvel objet est créé.

Integer i1 = 40;
Integer i2 = new Integer(40);
System.out.println(i1==i2);//输出 false

 
Permettez-moi de donner un exemple plus difficile:

Integer i1 = 40;
Integer i2 = 40;
Integer i3 = 0;
Integer i4 = new Integer(40);
Integer i5 = new Integer(40);
Integer i6 = new Integer(0);
  
System.out.println("i1=i2   " + (i1 == i2));
System.out.println("i1=i2+i3   " + (i1 == i2 + i3));
System.out.println("i1=i4   " + (i1 == i4));
System.out.println("i4=i5   " + (i4 == i5));
System.out.println("i4=i5+i6   " + (i4 == i5 + i6));   
System.out.println("40=i5+i6   " + (40 == i5 + i6));     

Production:

i1=i2   true
i1=i2+i3   true
i1=i4   false
i4=i5   false
i4=i5+i6   true
40=i5+i6   true

Explication:

Déclaration i4 == i5 + i6, parce que +cet opérateur n'est pas applicable aux objets Integer, d'abord, i5 et i6 sont automatiquement déballés et les valeurs sont ajoutées, c'est-à-dire i4 == 40. Ensuite, l'objet Integer ne peut pas être directement comparé à la valeur, donc le déballage automatique i4 converti la valeur int de 40, cette instruction dans la 40 == 40comparaison numérique finale .

 
 

BigDecimal

Le "Alibaba Java Development Manual" mentionne: Le jugement équivalent entre les nombres à virgule flottante, les types de données de base ne peut pas être comparé à ==, et les types de données d'empaquetage ne peuvent pas être jugés avec des égaux. Prenons l'exemple suivant:

float a = 1.0f - 0.9f;
float b = 0.9f - 0.8f;
System.out.println(a);// 0.100000024
System.out.println(b);// 0.099999964
System.out.println(a == b);// false

Avec des connaissances mathématiques de base, nous savons clairement que le résultat n'est pas ce que nous voulons (perte de précision) Comment pouvons-nous résoudre ce problème?

Une méthode très courante consiste à utiliser BigDecimal pour définir la valeur d'un nombre à virgule flottante, puis à effectuer des opérations arithmétiques sur le nombre à virgule flottante.

BigDecimal a = new BigDecimal("1.0");
BigDecimal b = new BigDecimal("0.9");
BigDecimal c = new BigDecimal("0.8");

BigDecimal x = a.subtract(b); //两数相减
BigDecimal y = b.subtract(c); 

System.out.println(x); /* 0.1 */
System.out.println(y); /* 0.1 */
System.out.println(Objects.equals(x, y)); /* true */

 

Comparaison de la taille BigDecimal

a.compareTo(b) : Renvoie -1 signifie que a est inférieur à b, 0 signifie que a est égal à b, 1 signifie que a est supérieur à b

BigDecimal a = new BigDecimal("1.0");
BigDecimal b = new BigDecimal("0.9");
System.out.println(a.compareTo(b));// 1

 

BigDecimal conserve quelques décimales

By setScaleconserve plusieurs décimales et des moyens de définir des règles de rétention. Il existe de nombreuses règles de conservation, inutile de s'en souvenir, IDEA vous le proposera.

BigDecimal m = new BigDecimal("1.255433");
BigDecimal n = m.setScale(3,BigDecimal.ROUND_HALF_DOWN);
System.out.println(n);// 1.255

 
Remarque

1. Lorsque nous utilisons BigDecimal, afin d'éviter toute perte de précision, il est recommandé d'utiliser sa méthode de construction BigDecimal (String) pour créer des objets.
2. BigDecimal est principalement utilisé pour manipuler les (grands) nombres à virgule flottante, BigInteger est principalement utilisé pour manipuler de grands entiers (plus que le type long).
3. La réalisation de BigDecimal utilise BigInteger, la différence est que BigDecimal ajoute le concept de décimales