Pausa para el café #190. Cómo convertir un número entero a una cadena. Clases internas estáticas y no estáticas en Java

Cómo convertir un número entero a una cadena

Fuente: FreeCodeCamp Este tutorial le indicará varias formas de convertir un número entero en una cadena. Para convertir variables de un tipo de datos a otro, el lenguaje Java utiliza varios métodos. En el caso de convertir Integer a String, puede utilizar uno de los siguientes métodos:

• Usando el método Integer.toString() .
• Usando el método String.valueOf() .
• Usando el método String.format() .
• Usando la clase DecimalFormat .

Cómo convertir un número entero en una cadena en Java usando Integer.toString()

El método Integer.toString() toma un número entero para convertir como parámetro. Sintaxis de ejemplo:

Integer.toString(INTEGER_VARIABLE)

Código de muestra:

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

En este ejemplo, creamos una edad entera y le asignamos el valor 2 . Para convertir la variable edad en una cadena, la pasamos como parámetro al método Integer.toString(): Integer.toString(age) . Luego almacenamos este nuevo valor de cadena en una variable de cadena llamada AGE_AS_STRING . Finalmente, combinamos la nueva variable de cadena con otras cadenas: "El niño tiene " + AGE_AS_STRING + " años" . Ahora la pregunta es: ¿se producirá un error si simplemente concatenamos la variable edad con estas otras cadenas sin ninguna conversión?

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

El resultado es el mismo que en el ejemplo en el que necesitábamos convertir un número entero en una cadena. Pero, ¿cómo sabemos si la conversión de tipos realmente funcionó? Para hacer esto, podemos verificar los tipos de variables usando el objeto getClass() . Algo como esto:

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

Ahora podemos verificar que cuando se creó la variable edad , era un Integer , y después de la conversión de tipo se convirtió en un String .

Cómo convertir un número entero en una cadena en Java usando String.valueOf()

El método String.valueOf() también toma como parámetro la variable que se va a convertir en una cadena.

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

El código anterior es similar al código de la sección anterior:

1. Creamos un número entero llamado edad .
2. Pasamos la edad entera como parámetro al método String.valueOf(): String.valueOf(age) .

Ahora puedes comprobar si la conversión de tipos funciona utilizando el objeto getClass() :

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

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

Cómo convertir un número entero en una cadena en Java usando String.format()

El método String.format() toma dos parámetros: un especificador de formato y la variable a formatear. He aquí un ejemplo:

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

    }
}

En este ejemplo, pasamos dos parámetros al método String.format() : "%d" y age . "%d" es un especificador de formato que indica que la variable que se está formateando es un número entero. age , que es el segundo parámetro, se convertirá en una cadena y se almacenará en la variable AGE_AS_STRING . También puede consultar los tipos de variables antes y después de la conversión:

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

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

Cómo convertir un número entero en una cadena en Java usando DecimalFormat

La clase DecimalFormat se utiliza para formatear números decimales en Java. Se puede usar de muchas maneras diferentes, pero por ahora lo usaremos para convertir un número entero en una cadena. Aquí hay un ejemplo:

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

    }
}

Veamos este código:

1. Para poder utilizar la clase DecimalFormat en un ejemplo específico, la importamos: import java.text.DecimalFormat; .
3. Hemos creado una variable entera edad .
4. Luego creamos un nuevo objeto DecimalFormat llamado DFormat .
5. Usando el método format() del objeto , convertimos la edad en una cadena: DFormat.format(age); .

Conclusión

En este artículo, hablamos sobre la conversión de números enteros en cadenas en Java. Viste ejemplos de código usando tres métodos diferentes: Integer.toString() , String.valueOf() , String.format() y la clase DecimalFormat . Cada ejemplo muestra el proceso de conversión y la verificación del tipo de datos de una variable antes y después de la conversión.

Clases internas estáticas y no estáticas en Java

Fuente: Medio Con este artículo, aprenderá las diferencias entre clases internas estáticas y no estáticas en Java. En Java, las clases internas no estáticas (también conocidas como clases internas u objetos internos) tienen una referencia implícita a una instancia adjunta de la clase externa. Esto significa que tienen acceso a variables de instancia y métodos de la clase externa y pueden usarse para crear múltiples instancias de la clase interna que están asociadas con diferentes instancias de la clase externa. Veamos el siguiente código:

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

