Pausa para café #190. Como converter inteiro em string. Classes internas estáticas e não estáticas em Java

Como converter inteiro em string

Fonte: FreeCodeCamp Este tutorial mostrará várias maneiras de converter um número inteiro em uma string. Para converter variáveis ​​de um tipo de dados para outro, a linguagem Java utiliza vários métodos. No caso de conversão de Inteiro em String, você pode usar um dos seguintes métodos:

• Usando o método Integer.toString() .
• Usando o método String.valueOf() .
• Usando o método String.format() .
• Usando a classe DecimalFormat .

Como converter um número inteiro em uma string em Java usando Integer.toString()

O método Integer.toString() usa um número inteiro para converter como parâmetro. Sintaxe de exemplo:

Integer.toString(INTEGER_VARIABLE)

Código de amostra:

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

Neste exemplo, criamos uma idade inteira e atribuímos a ela o valor 2 . Para converter a variável age em uma string, passamos ela como parâmetro para o método Integer.toString(): Integer.toString(age) . Em seguida, armazenamos esse novo valor de string em uma variável de string chamada AGE_AS_STRING . Por fim, combinamos a nova variável string com outras strings: "The child is " + AGE_AS_STRING + " years old" . Agora a questão é: ocorrerá um erro se apenas concatenarmos a variável age com essas outras strings sem qualquer conversão?

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

A saída é a mesma do exemplo onde precisávamos converter um número inteiro em uma string. Mas como sabemos se a conversão de tipo realmente funcionou? Para fazer isso, podemos verificar os tipos de variáveis ​​usando o objeto getClass() . Algo assim:

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

Agora podemos verificar que quando a variável idade foi criada ela era um Integer , e após a conversão do tipo ela passou a ser uma String .

Como converter um número inteiro em uma string em Java usando String.valueOf()

O método String.valueOf() também leva a variável a ser convertida em uma string como parâmetro.

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

O código acima é semelhante ao código da seção anterior:

1. Criamos um número inteiro chamado age .
2. Passamos o inteiro age como parâmetro para o método String.valueOf(): String.valueOf(age) .

Agora você pode verificar se a conversão de tipo funciona usando o objeto getClass() :

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

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

Como converter um número inteiro em uma string em Java usando String.format()

O método String.format() usa dois parâmetros: um especificador de formato e a variável a ser formatada. Aqui está um exemplo:

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

    }
}

Neste exemplo, passamos dois parâmetros para o método String.format() : "%d" e age . "%d" é um especificador de formato que indica que a variável que está sendo formatada é um número inteiro. age , que é o segundo parâmetro, será convertido em uma string e armazenado na variável AGE_AS_STRING . Você também pode verificar os tipos de variáveis ​​antes e depois da conversão:

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

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

Como converter um número inteiro em uma string em Java usando DecimalFormat

A classe DecimalFormat é usada para formatar números decimais em Java. Ele pode ser usado de muitas maneiras diferentes, mas por enquanto vamos usá-lo para converter um número inteiro em uma string. Aqui está um exemplo:

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

    }
}

Vejamos este código:

1. Para poder utilizar a classe DecimalFormat em um exemplo específico, nós a importamos: import java.text.DecimalFormat; .
3. Criamos uma variável inteira age .
4. Em seguida, criamos um novo objeto DecimalFormat chamado DFormat .
5. Usando o método format() do objeto , convertemos age em uma string: DFormat.format(age); .

Conclusão

Neste artigo, falamos sobre a conversão de inteiros em strings em Java. Você viu exemplos de código usando três métodos diferentes: Integer.toString() , String.valueOf() , String.format() e a classe DecimalFormat . Cada exemplo mostra o processo de conversão e a verificação do tipo de dados de uma variável antes e depois da conversão.

Classes internas estáticas e não estáticas em Java

Fonte: Médio Com este artigo, você aprenderá as diferenças entre classes internas estáticas e não estáticas em Java. Em Java, as classes internas não estáticas (também conhecidas como classes internas ou objetos internos) têm uma referência implícita a uma instância envolvente da classe externa. Isso significa que eles têm acesso a variáveis ​​de instância e métodos da classe externa e podem ser usados ​​para criar múltiplas instâncias da classe interna que estão associadas a diferentes instâncias da classe externa. Vejamos o seguinte 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

