Coffee break #190. Paano i-convert ang Integer sa String. Static at non-static na mga panloob na klase sa Java

Paano i-convert ang Integer sa String

Pinagmulan: FreeCodeCamp Ang tutorial na ito ay magsasabi sa iyo ng ilang paraan upang i-convert ang isang integer sa isang string. Upang i-convert ang mga variable mula sa isang uri ng data patungo sa isa pa, ang wikang Java ay gumagamit ng iba't ibang mga pamamaraan. Sa kaso ng pag-convert ng Integer sa String, maaari mong gamitin ang isa sa mga sumusunod na pamamaraan:

• Gamit ang Integer.toString() method .
• Gamit ang String.valueOf() method .
• Gamit ang String.format() method .
• Gamit ang klase ng DecimalFormat .

Paano i-convert ang isang integer sa isang string sa Java gamit ang Integer.toString()

Ang Integer.toString() na pamamaraan ay tumatagal ng isang integer upang ma-convert bilang isang parameter. Halimbawa ng syntax:

Integer.toString(INTEGER_VARIABLE)

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

Sa halimbawang ito, lumikha kami ng isang integer na edad at itinalaga dito ang halaga 2 . Upang i-convert ang variable ng edad sa isang string, ipinasa namin ito bilang isang parameter sa Integer.toString() method: Integer.toString(age) . Pagkatapos ay inimbak namin ang bagong string value na ito sa isang string variable na tinatawag na AGE_AS_STRING . Sa wakas, pinagsama namin ang bagong string variable sa iba pang mga string: "Ang bata ay " + AGE_AS_STRING + " years old" . Ngayon ang tanong ay: magkakaroon ba ng error kung isasama lang natin ang variable ng edad sa iba pang mga string na ito nang walang anumang 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
    }
}

Ang output ay pareho sa halimbawa kung saan kailangan naming i-convert ang isang integer sa isang string. Ngunit paano natin malalaman kung talagang gumana ang uri ng conversion? Upang gawin ito, maaari naming suriin ang mga uri ng mga variable gamit ang getClass() object . Isang bagay na tulad nito:

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

Ngayon ay maaari nating patunayan na kapag ang variable ng edad ay nilikha , ito ay isang Integer , at pagkatapos ng uri ng conversion ito ay naging isang String .

Paano i-convert ang isang integer sa isang string sa Java gamit ang String.valueOf()

Kinukuha din ng String.valueOf() na pamamaraan ang variable upang ma-convert sa isang string bilang isang 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
    }
}

Ang code sa itaas ay katulad ng code sa nakaraang seksyon:

1. Gumawa kami ng integer na tinatawag na edad .
2. Ipinasa namin ang integer age bilang parameter sa String.valueOf() method: String.valueOf(age) .

Ngayon ay maaari mong suriin kung gumagana ang uri ng conversion gamit ang getClass() object :

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

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

Paano i-convert ang isang integer sa isang string sa Java gamit ang String.format()

Ang String.format() na paraan ay tumatagal ng dalawang parameter: isang format specifier at ang variable na ipo-format. Narito ang isang halimbawa:

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

    }
}

Sa halimbawang ito, nagpasa kami ng dalawang parameter sa String.format() na paraan: "%d" at edad . Ang "%d" ay isang format specifier na nagsasaad na ang variable na pino-format ay isang integer. age , na siyang pangalawang parameter, ay iko-convert sa isang string at iimbak sa AGE_AS_STRING variable . Maaari mo ring suriin ang mga uri ng mga variable bago at pagkatapos ng conversion:

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

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

Paano i-convert ang isang integer sa isang string sa Java gamit ang DecimalFormat

Ang klase ng DecimalFormat ay ginagamit upang i-format ang mga decimal na numero sa Java. Maaari itong magamit sa maraming iba't ibang paraan, ngunit sa ngayon ay gagamitin namin ito upang i-convert ang isang integer sa isang string. Narito ang isang halimbawa:

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

    }
}

Tingnan natin ang code na ito:

1. Upang magamit ang klase ng DecimalFormat sa isang partikular na halimbawa, na-import namin ito: import java.text.DecimalFormat; .
3. Gumawa kami ng integer variable age .
4. Pagkatapos ay gumawa kami ng bagong DecimalFormat object na tinatawag na DFormat .
5. Gamit ang paraan ng format() ng object , na-convert namin ang edad sa isang string: DFormat.format(age); .

Konklusyon

Sa artikulong ito, napag-usapan namin ang tungkol sa pag-convert ng mga integer sa mga string sa Java. Nakakita ka ng mga halimbawa ng code gamit ang tatlong magkakaibang pamamaraan: Integer.toString() , String.valueOf() , String.format() , at ang DecimalFormat class . Ipinapakita ng bawat halimbawa ang proseso ng conversion at pagsuri sa uri ng data ng isang variable bago at pagkatapos ng conversion.

Static at non-static na mga panloob na klase sa Java

Source: Medium Gamit ang artikulong ito, matututunan mo ang mga pagkakaiba sa pagitan ng static at non-static na mga panloob na klase sa Java. Sa Java, ang mga non-static na panloob na klase (kilala rin bilang mga panloob na klase o panloob na mga bagay) ay may implicit na sanggunian sa isang nakapaloob na halimbawa ng panlabas na klase. Nangangahulugan ito na mayroon silang access sa mga variable ng instance at pamamaraan ng panlabas na klase at maaaring magamit upang lumikha ng maraming mga instance ng inner class na nauugnay sa iba't ibang mga instance ng panlabas na klase. Tingnan natin ang sumusunod na 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

