Pause café #221. Trois façons de rechercher un élément dans un tableau Java. Qu'est-ce que Java Thread Local et comment l'utiliser

Trois façons de trouver un élément dans un tableau Java

Source : Asyncq Cet article vous aidera à mieux comprendre les différentes manières de rechercher un élément dans un tableau en Java. Trouver un élément spécifique dans un ensemble de valeurs est une opération très courante et fréquemment utilisée dans le développement de logiciels. Il existe différentes approches pour résoudre ce problème, de la simple à l'optimisée. Regardons-les.

Des données d'entrée

Le tableau d'entrée contient des données d'identification primitives et nous devons savoir s'il contient id->3.

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

Méthode 1 (simple)

1. Nous visitons tous les éléments du tableau, un élément à la fois.
2. De plus, nous suivons l'état de l'élément cible s'il existe dans le tableau.
3. Dès que nous trouvons cet élément, nous passons le statut de false à true .
4. Une fois la boucle terminée, nous renvoyons l'indicateur d'état.

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

Cette solution fonctionne, mais elle n'est pas très efficace. Si vous regardez la condition if , vous réaliserez que nous testons cette condition pour tous les éléments. Disons que l'élément que nous recherchons est le premier élément, mais notre boucle continuera à s'exécuter pour tous les éléments. Ici il serait plus sage de sortir de la boucle dès qu'on trouve l'élément. En faisant cela, nous économiserions sur les calculs lorsque l'élément que nous recherchons n'est pas en dernière position.

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

Vous pouvez rendre votre code encore plus concis en utilisant return . Nous pouvons renvoyer true dès que nous voyons l'élément que nous recherchons, sinon nous renvoyons false dès que la boucle est terminée. Et nous n'avons pas besoin de créer et de maintenir une variable d'état.

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

Méthode 2

1. Nous pouvons utiliser un ArrayList contenant une méthode qui recherche par défaut l'élément cible dans la liste.
2. Puisque cette méthode est fournie par List , nous devons convertir notre tableau primitif en liste.
3. Nous pouvons utiliser une seule chaîne lambda qui convertit une primitive en type d'objet et crée une liste à partir de celle-ci.
   

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

4. Nous pouvons utiliser l'API Java 8 Stream pour rendre notre code fonctionnel et beaucoup plus court.
5. Pour comprendre comment les API Stream fonctionnent avec les flux, nous devons convertir notre tableau d'entrée en flux.
6. Arrays.stream prend le tableau d'entrée et le convertit en flux.
7. Maintenant que nous avons des threads, nous pouvons utiliser de nombreuses méthodes utiles, dont anyMatch . Il renvoie l'élément correspondant au prédicat (id == inputId) .
8. Tout cela rend notre code beaucoup plus court et plus facile à lire.
   

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

Méthode 3 (optimisée)

Oui, le code présenté ci-dessus fonctionne et est facile à lire, mais nous devons quand même visiter et comparer chaque élément du flux.

1. Si la mémoire n'est pas un problème et que nous souhaitons optimiser les calculs, l'une des choses que nous pouvons faire ici est de créer un ensemble à partir du tableau d'entrée.
2. Nous pouvons à nouveau utiliser du code de style fonctionnel pour convertir le tableau primitif en Set .
3. Maintenant que nous avons un Set , nous pouvons rechercher un élément sur une période de temps constante.

S

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

Prime

La recherche d’un seul élément peut être considérée comme une opération courante, mais la recherche de plusieurs éléments dans un tableau est plus courante. Dans ce cas, si nous n'utilisons pas Set , nous aurons deux boucles et la complexité temporelle augmentera pour multiplier la longueur des deux collections. Vous trouverez ci-dessous un exemple dans lequel nous convertissons l'un des tableaux en un ensemble, puis parcourons l'autre tableau et effectuons une recherche dans l'opération d'ensemble. En faisant cela, nous augmentons la mémoire et en même temps économisons sur les calculs.

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

