Kaffeepause Nr. 221. Drei Möglichkeiten, ein Element in einem Java-Array zu finden. Was ist Java Thread Local und wie wird es verwendet?

Drei Möglichkeiten, ein Element in einem Java-Array zu finden

Quelle: Asyncq Dieser Beitrag hilft Ihnen, die verschiedenen Möglichkeiten zum Suchen nach einem Element in einem Array in Java besser zu verstehen. Das Finden eines bestimmten Elements in einer Wertemenge ist ein sehr häufiger und häufig verwendeter Vorgang in der Softwareentwicklung. Zur Lösung dieses Problems gibt es unterschiedliche Ansätze, von einfach bis optimiert. Schauen wir sie uns an.

Eingabedaten

Das Eingabearray enthält primitive ID-Daten und wir müssen wissen, ob es id->3 enthält.

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

Methode 1 (einfach)

1. Wir besuchen alle Elemente des Arrays, Element für Element.
2. Darüber hinaus verfolgen wir den Status des Zielelements, sofern es im Array vorhanden ist.
3. Sobald wir dieses Element finden, ändern wir den Status von false auf true .
4. Nachdem die Schleife abgeschlossen ist, geben wir das Statusflag zurück.

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

Diese Lösung funktioniert, ist aber nicht sehr effizient. Wenn Sie sich die if- Bedingung ansehen , werden Sie feststellen, dass wir diese Bedingung für alle Elemente testen. Nehmen wir an, das gesuchte Element ist das erste Element, aber unsere Schleife läuft trotzdem für alle Elemente weiter. Hier wäre es klüger, die Schleife zu verlassen, sobald wir das Element gefunden haben. Auf diese Weise würden wir Berechnungen einsparen, wenn das gesuchte Element nicht an der letzten Position steht.

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

Sie können Ihren Code noch prägnanter gestalten, indem Sie return verwenden . Wir können true zurückgeben , sobald wir das gesuchte Element sehen, andernfalls geben wir false zurück , sobald die Schleife abgeschlossen ist. Und wir müssen keine Zustandsvariable erstellen und verwalten.

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

Methode 2

1. Wir können eine ArrayList verwenden , die eine Methode enthält, die standardmäßig nach dem Zielelement in der Liste sucht.
2. Da diese Methode von List bereitgestellt wird , müssen wir unser primitives Array in eine Liste konvertieren.
3. Wir können einen einzelnen Lambda-String verwenden, der ein Grundelement in einen Objekttyp konvertiert und daraus eine Liste erstellt.
   

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

4. Wir können die Java 8 Stream API verwenden, um unseren Code funktionsfähig und viel kürzer zu machen.
5. Um zu verstehen, wie die Stream-APIs mit Streams funktionieren, müssen wir unser Eingabearray in einen Stream konvertieren.
6. Arrays.stream nimmt das Eingabearray und wandelt es in Streams um.
7. Da wir nun Threads haben, können wir viele nützliche Methoden verwenden, darunter auch „anyMatch“ . Es gibt das Element zurück, das dem Prädikat (id == inputId) entspricht .
8. All dies macht unseren Code viel kürzer und leichter lesbar.
   

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

Methode 3 (optimiert)

Ja, der oben gezeigte Code funktioniert und ist leicht zu lesen, aber wir müssen trotzdem jedes Element im Stream besuchen und vergleichen.

1. Wenn der Speicher kein Problem darstellt und wir die Berechnungen optimieren möchten, können wir hier unter anderem einen Satz aus dem Eingabearray erstellen.
2. Wir können wieder funktionalen Stilcode verwenden, um das primitive Array in ein Set umzuwandeln .
3. Da wir nun ein Set haben , können wir über einen konstanten Zeitraum nach einem Element suchen.

S

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

Bonus

Die Suche nach einem einzelnen Element kann als üblicher Vorgang betrachtet werden, häufiger ist jedoch die Suche nach mehreren Elementen in einem Array. Wenn wir in diesem Fall Set nicht verwenden , haben wir zwei Schleifen und die Zeitkomplexität erhöht sich, um die Länge der beiden Sammlungen zu vervielfachen. Unten sehen Sie ein Beispiel, in dem wir eines der Arrays als Menge konvertieren, dann über das andere Array iterieren und eine Suche in der Mengenoperation durchführen. Dadurch erhöhen wir den Speicher und sparen gleichzeitig Berechnungen.

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

Was ist Java Thread Local und wie wird es verwendet?

