table des matières
Type de données de base
8 types de données de base
Elles sont:
- 6 types de nombres: byte, short, int, long, float, double
- 1 type de caractère: char
- 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:
Integer i1=40;
Java encapsulera directement le code lors de la compilationInteger i1=Integer.valueOf(40);
, utilisant ainsi les objets du pool de constantes.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 == 40
comparaison 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 setScale
conserve 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
- 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.
- 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).
- La réalisation de BigDecimal utilise BigInteger, la différence est que BigDecimal ajoute le concept de décimales