Java String ประกอบด้วย:คำแนะนำทีละขั้นตอน

Java contains() วิธีการตรวจสอบว่าสตริงมีสตริงย่อยอื่นหรือไม่ contains() วิธีการส่งกลับค่า True หรือ False Java contains() ยอมรับหนึ่งพารามิเตอร์:สตริงย่อยเพื่อค้นหาในสตริงของคุณ

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

Java นำเสนอเมธอดในตัวที่ใช้ในการตรวจสอบว่าสตริงมีค่าเฉพาะหรือไม่:มี() กวดวิชานี้จะกล่าวถึงวิธีการใช้สตริงมี () วิธีการตรวจสอบว่าสตริงมีสตริงย่อยในจาวาโดยอ้างอิงถึงตัวอย่าง

จาวาสตริง

ใน Java สตริงใช้เพื่อเก็บข้อมูลแบบข้อความ สตริงคือลำดับของอักขระตั้งแต่ศูนย์ขึ้นไปที่ประกอบด้วยตัวอักษร สัญลักษณ์ ช่องว่าง และตัวเลขได้

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

String phone_number = “+1 000 000 0000”;

ในตัวอย่างนี้ เราได้ประกาศตัวแปรชื่อ phone_number ซึ่งเก็บค่าสตริง สตริงของเราได้รับการกำหนดค่า +1 000 000 0000 .

ตอนนี้เรารู้พื้นฐานของสตริง Java แล้ว เราสามารถพูดถึงวิธีใช้เมธอด contain() ได้

81% ของผู้เข้าร่วมกล่าวว่าพวกเขารู้สึกมั่นใจมากขึ้นเกี่ยวกับโอกาสในการทำงานด้านเทคโนโลยีหลังจากเข้าร่วม bootcamp จับคู่กับ Bootcamp วันนี้

ผู้สำเร็จการศึกษาจากหลักสูตร bootcamp โดยเฉลี่ยใช้เวลาน้อยกว่าหกเดือนในการเปลี่ยนอาชีพ ตั้งแต่เริ่มต้น bootcamp ไปจนถึงหางานแรก

Java String ประกอบด้วย ()

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

เพื่อความกระจ่าง มี() เป็นวิธีการ Java ในตัวที่ตรวจสอบว่าสตริงมีอักขระเฉพาะหรือลำดับของอักขระหรือไม่ นี่คือไวยากรณ์สำหรับสตริงมีเมธอด ():

string_name.contains(substring);

มี () วิธีการยอมรับหนึ่งพารามิเตอร์:ลำดับของอักขระที่คุณต้องการค้นหาในสตริงของคุณ

มี () สามารถส่งคืนค่าที่เป็นไปได้สองค่า หากสตริงที่คุณระบุมีสตริงย่อย เมธอด contain() จะคืนค่าเป็นจริง มิฉะนั้นมี()ส่งกลับเท็จ

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

เพื่อตรวจสอบว่านามสกุลของลูกค้าตรงกับชื่อที่จัดเก็บไว้ในไฟล์หรือไม่ เราสามารถใช้รหัสนี้:

<ก่อน> CheckReservation คลาส { โมฆะคงที่สาธารณะ main (สตริง [] args) { String name_on_file ="Jeff Clinton"; สตริง name_given_to_clerk ="คลินตัน"; if (name_on_file.contains(name_given_to_clerk)) { System.out.println("การจองนี้ได้รับการยืนยันแล้ว"); } อื่น { System.out.println ("ไม่มีการจองนี้"); } }}

เมื่อเรารันโค้ดของเรา การตอบสนองต่อไปนี้จะถูกส่งกลับ:

This reservation is confirmed.

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