Quelle: Medium In diesem Artikel befassen wir uns mit Java Thread Local und wie Sie es effektiv in Ihren Java-Anwendungen nutzen können. Java Thread Local ist eine leistungsstarke Funktion, die es Entwicklern ermöglicht, Variablen nur für einen bestimmten Thread zu erstellen. Dies bedeutet, dass jeder Thread seine eigene Kopie einer Variablen haben kann und Änderungen, die an einer Variablen in einem Thread vorgenommen werden, keinen Einfluss auf deren Wert in einem anderen Thread haben.

Was ist Thread Local?

Thread Local ist eine Klasse in der Java-API, mit der Sie Variablen erstellen können, die lokal für einen bestimmten Thread sind. Das heißt, jeder Thread verfügt über eine eigene Kopie der Variablen, und Änderungen, die in einem Thread an einer Variablen vorgenommen werden, wirken sich nicht auf deren Wert in einem anderen Thread aus. Dies macht Thread Local zu einer idealen Lösung zum Speichern threadspezifischer Daten wie Benutzerauthentifizierungsinformationen, Datenbankverbindungen oder anderer threadspezifischer Informationen.

So funktioniert Thread Local in Java

Um Thread Local in Ihrer Java-Anwendung verwenden zu können, müssen Sie zunächst eine Instanz der Thread Local- Klasse erstellen . Dies kann durch Aufrufen des ThreadLocal- Konstruktors erfolgen , der eine neue Instanz dieser Klasse erstellt. Als Nächstes können Sie durch Erstellen eines lokalen Thread- Objekts damit Thread-spezifische Daten speichern und abrufen. Hier ist ein Beispiel für die Verwendung von Thread Local in Ihrer Java-Anwendung:

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

In diesem Beispiel haben wir ein Thread Local- Objekt namens threadLocal vom Typ String erstellt . Wir haben außerdem zwei Methoden erstellt: set() und get() , mit denen wir den Wert der Thread Local- Variablen speichern und abrufen können . Um einen Wert in einer Thread Local- Variable zu speichern , rufen wir einfach die Methode set() auf und übergeben den Wert, den wir speichern möchten. Beispielsweise können wir MyThreadLocalClass.set("Hello, World!") aufrufen , um die Zeichenfolge „Hello, World!“ zu speichern. in der Thread Local- Variable . Um den Wert der Thread Local- Variablen zu erhalten , rufen wir einfach die Methode get() auf . Beispielsweise können wir String value = MyThreadLocalClass.get() aufrufen , um den Wert der Thread Local- Variablen abzurufen .

Empfehlungen für die Arbeit mit Thread Local

Obwohl Thread Local ein leistungsstarkes Tool in Ihren Java-Anwendungen sein kann, ist es wichtig, es richtig zu verwenden, um potenzielle Probleme zu vermeiden. Hier sind einige Richtlinien, die Sie bei der Verwendung von Thread Local beachten sollten :

1. Verwenden Sie Thread Local nur bei Bedarf: nur für Thread-spezifische Daten. Wenn die Daten nicht threadspezifisch sind, müssen sie auf andere Weise gespeichert werden.
2. Vermeiden Sie übermäßige Speichernutzung: Thread Local kann eine erhebliche Menge an Speicher verbrauchen, wenn es nicht sorgfältig verwendet wird. Stellen Sie sicher, dass Sie Thread-Local- Variablen löschen , wenn sie nicht mehr benötigt werden, um eine übermäßige Speichernutzung zu vermeiden.
3. Verwenden Sie Thread Local in Multithread-Umgebungen mit Vorsicht: Es ist wichtig, die potenziellen Risiken und Einschränkungen zu verstehen. Testen Sie Ihren Code unbedingt gründlich, um sicherzustellen, dass Thread Local in Ihrer spezifischen Umgebung wie erwartet funktioniert.

Abschluss

Java Thread Local ist ein großartiges Tool, mit dem Entwickler Variablen nur für einen bestimmten Thread erstellen können. Mit Thread Local können Sie Thread-spezifische Daten speichern, z. B. Benutzerauthentifizierungsinformationen, Datenbankverbindungen oder andere Thread-spezifische Informationen. Obwohl Thread Local ein leistungsstarkes Tool sein kann, ist es wichtig, es richtig zu verwenden, um potenzielle Probleme zu vermeiden. Indem Sie Best Practices befolgen und Ihren Code testen, können Sie ihn effektiv nutzen, um die Leistung und Zuverlässigkeit Ihrer Java-Anwendungen zu verbessern.