Pausa para café #116. Como usar ponteiros de função em Java. indexOf em Java – Como encontrar o índice de uma string em Java

Como usar ponteiros de função em Java

Fonte: Dev.to Ponteiros são objetos que armazenam um endereço de memória e podem economizar memória apontando diretamente para um objeto de destino, array ou endereço de variável em vez de passar por valor. Infelizmente, não existe um conceito “real” de ponteiros em Java. Mas, felizmente para nós, existe uma solução alternativa usando referências de método que é próxima da realidade.

Ponteiros de função

Um ponteiro de função é um ponteiro que aponta para o endereço de uma função. Alguns casos de uso incluem a criação de uma rotina de retorno de chamada criando uma função que chama outra função com base em sua execução ou armazenando uma matriz de ponteiros de função para métodos chamados dinamicamente (por exemplo, armazenando instruções do processador para um emulador).

Simulação de ponteiro de função

Existem quatro tipos de referências de método . Usamos um tipo que se refere a um método de instância de um objeto específico. Vamos começar definindo uma interface que defina as assinaturas dos métodos para os quais você aponta.

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

Então criaremos métodos com a assinatura do método alvo.

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

A próxima etapa é criar variáveis ​​de interface wrapper e atribuir métodos a elas. As variáveis ​​atuarão como um ponteiro para a função a ser armazenada ou executada.

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

Usando expressões lambda

As referências de método podem ser atribuídas usando expressões 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);

Matriz de ponteiros de função

A funcionalidade de uma matriz de referências de método pode ser emulada criando uma matriz de interface 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);

Ponteiro de função vs chamada direta

Se você comparar as duas opções, chamar um método diretamente é quase 5 vezes mais rápido do que usar uma referência de método. Tudo isso por causa da etapa extra de chamar uma expressão lambda em comparação com um método armazenado. Mas você provavelmente não notará nenhuma perda de desempenho em um ano, então não se preocupe com isso.

Conclusão

Ponteiros são variáveis ​​que apontam diretamente para o endereço de um objeto em vez de para um valor. O ponteiro de função aponta diretamente para o endereço da função, o que pode reduzir o consumo de memória. Java não possui ponteiros, mas pode emular comportamento usando referências de métodos ou expressões lambda. Usar uma referência de método é mais lento do que chamar um método diretamente, mas isso não impede seu uso.

indexOf em Java – Como encontrar o índice de uma string em Java

Fonte: FreeCodeCamp Uma string é um conjunto de caracteres entre aspas duplas. O método indexOf retorna a posição do índice do caractere ou substring especificado em uma string. Neste artigo, aprenderemos sobre a sintaxe de vários métodos indexOf . Também veremos exemplos que o ajudarão a compreender e usar com eficácia a pesquisa do índice de um caractere ou substring no código Java.

Sintaxe do método indexOf

O método indexOf possui os seguintes métodos:

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

Vamos explicar esses parâmetros:

• char representa um caractere por linha.
• fromIndex especifica a posição na qual a busca pelo índice de um caractere ou substring deve começar. Isso é importante quando você tem dois caracteres/strings que possuem o mesmo valor em uma string. Com este parâmetro, você pode informar ao método indexOf por onde começar.
• str representa uma substring em uma string.

Não se preocupe se ainda não entende como tudo funciona – os exemplos deixarão tudo claro!

Como usar o método indexOf em Java

No primeiro exemplo encontraremos o índice de um caractere em uma string. Isso nos ajudará a entender o método public int indexOf(int char) .

Exemplo do método IndexOf(int Char)

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

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

    // 4
  }
}

No código acima, obtivemos o índice do caracter “o” que nos foi retornado, que é 4. Temos dois caracteres “o”, mas apenas o índice do primeiro foi retornado. No exemplo a seguir veremos como podemos retornar o índice do segundo “o”. Se você está se perguntando como os números de sequência são obtidos, notará que o primeiro caractere em uma string tem índice zero, o segundo caractere tem índice um e assim por diante.

Exemplo do método indexOf(int Char, Int fromIndex)

Aqui está um exemplo explicando o método 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
  }
}

No exemplo acima, dizemos ao método indexOf para começar a trabalhar no quinto índice. H => índice 0 e => índice 1 l => índice 2 l => índice 3 0 => índice 4 Observe que o índice 5 não é um caractere “W”. O quinto índice é o espaço entre “Hello” e “World”. Assim, neste código, todos os outros caracteres anteriores ao quinto índice serão ignorados. 7 é retornado como o índice do segundo caractere “o”.

Exemplo do método Int indexOf(String Str)

No exemplo a seguir, entenderemos como funciona o método public int indexOf(String str) , que retorna o índice de uma 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
  }
}

Eu me pergunto como conseguimos 11 de volta? Você deve revisar a última seção para entender como os índices são contados e como os espaços entre substrings também são considerados índices. Observe que quando uma substring é passada como parâmetro, o índice retornado é o índice do primeiro caractere da substring. 11 é o índice do caractere “b”.

Exemplo do método indexOf(String Str, Int fromIndex)

O último método é public int indexOf(String str, int fromIndex) - o mesmo que o método public int indexOf(int char, int fromIndex) . Ele retorna o índice da posição especificada.

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

Neste exemplo, especificamos que o método deve começar seu trabalho no quinto índice, que vem depois da primeira substring for. 21 é o índice da segunda substring de for. Finalmente, quando passamos um caractere ou substring que não está na string, o método indexOf retornará -1. Aqui está um exemplo:

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

Conclusão

Neste artigo, aprendemos como usar os quatro métodos indexOf , com exemplos claros. Também vimos como é a sintaxe de cada um desses métodos e como eles informam o índice para retornar. Além disso, conseguimos descobrir o que acontece quando um caractere ou substring inexistente é passado como parâmetro.