Pause café #190. Comment convertir un entier en chaîne. Classes internes statiques et non statiques en Java

Comment convertir un entier en chaîne

Source : FreeCodeCamp Ce tutoriel vous expliquera plusieurs façons de convertir un entier en chaîne. Pour convertir des variables d'un type de données à un autre, le langage Java utilise diverses méthodes. Dans le cas de la conversion d'un entier en chaîne, vous pouvez utiliser l'une des méthodes suivantes :

• Utilisation de la méthode Integer.toString() .
• Utilisation de la méthode String.valueOf() .
• Utilisation de la méthode String.format() .
• Utilisation de la classe DecimalFormat .

Comment convertir un entier en chaîne en Java en utilisant Integer.toString()

La méthode Integer.toString() prend un entier à convertir en paramètre. Exemple de syntaxe :

Integer.toString(INTEGER_VARIABLE)

Exemple de code :

class IntToStr {
    public static void main(String[] args) {

        int age = 2;
        String AGE_AS_STRING = Integer.toString(age);

        System.out.println("The child is " + AGE_AS_STRING + " years old");
        // The child is 2 years old
    }
}

Dans cet exemple, nous avons créé un âge entier et lui avons attribué la valeur 2 . Pour convertir la variable age en chaîne, nous l'avons passée en paramètre à la méthode Integer.toString() : Integer.toString(age) . Nous avons ensuite stocké cette nouvelle valeur de chaîne dans une variable chaîne appelée AGE_AS_STRING . Enfin, nous avons combiné la nouvelle variable chaîne avec d'autres chaînes : "L'enfant a " + AGE_AS_STRING + " ans" . Maintenant, la question est : une erreur se produira-t-elle si nous concaténons simplement la variable age avec ces autres chaînes sans aucune conversion ?

class IntToStr {
    public static void main(String[] args) {

        int age = 2;

        System.out.println("The child is " + age + " years old");
        // The child is 2 years old
    }
}

Le résultat est le même que dans l’exemple où nous devions convertir un entier en chaîne. Mais comment savoir si la conversion de type a réellement fonctionné ? Pour ce faire, nous pouvons vérifier les types de variables à l'aide de l' objet getClass() . Quelque chose comme ça:

class IntToStr {
    public static void main(String[] args) {

        int age = 2;

        String AGE_AS_STRING = Integer.toString(age);


        System.out.println(((Object)age).getClass().getSimpleName());
        // Integer

        System.out.println(AGE_AS_STRING.getClass().getSimpleName());
        // String
    }
}

Nous pouvons maintenant vérifier que lorsque la variable age a été créée , elle était un Integer et qu'après la conversion de type, elle est devenue une String .

Comment convertir un entier en chaîne en Java en utilisant String.valueOf()

La méthode String.valueOf() prend également la variable à convertir en chaîne comme paramètre.

class IntToStr {
    public static void main(String[] args) {

        int age = 2;

        String AGE_AS_STRING = String.valueOf(age);

        System.out.println("The child is " + AGE_AS_STRING + " years old");
        // The child is 2 years old
    }
}

Le code ci-dessus est similaire au code de la section précédente :

1. Nous avons créé un entier appelé age .
2. Nous avons passé l'âge entier en paramètre à la méthode String.valueOf() : String.valueOf(age) .

Vous pouvez maintenant vérifier si la conversion de type fonctionne en utilisant l' objet getClass() :

System.out.println(((Object)age).getClass().getSimpleName());
// Integer

System.out.println(AGE_AS_STRING.getClass().getSimpleName());
// String

Comment convertir un entier en chaîne en Java en utilisant String.format()

La méthode String.format() prend deux paramètres : un spécificateur de format et la variable à formater. Voici un exemple :

class IntToStr {
    public static void main(String[] args) {

        int age = 2;

        String AGE_AS_STRING = String.format("%d", age);

        System.out.println("The child is " + AGE_AS_STRING + " years old");
        // The child is 2 years old

    }
}

Dans cet exemple, nous avons passé deux paramètres à la méthode String.format() : "%d" et age . "%d" est un spécificateur de format indiquant que la variable en cours de formatage est un entier. age , qui est le deuxième paramètre, sera converti en chaîne et stocké dans la variable AGE_AS_STRING . Vous pouvez également vérifier les types de variables avant et après la conversion :

