คอฟฟี่เบรค #190. วิธีแปลงจำนวนเต็มเป็นสตริง คลาสภายในแบบคงที่และไม่คงที่ใน Java

วิธีแปลงจำนวนเต็มเป็นสตริง

ที่มา: FreeCodeCamp บทช่วยสอนนี้จะบอกวิธีการแปลงจำนวนเต็มเป็นสตริงหลายวิธี ในการแปลงตัวแปรจากประเภทข้อมูลหนึ่งไปเป็นอีกประเภทหนึ่ง ภาษา Java จะใช้วิธีการต่างๆ ในกรณีของการแปลงจำนวนเต็มเป็นสตริง คุณสามารถใช้วิธีใดวิธีหนึ่งต่อไปนี้:

• ใช้ เมธอด Integer.toString( )
• การ ใช้ เมธอด String.valueOf( )
• ใช้ เมธอด String.format( )
• การใช้คลาสDecimalFormat

วิธีแปลงจำนวนเต็มเป็นสตริงใน Java โดยใช้ Integer.toString()

Integer.toString()วิธีการใช้จำนวนเต็มในการแปลงเป็นพารามิเตอร์ ไวยากรณ์ตัวอย่าง:

Integer.toString(INTEGER_VARIABLE)

รหัสตัวอย่าง:

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

ในตัวอย่างนี้ เราสร้าง อายุ จำนวนเต็มและกำหนดค่าให้เป็น2 ในการแปลงตัวแปรอายุเป็นสตริง เราได้ส่งตัวแปรดังกล่าวเป็นพารามิเตอร์ไปยังเมธอดInteger.toString(): Integer.toString(age ) จากนั้นเราเก็บ ค่าสตริงใหม่นี้ไว้ในตัวแปรสตริงชื่อAGE_AS_STRING สุดท้าย เราได้รวมตัวแปรสตริงใหม่เข้ากับสตริงอื่นๆ: "The child is " + AGE_AS_STRING + " years old " ตอนนี้คำถามคือ: จะเกิดข้อผิดพลาดหรือไม่หากเราเชื่อม ตัวแปร อายุเข้ากับสตริงอื่นๆ เหล่านี้โดยไม่มีการแปลงใดๆ

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

ผลลัพธ์จะเหมือนกับในตัวอย่างที่เราจำเป็นต้องแปลงจำนวนเต็มเป็นสตริง แต่เราจะรู้ได้อย่างไรว่าการแปลงประเภทใช้งานได้จริงหรือไม่? ในการดำเนินการนี้ เราสามารถตรวจสอบประเภทของตัวแปรได้โดยใช้วัตถุgetClass() บางสิ่งเช่นนี้:

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

ตอนนี้เราสามารถตรวจสอบได้ว่าเมื่อมี การสร้างตัวแปร อายุมันเป็นจำนวนเต็มและหลังจากการแปลงประเภทจะกลายเป็น สตริง

วิธีแปลงจำนวนเต็มเป็นสตริงใน Java โดยใช้ String.valueOf()

เมธอดString.valueOf()ยังใช้ตัวแปรที่จะแปลงเป็นสตริงเป็นพารามิเตอร์

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

รหัสข้างต้นคล้ายกับรหัสในส่วนก่อนหน้า:

1. เราสร้างจำนวนเต็มที่เรียกว่าage
2. เราส่งอายุจำนวนเต็มเป็นพารามิเตอร์ไปยังเมธอด String.valueOf(): String.valueOf(age )

ตอนนี้คุณสามารถตรวจสอบได้ว่าการแปลงประเภททำงานโดยใช้ วัตถุ getClass() หรือไม่ :

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

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

วิธีแปลงจำนวนเต็มเป็นสตริงใน Java โดยใช้ String.format()

เมธอดString.format()รับพารามิเตอร์สองตัว: ตัวระบุรูปแบบและตัวแปรที่จะจัดรูปแบบ นี่คือตัวอย่าง:

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

    }
}

ในตัวอย่าง นี้ เราส่งพารามิเตอร์สองตัว ไปยังเมธอด String.format() : "%d"และage "%d"เป็นตัวระบุรูปแบบที่ระบุว่าตัวแปรที่กำลังจัดรูปแบบเป็นจำนวนเต็ม age ซึ่งเป็นพารามิเตอร์ที่สอง จะถูก แปลงเป็นสตริงและจัดเก็บไว้ใน ตัวแปร AGE_AS_STRING คุณยังสามารถตรวจสอบประเภทของตัวแปรก่อนและหลังการแปลง:

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

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

วิธีแปลงจำนวนเต็มเป็นสตริงใน Java โดยใช้ DecimalFormat

คลาสDecimalFormatใช้ในการจัดรูปแบบตัวเลขทศนิยมใน Java มันสามารถใช้ได้หลายวิธี แต่ตอนนี้เราจะใช้มันเพื่อแปลงจำนวนเต็มให้เป็นสตริง นี่คือตัวอย่าง:

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

    }
}

