Coffee break #190. Bagaimana untuk menukar Integer kepada String. Kelas dalaman statik dan bukan statik di Jawa

Bagaimana untuk menukar Integer kepada String

Sumber: FreeCodeCamp Tutorial ini akan memberitahu anda beberapa cara untuk menukar integer kepada rentetan. Untuk menukar pembolehubah daripada satu jenis data kepada yang lain, bahasa Java menggunakan pelbagai kaedah. Dalam kes menukar Integer kepada String, anda boleh menggunakan salah satu kaedah berikut:

• Menggunakan kaedah Integer.toString() .
• Menggunakan kaedah String.valueOf() .
• Menggunakan kaedah String.format() .
• Menggunakan kelas DecimalFormat .

Bagaimana untuk menukar integer kepada rentetan dalam Java menggunakan Integer.toString()

Kaedah Integer.toString() mengambil integer untuk ditukar sebagai parameter. Contoh sintaks:

Integer.toString(INTEGER_VARIABLE)

Kod sampel:

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

Dalam contoh ini, kami mencipta umur integer dan memberikannya nilai 2 . Untuk menukar pembolehubah umur kepada rentetan, kami menyerahkannya sebagai parameter kepada kaedah Integer.toString(): Integer.toString(age) . Kami kemudiannya menyimpan nilai rentetan baharu ini dalam pembolehubah rentetan yang dipanggil AGE_AS_STRING . Akhir sekali, kami menggabungkan pembolehubah rentetan baharu dengan rentetan lain: "Kanak-kanak itu berumur " + AGE_AS_STRING + " tahun" . Sekarang persoalannya ialah: adakah ralat akan berlaku jika kita hanya menggabungkan pembolehubah umur dengan rentetan lain ini tanpa sebarang penukaran?

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

Output adalah sama seperti dalam contoh di mana kita perlu menukar integer kepada rentetan. Tetapi bagaimana kita tahu jika penukaran jenis benar-benar berfungsi? Untuk melakukan ini, kita boleh menyemak jenis pembolehubah menggunakan objek getClass() . Sesuatu seperti ini:

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

Sekarang kita boleh mengesahkan bahawa apabila pembolehubah umur dicipta , ia adalah Integer , dan selepas penukaran jenis ia menjadi String .

Bagaimana untuk menukar integer kepada rentetan dalam Java menggunakan String.valueOf()

Kaedah String.valueOf() juga mengambil pembolehubah untuk ditukar kepada rentetan sebagai 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
    }
}

Kod di atas adalah serupa dengan kod di bahagian sebelumnya:

1. Kami mencipta integer yang dipanggil umur .
2. Kami melepasi umur integer sebagai parameter kepada kaedah String.valueOf(): String.valueOf(age) .

Kini anda boleh menyemak sama ada penukaran jenis berfungsi menggunakan objek getClass() :

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

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

Bagaimana untuk menukar integer kepada rentetan dalam Java menggunakan String.format()

Kaedah String.format() mengambil dua parameter: penentu format dan pembolehubah yang akan diformatkan. Berikut ialah contoh:

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

    }
}

Dalam contoh ini, kami menghantar dua parameter kepada kaedah String.format() : "%d" dan umur . "%d" ialah penentu format yang menunjukkan bahawa pembolehubah yang diformatkan ialah integer. age , yang merupakan parameter kedua, akan ditukar kepada rentetan dan disimpan dalam pembolehubah AGE_AS_STRING . Anda juga boleh menyemak jenis pembolehubah sebelum dan selepas penukaran:

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

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

Bagaimana untuk menukar integer kepada rentetan dalam Java menggunakan DecimalFormat

Kelas DecimalFormat digunakan untuk memformat nombor perpuluhan dalam Java. Ia boleh digunakan dalam pelbagai cara, tetapi buat masa ini kita akan menggunakannya untuk menukar integer kepada rentetan. Berikut adalah contoh:

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

    }
}

Mari lihat kod ini:

1. Untuk dapat menggunakan kelas DecimalFormat dalam contoh khusus, kami mengimportnya: import java.text.DecimalFormat; .
3. Kami telah mencipta umur pembolehubah integer .
4. Kami kemudian mencipta objek DecimalFormat baharu yang dipanggil DFormat .
5. Menggunakan kaedah format() objek , kami menukar umur kepada rentetan: DFormat.format(age); .

Kesimpulan

Dalam artikel ini, kita bercakap tentang menukar integer kepada rentetan dalam Java. Anda melihat contoh kod menggunakan tiga kaedah berbeza: Integer.toString() , String.valueOf() , String.format() dan kelas DecimalFormat . Setiap contoh menunjukkan proses penukaran dan menyemak jenis data pembolehubah sebelum dan selepas penukaran.

Kelas dalaman statik dan bukan statik di Jawa

Sumber: Sederhana Dengan artikel ini, anda akan mempelajari perbezaan antara kelas dalaman statik dan bukan statik di Jawa. Di Jawa, kelas dalam bukan statik (juga dikenali sebagai kelas dalam atau objek dalam) mempunyai rujukan tersirat kepada contoh tertutup kelas luar. Ini bermakna bahawa mereka mempunyai akses kepada pembolehubah contoh dan kaedah kelas luar dan boleh digunakan untuk mencipta berbilang kejadian kelas dalam yang dikaitkan dengan kejadian kelas luar yang berbeza. Mari lihat kod berikut:

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