Qu'est-ce que Java Thread Local et comment l'utiliser

Source : Medium Dans cet article, nous examinerons Java Thread Local et comment l'utiliser efficacement dans vos applications Java. Java Thread Local est une fonctionnalité puissante qui permet aux développeurs de créer des variables uniquement pour un thread spécifique. Cela signifie que chaque thread peut avoir sa propre copie d'une variable et que les modifications apportées à une variable dans un thread n'affecteront pas sa valeur dans un autre thread.

Qu'est-ce que le fil de discussion local ?

Thread Local est une classe de l'API Java qui vous permet de créer des variables locales à un thread spécifique. Autrement dit, chaque thread possède sa propre copie de la variable et les modifications apportées à une variable dans un thread n'affectent pas sa valeur dans un autre thread. Cela fait de Thread Local une solution idéale pour stocker des données spécifiques au thread telles que les informations d'authentification des utilisateurs, les connexions à la base de données ou toute autre information spécifique au thread.

Comment fonctionne Thread Local en Java

Pour utiliser Thread Local dans votre application Java, vous devez d'abord créer une instance de la classe Thread Local . Cela peut être fait en appelant le constructeur ThreadLocal , qui créera une nouvelle instance de cette classe. Ensuite, en créant un objet Thread Local , vous pouvez l'utiliser pour stocker et récupérer des données spécifiques au thread. Voici un exemple d'utilisation de Thread Local dans votre application 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();
  }
}

Dans cet exemple, nous avons créé un objet Thread Local appelé threadLocal de type String . Nous avons également créé deux méthodes : set() et get() qui nous permettent de stocker et de récupérer la valeur de la variable Thread Local . Pour stocker une valeur dans une variable Thread Local , nous appelons simplement la méthode set() et transmettons la valeur que nous voulons stocker. Par exemple, nous pouvons appeler MyThreadLocalClass.set("Hello, World!") pour stocker la chaîne "Hello, World!" dans la variable locale du thread . Pour obtenir la valeur de la variable Thread Local , nous appelons simplement la méthode get() . Par exemple, nous pouvons appeler String value = MyThreadLocalClass.get() pour obtenir la valeur de la variable Thread Local .

Recommandations pour travailler avec Thread Local

Bien que Thread Local puisse être un outil puissant dans vos applications Java, il est important de l'utiliser correctement pour éviter des problèmes potentiels. Voici quelques directives à garder à l’esprit lors de l’utilisation de Thread Local :

1. Utilisez Thread Local uniquement lorsque cela est nécessaire : uniquement pour les données spécifiques au thread. Si les données ne sont pas spécifiques à un thread, elles doivent être stockées d'une autre manière.
2. Évitez une utilisation excessive de la mémoire : Thread Local peut consommer une quantité importante de mémoire s’il n’est pas utilisé avec précaution. Assurez-vous d'effacer les variables Thread Local lorsqu'elles ne sont plus nécessaires pour éviter une utilisation excessive de la mémoire.
3. Utilisez Thread Local avec prudence dans les environnements multithread : il est important de comprendre les risques et les limites potentiels. Assurez-vous de tester minutieusement votre code pour vous assurer que Thread Local fonctionne comme prévu dans votre environnement spécifique.

Conclusion

Java Thread Local est un excellent outil qui permet aux développeurs de créer des variables uniquement pour un thread spécifique. À l'aide de Thread Local , vous pouvez stocker des données spécifiques au thread, telles que les informations d'authentification utilisateur, les connexions à la base de données ou d'autres informations spécifiques au thread. Bien que Thread Local puisse être un outil puissant, il est important de l’utiliser correctement pour éviter des problèmes potentiels. En suivant les meilleures pratiques et en testant votre code, vous pouvez l'utiliser efficacement pour améliorer les performances et la fiabilité de vos applications Java.