Java

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

Classes enveloppe - Number, Integer, Double ...

Normalement, lorsque nous travaillons avec des valeurs numériques, nous utilisons des types de données primitifs tels que byte, int, long, double, etc.

Cependant, en développement, nous rencontrons des situations dans lesquelles nous devons utiliser des objets plutôt que des types de données primitifs. Pour ce faire, Java fournit des classes enveloppe.

Toutes les classes enveloppe (Integer, Long, Byte, Double, Float, Short) sont des sous-classes de la classe abstraite Number.

L'objet de la classe enveloppe contient ou encapsule son type de données primitif respectif. La conversion de types de données primitifs en objet s'appelle boxing et est prise en charge par le compilateur. Par conséquent, lorsque vous utilisez une classe enveloppe, il vous suffit de transmettre la valeur du type de données primitif au constructeur de la classe enveloppe.

Et l'objet enveloppe sera reconverti en un type de données primitif, et ce processus s'appelle unboxing. La classe Number fait partie du package java.lang.

Besoins des classes enveloppe

  •   Ils convertissent les types de données primitifs en objets. Les objets sont nécessaires si l'on souhaite modifier les arguments passés dans une méthode (car les types primitifs sont passés par valeur).
  •   Les classes du package java.util ne traitent que les objets et, par conséquent, les classes wrapper sont également utiles.
  •   Les structures de données du framework Collection, telles que ArrayList et Vector, stockent uniquement des objets (types de référence) et non des types primitifs.
  •   Un objet est nécessaire pour prendre en charge la synchronisation en multithreading.

Auto-boxing

La conversion automatique de types primitifs en objets de leurs classes enveloppe correspondantes est appelée auto-boxing. Par exemple - conversion de int en Integer, long en Long, double en Double, etc.

Exemple 1 :
                                Integer i =  new Integer(5) ;  // instanciation classique d'un Integer  
                                Integer j =  2 ;               // conversion automatatique -> auto-boxing  
                            

auto-unboxing

C'est juste le processus inverse de l'autoboxing. La conversion automatique d'un objet d'une classe enveloppe en son type primitif correspondant est appelée un-boxing. Par exemple - conversion d'Integer en int, de Long en long, de Double en double, etc.

Exemple 2 :
                                Integer i =  new Integer(5) ;  // instanciation classique d'un Integer  
                                int a=i;               // conversion automatique -> auto-unboxing
                            

Classe java.lang.Number

Méthodes communes à toutes les sous-classes de Number

xxxValue()

Ici xxx représentent des types de données numériques primitifs (byte, short, int, long, float, double).
Cette méthode permet de convertir la valeur de cet objet Number en type de données primitif spécifié.

Syntaxe :
                                byte byteValue()
                                short shortValue()
                                int intValue()
                                long longValue()
                                float floatValue()
                                double doubleValue()
                            

Cette méthode retourne la valeur numérique représentée par cet objet après conversion au type spécifié.

Exemple 3 :
                                public class Test {

                                    public static void main(String args[]) {
                                        Double d = 56.7689;
                                    
                                        System.out.println("Entier : " + d.intValue());
                                        System.out.println("byte : " + d.byteValue());
                                        System.out.println("short : " + d.shortValue());
                                        System.out.println("float : " + d.floatValue());
                                    
                                    }
                                }
                            
Entier : 56
byte : 56
short : 56
float : 56.7689

Lors de la conversion, une perte de précision est possible. Par exemple, comme nous pouvons le constater, la fraction (".7689") a été omise lors de la conversion d'un objet Double en type de données int.

compareTo()

La méthode compare l'objet Number qui a appelé la méthode à l'argument. Il est possible de comparer Byte, Long, Integer, etc.

Cependant, deux types différents ne peuvent pas être comparés, l'argument et l'objet Number appelant la méthode doivent être du même type.

Syntaxe :
                                public int compareTo( NumberSubClass referenceName )
                            

referenceName - Cela peut être un Byte, Double, Integer, Float, Long ou Short.

valeur retournée
  •  la valeur 0 si le Number est égal à l'argument.
  •  la valeur -1 si le Number est inférieur à l'argument.
  •  la valeur 1 si le Number est supérieur à l'argument.
Exemple 4 :
                                public class Test {

                                    public static void main(String args[]) {
                                        Integer i = 10;
                                    
                                        System.out.println(i.compareTo(7));
                                        System.out.println(i.compareTo(11));
                                        System.out.println(i.compareTo(10));
                                    
                                    }
                                }
                            
1
-1
0

equals()

La méthode détermine si l'objet Number qui appel la méthode est égal à l'objet transmis en tant qu'argument.

