Coffee break #190. How to convert Integer to String. Static and non-static inner classes in Java

How to convert Integer to String

Source: FreeCodeCamp This tutorial will tell you several ways to convert an integer to a string. Coffee break #190. How to convert Integer to String. Static and non-static inner classes in Java - 1

To convert variables from one data type to another, the Java language uses various methods. In the case of converting Integer to String, you can use one of the following methods:

Using the Integer.toString() method .
Using the String.valueOf() method .
Using the String.format() method .
Using the DecimalFormat class .

How to convert an integer to a string in Java using Integer.toString()

The Integer.toString() method takes an integer to convert as a parameter. Example syntax:

Integer.toString(INTEGER_VARIABLE)

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

In this example, we created an integer age and assigned it the value 2 . To convert the age variable to a string, we passed it as a parameter to the Integer.toString() method: Integer.toString(age) . We then stored this new string value in a string variable called AGE_AS_STRING . Finally, we combined the new string variable with other strings: "The child is " + AGE_AS_STRING + " years old" . Now the question is: will an error occur if we just concatenate the age variable with these other strings without any 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
    }
}

The output is the same as in the example where we needed to convert an integer to a string. But how do we know if the type conversion actually worked? To do this, we can check the types of variables using the getClass() object . Something like this:

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

Now we can verify that when the age variable was created , it was an Integer , and after the type conversion it became a String .

How to convert an integer to a string in Java using String.valueOf()

The String.valueOf() method also takes the variable to be converted to a string as a parameter.

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

The above code is similar to the code in the previous section:

We created an integer called age .
We passed the integer age as a parameter to the String.valueOf() method: String.valueOf(age) .

Now you can check if the type conversion works using the getClass() object :

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

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

How to convert an integer to a string in Java using String.format()

The String.format() method takes two parameters: a format specifier and the variable to be formatted. Here's an example:

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 this example, we passed two parameters to the String.format() method: "%d" and age . "%d" is a format specifier indicating that the variable being formatted is an integer. age , which is the second parameter, will be converted to a string and stored in the AGE_AS_STRING variable . You can also check the types of variables before and after conversion:

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

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

How to convert an integer to a string in Java using DecimalFormat

The DecimalFormat class is used to format decimal numbers in Java. It can be used in many different ways, but for now we will use it to convert an integer to a string. Here is an example:

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

    }
}

Let's look at this code:

To be able to use the DecimalFormat class in a specific example, we imported it: import java.text.DecimalFormat; .
We have created an integer variable age .
We then created a new DecimalFormat object called DFormat .
Using the object's format() method , we converted age to a string: DFormat.format(age); .

Conclusion

In this article, we talked about converting integers to strings in Java. You saw code examples using three different methods: Integer.toString() , String.valueOf() , String.format() , and the DecimalFormat class . Each example shows the conversion process and checking the data type of a variable before and after conversion.

Static and non-static inner classes in Java

Source: Medium With this article, you will learn the differences between static and non-static inner classes in Java. In Java, non-static inner classes (also known as inner classes or inner objects) have an implicit reference to an enclosing instance of the outer class. This means that they have access to instance variables and methods of the outer class and can be used to create multiple instances of the inner class that are associated with different instances of the outer class. Let's look at the following code:

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

Here, the Outer class has an inner class, Inner , which has a printX method . And it, in turn, prints the value x from the surrounding Outer instance . The code creates two Outer instances ( outer1 and outer2 ) and two Inner instances ( inner1 and inner2 ), each associated with a different Outer instance . When printX calls inner1 and inner2 , it prints the value x from the corresponding Outer instance . Because non-static inner classes have an implicit reference to the surrounding instance, they require additional memory to store this reference. This means that they are less memory efficient than static inner classes, which do not have an implicit reference to the enclosing instance and do not require additional memory for this purpose. On the other hand, static inner classes cannot access outer class instance variables or methods, so their capabilities are limited. They are useful when you want to define a class that is closely related to an outer class and does not need access to its instance variables or methods. Non-static inner classes (also known as inner classes or inner objects) are useful when you want to define a class that is closely related to another class and has access to the instance variables and methods of the outer class.

Using non-static inner classes

Here are a few situations where you might want to use a non-static inner class:

When the inner class needs to access instance variables or methods of the outer class that are not static . Because non-static inner classes have an implicit reference to the surrounding instance of the outer class, they can directly access non-static instance variables and methods.
When you want to define multiple instances of an inner class associated with different instances of an outer class. For example, you might want to create a non-static inner class Button for the Dialog class , where each Button instance is associated with another Dialog instance and can access instance variables and methods of the Dialog instance .
When you want to define a class that is only used in the context of the outer class and is not intended to be used independently. Non-static inner classes can only be accessed from the outer class, so they are more encapsulated and less susceptible to unintended use.

Using Static Inner Classes

We can use static inner classes if we do not need access to any instance variables or methods of the outer class, and for this reason they do not need to have an implicit reference to the surrounding instance of the outer class. This makes them more memory efficient than non-static inner classes, which have an implicit reference to the surrounding instance. Let's say we need to design a graph that contains trajectories (edges) and intersection points (nodes). The Node and Edge classes are closely related to the Graph class and are used only in the context of a Graph object . Defining them as static inner classes makes it clear that they are part of the Graph class and are not intended to be used independently.

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

}

Static inner classes cannot access instance variables or methods Here is an example to illustrate the fact that static inner classes cannot access instance variables or methods of an outer class:

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

In this example, the Outer class has a private instance variable x and a static inner class Inner . The Inner class has a printX method that attempts to access the value x from the surrounding Outer instance . However, this code will not compile because static inner classes cannot access outer class instance variables or methods. To access instance variables or methods of an outer class from a static inner class, you can:

Create static instance variables or methods . This will allow the inner class to refer to them using the outer class name (eg Outer.x ).
Pass an instance of the outer class to the inner class and store it in a field. The inner class can then access instance variables or methods of the outer class through this field.

Here's an example that shows how to do this:

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 this example, the Outer class has a non-static setX method that sets the value of x , and a static inner class Inner with a field outer of type Outer . The Inner class has a constructor that takes an Outer instance and stores it in the outer field . The Inner class's printX method can then access the x field of the outer instance using outer.x notation .