คุณจะเชื่อมต่อสตริงใน Java ได้อย่างไร

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

ในกรณีของภาษาการเขียนโปรแกรม Java สตริงจะอยู่ภายใต้ประเภทข้อมูลที่สำคัญที่สุดประเภทหนึ่งที่เรียกว่าสตริง ใน Java สตริงเป็นออบเจกต์ และมีสองวิธีที่ต่างกันในการต่อเข้าด้วยกัน วิธีหนึ่งคือการใช้ตัวดำเนินการการบวก (+) และอีกวิธีหนึ่งคือการใช้เมธอด concat( ) ของคลาสสตริง

มาดูกันว่าทั้งสองวิธีทำงานอย่างไร:

เชื่อมสตริงในภาษา Java โดยใช้ตัวดำเนินการ +

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

เช่น ถ้าเราเขียนว่า

“นี่คือวิธีเชื่อมสตริงเข้าด้วยกัน” + “ใน Java”

ผลลัพธ์จะเป็น: นี่คือวิธีการเชื่อมสตริงใน Java

ตัวดำเนินการ + ช่วยให้คุณสามารถเชื่อมสตริงที่ต่อเนื่องกันหลายสตริงได้

ข้อดีประการหนึ่งของการเชื่อมโดยใช้ตัวดำเนินการ + คือช่วยให้คุณสามารถเชื่อมสตริงหลาย ๆ สตริงเข้าด้วยกันได้ ตัวอย่างเช่น หากเราต้องการรวม “นี่คือวิธีเชื่อมต่อสตริง” กับ ” ใน Java” และ “มันง่ายมาก!” จากนั้นจำเป็นต้องใส่ตัวดำเนินการ + ระหว่างนิพจน์แต่ละคู่เท่านั้น:

“นี่คือวิธีเชื่อมสตริงเข้าด้วยกัน” + “ใน Java” + “มันง่ายมาก!”

สิ่งนี้จะส่งผลให้เกิดสตริงที่ระบุว่า: นี่คือวิธีเชื่อมสตริงใน Java ง่ายเกินไป!

สามารถใช้ตัวดำเนินการ + ภายใน คำสั่ง println()

ในกรณีที่คุณต้องการพิมพ์ผลลัพธ์ของการเชื่อมสตริงอักขระหลายตัวเข้าด้วยกัน สามารถทำได้ง่ายๆ เพียงใช้ตัวดำเนินการ + ภายในคำสั่งprintln()

ตัวดำเนินการ + ช่วยให้คุณสามารถรวมวัตถุต่าง ๆ ในรูปแบบของสตริง

คุณสมบัติที่สำคัญของตัวดำเนินการ + คือยอมรับตัวแปรที่กำหนดไว้ล่วงหน้าเป็นอาร์กิวเมนต์ เช่นเดียวกับตัวเลขและตัวอักษรสตริง (นิพจน์ที่ยกมา เช่น “Hello world”)

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

ตัวอย่างเช่น โค้ดต่อไปนี้กำหนดออบเจกต์ต่างๆ สองสามออบเจ็กต์ จากนั้นใช้ตัวดำเนินการ + เพื่อเชื่อมออบเจกต์เหล่านั้นให้เป็นสตริงเดียวเพื่อพิมพ์บนหน้าจอ:

ข้อความสตริง 1 = “นี่คือวิธีเชื่อมต่อสตริง”;

ข้อความสตริง 2 = “ออบเจกต์ที่แตกต่างกัน”;

int bnum = 3;

System.out.println (message1 + “จาก “ + numob + message2);

การเรียกใช้รหัสนี้จะพิมพ์ข้อความต่อไปนี้:

นี่คือวิธีการเชื่อมสตริงจากวัตถุ 3 ชิ้นที่แตกต่างกัน

เชื่อมสตริงใน Java โดยใช้เมธอด “concat()” ของคลาส String

ใน Java คลาส สตริงของออบเจกต์ มี เมธอดconcat()ที่ทำหน้าที่คล้ายกับตัวดำเนินการ + กล่าวคือ อนุญาตให้สตริงอักขระหนึ่งตัวเชื่อมต่อกับอีกสตริงหนึ่งได้ อย่างไรก็ตาม มีความแตกต่างพื้นฐานบางประการกับตัวดำเนินการดังกล่าว

วิธี นี้ทำงานโดยเชื่อมอักขระของString ที่สองที่ใช้เป็นอาร์กิวเมนต์กับ String ดั้งเดิม ตัวอย่างเช่น:

ข้อความสตริง 1 = “นี่คือวิธีเชื่อมต่อสตริง”;    // สิ่งนี้สร้างข้อความสตริง1

ข้อความสตริง 2 = “โดยใช้ เมธอด concat ()”;    // สิ่งนี้สร้างข้อความสตริง2

message1 = message1.concat (ข้อความ 2);                // สิ่งนี้เชื่อมข้อความ 1 กับข้อความ 2

System.out.println (ข้อความ1)

ผลลัพธ์ของรหัสนี้คือมันจะถูกพิมพ์บนหน้าจอ:

นี่คือวิธีเชื่อมสตริงโดยใช้เมธอดconcat ()

วิธีการเชื่อมแบบใดที่ดีกว่าใน Java

คำถามทั่วไปเมื่อมีวิธีทำมากกว่า 1 วิธีคือ “วิธีไหนดีกว่ากัน”

โดยทั่วไปแล้ว ตัวดำเนินการ + มีความหลากหลายมากกว่า เมธอด concat () ด้วยเหตุผลหลายประการ:

• ช่วยให้คุณสามารถเชื่อมต่อวัตถุได้ไม่จำกัดจำนวน ในขณะที่วิธีการเชื่อมต่อจะอนุญาตให้คุณเชื่อมวัตถุครั้งละสองชิ้นเท่านั้น
• ช่วยให้คุณสามารถรวมคลาสต่างๆ ของอ็อบเจกต์เป็นสตริงเดียวได้โดยการเรียก เมธอด toString () โดยอัตโนมัติเมื่อตัวแปรหรืออ็อบเจ็กต์ไม่ใช่สตริง ในทางตรงกันข้าม concat สามารถเรียกได้เฉพาะกับวัตถุที่เป็นStringและรับเฉพาะString อื่นเป็น พารามิเตอร์

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