ลองดูรหัสนี้:

1. เพื่อให้สามารถใช้ คลาส DecimalFormatในตัวอย่างเฉพาะ เราได้นำเข้าคลาสนี้: import java.text.DecimalFormat; .
3. เราได้สร้าง ตัวแปรอายุจำนวนเต็ม
4. จากนั้นเราสร้าง อ อบ เจ็กต์ DecimalFormat ใหม่ ชื่อDFormat
5. ด้วยการใช้เมธอดformat() ของวัตถุ เราแปลงอายุเป็นสตริง: DFormat.format(age); .

บทสรุป

ในบทความนี้ เราได้พูดคุยเกี่ยวกับการแปลงจำนวนเต็มเป็นสตริงใน Java คุณเห็นตัวอย่างโค้ดโดยใช้วิธีที่ แตกต่างกันสามวิธี: Integer.toString() , String.valueOf() , String.format()และ คลาส DecimalFormat แต่ละตัวอย่างจะแสดงกระบวนการแปลงและการตรวจสอบประเภทข้อมูลของตัวแปรก่อนและหลังการแปลง

คลาสภายในแบบคงที่และไม่คงที่ใน Java

ที่มา: ปานกลาง ในบทความนี้ คุณจะได้เรียนรู้ความแตกต่างระหว่างคลาสภายในแบบคงที่และแบบไม่คงที่ใน Java ใน Java คลาสภายในที่ไม่คงที่ (หรือที่เรียกว่าคลาสภายในหรือวัตถุภายใน) มีการอ้างอิงโดยนัยไปยังอินสแตนซ์ที่ล้อมรอบของคลาสภายนอก ซึ่งหมายความว่าพวกเขาสามารถเข้าถึงตัวแปรอินสแตนซ์และวิธีการของคลาสภายนอก และสามารถใช้เพื่อสร้างหลายอินสแตนซ์ของคลาสภายในที่เกี่ยวข้องกับอินสแตนซ์ที่แตกต่างกันของคลาสภายนอก ลองดูรหัสต่อไปนี้:

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

ที่นี่ คลาสOuterมีคลาสภายในInner ซึ่งมี เมธอด printX และในทางกลับกันจะพิมพ์ค่า x จากอินสแตนซ์ภายนอกโดยรอบ โค้ดจะสร้างอินสแตนซ์ภายนอกสองอินส แตนซ์ ( outer1และexternal2 ) และอินส แตนซ์ภายในสองอินสแตนซ์ ( inner1และinner2 ) ซึ่งแต่ละอินสแตนซ์เชื่อมโยงกับ อินสแตนซ์ ภายนอก ที่แตกต่างกัน เมื่อprintXเรียกinner1และinner2มันจะพิมพ์ค่า x จาก อินสแตนซ์ ภายนอก ที่สอดคล้อง กัน เนื่องจากคลาสภายในที่ไม่คงที่มีการอ้างอิงโดยนัยไปยังอินสแตนซ์โดยรอบ จึงจำเป็นต้องมีหน่วยความจำเพิ่มเติมเพื่อจัดเก็บข้อมูลอ้างอิงนี้ ซึ่งหมายความว่ามีประสิทธิภาพหน่วยความจำน้อยกว่าคลาสภายในแบบคงที่ ซึ่งไม่มีการอ้างอิงโดยนัยไปยังอินสแตนซ์ที่ล้อมรอบ และไม่ต้องการหน่วยความจำเพิ่มเติมเพื่อจุดประสงค์นี้ ในทางกลับกัน คลาสภายในแบบคงที่ไม่สามารถเข้าถึงตัวแปรหรือเมธอดอินสแตนซ์ของคลาสภายนอก ดังนั้นความสามารถจึงมีจำกัด มีประโยชน์เมื่อคุณต้องการกำหนดคลาสที่เกี่ยวข้องกับคลาสภายนอกอย่างใกล้ชิด และไม่จำเป็นต้องเข้าถึงตัวแปรหรือเมธอดของอินสแตนซ์ คลาสภายในที่ไม่คงที่ (หรือที่เรียกว่าคลาสภายในหรืออ็อบเจ็กต์ภายใน) มีประโยชน์เมื่อคุณต้องการกำหนดคลาสที่เกี่ยวข้องอย่างใกล้ชิดกับคลาสอื่นและมีสิทธิ์เข้าถึงตัวแปรอินสแตนซ์และวิธีการของคลาสภายนอก

การใช้คลาสภายในที่ไม่คงที่

ต่อไปนี้เป็นบางสถานการณ์ที่คุณอาจต้องการใช้คลาสภายในที่ไม่คงที่:

1. เมื่อคลาสภายในต้องการเข้าถึงตัวแปรอินสแตนซ์หรือวิธีการของคลาสภายนอกที่ไม่คงที่ เนื่องจากคลาสภายในที่ไม่คงที่มีการอ้างอิงโดยนัยไปยังอินสแตนซ์โดยรอบของคลาสภายนอก พวกเขาจึงสามารถเข้าถึงตัวแปรและวิธีการของอินสแตนซ์ที่ไม่คงที่ได้โดยตรง

