Java Academy · บทเรียน

Autoboxing และ Unboxing

กฎการแปลงโดยอัตโนมัติ

Autoboxing และ Unboxing เป็นบทเรียน Java Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Java Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Java Academy มีบทเรียนทั้งหมด 4 บทเรียน

การแปลงอัตโนมัติ

การห่อหุ้มอัตโนมัติ คือการที่ Java แปลงชนิดข้อมูลพื้นฐานเป็นออบเจ็กต์คลาสห่อหุ้มให้โดยอัตโนมัติ ส่วนการแกะห่อหุ้มอัตโนมัติคือการแปลงย้อนกลับจากคลาสห่อหุ้มเป็นชนิดข้อมูลพื้นฐาน

กระบวนการนี้เกิดขึ้นอย่างเงียบ ๆ ทำให้คุณผสมผสานทั้งสองรูปแบบได้โดยไม่ต้องเรียกใช้เมธอดแปลงค่าด้วยตนเอง

การห่อหุ้มขณะทำงาน

การกำหนดค่า int ให้กับตัวแปร Integer จะเรียกใช้การห่อหุ้มอัตโนมัติ คอมไพเลอร์จะแทรกการเรียก Integer.valueOf ให้คุณ

public class Main {
    public static void main(String[] args) {
        int primitive = 42;
        Integer boxed = primitive;
        System.out.println(boxed);
    }
}

การแกะห่อหุ้มขณะทำงาน

การกำหนดค่า Integer ให้กับ int จะเรียกใช้การแกะห่อหุ้มอัตโนมัติ คอมไพเลอร์จะแทรกการเรียก intValue ให้เบื้องหลัง

public class Main {
    public static void main(String[] args) {
        Integer boxed = 99;
        int primitive = boxed;
        System.out.println(primitive);
    }
}

การห่อหุ้มในคอลเลกชัน

จุดที่พบการห่อหุ้มอัตโนมัติบ่อยที่สุดคือการเพิ่มชนิดข้อมูลพื้นฐานลงในคอลเลกชัน คุณเขียน list.add(5) แล้ว Java จะห่อหุ้มค่า 5 เป็น Integer ให้โดยอัตโนมัติ

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>();
        nums.add(1);
        nums.add(2);
        int first = nums.get(0);
        System.out.println(first);
    }
}

การคำนวณทำให้เกิดการแกะห่อหุ้ม

เมื่อคุณใช้ตัวดำเนินการทางคณิตศาสตร์กับออบเจ็กต์คลาสห่อหุ้ม Java จะแกะห่อหุ้มเป็นชนิดข้อมูลพื้นฐานก่อน คำนวณ แล้วจึงอาจห่อหุ้มผลลัพธ์กลับอีกครั้ง

ด้านล่าง ค่า Integer สองค่าถูกนำมาบวกโดยแกะห่อหุ้มทั้งสองค่าก่อน

public class Main {
    public static void main(String[] args) {
        Integer a = 10;
        Integer b = 32;
        int sum = a + b;
        System.out.println(sum);
    }
}

การผสมชนิดข้อมูลพื้นฐานกับคลาสห่อหุ้ม

คุณสามารถผสมชนิดข้อมูลพื้นฐานกับคลาสห่อหุ้มในนิพจน์ได้อย่างอิสระ Java จะแกะห่อหุ้มคลาสห่อหุ้มเพื่อให้ทั้งสองฝั่งเป็นชนิดข้อมูลพื้นฐานระหว่างการคำนวณ

public class Main {
    public static void main(String[] args) {
        Integer wrapped = 7;
        int raw = 3;
        int product = wrapped * raw;
        System.out.println(product);
    }
}

การห่อหุ้มในการเรียกเมธอด

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

public class Main {
    static void show(Object value) {
        System.out.println("Got: " + value);
    }

    public static void main(String[] args) {
        show(123);
        show(true);
    }
}

ต้นทุนที่ซ่อนอยู่

การห่อหุ้มอัตโนมัติสะดวก แต่ไม่ได้ไม่มีต้นทุน การห่อหุ้มแต่ละครั้งจะสร้างออบเจ็กต์หนึ่งตัว และลูปที่ทำงานซ้ำอย่างเข้มข้นอาจสร้างออบเจ็กต์อายุสั้นหลายล้านตัว

สำหรับลูปตัวเลขที่ต้องการประสิทธิภาพสูง ให้ทำงานกับชนิดข้อมูลพื้นฐานโดยตรงแทนการใช้คลาสห่อหุ้ม

public class Main {
    public static void main(String[] args) {
        long total = 0;
        for (int i = 0; i < 5; i++) {
            total += i;
        }
        System.out.println(total);
    }
}

valueOf เทียบกับการสร้างใหม่

การห่อหุ้มอัตโนมัติใช้ Integer.valueOf ซึ่งเก็บค่าขนาดเล็กระหว่าง -128 ถึง 127 ไว้ในแคช การเรียก new Integer(...) จะสร้างออบเจ็กต์ใหม่เสมอ และปัจจุบันไม่แนะนำให้ใช้แล้ว

ควรปล่อยให้การห่อหุ้มอัตโนมัติทำงานของมันเอง

public class Main {
    public static void main(String[] args) {
        Integer cached = Integer.valueOf(50);
        System.out.println(cached);
    }
}

นิพจน์เงื่อนไขสามทางและการห่อหุ้ม

มีกฎหนึ่งที่ควรสังเกต: ในนิพจน์เงื่อนไขสามทาง หากแขนงหนึ่งเป็นชนิดข้อมูลพื้นฐานและอีกแขนงเป็นคลาสห่อหุ้ม Java อาจแกะห่อหุ้มทั้งสองค่าให้เป็นชนิดข้อมูลพื้นฐานร่วมกัน

โดยทั่วไปจะปลอดภัย แต่ควรตระหนักว่ากระบวนการนี้อาจทำให้เกิดการแปลงค่าที่คุณไม่คาดคิด

public class Main {
    public static void main(String[] args) {
        boolean flag = true;
        Integer result = flag ? 1 : 2;
        System.out.println(result);
    }
}

กรณีที่มีประโยชน์

การห่อหุ้มอัตโนมัติมีไว้เพื่อทำให้โค้ดอ่านเข้าใจง่ายเมื่อต้องผสมชนิดข้อมูลพื้นฐานกับชนิดข้อมูลทั่วไปและคอลเลกชัน หากใช้อย่างเหมาะสมจะช่วยลดความยุ่งยาก แต่หากใช้โดยไม่ระวังในลูปที่ทำงานบ่อย จะทำให้ประสิทธิภาพลดลง

ตรวจสอบความเข้าใจสั้น ๆ

ตรวจสอบความเข้าใจของคุณเกี่ยวกับกฎการห่อหุ้มอัตโนมัติ

ทบทวน

คุณได้เรียนรู้วิธีทำงานของการห่อหุ้มและการแกะห่อหุ้มอัตโนมัติ

การห่อหุ้มอัตโนมัติเปลี่ยนชนิดข้อมูลพื้นฐานเป็นคลาสห่อหุ้มโดยใช้ valueOf
การแกะห่อหุ้มอัตโนมัติเปลี่ยนคลาสห่อหุ้มกลับเป็นชนิดข้อมูลพื้นฐานโดยใช้เมธอด เช่น intValue
กระบวนการนี้เกิดขึ้นในการกำหนดค่า คอลเลกชัน การคำนวณ และการเรียกเมธอด
กระบวนการนี้สะดวกแต่สร้างออบเจ็กต์ จึงควรหลีกเลี่ยงในลูปที่ทำงานบ่อย

คำถามที่พบบ่อย

บทเรียน “Autoboxing และ Unboxing” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “Autoboxing และ Unboxing” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Java Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Java Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “Autoboxing และ Unboxing”

กฎการแปลงโดยอัตโนมัติ คุณปฏิบัติ Java Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Java Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Java Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน

บทเรียน “Autoboxing และ Unboxing” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Java Academy นี้ได้ไหม

ได้ บทเรียน Java Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Java Academy