Dito, ang Outer class ay may panloob na klase, Inner , na mayroong printX method . At ito naman ay nagpi-print ng value x mula sa nakapalibot na Outer instance . Lumilikha ang code ng dalawang Outer instance ( outer1 at outer2 ) at dalawang Inner instance ( inner1 at inner2 ), bawat isa ay nauugnay sa ibang Outer instance . Kapag tinawag ng printX ang inner1 at inner2 , ini-print nito ang halagang x mula sa kaukulang Outer instance . Dahil ang mga non-static na panloob na klase ay may implicit na reference sa nakapalibot na instance, nangangailangan sila ng karagdagang memory upang maiimbak ang reference na ito. Nangangahulugan ito na ang mga ito ay hindi gaanong mahusay sa memorya kaysa sa mga static na panloob na klase, na walang implicit na sanggunian sa nakapaloob na halimbawa at hindi nangangailangan ng karagdagang memorya para sa layuning ito. Sa kabilang banda, hindi ma-access ng mga static na panloob na klase ang mga variable o pamamaraan ng halimbawa ng panlabas na klase, kaya limitado ang kanilang mga kakayahan. Kapaki-pakinabang ang mga ito kapag gusto mong tukuyin ang isang klase na malapit na nauugnay sa isang panlabas na klase at hindi nangangailangan ng access sa mga variable o pamamaraan ng instance nito. Ang mga non-static na panloob na klase (kilala rin bilang mga panloob na klase o panloob na mga bagay) ay kapaki-pakinabang kapag gusto mong tukuyin ang isang klase na malapit na nauugnay sa isa pang klase at may access sa mga variable ng instance at pamamaraan ng panlabas na klase.

Paggamit ng hindi static na mga panloob na klase

Narito ang ilang sitwasyon kung saan maaaring gusto mong gumamit ng hindi static na panloob na klase:

1. Kapag ang panloob na klase ay kailangang ma-access ang mga variable ng halimbawa o mga pamamaraan ng panlabas na klase na hindi static . Dahil ang mga non-static na inner class ay may implicit na reference sa nakapalibot na instance ng outer class, maaari nilang direktang ma-access ang mga non-static na instance variable at method.

2. Kapag gusto mong tukuyin ang maramihang mga pagkakataon ng isang panloob na klase na nauugnay sa iba't ibang mga pagkakataon ng isang panlabas na klase. Halimbawa, maaaring gusto mong lumikha ng isang hindi static na inner class na Button para sa Dialog class , kung saan ang bawat Button instance ay nauugnay sa isa pang Dialog instance at maaaring ma-access ang mga instance na variable at pamamaraan ng Dialog instance .

3. Kapag gusto mong tukuyin ang isang klase na ginagamit lamang sa konteksto ng panlabas na klase at hindi nilayon na gamitin nang nakapag-iisa. Maa-access lang ang mga hindi static na panloob na klase mula sa panlabas na klase, kaya mas naka-encapsulate ang mga ito at hindi gaanong madaling kapitan sa hindi sinasadyang paggamit.

Paggamit ng Static Inner Classes

Maaari kaming gumamit ng mga static na panloob na klase kung hindi namin kailangan ng access sa anumang mga variable ng instance o pamamaraan ng panlabas na klase, at dahil dito hindi nila kailangang magkaroon ng implicit na reference sa nakapalibot na instance ng outer class. Ginagawa nitong mas mahusay ang memorya kaysa sa mga hindi static na panloob na klase, na may implicit na reference sa nakapalibot na instance. Sabihin nating kailangan nating magdisenyo ng graph na naglalaman ng mga trajectory (mga gilid) at mga intersection point (mga node). Ang mga klase ng Node at Edge ay malapit na nauugnay sa klase ng Graph at ginagamit lamang sa konteksto ng isang object ng Graph . Ang pagtukoy sa mga ito bilang mga static na panloob na klase ay ginagawang malinaw na ang mga ito ay bahagi ng klase ng Graph at hindi nilalayong gamitin nang nakapag-iisa.

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

}

Hindi ma-access ng mga static na panloob na klase ang mga variable o pamamaraan ng instance Narito ang isang halimbawa upang ilarawan ang katotohanang hindi ma-access ng mga static na panloob na klase ang mga variable ng instance o pamamaraan ng isang panlabas na klase:

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

Sa halimbawang ito, ang Outer class ay may pribadong instance variable x at isang static na inner class Inner . Ang Inner class ay may printX na paraan na sumusubok na i-access ang value x mula sa nakapalibot na Outer instance . Gayunpaman, hindi mag-compile ang code na ito dahil hindi ma-access ng mga static na panloob na klase ang mga variable o pamamaraan ng halimbawa ng panlabas na klase. Upang ma-access ang mga variable ng instance o pamamaraan ng isang panlabas na klase mula sa isang static na panloob na klase, maaari mong:

1. Gumawa ng mga static na instance na variable o pamamaraan . Papayagan nito ang panloob na klase na sumangguni sa kanila gamit ang pangalan ng panlabas na klase (hal. Outer.x ).

2. Ipasa ang isang instance ng outer class sa inner class at iimbak ito sa isang field. Pagkatapos ay maa-access ng panloob na klase ang mga variable ng instance o pamamaraan ng panlabas na klase sa pamamagitan ng field na ito.

Narito ang isang halimbawa na nagpapakita kung paano ito gawin:

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

Sa halimbawang ito, ang Outer class ay may non-static na setX method na nagtatakda ng value ng x , at isang static na inner class na Inner na may field na panlabas na uri ng Outer . Ang Inner class ay may constructor na kumukuha ng Outer instance at iniimbak ito sa outer field . Ang paraan ng printX ng Inner class ay maaaring ma-access ang x field ng outer instance gamit ang outer.x notation .