Pausa para café #221. Três maneiras de encontrar um elemento em um array Java. O que é Java Thread Local e como usá-lo

Três maneiras de encontrar um elemento em um array Java

Fonte: Asyncq Este post irá ajudá-lo a entender melhor as diferentes maneiras de procurar um elemento em um array em Java. Encontrar um elemento específico em um conjunto de valores é uma operação muito comum e frequentemente utilizada no desenvolvimento de software. Existem diferentes abordagens para resolver este problema, desde simples até otimizadas. Vamos dar uma olhada neles.

Dados de entrada

A matriz de entrada contém dados de id primitivos e precisamos saber se ela contém id->3.

int[] ids = { 1,2,13,14,15,3,10,11,12,4,5,6,7,8,9 };
int inputId = 3;

Método 1 (simples)

1. Visitamos todos os elementos do array, um elemento de cada vez.
2. Além disso, rastreamos o estado do elemento de destino, se ele existir no array.
3. Assim que encontrarmos este elemento, mudamos o status de false para true .
4. Após a conclusão do loop, retornamos o sinalizador de status.

boolean valExist = false;
for (int id : ids) {
   if (inputId == id) {
             valExist = true;
   }
}
return valExist;

Esta solução funciona, mas não é muito eficiente. Se você observar a condição if , perceberá que estamos testando essa condição para todos os elementos. Digamos que o elemento que procuramos seja o primeiro elemento, mas nosso loop continuará a ser executado para todos os elementos. Aqui seria mais sensato sair do loop assim que encontrarmos o elemento. Ao fazer isso, economizaríamos em cálculos quando o elemento que procuramos não estiver na última posição.

boolean valExist = false;
for (int id : ids) {
    if (inputId == id) {
                valExist = true;
                break;
     }
}
return valExist;

Você pode tornar seu código ainda mais conciso usando return . Podemos retornar true assim que virmos o elemento que procuramos, caso contrário, retornaremos false assim que o loop for concluído. E não precisamos criar e manter uma variável de estado.

for (int id : ids) {
      if (inputId == id) {
                return true;
       }
  }
  return false;

Método 2

1. Podemos usar um ArrayList contendo um método que por padrão procura o elemento alvo na lista.
2. Como este método é fornecido por List , precisamos converter nosso array primitivo em uma lista.
3. Podemos usar uma única string lambda que converte um primitivo em um tipo de objeto e cria uma lista a partir dele.
   

   return Arrays.asList(Arrays.stream(ids).boxed().toArray())
                 .contains(inputId);

4. Podemos usar a API Java 8 Stream para tornar nosso código funcional e muito mais curto.
5. Para entender como as APIs Stream funcionam com streams, precisamos converter nosso array de entrada em um stream.
6. Arrays.stream pega o array de entrada e o converte em streams.
7. Agora que temos threads, podemos usar muitos métodos úteis, um dos quais é anyMatch . Ele retorna o elemento que corresponde ao predicado (id == inputId) .
8. Tudo isso torna nosso código muito mais curto e fácil de ler.
   

   return Arrays.stream(ids)
             .anyMatch(id -> id == inputId);

Método 3 (otimizado)

Sim, o código mostrado acima funciona e é fácil de ler, mas ainda precisamos visitar e comparar cada elemento do stream.

1. Se a memória não for um problema e quisermos otimizar os cálculos, uma das coisas que podemos fazer aqui é criar um conjunto a partir do array de entrada.
2. Podemos novamente usar código de estilo funcional para converter o array primitivo em Set .
3. Agora que temos um Set , podemos procurar um elemento durante um período constante de tempo.

S

et<Integer> idsSet = Arrays.stream(ids).boxed().collect(Collectors.toSet());
return idsSet.contains(inputId);

Bônus

A busca por um único elemento pode ser considerada uma operação comum, mas mais comum é a busca por múltiplos elementos em um array. Neste caso, se não usarmos Set , teremos dois loops e a complexidade do tempo aumentará para multiplicar o comprimento das duas coleções. Abaixo está um exemplo onde convertemos um dos arrays como um conjunto e então iteramos sobre o outro array e realizamos uma pesquisa na operação de conjunto. Ao fazer isso, aumentamos a memória e ao mesmo tempo economizamos em cálculos.