ตัวแปรชื่อ name_on_file มีการประกาศ ซึ่งเก็บชื่อเต็มของลูกค้าของเราให้ทางโทรศัพท์เมื่อทำการจอง
name_given_to_clerk ประกาศซึ่งเป็นนามสกุลของลูกค้า
โปรแกรมของเราใช้เมธอด contain() เพื่อตรวจสอบว่าชื่อที่ให้ไว้เมื่อทำการจองตรงกับชื่อที่ให้ไว้กับพนักงานหรือไม่
1. หากชื่อในไฟล์มีนามสกุลที่มอบให้กับพนักงาน This reservation is confirmed. ถูกพิมพ์ไปที่คอนโซล
2. หากชื่อในไฟล์ไม่มีนามสกุลที่มอบให้กับเสมียน This reservation does not exist. ถูกพิมพ์ไปที่คอนโซล

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

ตัวพิมพ์เล็กมี()

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

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

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

ไม่มีการจองนี้

เนื่องจากกรณีของสตริงต่างกัน โปรแกรมของเราจะไม่รู้จักสตริงเหมือนกัน อย่างไรก็ตาม หากเราใช้ toLowerCase() หรือ toUpperCase() เราสามารถแปลงกรณีของทั้งสองสตริงเพื่อให้สอดคล้องกัน

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

<ก่อน> CheckReservation คลาส { โมฆะคงที่สาธารณะหลัก (สตริง [] args) { สตริง name_on_file ="เจฟฟ์ คลินตัน" .toLowerCase (); สตริง name_given_to_clerk ="คลินตัน".toLowerCase(); if (name_on_file.contains(name_given_to_clerk)) { System.out.println("การจองนี้ได้รับการยืนยันแล้ว"); } อื่น { System.out.println ("ไม่มีการจองนี้"); } }}

ในตัวอย่างนี้ เราได้ทำการเปลี่ยนแปลงบางอย่าง อันดับแรก เราได้เปลี่ยนตัวพิมพ์ของชื่อที่กำหนดให้กับเสมียนเป็นตัวพิมพ์เล็กทั้งหมด (ค่าตอนนี้คือ clinton แทนที่จะเป็น Clinton ). ประการที่สอง เราได้ใช้วิธี toLowerCase() เพื่อแปลงตัวแปร name_on_file และ name_given_to_clerk เป็นตัวพิมพ์เล็ก

รหัสของเราส่งคืน:

This reservation is confirmed.

แม้ว่า “name_on_fil . ของเรา และ name_given_to_clerk ตัวแปรใช้กรณีที่แตกต่างกัน วิธีการ toLowerCase() จะแปลงตัวแปรทั้งสองเป็นตัวพิมพ์เล็ก จึงสามารถเปรียบเทียบกันได้

สามารถใช้เมธอด toUpperCase() ในลักษณะเดียวกับที่เราใช้วิธี toLowerCase() ด้านบน เนื่องจากช่วยให้เปรียบเทียบระหว่างสองสตริงเท่ากันได้

หากคุณสนใจที่จะเรียนรู้เพิ่มเติมเกี่ยวกับวิธีการ toUpperCase() และ toLowerCase() โปรดอ่านเกี่ยวกับวิธีเหล่านี้ในบทแนะนำเกี่ยวกับวิธีการเหล่านั้นที่นี่

บทสรุป

สตริงมีเมธอด () ใช้ใน Java เพื่อตรวจสอบว่าสตริงมีสตริงย่อยเฉพาะหรือไม่

บทช่วยสอนนี้กล่าวถึงวิธีใช้เมธอด contain() ใน Java พร้อมกับตัวอย่างบางส่วนเพื่อช่วยคุณ นอกจากนี้ เราได้กล่าวถึงวิธีการใช้เมธอด toUpperCase() และ toLowerCase() เพื่อตรวจสอบตัวพิมพ์เล็กและตัวพิมพ์ใหญ่โดยใช้ contain()

ตอนนี้คุณพร้อมที่จะเริ่มใช้เมธอดสตริง Java แบบมี () อย่างผู้เชี่ยวชาญแล้ว!