System.out.println(((Object)age).getClass().getSimpleName());
// Integer

System.out.println(AGE_AS_STRING.getClass().getSimpleName());
// String

Comment convertir un entier en chaîne en Java en utilisant DecimalFormat

La classe DecimalFormat est utilisée pour formater les nombres décimaux en Java. Il peut être utilisé de différentes manières, mais pour l’instant nous allons l’utiliser pour convertir un entier en chaîne. Voici un exemple:

import java.text.DecimalFormat;

class IntToStr {
    public static void main(String[] args) {

        int age = 2;

        DecimalFormat DFormat = new DecimalFormat("#");


        String AGE_AS_STRING = DFormat.format(age);

        System.out.println("The child is " + AGE_AS_STRING + " years old");
        // The child is 2 years old


        System.out.println(((Object)age).getClass().getSimpleName());
        // Integer

        System.out.println(AGE_AS_STRING.getClass().getSimpleName());
        // String

    }
}

Regardons ce code :

1. Pour pouvoir utiliser la classe DecimalFormat dans un exemple précis, nous l'avons importée : import java.text.DecimalFormat; .
3. Nous avons créé une variable entière age .
4. Nous avons ensuite créé un nouvel objet DecimalFormat appelé DFormat .
5. En utilisant la méthode format() de l'objet , nous avons converti age en chaîne : DFormat.format(age); .

Conclusion

Dans cet article, nous avons parlé de la conversion d'entiers en chaînes en Java. Vous avez vu des exemples de code utilisant trois méthodes différentes : Integer.toString() , String.valueOf() , String.format() et la classe DecimalFormat . Chaque exemple montre le processus de conversion et vérifie le type de données d'une variable avant et après la conversion.

Classes internes statiques et non statiques en Java

Source : Medium Avec cet article, vous découvrirez les différences entre les classes internes statiques et non statiques en Java. En Java, les classes internes non statiques (également appelées classes internes ou objets internes) ont une référence implicite à une instance englobante de la classe externe. Cela signifie qu'ils ont accès aux variables d'instance et aux méthodes de la classe externe et peuvent être utilisés pour créer plusieurs instances de la classe interne associées à différentes instances de la classe externe. Regardons le code suivant :

class Outer {
    private int x;
 class Inner {
        public void printX() {
            System.out.println(x);
        }
    }
}
Outer outer1 = new Outer();
outer1.x = 5;
Outer.Inner inner1 = outer1.new Inner();
inner1.printX(); // prints 5
Outer outer2 = new Outer();
outer2.x = 10;
Outer.Inner inner2 = outer2.new Inner();
inner2.printX(); // prints 10

Ici, la classe Outer a une classe interne, Inner , qui possède une méthode printX . Et il imprime à son tour la valeur x à partir de l' instance externe environnante . Le code crée deux instances externes ( external1 et external2 ) et deux instances internes ( inner1 et inner2 ), chacune associée à une instance externe différente . Lorsque printX appelle inner1 et inner2 , il imprime la valeur x à partir de l' instance externe correspondante . Étant donné que les classes internes non statiques ont une référence implicite à l’instance environnante, elles nécessitent de la mémoire supplémentaire pour stocker cette référence. Cela signifie qu'elles sont moins efficaces en termes de mémoire que les classes internes statiques, qui n'ont pas de référence implicite à l'instance englobante et ne nécessitent pas de mémoire supplémentaire à cette fin. D’un autre côté, les classes internes statiques ne peuvent pas accéder aux variables ou méthodes d’instance de classe externe, leurs capacités sont donc limitées. Ils sont utiles lorsque vous souhaitez définir une classe étroitement liée à une classe externe et qui n'a pas besoin d'accéder à ses variables ou méthodes d'instance. Les classes internes non statiques (également appelées classes internes ou objets internes) sont utiles lorsque vous souhaitez définir une classe étroitement liée à une autre classe et ayant accès aux variables d'instance et aux méthodes de la classe externe.

Utiliser des classes internes non statiques

Voici quelques situations dans lesquelles vous souhaiterez peut-être utiliser une classe interne non statique :

