Pausa caffè #190. Come convertire un numero intero in una stringa. Classi interne statiche e non statiche in Java

Come convertire un numero intero in una stringa

Fonte: FreeCodeCamp Questo tutorial ti spiegherà diversi modi per convertire un numero intero in una stringa. Per convertire le variabili da un tipo di dati a un altro, il linguaggio Java utilizza vari metodi. Nel caso della conversione di un numero intero in una stringa, è possibile utilizzare uno dei seguenti metodi:

• Utilizzando il metodo Integer.toString() .
• Utilizzando il metodo String.valueOf() .
• Utilizzando il metodo String.format() .
• Utilizzando la classe DecimalFormat .

Come convertire un numero intero in una stringa in Java utilizzando Integer.toString()

Il metodo Integer.toString() accetta un numero intero da convertire come parametro. Sintassi di esempio:

Integer.toString(INTEGER_VARIABLE)

Codice d'esempio:

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
    }
}

In questo esempio, abbiamo creato un numero intero age e gli abbiamo assegnato il valore 2 . Per convertire la variabile age in una stringa, l'abbiamo passata come parametro al metodo Integer.toString(): Integer.toString(age) . Abbiamo quindi memorizzato questo nuovo valore stringa in una variabile stringa denominata AGE_AS_STRING . Infine, abbiamo combinato la nuova variabile stringa con altre stringhe: "The child is " + AGE_AS_STRING + " years old" . Ora la domanda è: si verificherà un errore se concateniamo semplicemente la variabile età con queste altre stringhe senza alcuna conversione?

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
    }
}

L'output è lo stesso dell'esempio in cui dovevamo convertire un numero intero in una stringa. Ma come facciamo a sapere se la conversione del tipo ha effettivamente funzionato? Per fare ciò, possiamo controllare i tipi di variabili utilizzando l' oggetto getClass() . Qualcosa come questo:

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
    }
}

Ora possiamo verificare che quando è stata creata la variabile age , era un Integer e dopo la conversione del tipo è diventata una String .

Come convertire un numero intero in una stringa in Java utilizzando String.valueOf()

Il metodo String.valueOf() accetta anche la variabile da convertire in una stringa come parametro.

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
    }
}

Il codice sopra è simile al codice nella sezione precedente:

1. Abbiamo creato un numero intero chiamato age .
2. Abbiamo passato l'età intera come parametro al metodo String.valueOf(): String.valueOf(age) .

Ora puoi verificare se la conversione del tipo funziona utilizzando l' oggetto getClass() :

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

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

Come convertire un numero intero in una stringa in Java utilizzando String.format()

Il metodo String.format() accetta due parametri: uno specificatore di formato e la variabile da formattare. Ecco un esempio:

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

    }
}

In questo esempio, abbiamo passato due parametri al metodo String.format() : "%d" e age . "%d" è un identificatore di formato che indica che la variabile da formattare è un numero intero. age , che è il secondo parametro, verrà convertito in una stringa e archiviato nella variabile AGE_AS_STRING . Puoi anche controllare i tipi di variabili prima e dopo la conversione:

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

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

Come convertire un numero intero in una stringa in Java utilizzando DecimalFormat

La classe DecimalFormat viene utilizzata per formattare i numeri decimali in Java. Può essere utilizzato in molti modi diversi, ma per ora lo useremo per convertire un numero intero in una stringa. Ecco un esempio:

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

    }
}

Diamo un'occhiata a questo codice:

1. Per poter utilizzare la classe DecimalFormat in un esempio specifico, l'abbiamo importata: import java.text.DecimalFormat; .
3. Abbiamo creato una variabile intera age .
4. Abbiamo quindi creato un nuovo oggetto DecimalFormat chiamato DFormat .
5. Utilizzando il metodo format() dell'oggetto , abbiamo convertito age in una stringa: DFormat.format(age); .

Conclusione

In questo articolo abbiamo parlato della conversione di numeri interi in stringhe in Java. Hai visto esempi di codice utilizzando tre metodi diversi: Integer.toString() , String.valueOf() , String.format() e la classe DecimalFormat . Ogni esempio mostra il processo di conversione e il controllo del tipo di dati di una variabile prima e dopo la conversione.

Classi interne statiche e non statiche in Java

Fonte: Medium Con questo articolo imparerai le differenze tra classi interne statiche e non statiche in Java. In Java, le classi interne non statiche (note anche come classi interne o oggetti interni) hanno un riferimento implicito a un'istanza che racchiude la classe esterna. Ciò significa che hanno accesso alle variabili di istanza e ai metodi della classe esterna e possono essere utilizzati per creare più istanze della classe interna associate a diverse istanze della classe esterna. Diamo un'occhiata al seguente codice:

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