Aquí, la clase Outer tiene una clase interna, Inner , que tiene un método printX . Y, a su vez, imprime el valor x de la instancia exterior circundante . El código crea dos instancias externas ( externa1 y externa2 ) y dos instancias internas ( interior1 e interna2 ), cada una asociada con una instancia externa diferente . Cuando printX llama a Inner1 e Inner2 , imprime el valor x de la instancia externa correspondiente . Debido a que las clases internas no estáticas tienen una referencia implícita a la instancia circundante, requieren memoria adicional para almacenar esta referencia. Esto significa que son menos eficientes en memoria que las clases internas estáticas, que no tienen una referencia implícita a la instancia adjunta y no requieren memoria adicional para este propósito. Por otro lado, las clases internas estáticas no pueden acceder a variables o métodos de instancia de clases externas, por lo que sus capacidades son limitadas. Son útiles cuando desea definir una clase que está estrechamente relacionada con una clase externa y no necesita acceso a sus variables o métodos de instancia. Las clases internas no estáticas (también conocidas como clases internas u objetos internos) son útiles cuando desea definir una clase que está estrechamente relacionada con otra clase y tiene acceso a las variables de instancia y métodos de la clase externa.

Usando clases internas no estáticas

A continuación se muestran algunas situaciones en las que es posible que desee utilizar una clase interna no estática:

1. Cuando la clase interna necesita acceder a variables de instancia o métodos de la clase externa que no son estáticos . Debido a que las clases internas no estáticas tienen una referencia implícita a la instancia circundante de la clase externa, pueden acceder directamente a variables y métodos de instancia no estáticas.

2. Cuando desee definir varias instancias de una clase interna asociadas con diferentes instancias de una clase externa. Por ejemplo, es posible que desee crear una clase interna no estática Button para la clase Dialog , donde cada instancia de Button esté asociada con otra instancia de Dialog y pueda acceder a variables de instancia y métodos de la instancia de Dialog .

3. Cuando desea definir una clase que solo se usa en el contexto de la clase externa y no está destinada a usarse de forma independiente. Solo se puede acceder a las clases internas no estáticas desde la clase externa, por lo que están más encapsuladas y menos susceptibles a un uso no deseado.

Usando clases internas estáticas

Podemos usar clases internas estáticas si no necesitamos acceso a ninguna variable de instancia o método de la clase externa y, por esta razón, no necesitan tener una referencia implícita a la instancia circundante de la clase externa. Esto las hace más eficientes en memoria que las clases internas no estáticas, que tienen una referencia implícita a la instancia circundante. Digamos que necesitamos diseñar un gráfico que contenga trayectorias (bordes) y puntos de intersección (nodos). Las clases Node y Edge están estrechamente relacionadas con la clase Graph y se utilizan sólo en el contexto de un objeto Graph . Definirlas como clases internas estáticas deja claro que son parte de la clase Graph y no están destinadas a usarse de forma independiente.

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

}

Las clases internas estáticas no pueden acceder a variables o métodos de instancia. Aquí hay un ejemplo para ilustrar el hecho de que las clases internas estáticas no pueden acceder a variables o métodos de instancia de una clase externa:

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

En este ejemplo, la clase Outer tiene una variable de instancia privada x y una clase interna estática Inner . La clase Inner tiene un método printX que intenta acceder al valor x desde la instancia Outer circundante . Sin embargo, este código no se compilará porque las clases internas estáticas no pueden acceder a variables o métodos de instancia de clases externas. Para acceder a variables de instancia o métodos de una clase externa desde una clase interna estática, puede:

1. Cree variables o métodos de instancia estática . Esto permitirá que la clase interna haga referencia a ellos usando el nombre de la clase externa (por ejemplo, Outer.x ).

2. Pase una instancia de la clase externa a la clase interna y guárdela en un campo. Luego, la clase interna puede acceder a variables de instancia o métodos de la clase externa a través de este campo.

Aquí hay un ejemplo que muestra cómo hacer esto:

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

En este ejemplo, la clase Outer tiene un método setX no estático que establece el valor de x y una clase interna estática Inner con un campo externo de tipo Outer . La clase Interior tiene un constructor que toma una instancia Exterior y la almacena en el campo exterior . El método printX de la clase interna puede acceder al campo x de la instancia externa usando la notación externa.x .