Syntaxe :
                                public boolean equals(Object o)
                            

La méthode retourne True si l'argument n'est pas null et est un objet du même type et avec la même valeur numérique.

Exemple 5 :
                                public class Test {

                                    public static void main(String args[]) {
                                        Integer x = 5;
                                        Integer y = 10;
                                        Integer z = 5;
                                        Short a = 5;
                                    
                                        System.out.println(x.equals(y));
                                        System.out.println(x.equals(z));
                                        System.out.println(x.equals(a));
                                    
                                    }
                                }
                            
false
true
false

parseXxx()

Cette méthode est utilisée pour obtenir le type de données primitif d'une certaine String. parseXxx() est une méthode statique et peut avoir un argument ou deux.

Syntaxe :
                                static int parseInt(String s)
                                static int parseInt(String s, int radix)
                            
Paramètres :
  •  s - Ceci est une représentation sous forme de chaîne de décimale.
  •  radix - Ceci serait utilisé pour convertir String s en entier.
Valeur de retour
  •  parseInt (String s) - Ceci retourne un entier (décimal seulement).
  •   parseInt (String s, int i) - Ceci retourne un entier, étant donné une représentation sous forme de chaîne de nombres décimaux, binaires, octaux ou hexadécimaux (valeur de base égale à 10, 2, 8 ou 16 respectivement), en entrée.
Exemple 6 :
                                public class Test {

                                    public static void main(String args[]) {
                                        int x = Integer.parseInt("9");
                                        double c = Double.parseDouble("5");
                                        int b = Integer.parseInt("444", 16);
                                    
                                        System.out.println(x);
                                        System.out.println(c);
                                        System.out.println(b);
                                    
                                    }
                                }
                            
9
5.0
1092

toString()

La méthode est utilisée pour obtenir un objet String représentant la valeur de l'objet Number.

Il existe deux variantes de la méthode toString(). Elles sont utilisées pour obtenir une représentation sous forme de chaîne d'un nombre. Les autres variantes de ces méthodes sont Integer.toBinaryString (int i), Integer.toHexString(int i), Integer.toOctalString(int i), qui renverront respectivement une représentation binaire, hexa-décimale, octale sous forme de String, d'un entier spécifié (i).

Syntaxe :
                                String toString()
                                static String toString(int i)
                            
Valeur de retour
  •   String toString () - retourne un objet String représentant la valeur de l'objet Number sur lequel il est appelé.
  •   static String toString (int i) - retourne un objet String décimal représentant l'entier spécifié (i)
Exemple 7 :
                                public class Test {

                                    public static void main(String args[]) {
                                        Integer x = 12;
                                    
                                        System.out.println(x.toString());
                                    
                                        System.out.println(Integer.toString(13));
                                    
                                        System.out.println(Integer.toBinaryString(35));
                                        System.out.println(Integer.toHexString(30));
                                        System.out.println(Integer.toOctalString(12));
                                    
                                    }
                                }
                            
12
13
100011
1e
14

valueOf()

La méthode valueOf renvoie l'objet Number correspondant contenant la valeur de l'argument transmis. L'argument peut être un type de données primitif, une chaîne, etc.

Cette méthode est une méthode statique. La méthode peut prendre deux arguments, l'un étant une chaîne et l'autre une base.

Syntaxe :
                                static Integer valueOf(int i)
                                static Integer valueOf(String s)
                                static Integer valueOf(String s, int radix)
                            
Paramètres :
  •  - Un entier pour lequel la représentation Integer sera retournée.
  •  s - String pour laquelle la représentation Integer serait renvoyée.
  •   radix - Ceci serait utilisé pour décider de la valeur de Integer renvoyé en fonction de la chaîne transmise.
Valeur de retour
  •   valueOf(int i) - Ceci retourne un objet Integer contenant la valeur de la primitive spécifiée.
  •   valueOf(String s) - Ceci retourne un objet Integer contenant la valeur de la représentation de chaîne spécifiée.
  •   valueOf(String s, radix int) - Ceci retourne un objet Integer contenant la valeur entière de la représentation de chaîne spécifiée, analysée avec la valeur de radix.
Exemple 8 :
                                public class Test {

                                    public static void main(String args[]) {
                                        Integer x = Integer.valueOf(9);
                                        Double c = Double.valueOf(5);
                                        Float a = Float.valueOf("80");
                                        Integer b = Integer.valueOf("444", 16);
                                    
                                        System.out.println(x);
                                        System.out.println(c);
                                        System.out.println(a);
                                        System.out.println(b);
                                    
                                    }
                                }
                            
9
5.0
80.0
1092

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :