Deep Java

วิธีจัดการการขึ้นบรรทัดใหม่ใน Java: ตัวอักษร Newline, ความแตกต่างของ OS, และ Text Blocks อธิบาย

พื้นฐาน Java
目次

1. บทนำ

ในบรรดาภาษาโปรแกรม, Java ถูกใช้อย่างกว้างขวางตั้งแต่ระบบองค์กรจนถึงแอปพลิเคชัน Android การจัดการการขึ้นบรรทัดใหม่อย่างถูกต้องไม่เพียงสำคัญต่อการปรับปรุงความอ่านง่ายของผลลัพธ์เท่านั้น แต่ยังมีบทบาทสำคัญในการป้องกันบั๊กและหลีกเลี่ยงปัญหาที่ขึ้นกับสภาพแวดล้อม

ในบทความนี้ เราจะอธิบายอย่างละเอียดตั้งแต่วิธีพื้นฐานในการสร้างการขึ้นบรรทัดใหม่ใน Java ไปจนถึงหัวข้อเชิงปฏิบัติเช่นความแตกต่างของรหัสการขึ้นบรรทัดใหม่ระหว่างระบบปฏิบัติการ การจัดการลิเทรัลหลายบรรทัด และข้อผิดพลาดทั่วไปที่ผู้เริ่มต้นมักพบ นอกจากนี้เรายังจะแนะนำไวยากรณ์ใหม่ที่เพิ่มใน Java 15 เป็นต้นไป (Text Blocks) พร้อมตัวอย่างเชิงปฏิบัติ

ในครึ่งหลังของบทความ เราจะครอบคลุมคำถามที่พบบ่อยและวิธีแก้ปัญหาทั่วไปที่มักเกิดขึ้นในสภาพแวดล้อมการพัฒนาจริง บทความนี้ออกแบบให้เป็นแหล่งอ้างอิงแรกที่คุณควรปรึกษาเมื่อไม่แน่ใจเกี่ยวกับการจัดการการขึ้นบรรทัดใหม่ใน Java

เราจะเริ่มด้วยการอธิบายพื้นฐานของการขึ้นบรรทัดใหม่ใน Java ทีละขั้นตอน ดังนั้นกรุณาอ่านต่อจนจบ

2. วิธีพื้นฐานในการแทรกการขึ้นบรรทัดใหม่ใน Java

มีหลายวิธีในการแสดงการขึ้นบรรทัดใหม่ใน Java แต่วิธีที่พื้นฐานที่สุดและใช้บ่อยที่สุดคืออักขระขึ้นบรรทัดใหม่ (\n) และเมธอดการพิมพ์มาตรฐาน System.out.println() ในส่วนนี้ เราจะอธิบายว่าทำงานอย่างไรและความแตกต่างระหว่างกัน

2.1 การใช้อักขระขึ้นบรรทัดใหม่ \n

ใน Java คุณสามารถแทรกการขึ้นบรรทัดใหม่ได้ทุกตำแหน่งโดยใส่ \n (แบ็กสแลช + n) ไว้ในสตริง ตัวอย่างเช่น

System.out.print("First line\nSecond line");

ในกรณีนี้ “First line” และ “Second line” จะถูกแสดงบนบรรทัดแยกกัน ผลลัพธ์จะเป็นดังนี้:

First line
Second line

อักขระ \n มักใช้เป็นรหัสการขึ้นบรรทัดใหม่ในระบบปฏิบัติการแบบ UNIX เช่น Linux และ macOS อย่างไรก็ตาม Windows ปกติใช้ \r\n ดังนั้นจึงสำคัญที่ต้องตระหนักว่าพฤติกรรมการขึ้นบรรทัดใหม่อาจแตกต่างกันตามสภาพแวดล้อม

2.2 ความแตกต่างระหว่าง System.out.println() และ System.out.print()

เมื่อพิมพ์ข้อความไปยังคอนโซลใน Java เมธอดที่ใช้บ่อยที่สุดคือ System.out.print() และ System.out.println() การเข้าใจความแตกต่างระหว่างสองเมธอดนี้อย่างชัดเจนเป็นสิ่งสำคัญ

  • System.out.print() แสดงสตริงตามที่เป็นอยู่โดยไม่เพิ่มการขึ้นบรรทัดใหม่หลังการพิมพ์
    System.out.print("Hello");
System.out.print("World");

ผลลัพธ์:

HelloWorld
  • System.out.println() แสดงสตริงและเพิ่มการขึ้นบรรทัดใหม่โดยอัตโนมัติหลังจากนั้น ตัวอักษร “ln” ย่อมาจาก “line”
    System.out.println("Hello");
System.out.println("World");

ผลลัพธ์:

Hello
World

คุณยังสามารถใช้ System.out.println() โดยไม่มีอาร์กิวเมนต์เพื่อแทรกบรรทัดว่างได้:

System.out.println();

โดยการใช้ \n และ System.out.println() อย่างเหมาะสม คุณสามารถควบคุมการขึ้นบรรทัดใหม่ใน Java ได้อย่างอิสระ

3. รหัสการขึ้นบรรทัดใหม่ตามระบบปฏิบัติการ (Windows / UNIX / Mac)

สิ่งสำคัญที่ต้องจำไว้เมื่อทำงานกับการขึ้นบรรทัดใหม่ใน Java คือรหัสการขึ้นบรรทัดใหม่จะแตกต่างกันตามระบบปฏิบัติการ แม้ว่าความแตกต่างนี้มักถูกมองข้าม แต่ก็อาจทำให้เกิดปัญหาเมื่อเขียนไฟล์หรือเชื่อมต่อกับระบบภายนอก

3.1 รหัสการขึ้นบรรทัดใหม่ที่ใช้โดยแต่ละ OS

รหัสการขึ้นบรรทัดใหม่คือลำดับอักขระพิเศษที่ใช้ในข้อมูลข้อความเพื่อบ่งบอกการเริ่มต้นบรรทัดใหม่ รหัสการขึ้นบรรทัดใหม่หลักที่แต่ละระบบปฏิบัติการใช้มีดังนี้:

  • Windows : \r\n (คาริเอจ รีเทิร์น + ไลน์ ฟีด)
  • UNIX/Linux/macOS (สมัยใหม่) : \n (ไลน์ ฟีดเท่านั้น)
  • Old Mac OS (จนถึง OS 9) : \r (คาริเอจ รีเทิร์นเท่านั้น)

3.2 ทำไมรหัสการขึ้นบรรทัดใหม่จึงแตกต่างตาม OS

เหตุผลที่รหัสการขึ้นบรรทัดใหม่แตกต่างกันตามระบบปฏิบัติการมาจากยุคแรกของการคอมพิวเตอร์ เมื่อแต่ละผู้ผลิตและ OS กำหนดการขึ้นบรรทัดใหม่แตกต่างกัน ความแตกต่างเหล่านี้ได้ถูกสืบทอดมาจนถึงปัจจุบัน

ตัวอย่างเช่น Windows ได้นำสองตัวอักษร—carriage return และ line feed—มาใช้เพื่อเลียนแบบการเคลื่อนไหวเชิงกลของเครื่องพิมพ์ดีด ในทางตรงกันข้าม ระบบที่ใช้ UNIX ได้เลือกแนวทางที่ง่ายกว่า โดยใช้ตัวอักษร line feed เดียว (\n) เพื่อแทนบรรทัดใหม่

3.3 สิ่งที่จะเกิดขึ้นเมื่อคุณใช้ \n ใน Java?

ในกรณีส่วนใหญ่ การใช้ \n ในโปรแกรม Java จะสร้างการขึ้นบรรทัดใหม่ได้อย่างถูกต้อง อย่างไรก็ตาม ปัญหาอาจเกิดขึ้นเมื่อไฟล์ข้อความที่สร้างขึ้นถูกเปิดในแอปพลิเคชันภายนอก เช่น Notepad บน Windows หรือโปรแกรมแก้ไขข้อความบนระบบปฏิบัติการที่แตกต่างกัน

โดยเฉพาะอย่างยิ่ง หากคุณสร้างไฟล์ข้อความโดยใช้เฉพาะ \n บน Windows บรรทัดต่างๆ อาจปรากฏเชื่อมต่อกันเมื่อดูใน Notepad ทำให้ดูเหมือนว่าการขึ้นบรรทัดใหม่ไม่ถูกนำไปใช้

