Pausa caffè #116. Come utilizzare i puntatori a funzione in Java. indexOf in Java - Come trovare l'indice di una stringa in Java

Come utilizzare i puntatori a funzione in Java

Origine: i puntatori Dev.to sono oggetti che memorizzano un indirizzo di memoria e possono risparmiare memoria puntando direttamente a un oggetto, un array o un indirizzo di variabile di destinazione invece di passare per valore. Sfortunatamente, in Java non esiste un concetto “reale” di puntatori. Ma fortunatamente per noi, esiste una soluzione alternativa che utilizza riferimenti al metodo che è vicino alla realtà.

Puntatori di funzioni

Un puntatore a funzione è un puntatore che punta all'indirizzo di una funzione. Alcuni casi d'uso includono la creazione di una routine di callback creando una funzione che chiama un'altra funzione in base alla sua esecuzione o la memorizzazione di un array di puntatori a funzione per metodi chiamati dinamicamente (ad esempio, la memorizzazione di istruzioni del processore per un emulatore).

Simulazione del puntatore di funzione

Esistono quattro tipi di riferimenti al metodo . Usiamo un tipo che fa riferimento a un metodo di istanza di un oggetto specifico. Iniziamo definendo un'interfaccia che definisca le firme dei metodi a cui punti.

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

Quindi creeremo metodi con la firma del metodo di destinazione.

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

Il passaggio successivo consiste nel creare variabili dell'interfaccia wrapper e assegnare loro dei metodi. Le variabili fungeranno da puntatore alla funzione da memorizzare o eseguire.

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

Utilizzo delle espressioni Lambda

I riferimenti ai metodi possono essere assegnati utilizzando espressioni 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);

Matrice di puntatori a funzioni

La funzionalità di un array di riferimenti a metodi può essere emulata creando un array di interfaccia 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);

Puntatore a funzione vs chiamata diretta

Se si confrontano entrambe le opzioni, chiamare direttamente un metodo è quasi 5 volte più veloce rispetto all'utilizzo di un riferimento al metodo. Tutto ciò è dovuto al passaggio aggiuntivo di chiamata di un'espressione lambda rispetto a un metodo memorizzato. Ma probabilmente non noterai alcuna perdita di prestazioni in un anno, quindi non preoccuparti.

Conclusione

I puntatori sono variabili che puntano direttamente all'indirizzo di un oggetto anziché a un valore. Il puntatore della funzione punta direttamente all'indirizzo della funzione, il che può ridurre il consumo di memoria. Java non dispone di puntatori, ma può emulare il comportamento utilizzando riferimenti a metodi o espressioni lambda. L'utilizzo di un riferimento al metodo è più lento rispetto alla chiamata diretta a un metodo, ma ciò non ne impedisce l'utilizzo.

indexOf in Java - Come trovare l'indice di una stringa in Java

Fonte: FreeCodeCamp Una stringa è un insieme di caratteri racchiusi tra virgolette doppie. Il metodo indexOf restituisce la posizione dell'indice del carattere o della sottostringa specificata in una stringa. In questo articolo impareremo la sintassi di vari metodi indexOf . Vedremo anche esempi che ti aiuteranno a comprendere e utilizzare in modo efficace la ricerca dell'indice di un carattere o di una sottostringa nel codice Java.

Sintassi del metodo indexOf

Il metodo indexOf ha i seguenti metodi:

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

Spieghiamo questi parametri:

• char rappresenta un carattere per riga.
• fromIndex specifica la posizione in cui dovrebbe iniziare la ricerca dell'indice di un carattere o di una sottostringa. Questo è importante quando sono presenti due caratteri/stringhe che hanno lo stesso valore in una stringa. Con questo parametro puoi indicare al metodo indexOf da dove iniziare.
• str rappresenta una sottostringa in una stringa.

Non preoccuparti se non hai ancora capito come funziona: gli esempi chiariranno tutto!

Come utilizzare il metodo indexOf in Java

Nel primo esempio troveremo l'indice di un carattere in una stringa. Questo ci aiuterà a comprendere il metodo public int indexOf(int char) .

Esempio di metodo IndexOf(int Char).

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

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

    // 4
  }
}

Nel codice sopra, ci è stato restituito l'indice del carattere "o", che è 4. Abbiamo due caratteri "o", ma è stato restituito solo l'indice del primo. Nell'esempio seguente vedremo come possiamo restituire l'indice della seconda "o". Se ti stai chiedendo come si ottengono i numeri di sequenza, noterai che il primo carattere di una stringa ha un indice pari a zero, il secondo carattere ha un indice pari a uno e così via.

Esempio del metodo indexOf(int Char, Int fromIndex).

Ecco un esempio che spiega il metodo 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
  }
}

Nell'esempio sopra, diciamo al metodo indexOf di iniziare a lavorare dal quinto indice. H => indice 0 e => indice 1 l => indice 2 l => indice 3 0 => indice 4 Si noti che l'indice 5 non è un carattere "W". Il quinto indice è lo spazio tra “Hello” e “World”. Pertanto, in questo codice, tutti gli altri caratteri che precedono il quinto indice verranno ignorati. 7 viene restituito come indice del secondo carattere “o”.

Esempio del metodo Int indexOf(String Str).

Nell'esempio seguente capiremo come funziona il metodo public int indexOf(String str) che restituisce l'indice di una sottostringa.

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

Mi chiedo come ne abbiamo recuperati 11? Dovresti rivedere l'ultima sezione per capire come vengono contati gli indici e come anche gli spazi tra le sottostringhe sono considerati indici. Si noti che quando una sottostringa viene passata come parametro, l'indice restituito è l'indice del primo carattere nella sottostringa. 11 è l'indice del carattere “b”.

Esempio del metodo indexOf(String Str, Int fromIndex).

L'ultimo metodo è public int indexOf(String str, int fromIndex) - lo stesso del metodo public int indexOf(int char, int fromIndex) . Restituisce l'indice dalla posizione specificata.

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

In questo esempio, abbiamo specificato che il metodo dovrebbe iniziare il suo lavoro dal quinto indice, che viene dopo la prima sottostringa for. 21 è l'indice della seconda sottostringa di for. Infine, quando passiamo un carattere o una sottostringa che non è nella stringa, il metodo indexOf restituirà -1. Ecco un esempio:

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

Conclusione

In questo articolo abbiamo imparato come utilizzare i quattro metodi indexOf , con chiari esempi. Abbiamo anche visto come appare la sintassi di ciascuno di questi metodi e come dicono all'indice di restituire. Inoltre, siamo riusciti a scoprire cosa succede quando un carattere o una sottostringa inesistente viene passato come parametro.