int[] targetIds = { 1, 3, 6, 88, 999, 34, 44, 55};
int[] ids = { 1,2,13,14,15,3,10,11,12,4,5,6,7,8,9 };


Set<Integer> idsSet = Arrays.stream(ids).boxed().collect(Collectors.toSet());
return Arrays.stream(targetIds)
            .boxed()
            .filter(id -> !idsSet.contains(id))
            .mapToInt(a -> a)
            .toArray();

O que é Java Thread Local e como usá-lo

Fonte: Médio Neste artigo, veremos Java Thread Local e como usá-lo de forma eficaz em seus aplicativos Java. Java Thread Local é um recurso poderoso que permite aos desenvolvedores criar variáveis ​​apenas para um thread específico. Isso significa que cada thread pode ter sua própria cópia de uma variável, e as alterações feitas em uma variável em um thread não afetarão seu valor em outro thread.

O que é tópico local

Thread Local é uma classe na API Java que permite criar variáveis ​​locais para um thread específico. Ou seja, cada thread possui sua própria cópia da variável e as alterações feitas em uma variável em um thread não afetam seu valor em outro thread. Isso torna o Thread Local uma solução ideal para armazenar dados específicos de thread, como informações de autenticação de usuário, conexões de banco de dados ou qualquer outra informação específica de thread.

Como funciona o Thread Local em Java

Para usar Thread Local em seu aplicativo Java, primeiro você precisa criar uma instância da classe Thread Local . Isso pode ser feito chamando o construtor ThreadLocal , que criará uma nova instância desta classe. Em seguida, criando um objeto Thread Local , você pode usá-lo para armazenar e recuperar dados específicos do thread. Aqui está um exemplo de como usar Thread Local em seu aplicativo Java:

public class MyThreadLocalClass {
  private static final ThreadLocal<String> threadLocal = new ThreadLocal<>();

  public static void set(String value) {
    threadLocal.set(value);
  }

  public static String get() {
    return threadLocal.get();
  }
}

Neste exemplo, criamos um objeto Thread Local chamado threadLocal do tipo String . Também criamos dois métodos: set() e get() que nos permitem armazenar e recuperar o valor da variável Thread Local . Para armazenar um valor em uma variável Thread Local , simplesmente chamamos o método set() e passamos o valor que queremos armazenar. Por exemplo, podemos chamar MyThreadLocalClass.set("Hello, World!") para armazenar a string “Hello, World!” na variável Thread Local . Para obter o valor da variável Thread Local , simplesmente chamamos o método get() . Por exemplo, podemos chamar String value = MyThreadLocalClass.get() para obter o valor da variável Thread Local .

Recomendações para trabalhar com Thread Local

Embora o Thread Local possa ser uma ferramenta poderosa em suas aplicações Java, é importante utilizá-lo corretamente para evitar possíveis problemas. Aqui estão algumas diretrizes que você deve ter em mente ao usar Thread Local :

1. Use Thread Local somente quando necessário: apenas para dados específicos do thread. Se os dados não forem específicos do thread, eles deverão ser armazenados de outra maneira.
2. Evite o uso excessivo de memória: Thread Local pode consumir uma quantidade significativa de memória se não for usado com cuidado. Certifique-se de limpar as variáveis ​​Thread Local quando elas não forem mais necessárias para evitar o uso excessivo de memória.
3. Use Thread Local com cuidado em ambientes multithread: é importante compreender os riscos e limitações potenciais. Certifique-se de testar seu código completamente para garantir que Thread Local funcione conforme esperado em seu ambiente específico.

Conclusão

Java Thread Local é uma ótima ferramenta que permite aos desenvolvedores criar variáveis ​​apenas para um thread específico. Usando Thread Local , você pode armazenar dados específicos do thread, como informações de autenticação do usuário, conexões de banco de dados ou outras informações específicas do thread. Embora Thread Local possa ser uma ferramenta poderosa, é importante usá-la corretamente para evitar possíveis problemas. Seguindo as práticas recomendadas e testando seu código, você poderá usá-lo de maneira eficaz para melhorar o desempenho e a confiabilidade de seus aplicativos Java.