3.4 ข้อพิจารณาเชิงปฏิบัติในการพัฒนาในโลกจริง

  • เมื่อเขียนไฟล์หรือแลกเปลี่ยนข้อมูลข้ามระบบปฏิบัติการ ให้ใส่ใจกับรหัสการขึ้นบรรทัดเสมอ
  • แม้ว่าข้อความจะปรากฏถูกต้องในสภาพแวดล้อมของคุณเอง มันอาจไม่แสดงผลอย่างถูกต้องในสภาพแวดล้อมอื่น
  • เพื่อหลีกเลี่ยงปัญหาเหล่านี้ แนะนำให้ใช้แนวทางที่ไม่ขึ้นกับสภาพแวดล้อม ซึ่งจะอธิบายในส่วนถัดไป

4. วิธีหลีกเลี่ยงปัญหาการขึ้นบรรทัดที่ขึ้นกับสภาพแวดล้อม

ตามที่อธิบายในส่วนก่อนหน้า รหัสการขึ้นบรรทัดแตกต่างกันไปตามระบบปฏิบัติการ ส่งผลให้ผลลัพธ์ข้อความจากโปรแกรม Java อาจไม่ปรากฏตามที่ตั้งใจ โดยเฉพาะอย่างยิ่งเมื่อแลกเปลี่ยนไฟล์ข้อความระหว่างสภาพแวดล้อม OS ที่แตกต่างกัน หรือเมื่อทำงานในสถานการณ์การพัฒนาทีมและการรวมระบบ

4.1 การใช้ System.getProperty("line.separator")

Java มีกลไกในตัวสำหรับดึงรหัสการขึ้นบรรทัดที่เหมาะสมที่สุดสำหรับสภาพแวดล้อมการรันปัจจุบันโดยอัตโนมัติ ซึ่งทำได้โดยใช้ System.getProperty("line.separator")

ตัวอย่าง:

String lineSeparator = System.getProperty("line.separator");
System.out.print("Line 1" + lineSeparator + "Line 2");

เมื่อรันบน Windows โค้ดนี้จะใช้ \r\n บน Linux หรือ macOS มันจะใช้ \n ซึ่งรับประกันว่าการขึ้นบรรทัดจะถูกจัดการอย่างถูกต้องโดยไม่คำนึงถึง OS

4.2 เมธอดการขึ้นบรรทัดใน PrintWriter และ BufferedWriter

เมื่อเขียนไฟล์โดยใช้คลาสเช่น PrintWriter หรือ BufferedWriter เมธอด println() จะใช้รหัสการขึ้นบรรทัดที่เหมาะสมสำหรับสภาพแวดล้อมโดยอัตโนมัติ

PrintWriter pw = new PrintWriter("output.txt");
pw.println("This is the first line.");
pw.println("This is the second line.");
pw.close();

การมอบหมายการจัดการการขึ้นบรรทัดให้กับเมธอดของไลบรารีมาตรฐานเช่นนี้เป็นแนวทางที่ปลอดภัยและปฏิบัติได้จริงบ่อยครั้ง

4.3 สรุป

  • การแทรก \n หรือ \r\n เข้าสตริงด้วยตนเองนั้นเรียบง่าย แต่เพื่อความสามารถในการพกพาและนำกลับมาใช้ใหม่ การใช้ System.getProperty("line.separator") หรือเมธอดการแสดงผลเช่น println() จะปลอดภัยกว่า
  • หากโปรแกรมของคุณอาจรันบนระบบปฏิบัติการหลายตัว ให้เลือกโซลูชันที่ไม่ขึ้นกับสภาพแวดล้อมเสมอ

5. ลิเทอรัลหลายบรรทัดด้วย Text Blocks (Java 15 ขึ้นไป)

เริ่มตั้งแต่ Java 15 มีการแนะนำประเภทลิเทอรัลสตริงใหม่ที่เรียกว่า Text Blocks อย่างเป็นทางการ Text blocks ช่วยให้คุณกำหนดสตริงหลายบรรทัดได้อย่างกระชับและอ่านง่าย ทำให้มีประโยชน์โดยเฉพาะเมื่อจัดการกับข้อความที่จัดรูปแบบหรือหลายบรรทัด

5.1 ไวยากรณ์พื้นฐานของ Text Blocks