Aqui, a classe Outer possui uma classe interna, Inner , que possui um método printX . E, por sua vez, imprime o valor x da instância Outer circundante . O código cria duas instâncias Outer ( outer1 e outer2 ) e duas instâncias Inner ( inner1 e inner2 ), cada uma associada a uma instância Outer diferente . Quando printX chama inner1 e inner2 , ele imprime o valor x da instância Outer correspondente . Como as classes internas não estáticas têm uma referência implícita à instância circundante, elas requerem memória adicional para armazenar essa referência. Isso significa que elas são menos eficientes em termos de memória do que as classes internas estáticas, que não possuem uma referência implícita à instância envolvente e não requerem memória adicional para esse propósito. Por outro lado, classes internas estáticas não podem acessar variáveis ​​ou métodos de instância de classe externa, portanto seus recursos são limitados. Eles são úteis quando você deseja definir uma classe que está intimamente relacionada a uma classe externa e não precisa de acesso às suas variáveis ​​ou métodos de instância. Classes internas não estáticas (também conhecidas como classes internas ou objetos internos) são úteis quando você deseja definir uma classe que esteja intimamente relacionada a outra classe e tenha acesso às variáveis ​​de instância e aos métodos da classe externa.

Usando classes internas não estáticas

Aqui estão algumas situações em que você pode querer usar uma classe interna não estática:

1. Quando a classe interna precisa acessar variáveis ​​​​de instância ou métodos da classe externa que não são estáticos . Como as classes internas não estáticas têm uma referência implícita à instância circundante da classe externa, elas podem acessar diretamente variáveis ​​e métodos de instância não estáticos.

2. Quando você deseja definir múltiplas instâncias de uma classe interna associadas a diferentes instâncias de uma classe externa. Por exemplo, você pode querer criar uma classe interna não estática Button para a classe Dialog , onde cada instância de Button está associada a outra instância de Dialog e pode acessar variáveis ​​de instância e métodos da instância de Dialog .

3. Quando você deseja definir uma classe que é usada apenas no contexto da classe externa e não se destina a ser usada de forma independente. Classes internas não estáticas só podem ser acessadas a partir da classe externa, portanto são mais encapsuladas e menos suscetíveis ao uso não intencional.

Usando classes internas estáticas

Podemos usar classes internas estáticas se não precisarmos de acesso a nenhuma variável de instância ou método da classe externa e, por esse motivo, elas não precisam ter uma referência implícita à instância circundante da classe externa. Isso os torna mais eficientes em termos de memória do que classes internas não estáticas, que possuem uma referência implícita à instância circundante. Digamos que precisamos projetar um gráfico que contenha trajetórias (arestas) e pontos de interseção (nós). As classes Node e Edge estão intimamente relacionadas à classe Graph e são usadas apenas no contexto de um objeto Graph . Defini-los como classes internas estáticas deixa claro que eles fazem parte da classe Graph e não se destinam a serem usados ​​de forma independente.

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

}

Classes internas estáticas não podem acessar variáveis ​​de instância ou métodos Aqui está um exemplo para ilustrar o fato de que classes internas estáticas não podem acessar variáveis ​​de instância ou métodos de uma classe externa:

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

Neste exemplo, a classe Outer possui uma variável de instância privada x e uma classe interna estática Inner . A classe Inner possui um método printX que tenta acessar o valor x da instância Outer circundante . No entanto, esse código não será compilado porque as classes internas estáticas não podem acessar variáveis ​​ou métodos de instância da classe externa. Para acessar variáveis ​​de instância ou métodos de uma classe externa a partir de uma classe interna estática, você pode:

1. Crie variáveis ​​ou métodos de instância estáticos . Isso permitirá que a classe interna se refira a eles usando o nome da classe externa (por exemplo, Outer.x ).

2. Passe uma instância da classe externa para a classe interna e armazene-a em um campo. A classe interna pode então acessar variáveis ​​de instância ou métodos da classe externa por meio deste campo.

Aqui está um exemplo que mostra como fazer isso:

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

Neste exemplo, a classe Outer possui um método setX não estático que define o valor de x e uma classe interna estática Inner com um campo outer do tipo Outer . A classe Inner possui um construtor que pega uma instância Outer e a armazena no campo externo . O método printX da classe Inner pode então acessar o campo x da instância externa usando a notação outer.x .