Coffee break #116. Paano gamitin ang mga function pointer sa Java. indexOf sa Java - Paano hanapin ang index ng isang string sa Java

Paano gamitin ang mga function pointer sa Java

Pinagmulan: Ang Dev.to Pointers ay mga bagay na nag-iimbak ng memory address at maaaring mag-save ng memory sa pamamagitan ng direktang pagturo sa isang target na object, array, o variable na address sa halip na ipasa sa halaga. Sa kasamaang palad, walang "tunay" na konsepto ng mga pointer sa Java. Ngunit sa kabutihang-palad para sa amin, mayroong isang workaround gamit ang mga sanggunian ng pamamaraan na malapit sa tunay na bagay.

Mga payo ng function

Ang function pointer ay isang pointer na tumuturo sa address ng isang function. Kasama sa ilang kaso ng paggamit ang paggawa ng callback routine sa pamamagitan ng paggawa ng function na tumatawag sa isa pang function batay sa execution nito, o pag-iimbak ng array ng mga function pointer para sa dynamic na tinatawag na mga pamamaraan (halimbawa, pag-iimbak ng mga tagubilin ng processor para sa isang emulator).

Function pointer simulation

Mayroong apat na uri ng mga sanggunian sa pamamaraan . Gumagamit kami ng isang uri na tumutukoy sa isang paraan ng halimbawa ng isang partikular na bagay. Magsimula tayo sa pamamagitan ng pagtukoy sa isang interface na tumutukoy sa mga lagda ng mga pamamaraan na iyong itinuturo.

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

Pagkatapos ay gagawa kami ng mga pamamaraan na may lagda ng target na paraan.

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);
}

Ang susunod na hakbang ay lumikha ng mga variable ng interface ng wrapper at magtalaga ng mga pamamaraan sa kanila. Ang mga variable ay magsisilbing pointer sa function na iimbak o isasagawa.

// 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);

Paggamit ng Lambda Expressions

Ang mga sanggunian ng pamamaraan ay maaaring italaga gamit ang mga expression ng lambda.

// 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);

Array ng mga function pointer

Maaaring tularan ang functionality ng isang array ng method reference sa pamamagitan ng paggawa ng wrapper interface array.

// 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);

Function pointer kumpara sa direktang tawag

Kung ihahambing mo ang parehong mga opsyon, ang direktang pagtawag sa isang paraan ay halos 5 beses na mas mabilis kaysa sa paggamit ng isang sanggunian ng pamamaraan. Ang lahat ng ito ay dahil sa dagdag na hakbang ng pagtawag ng lambda expression kumpara sa isang nakaimbak na paraan. Ngunit malamang na hindi mo mapapansin ang anumang pagkawala ng pagganap sa isang taon, kaya huwag mag-alala tungkol dito.

Konklusyon

Ang mga pointer ay mga variable na direktang tumuturo sa address ng isang bagay sa halip na isang halaga. Direktang tumuturo ang function pointer sa function address, na maaaring mabawasan ang pagkonsumo ng memorya. Walang mga pointer ang Java, ngunit maaaring tularan ang pag-uugali gamit ang mga sanggunian ng pamamaraan o mga expression ng lambda. Ang paggamit ng sanggunian ng pamamaraan ay mas mabagal kaysa sa direktang pagtawag sa isang pamamaraan, ngunit hindi nito pinipigilan ang paggamit nito.

indexOf sa Java - Paano hanapin ang index ng isang string sa Java

Pinagmulan: FreeCodeCamp Ang string ay isang set ng mga character na nakapaloob sa double quotes. Ibinabalik ng indexOf method ang posisyon ng index ng tinukoy na character o substring sa isang string. Sa artikulong ito, malalaman natin ang tungkol sa syntax ng iba't ibang paraan ng indexOf . Titingnan din namin ang mga halimbawa na makakatulong sa iyong maunawaan at epektibong gamitin ang paghahanap para sa index ng isang character o substring sa Java code.

Syntax ng indexOf method

Ang indexOf method ay may mga sumusunod na pamamaraan:

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

Ipaliwanag natin ang mga parameter na ito:

