คอฟฟี่เบรค #116. วิธีใช้พอยน์เตอร์ฟังก์ชันใน Java indexOf ใน Java - วิธีค้นหาดัชนีของสตริงใน Java

วิธีใช้พอยน์เตอร์ฟังก์ชันใน Java

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

พอยน์เตอร์ฟังก์ชัน

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

การจำลองตัวชี้ฟังก์ชัน

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

// Wrapping interface
private interface FunctionPointer {
  // Method signatures of pointed method
  void methodSignature(int a);
}

จากนั้นเราจะสร้างวิธีการที่มีลายเซ็นของวิธีการเป้าหมาย

public void method1(int b) {
  System.out.println("Called method1 with integer " + b);
}

public void method2(int v) {
  System.out.println("Called method2 with integer " + v);
}

public void method3(int a) {
  System.out.println("Called method3 with integer " + a);
}

ขั้นตอนต่อไปคือการสร้างตัวแปรอินเทอร์เฟซของ wrapper และกำหนดวิธีการให้กับตัวแปรเหล่านั้น ตัวแปรจะทำหน้าที่เป็นตัวชี้ไปยังฟังก์ชันที่จะจัดเก็บหรือดำเนินการ

// Create a variable of the interface and assign
// the method references
FunctionPointer pointer1 = this::method1;
FunctionPointer pointer2 = this::method2;

// Call both methods using their "pointer"
pointer1.methodSignature(3);
pointer2.methodSignature(2);

// Reassign and call pointer 1
pointer1 = this::method3;

pointer1.methodSignature(5);

การใช้นิพจน์แลมบ์ดา

การอ้างอิงวิธีการสามารถกำหนดได้โดยใช้นิพจน์แลมบ์ดา

// Create a method reference and assign a methods using a lambda.
FunctionPointer pointer1 =
  (a) -> System.out.println("Called pointer1 with int " + a);

FunctionPointer pointer2 =
  (b) -> System.out.println("Called pointer2 with int " + b);

อาร์เรย์ของพอยน์เตอร์ฟังก์ชัน

ฟังก์ชันการทำงานของอาร์เรย์ของการอ้างอิงวิธีการสามารถจำลองได้โดยการสร้างอาร์เรย์อินเทอร์เฟซแบบ wrapper

// Create an array of "pointers"
FunctionPointer[] functionPointersArray = new FunctionPointer[3];

// Assign methods
functionPointersArray[0] = this::method1;
functionPointersArray[1] = this::method2;
functionPointersArray[2] = this::method3;

// Call methods    
functionPointersArray[0].methodSignature(3);
functionPointersArray[1].methodSignature(4);
functionPointersArray[2].methodSignature(5);

ตัวชี้ฟังก์ชันเทียบกับการโทรโดยตรง

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

บทสรุป

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

indexOf ใน Java - วิธีค้นหาดัชนีของสตริงใน Java

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

ไวยากรณ์ของวิธีการindexOf

วิธีการindexOfมีวิธีการดังต่อไปนี้:

public int indexOf(int char)
public int indexOf(int char, int fromIndex)
public int indexOf(String str)
public int indexOf(String str, int fromIndex)

มาอธิบายพารามิเตอร์เหล่านี้กัน:

• ถ่านแสดงถึงหนึ่งอักขระต่อบรรทัด
• fromIndexระบุตำแหน่งที่ควรเริ่มต้นการค้นหาดัชนีของอักขระหรือสตริงย่อย นี่เป็นสิ่งสำคัญเมื่อคุณมีอักขระ/สตริงสองตัวที่มีค่าเหมือนกันในสตริง ด้วยพารามิเตอร์นี้ คุณสามารถบอก วิธี indexOf ได้ ว่าจะเริ่มจากตรงไหน
• strแสดงถึงสตริงย่อยในสตริง

ไม่ต้องกังวลหากคุณยังไม่เข้าใจว่าทั้งหมดทำงานอย่างไร ตัวอย่างต่างๆ จะทำให้ทุกอย่างชัดเจน!

วิธีใช้วิธี indexOf ใน Java

ในตัวอย่างแรก เราจะค้นหาดัชนีของอักขระหนึ่งตัวในสตริง สิ่งนี้จะช่วยให้ เรา เข้าใจ วิธี public int indexOf(int char)

ตัวอย่างวิธีการ IndexOf(int Char)

public class Main {
  public static void main(String[] args) {
    String greetings = "Hello World";
    
    System.out.println(greetings.indexOf("o"));
    
    // 4
  }
}

ในโค้ดด้านบน เราได้ดัชนีของอักขระ “o” กลับมาหาเรา ซึ่งก็คือ 4 เรามีอักขระ “o” สองตัว แต่มีเพียงดัชนีของอักขระตัวแรกเท่านั้นที่ส่งคืน ในตัวอย่างต่อไปนี้ เราจะดูว่าเราจะส่งคืนดัชนีของตัว "o" ตัวที่สองได้อย่างไร หากคุณสงสัยว่าตัวเลขลำดับได้มาอย่างไร คุณจะสังเกตเห็นว่าอักขระตัวแรกในสตริงมีดัชนีเป็นศูนย์ อักขระตัวที่สองมีดัชนีเป็น 1 และอื่นๆ

ตัวอย่างของวิธีการ indexOf(int Char, Int fromIndex)

นี่คือตัวอย่างที่อธิบาย วิธีการ int indexOf(int char, int fromIndex) :

public class Main {
  public static void main(String[] args) {
    String greetings = "Hello World";
    
    System.out.println(greetings.indexOf("o", 5));
    
    // 7
  }
}

ในตัวอย่างด้านบน เราบอก วิธี indexOfให้เริ่มทำงานที่ดัชนีที่ห้า H => ดัชนี 0 e => ดัชนี 1 l => ดัชนี 2 l => ดัชนี 3 0 => ดัชนี 4 โปรดทราบว่าดัชนี 5 ไม่ใช่อักขระ “W” ดัชนีที่ห้าคือช่องว่างระหว่าง "สวัสดี" และ "โลก" ดังนั้นในโค้ดนี้ อักขระอื่นๆ ทั้งหมดที่อยู่ก่อนหน้าดัชนีที่ห้าจะถูกละเว้น 7 จะถูกส่งกลับเป็นดัชนีของอักขระตัวที่สอง "o"

ตัวอย่างของวิธีการInt indexOf(String Str)

ในตัวอย่างต่อไปนี้ เราจะเข้าใจ วิธีการทำงานของpublic int indexOf(String str)ซึ่งส่งคืนดัชนีของสตริงย่อย

public class Main {
  public static void main(String[] args) {
    String motivation = "Coding can be difficult but don't give up";
    
    System.out.println(motivation.indexOf("be"));
    
    // 11
  }
}

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

ตัวอย่างของวิธีการindexOf(String Str, Int fromIndex)

วิธีสุดท้ายคือ public int indexOf(String str , int fromIndex) - เช่นเดียวกับpublic int indexOf(int char, int fromIndex) วิธีการ มันจะส่งกลับดัชนีจากตำแหน่งที่ระบุ

public class Main {
  public static void main(String[] args) {
    String motivation = "The for loop is used for the following";
    
    System.out.println(motivation.indexOf("for", 5));
    
    // 21
  }
}

ในตัวอย่างนี้ เราระบุว่าเมธอดควรเริ่มทำงานที่ดัชนีที่ห้า ซึ่งอยู่หลังสตริงย่อยแรกสำหรับ 21 คือดัชนีของสตริงย่อยที่สองของ for สุดท้ายนี้ เมื่อเราส่งอักขระหรือสตริงย่อยที่ไม่อยู่ในสตริง เมธอด indexOfจะส่งกลับ -1 นี่คือตัวอย่าง:

public class Main {
  public static void main(String[] args) {
    String motivation = "The for loop is used for the following";
    
    System.out.println(motivation.indexOf("code"));
    
    // -1
  }
}

บทสรุป

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