2. เมื่อคุณต้องการกำหนดหลายอินสแตนซ์ของคลาสภายในที่เชื่อมโยงกับอินสแตนซ์ต่าง ๆ ของคลาสภายนอก ตัวอย่างเช่น คุณอาจต้องการสร้างปุ่ม คลาสภายในที่ไม่คงที่ สำหรับ คลาส Dialogโดยที่ อินสแตน ซ์ Button แต่ละรายการ เชื่อมโยงกับอินส แตนซ์ Dialog อื่น และสามารถเข้าถึงตัวแปรอินสแตนซ์และวิธีการของอินส แตนซ์ Dialog

3. เมื่อคุณต้องการกำหนดคลาสที่จะใช้เฉพาะในบริบทของคลาสภายนอกและไม่ได้มีวัตถุประสงค์เพื่อใช้อย่างอิสระ คลาสภายในที่ไม่คงที่สามารถเข้าถึงได้จากคลาสภายนอกเท่านั้น ดังนั้นจึงมีการห่อหุ้มมากขึ้นและเสี่ยงต่อการใช้งานโดยไม่ได้ตั้งใจน้อยลง

การใช้คลาสภายในแบบคงที่

เราสามารถใช้คลาสภายในแบบคงที่ได้หากเราไม่จำเป็นต้องเข้าถึงตัวแปรอินสแตนซ์หรือวิธีการใดๆ ของคลาสภายนอก และด้วยเหตุนี้ คลาสภายในจึงไม่จำเป็นต้องมีการอ้างอิงโดยนัยไปยังอินสแตนซ์โดยรอบของคลาสภายนอก ซึ่งทำให้หน่วยความจำมีประสิทธิภาพมากกว่าคลาสภายในที่ไม่คงที่ ซึ่งมีการอ้างอิงโดยนัยไปยังอินสแตนซ์โดยรอบ สมมติว่าเราจำเป็นต้องออกแบบกราฟที่มีวิถี (ขอบ) และจุดตัด (โหนด) คลาสNodeและEdgeมีความสัมพันธ์อย่างใกล้ชิดกับ คลาส Graphและใช้ในบริบทของ วัตถุ Graphเท่านั้น การกำหนดให้เป็นคลาสภายในแบบคงที่ทำให้ชัดเจนว่าเป็นส่วนหนึ่งของ คลาส กราฟและไม่ได้ตั้งใจที่จะใช้อย่างอิสระ

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

}

คลาสภายในแบบคงที่ไม่สามารถเข้าถึงตัวแปรอินสแตนซ์หรือวิธีการ นี่คือตัวอย่างที่แสดงให้เห็นถึงความจริงที่ว่าคลาสภายในแบบคงที่ไม่สามารถเข้าถึงตัวแปรอินสแตนซ์หรือวิธีการของคลาสภายนอก:

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

ในตัวอย่างนี้ คลาส ภายนอกมีตัวแปรอินสแตนซ์ส่วนตัวxและคลาสภายในแบบคงที่Inner คลาสInnerมี เมธอด printXที่พยายามเข้าถึงค่าxจากอิน ส แตน ซ์ ภายนอก ที่อยู่โดยรอบ อย่างไรก็ตาม รหัสนี้จะไม่คอมไพล์เนื่องจากคลาสภายในแบบคงที่ไม่สามารถเข้าถึงตัวแปรหรือวิธีการของอินสแตนซ์คลาสภายนอก หากต้องการเข้าถึงตัวแปรอินสแตนซ์หรือเมธอดของคลาสภายนอกจากคลาสภายในแบบคงที่ คุณสามารถ:

1. สร้าง ตัวแปรหรือวิธีการอินสแตนซ์แบบคงที่ สิ่งนี้จะช่วยให้คลาสภายในสามารถอ้างถึงพวกเขาโดยใช้ชื่อคลาสภายนอก (เช่นOuter.x )

2. ส่งต่ออินสแตนซ์ของคลาสภายนอกไปยังคลาสภายในและเก็บไว้ในฟิลด์ คลาสภายในสามารถเข้าถึงตัวแปรอินสแตนซ์หรือวิธีการของคลาสภายนอกผ่านฟิลด์นี้

นี่คือตัวอย่างที่แสดงวิธีการทำเช่นนี้:

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

ในตัวอย่างนี้ คลาสOuter มี เมธอดsetX ที่ไม่คงที่ ซึ่งตั้งค่าเป็นxและคลาสภายในแบบคงที่Inner พร้อมด้วยฟิลด์ด้านนอกประเภทOuter คลาส Inner มีตัวสร้างที่รับอิน สแตน ซ์ภายนอกและเก็บไว้ใน ฟิลด์ ด้านนอก เมธอด printXของคลาสInnerสามารถเข้าถึง ฟิลด์ x ของ อินสแตนซ์ภายนอกได้ โดยใช้ สัญลักษณ์ outer.x