Di sini, kelas Outer mempunyai kelas dalam, Inner , yang mempunyai kaedah printX . Dan ia, seterusnya, mencetak nilai x daripada contoh Luar di sekeliling . Kod ini mencipta dua tika Luar ( luar1 dan luar2 ) dan dua tika Dalam ( dalam1 dan dalam2 ), setiap satunya dikaitkan dengan tika Luar yang berbeza . Apabila printX memanggil inner1 dan inner2 , ia mencetak nilai x daripada contoh Luar yang sepadan . Oleh kerana kelas dalam bukan statik mempunyai rujukan tersirat kepada contoh sekeliling, mereka memerlukan memori tambahan untuk menyimpan rujukan ini. Ini bermakna bahawa mereka kurang cekap memori daripada kelas dalaman statik, yang tidak mempunyai rujukan tersirat kepada contoh yang disertakan dan tidak memerlukan memori tambahan untuk tujuan ini. Sebaliknya, kelas dalaman statik tidak boleh mengakses pembolehubah atau kaedah contoh kelas luar, jadi keupayaannya terhad. Ia berguna apabila anda ingin menentukan kelas yang berkait rapat dengan kelas luar dan tidak memerlukan akses kepada pembolehubah contoh atau kaedahnya. Kelas dalam bukan statik (juga dikenali sebagai kelas dalam atau objek dalam) berguna apabila anda ingin menentukan kelas yang berkait rapat dengan kelas lain dan mempunyai akses kepada pembolehubah contoh dan kaedah kelas luar.

Menggunakan kelas dalaman bukan statik

Berikut ialah beberapa situasi di mana anda mungkin mahu menggunakan kelas dalaman bukan statik:

1. Apabila kelas dalam perlu mengakses pembolehubah contoh atau kaedah kelas luar yang tidak statik . Oleh kerana kelas dalam bukan statik mempunyai rujukan tersirat kepada contoh sekeliling kelas luar, mereka boleh terus mengakses pembolehubah dan kaedah contoh bukan statik.

2. Apabila anda ingin menentukan berbilang kejadian kelas dalam yang dikaitkan dengan kejadian kelas luar yang berbeza. Sebagai contoh, anda mungkin ingin mencipta Butang kelas dalam bukan statik untuk kelas Dialog , di mana setiap tika Butang dikaitkan dengan tika Dialog yang lain dan boleh mengakses pembolehubah dan kaedah tika Dialog .

3. Apabila anda ingin menentukan kelas yang hanya digunakan dalam konteks kelas luar dan tidak bertujuan untuk digunakan secara bebas. Kelas dalam bukan statik hanya boleh diakses dari kelas luar, jadi mereka lebih terkapsul dan kurang terdedah kepada penggunaan yang tidak diingini.

Menggunakan Kelas Dalaman Statik

Kita boleh menggunakan kelas dalaman statik jika kita tidak memerlukan akses kepada mana-mana pembolehubah contoh atau kaedah kelas luar, dan atas sebab ini mereka tidak perlu mempunyai rujukan tersirat kepada contoh sekeliling kelas luar. Ini menjadikan mereka lebih cekap ingatan daripada kelas dalaman bukan statik, yang mempunyai rujukan tersirat kepada contoh sekeliling. Katakan kita perlu mereka bentuk graf yang mengandungi trajektori (tepi) dan titik persilangan (nod). Kelas Node dan Edge berkait rapat dengan kelas Graph dan hanya digunakan dalam konteks objek Graph . Mentakrifkannya sebagai kelas dalaman statik menjelaskan bahawa ia adalah sebahagian daripada kelas Graf dan tidak bertujuan untuk digunakan secara bebas.

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

}

Kelas dalaman statik tidak boleh mengakses pembolehubah contoh atau kaedah Berikut ialah contoh untuk menggambarkan fakta bahawa kelas dalaman statik tidak boleh mengakses pembolehubah contoh atau kaedah kelas luar:

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

Dalam contoh ini, kelas Luar mempunyai pembolehubah contoh peribadi x dan kelas dalaman statik Inner . Kelas Dalam mempunyai kaedah printX yang cuba mengakses nilai x daripada contoh Luar sekeliling . Walau bagaimanapun, kod ini tidak akan disusun kerana kelas dalaman statik tidak boleh mengakses pembolehubah atau kaedah contoh kelas luar. Untuk mengakses pembolehubah contoh atau kaedah kelas luar daripada kelas dalaman statik, anda boleh:

1. Cipta pembolehubah atau kaedah contoh statik . Ini akan membolehkan kelas dalam merujuk kepada mereka menggunakan nama kelas luar (cth. Outer.x ).

2. Hantarkan contoh kelas luar kepada kelas dalam dan simpannya dalam medan. Kelas dalam kemudiannya boleh mengakses pembolehubah contoh atau kaedah kelas luar melalui medan ini.

Berikut ialah contoh yang menunjukkan cara melakukan ini:

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

Dalam contoh ini, kelas Outer mempunyai kaedah setX bukan statik yang menetapkan nilai x , dan kelas dalam statik Dalam dengan medan luar jenis Outer . Kelas Dalam mempunyai pembina yang mengambil contoh Luar dan menyimpannya dalam medan luar . Kaedah printX kelas Dalam kemudiannya boleh mengakses medan x contoh luar menggunakan notasi outer.x .