Qui, la classe Outer ha una classe interna, Inner , che ha un metodo printX . E, a sua volta, stampa il valore x dall'istanza Outer circostante . Il codice crea due istanze Outer ( outer1 e outside2 ) e due istanze Inner ( inner1 e inner2 ), ciascuna associata a un'istanza Outer diversa . Quando printX chiama inner1 e inner2 , stampa il valore x dall'istanza Outer corrispondente . Poiché le classi interne non statiche hanno un riferimento implicito all'istanza circostante, richiedono memoria aggiuntiva per archiviare questo riferimento. Ciò significa che sono meno efficienti in termini di memoria rispetto alle classi interne statiche, che non hanno un riferimento implicito all'istanza che le racchiude e non richiedono memoria aggiuntiva per questo scopo. D'altra parte, le classi interne statiche non possono accedere alle variabili o ai metodi dell'istanza della classe esterna, quindi le loro capacità sono limitate. Sono utili quando si desidera definire una classe strettamente correlata a una classe esterna e non necessita dell'accesso alle variabili o ai metodi di istanza. Le classi interne non statiche (note anche come classi interne o oggetti interni) sono utili quando si desidera definire una classe strettamente correlata a un'altra classe e che abbia accesso alle variabili di istanza e ai metodi della classe esterna.

Utilizzo di classi interne non statiche

Ecco alcune situazioni in cui potresti voler utilizzare una classe interna non statica:

1. Quando la classe interna deve accedere a variabili di istanza o metodi della classe esterna che non sono statici . Poiché le classi interne non statiche hanno un riferimento implicito all'istanza circostante della classe esterna, possono accedere direttamente a variabili e metodi di istanza non statici.

2. Quando si desidera definire più istanze di una classe interna associate a diverse istanze di una classe esterna. Ad esempio, potresti voler creare una classe interna non statica Button per la classe Dialog , in cui ciascuna istanza Button è associata a un'altra istanza Dialog e può accedere alle variabili e ai metodi dell'istanza Dialog istanza .

3. Quando si desidera definire una classe che viene utilizzata solo nel contesto della classe esterna e non è destinata a essere utilizzata in modo indipendente. È possibile accedere alle classi interne non statiche solo dalla classe esterna, quindi sono più incapsulate e meno suscettibili all'uso non previsto.

Utilizzo di classi interne statiche

Possiamo utilizzare classi interne statiche se non abbiamo bisogno di accedere a variabili di istanza o metodi della classe esterna, e per questo motivo non è necessario che abbiano un riferimento implicito all'istanza circostante della classe esterna. Ciò le rende più efficienti in termini di memoria rispetto alle classi interne non statiche, che hanno un riferimento implicito all'istanza circostante. Diciamo che dobbiamo progettare un grafico che contenga traiettorie (spigoli) e punti di intersezione (nodi). Le classi Node e Edge sono strettamente correlate alla classe Graph e vengono utilizzate solo nel contesto di un oggetto Graph . Definirle come classi interne statiche rende chiaro che fanno parte della classe Graph e non sono destinate ad essere utilizzate in modo indipendente.

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;
        }
    }

}

Le classi interne statiche non possono accedere a variabili o metodi di istanza Ecco un esempio per illustrare il fatto che le classi interne statiche non possono accedere a variabili o metodi di istanza di una classe esterna:

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

In questo esempio, la classe Outer ha una variabile di istanza privata x e una classe interna statica Inner . La classe Inner ha un metodo printX che tenta di accedere al valore x dall'istanza Outer circostante . Tuttavia, questo codice non verrà compilato perché le classi interne statiche non possono accedere alle variabili o ai metodi dell'istanza della classe esterna. Per accedere alle variabili di istanza o ai metodi di una classe esterna da una classe interna statica, puoi:

1. Creare variabili o metodi di istanza statici . Ciò consentirà alla classe interna di fare riferimento ad essi utilizzando il nome della classe esterna (ad esempio Outer.x ).

2. Passa un'istanza della classe esterna alla classe interna e memorizzala in un campo. La classe interna può quindi accedere alle variabili di istanza o ai metodi della classe esterna attraverso questo campo.

Ecco un esempio che mostra come eseguire questa operazione:

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

In questo esempio, la classe Outer ha un metodo setX non statico che imposta il valore di x e una classe interna statica Inner con un campo esterno di tipo Outer . La classe Inner ha un costruttore che prende un'istanza Outer e la memorizza nel campo esterno . Il metodo printX della classe Inner può quindi accedere al campo x dell'istanza esterna utilizzando la notazione outside.x .