Text block ถูกกำหนดโดยการล้อมข้อความด้วยเครื่องหมายคำพูดคู่สามตัว (""")

String text = """
    This is the first line.
    This is the second line.
    This is the third line.
    """;
System.out.println(text);

เมื่อรันโค้ดนี้ ผลลัพธ์จะปรากฏดังนี้:

This is the first line.
This is the second line.
This is the third line.

5.2 คุณสมบัติและข้อควรระวังของ Text Blocks

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

5.3 กรณีการใช้งานจริงของบล็อกข้อความ

บล็อกข้อความมีประโยชน์อย่างมากเมื่อกำหนดเนื้อหาหลายบรรทัดที่มีรูปแบบ เช่น JSON, SQL หรือ HTML โดยตรงในโค้ดต้นฉบับ

ตัวอย่าง: การกำหนดคำสั่ง SQL หลายบรรทัด

String sql = """
    SELECT id, name, email
    FROM users
    WHERE status = 'active'
    ORDER BY id DESC
    """;

ตัวอย่าง: การใช้บล็อกข้อความเป็นเทมเพลต HTML

String html = """
    <html>
      <body>
        <h1>Hello, Java!</h1>
      </body>
    </html>
    """;

5.4 สรุป

  • บล็อกข้อความช่วยให้คุณเขียนสตริงหลายบรรทัดได้อย่างเข้าใจง่ายและอ่านง่าย
  • เนื่องจากการขึ้นบรรทัดใหม่และการเยื้องถูกเก็บไว้ รูปแบบจึงมีโอกาสน้อยที่จะเสียหายในระหว่างการแสดงผลหรือการเขียนไฟล์
  • บล็อกข้อความมีให้ใช้เฉพาะใน Java 15 ขึ้นไป ดังนั้นควรระวังหากคุณใช้เวอร์ชันที่เก่ากว่า

6. หัวข้อขั้นสูง: การรับข้อมูลด้วย Scanner และปัญหา “การบริโภคบรรทัดใหม่”

เมื่อรับข้อมูลจากผู้ใช้ใน Java คลาส Scanner มักใช้สำหรับรับข้อมูลมาตรฐาน อย่างไรก็ตาม จุดที่หลายคนเริ่มต้นมักเจอคือปัญหาที่เรียกว่า “การบริโภคบรรทัดใหม่”

6.1 สถานการณ์ปัญหาที่พบบ่อย

ตัวอย่างเช่น เมื่อรับค่าตัวเลขแล้วตามด้วยการรับสตริง โปรแกรมอาจทำงานไม่คาดคิด

Scanner scanner = new Scanner(System.in);

System.out.print("Please enter your age: ");
int age = scanner.nextInt();

System.out.print("Please enter your name: ");
String name = scanner.nextLine();

System.out.println("Age: " + age + "  Name: " + name);

เมื่อแรกเห็น โค้ดนี้ดูเหมือนถูกต้อง อย่างไรก็ตาม เมื่อรัน โปรแกรมจะข้ามการถามชื่อและดำเนินการต่อโดยไม่ให้ผู้ใช้พิมพ์อะไรเลย

6.2 ทำไมจึงเกิดเช่นนี้

สิ่งนี้เกิดขึ้นเพราะเมธอดรับค่าตัวเลขเช่น nextInt() อ่านเฉพาะตัวเลขเท่านั้นและไม่กินอักขระบรรทัดใหม่ (ปุ่ม Enter) ดังนั้น nextLine() ถัดไปจึงอ่านบรรทัดใหม่ที่เหลืออยู่ทันทีและถือว่าเป็นสตริงว่าง

6.3 วิธีแก้

เพื่อแก้ปัญหานี้ คุณต้องกินบรรทัดใหม่ที่เหลือโดยการเรียก nextLine() เพิ่มเติมหลังจากรับค่าตัวเลข

ตัวอย่างที่แก้ไขแล้ว:

Scanner scanner = new Scanner(System.in);

System.out.print("Please enter your age: ");
int age = scanner.nextInt();
scanner.nextLine();  // Consume the remaining newline

System.out.print("Please enter your name: ");
String name = scanner.nextLine();

System.out.println("Age: " + age + "  Name: " + name);

เมื่อผสมการรับค่าตัวเลข (หรือแบบโทเคน) กับการรับสตริงแบบบรรทัด การปฏิบัติที่ดีที่สุดคือการกินบรรทัดใหม่ที่เหลือเสมอโดยใช้ nextLine()

6.4 สรุป

  • เมื่อใช้ Scanner การผสมการรับค่าตัวเลขหรือโทเคนกับการรับสตริงอาจทำให้เกิดพฤติกรรมที่ไม่คาดคิด
  • ปัญหานี้สามารถหลีกเลี่ยงได้ง่ายโดยการกินบรรทัดใหม่อย่างชัดเจนด้วย nextLine()
  • ควรระมัดระวังการจัดการบรรทัดใหม่เสมอเมื่อผสมวิธีรับข้อมูลต่าง ๆ

7. สรุปการควบคุมการขึ้นบรรทัดและเคล็ดลับ Java ที่ใช้งานได้จริง

จนถึงตอนนี้ เราได้สำรวจวิธีต่าง ๆ ในการจัดการการขึ้นบรรทัดใน Java ในส่วนนี้ เราจะสรุปลักษณะของแต่ละวิธีและให้คำแนะนำที่ใช้งานได้จริงสำหรับการเลือกวิธีที่เหมาะสมในการพัฒนาในโลกจริง

7.1 การเปรียบเทียบวิธีการขึ้นบรรทัด

MethodCharacteristicsTypical UsagePortability
\nSimple and easy to use within strings"Line 1\nLine 2"△ (OS-dependent)
System.out.println()Automatically appends a line break to outputSystem.out.println("Text");◎ (OS-aware)
System.getProperty("line.separator")Retrieves the appropriate line break for the execution environmenttext + System.getProperty("line.separator")◎ (OS-adaptive)
Text Blocks (Java 15+)Clean multi-line literals with indentation support"""Multi-line text"""◎

7.2 แนวทางปฏิบัติ

  • การแสดงผลคอนโซลหรือบันทึกอย่างง่าย: ใช้ System.out.println() เพื่อความอ่านง่ายและความสะดวก
  • การเขียนข้อความลงไฟล์: รวมการแสดงผลกับ System.getProperty("line.separator") เพื่อให้ทำงานถูกต้องบนทุกระบบปฏิบัติการ
  • การจัดการลิเทรลหลายบรรทัดเช่น HTML หรือ SQL: หากใช้ Java 15 หรือใหม่กว่า แนะนำให้ใช้ text blocks อย่างยิ่ง
  • การประมวลผลอินพุตจากผู้ใช้: ให้ใส่ใจการบริโภค newline เมื่อใช้ Scanner

7.3 ความผิดพลาดทั่วไปในการพัฒนา

  • ใช้ \n อย่างเดียวโดยไม่คำนึงถึงความแตกต่างของ OS → ไฟล์ข้อความอาจดูต่อเนื่องเมื่อเปิดในสภาพแวดล้อมอื่น
  • อินพุตว่างที่ไม่คาดคิดกับ Scanner → ควรบริโภค newline หลังจากการรับค่าตัวเลขหรือโทเคนเสมอ
  • ใช้ text blocks บนเวอร์ชัน Java เก่า → text blocks ไม่รองรับก่อน Java 15 และจะทำให้เกิดข้อผิดพลาดในการคอมไพล์

7.4 เคล็ดลับปฏิบัติ

  • เพื่อหลีกเลี่ยงการพึ่งพาสภาพแวดล้อม ควรใช้ System.getProperty("line.separator") หรือ API การแสดงผลเช่น println() อย่างสม่ำเสมอ
  • Text blocks มีประโยชน์อย่างมากสำหรับการสร้างเอกสารและเทมเพลตที่ฝังอยู่
  • เลือกวิธีการทำ line break ตามผู้ใช้โค้ดและสถานที่ที่โค้ดจะทำงาน

8. คำถามที่พบบ่อย (FAQ)

ต่อไปนี้เป็นคำตอบสำหรับคำถามและปัญหาที่พบบ่อยเกี่ยวกับการจัดการ line break ใน Java โดยอิงจากประสบการณ์การพัฒนาจริง

Q1. ควรใช้ \n หรือ \r\n?

ในหลายกรณี การใช้ \n ภายในโปรแกรมก็เพียงพอ อย่างไรก็ตาม เมื่อเขียนไฟล์หรือแลกเปลี่ยนข้อมูลกับระบบอื่น ควรใช้ System.getProperty("line.separator") เพื่อหลีกเลี่ยงปัญหาเฉพาะสภาพแวดล้อม

Q2. ความแตกต่างระหว่าง System.out.println() กับ System.out.print("\n") คืออะไร?

System.out.println() จะเพิ่ม line break ที่เหมาะสมกับสภาพแวดล้อมโดยอัตโนมัติ ในขณะที่ System.out.print("\n") จะใส่ \n เสมอ ซึ่งอาจทำงานไม่ถูกต้องบนระบบปฏิบัติการบางอย่าง สำหรับการเขียนไฟล์ println() มักจะปลอดภัยกว่า

Q3. ฉันกังวลเรื่องการเยื้องหรือ line break เพิ่มเติมใน text blocks ควรทำอย่างไร?

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

Q4. ทำไมการรับสตริงถึงล้มเหลวหลังจากรับค่าตัวเลขเมื่อใช้ Scanner?

สิ่งนี้เกิดขึ้นเพราะเมธอดรับค่าตัวเลขจะทิ้งอักขระ newline ไว้ในบัฟเฟอร์ เมื่ออ่านสตริงต่อไป ให้เรียก scanner.nextLine() หนึ่งครั้งเพื่อบริโภค newline ที่เหลืออยู่

Q5. มีวิธีที่สะอาดในการเขียนสตริงหลายบรรทัดใน Java เวอร์ชันก่อน 15 หรือไม่?

Text blocks ไม่พร้อมใช้งานก่อน Java 15 ในกรณีเช่นนั้น ให้ต่อสตริงด้วย + และใส่ \n ด้วยตนเอง

String text = "Line 1\n"
            + "Line 2\n"
            + "Line 3";

ให้ใส่ใจความอ่านง่ายโดยการแบ่งบรรทัดและเยื้องอย่างเหมาะสม

9. สรุปสุดท้ายและขั้นตอนการเรียนต่อ

ในบทความนี้ เราได้ครอบคลุมเทคนิคและข้อพิจารณาต่าง ๆ สำหรับการจัดการ line break ใน Java ตั้งแต่การใช้งานพื้นฐานจนถึงสถานการณ์ขั้นสูง

แม้ว่า Java จะมีไวยากรณ์ที่เรียบง่าย แต่แม้กระทั่ง line break ก็ต้องจัดการอย่างระมัดระวังขึ้นอยู่กับสภาพแวดล้อมและกรณีการใช้งาน

ประเด็นสำคัญที่ควรจำ:

  • การทำ line break พื้นฐานสามารถจัดการได้ง่ายด้วย \n และ System.out.println()
  • เพื่อหลีกเลี่ยงปัญหาเฉพาะ OS ให้ใช้ System.getProperty("line.separator")
  • ใช้ text blocks ใน Java 15+ เพื่อสร้างลิเทรลหลายบรรทัดอย่างเข้าใจง่าย
  • ระวังการบริโภค newline เมื่อใช้ Scanner

แม้ว่าการจัดการ line break อาจดูเป็นหัวข้อเล็กน้อย แต่การเชี่ยวชาญจะทำให้ได้ โปรแกรมที่พกพาได้, เชื่อถือได้ และ โค้ดที่สะอาดและบำรุงรักษาง่าย.

หากคุณต้องการลึกซึ้งความรู้ Java ต่อไป ควรสำรวจหัวข้อต่อไปนี้:

  • การต่อสตริง, การแยกสตริง, และการจัดรูปแบบ ( String.format , StringBuilder )
  • การเข้ารหัสอักขระและการขึ้นบรรทัดใหม่ใน I/O ของไฟล์
  • การรับส่งข้อมูลมาตรฐานและการจัดการข้อยกเว้น
  • การทำ Internationalization และ Localization ใน Java

เทคนิคเล็ก ๆ และความรู้ที่สั่งสมกันกลายเป็นเครื่องมือที่ทรงพลังในการพัฒนาจริง เราหวังว่าบทความนี้จะช่วยพัฒนาทักษะ Java ของคุณและความเชี่ยวชาญเชิงปฏิบัติ