1. Lorsque la classe interne a besoin d'accéder à des variables d'instance ou à des méthodes de la classe externe qui ne sont pas statiques . Étant donné que les classes internes non statiques ont une référence implicite à l’instance environnante de la classe externe, elles peuvent accéder directement aux variables et méthodes d’instance non statiques.

2. Lorsque vous souhaitez définir plusieurs instances d'une classe interne associées à différentes instances d'une classe externe. Par exemple, vous souhaiterez peut-être créer une classe interne non statique Button pour la classe Dialog , où chaque instance de Button est associée à une autre instance de Dialog et peut accéder aux variables et méthodes d'instance de l' instance de Dialog .

3. Lorsque vous souhaitez définir une classe qui n'est utilisée que dans le contexte de la classe externe et n'est pas destinée à être utilisée indépendamment. Les classes internes non statiques ne sont accessibles qu'à partir de la classe externe, elles sont donc plus encapsulées et moins susceptibles d'être utilisées involontairement.

Utiliser des classes internes statiques

Nous pouvons utiliser des classes internes statiques si nous n'avons pas besoin d'accéder à des variables d'instance ou à des méthodes de la classe externe, et pour cette raison, elles n'ont pas besoin d'avoir une référence implicite à l'instance environnante de la classe externe. Cela les rend plus efficaces en termes de mémoire que les classes internes non statiques, qui ont une référence implicite à l'instance environnante. Disons que nous devons concevoir un graphique contenant des trajectoires (bords) et des points d'intersection (nœuds). Les classes Node et Edge sont étroitement liées à la classe Graph et sont utilisées uniquement dans le contexte d'un objet Graph . Les définir en tant que classes internes statiques indique clairement qu'elles font partie de la classe Graph et ne sont pas destinées à être utilisées indépendamment.

public class Graph {

    Map <String, Node> nodeMap;

    public Graph () {
        nodeMap = new HashMap<>();
    }

    static class Node {
        String name;
        List <Edge> edgeList;

        public Node(String name) {
            this.name = name;
            edgeList = new ArrayList();
        }
    }

    static class Edge {
        Node source;
        Node Destination;
        String type;

        public Edge(Node source, Node destination, String type) {
            this.Destination = destination;
            this.source = source;
            this.type = type;
        }
    }

}

Les classes internes statiques ne peuvent pas accéder aux variables d'instance ou aux méthodes. Voici un exemple pour illustrer le fait que les classes internes statiques ne peuvent pas accéder aux variables d'instance ou aux méthodes d'une classe externe :

class Outer {
    private int x;
static class Inner {
        public void printX() {
            System.out.println(x);  // compilation error: cannot access x
        }
    }
}

Dans cet exemple, la classe Outer a une variable d'instance privée x et une classe interne statique Inner . La classe Inner possède une méthode printX qui tente d'accéder à la valeur x à partir de l'instance Outer environnante . Cependant, ce code ne sera pas compilé car les classes internes statiques ne peuvent pas accéder aux variables ou méthodes d’instance de classe externe. Pour accéder aux variables d'instance ou aux méthodes d'une classe externe à partir d'une classe interne statique, vous pouvez :

1. Créez des variables ou des méthodes d'instance statiques . Cela permettra à la classe interne de s'y référer en utilisant le nom de la classe externe (par exemple Outer.x ).

2. Transmettez une instance de la classe externe à la classe interne et stockez-la dans un champ. La classe interne peut alors accéder aux variables d'instance ou aux méthodes de la classe externe via ce champ.

Voici un exemple qui montre comment procéder :

class Outer {
    private int x;
public void setX(int x) {
        this.x = x;
    }
    static class Inner {
        Outer outer;
        public Inner(Outer outer) {
            this.outer = outer;
        }
        public void printX() {
            System.out.println(outer.x);
        }
    }
}
Outer outer = new Outer();
outer.setX(5);
Outer.Inner inner = new Outer.Inner(outer);
inner.printX();  // prints 5

Dans cet exemple, la classe Outer possède une méthode setX non statique qui définit la valeur de x et une classe interne statique Inner avec un champ external de type Outer . La classe Inner a un constructeur qui prend une instance Outer et la stocke dans le champ externe . La méthode printX de la classe Inner peut alors accéder au champ x de l' instance externe en utilisant la notation external.x .