• char ay kumakatawan sa isang character bawat linya.
• Tinutukoy ng fromIndex ang posisyon kung saan dapat magsimula ang paghahanap para sa index ng isang character o substring. Mahalaga ito kapag mayroon kang dalawang character/string na may parehong halaga sa isang string. Sa parameter na ito maaari mong sabihin ang indexOf method kung saan magsisimula.
• Ang str ay kumakatawan sa isang substring sa isang string.

Huwag mag-alala kung hindi mo pa naiintindihan kung paano gumagana ang lahat—ang mga halimbawa ay gagawing malinaw ang lahat!

Paano gamitin ang indexOf method sa Java

Sa unang halimbawa ay makikita natin ang index ng isang character sa isang string. Makakatulong ito sa amin na maunawaan ang public int indexOf(int char) method .

Halimbawa ng paraan ng IndexOf(int Char).

public class Main {
  public static void main(String[] args) {
    String greetings = "Hello World";

    System.out.println(greetings.indexOf("o"));

    // 4
  }
}

Sa code sa itaas, nakuha namin ang index ng character na "o" na ibinalik sa amin, na 4. Mayroon kaming dalawang character na "o", ngunit ang index lamang ng una ang ibinalik. Sa sumusunod na halimbawa ay makikita natin kung paano natin maibabalik ang index ng pangalawang "o". Kung nagtataka ka kung paano nakuha ang mga sequence number, mapapansin mo na ang unang character sa isang string ay may index na zero, ang pangalawang character ay may index ng isa, at iba pa.

Halimbawa ng paraan ng indexOf(int Char, Int fromIndex).

Narito ang isang halimbawa na nagpapaliwanag ng int indexOf(int char, int fromIndex) na paraan :

public class Main {
  public static void main(String[] args) {
    String greetings = "Hello World";

    System.out.println(greetings.indexOf("o", 5));

    // 7
  }
}

Sa halimbawa sa itaas, sinasabi namin ang indexOf method na magsimulang magtrabaho sa ikalimang index. H => index 0 e => index 1 l => index 2 l => index 3 0 => index 4 Tandaan na ang index 5 ay hindi isang character na "W". Ang ikalimang index ay ang espasyo sa pagitan ng "Hello" at "World". Kaya, sa code na ito, ang lahat ng iba pang mga character na nauuna sa ikalimang index ay hindi papansinin. 7 ay ibinalik bilang index ng pangalawang character na "o".

Halimbawa ng pamamaraang Int indexOf(String Str).

Sa sumusunod na halimbawa, mauunawaan natin kung paano gumagana ang public int indexOf(String str) method , na nagbabalik ng index ng isang substring.

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
  }
}

Nagtataka ako kung paano kami nakabalik ng 11? Dapat mong suriin ang huling seksyon upang maunawaan kung paano binibilang ang mga index at kung paano itinuturing na mga indeks din ang mga puwang sa pagitan ng mga substring. Tandaan na kapag ang isang substring ay ipinasa bilang isang parameter, ang ibinalik na index ay ang index ng unang character sa substring. Ang 11 ay ang index ng character na "b".

Halimbawa ng paraan ng indexOf(String Str, Int fromIndex).

Ang huling paraan ay public int indexOf(String str, int fromIndex) - kapareho ng public int indexOf(int char, int fromIndex) method . Ibinabalik nito ang index mula sa tinukoy na posisyon.

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
  }
}

Sa halimbawang ito, tinukoy namin na ang pamamaraan ay dapat magsimula sa trabaho nito sa ikalimang index, na darating pagkatapos ng unang substring para sa. Ang 21 ay ang index ng pangalawang substring ng para sa. Sa wakas, kapag nagpasa kami ng character o substring na wala sa string, ang indexOf method ay magbabalik -1. Narito ang isang halimbawa:

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
  }
}

Konklusyon

Sa artikulong ito, natutunan namin kung paano gamitin ang apat na paraan ng indexOf , na may malinaw na mga halimbawa. Nakita rin namin kung ano ang hitsura ng syntax para sa bawat isa sa mga pamamaraang ito at kung paano nila sinasabing bumalik ang index. Bilang karagdagan, nalaman namin kung ano ang mangyayari kapag ang isang hindi umiiral na character o substring ay ipinasa bilang isang parameter.