Pausa caffè #221. Tre modi per trovare un elemento in un array Java. Cos'è Java Thread Local e come usarlo

Tre modi per trovare un elemento in un array Java

Fonte: Asyncq Questo post ti aiuterà a comprendere meglio i diversi modi per cercare un elemento in un array in Java. Trovare un elemento specifico in un insieme di valori è un'operazione molto comune e utilizzata di frequente nello sviluppo di software. Esistono diversi approcci per risolvere questo problema, da quelli semplici a quelli ottimizzati. Diamo un'occhiata a loro.

Dati in ingresso

L'array di input contiene dati ID primitivi e dobbiamo sapere se contiene id->3.

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

Metodo 1 (semplice)

1. Visitiamo tutti gli elementi dell'array, un elemento alla volta.
2. Inoltre, teniamo traccia dello stato dell'elemento di destinazione se esiste nell'array.
3. Non appena troviamo questo elemento, cambiamo lo stato da false a true .
4. Una volta completato il ciclo, restituiamo il flag di stato.

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

Questa soluzione funziona, ma non è molto efficiente. Se guardi la condizione if , ti renderai conto che stiamo testando questa condizione per tutti gli elementi. Diciamo che l'elemento che stiamo cercando è il primo elemento, ma il nostro ciclo continuerà comunque a funzionare per tutti gli elementi. Qui sarebbe più saggio uscire dal ciclo non appena troviamo l'elemento. In questo modo risparmieremmo sui calcoli quando l'elemento che stiamo cercando non si trova nell'ultima posizione.

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

Puoi rendere il tuo codice ancora più conciso utilizzando return . Possiamo restituire true non appena vediamo l'elemento che stiamo cercando, altrimenti restituiamo false non appena il ciclo viene completato. E non abbiamo bisogno di creare e mantenere una variabile di stato.

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

Metodo 2

1. Possiamo utilizzare un ArrayList contenente un metodo che per impostazione predefinita cerca l'elemento di destinazione nell'elenco.
2. Poiché questo metodo è fornito da List , dobbiamo convertire il nostro array primitivo in una lista.
3. Possiamo usare una singola stringa lambda che converte una primitiva in un tipo di oggetto e crea un elenco da esso.
   

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

4. Possiamo utilizzare Java 8 Stream API per rendere il nostro codice funzionale e molto più breve.
5. Per comprendere come funzionano le API Stream con i flussi, dobbiamo convertire il nostro array di input in un flusso.
6. Arrays.stream prende l'array di input e lo converte in flussi.
7. Ora che abbiamo i thread, possiamo usare molti metodi utili, uno dei quali è anyMatch . Restituisce l'elemento corrispondente al predicato (id == inputId) .
8. Tutto ciò rende il nostro codice molto più breve e più facile da leggere.
   

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

Metodo 3 (ottimizzato)

Sì, il codice mostrato sopra funziona ed è facile da leggere, ma dobbiamo comunque visitare e confrontare ogni elemento nello stream.

1. Se la memoria non è un problema e vogliamo ottimizzare i calcoli, una delle cose che possiamo fare qui è creare un set dall'array di input.
2. Possiamo nuovamente utilizzare il codice di stile funzionale per convertire l'array primitivo in un Set .
3. Ora che abbiamo un Set , possiamo cercare un elemento in un periodo di tempo costante.

S

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

Bonus

La ricerca di un singolo elemento può essere considerata un'operazione comune, ma più comune è la ricerca di più elementi in un array. In questo caso, se non utilizziamo Set , avremo due loop e la complessità temporale aumenterà per moltiplicare la lunghezza delle due raccolte. Di seguito è riportato un esempio in cui convertiamo uno degli array come set, quindi iteriamo sull'altro array ed eseguiamo una ricerca nell'operazione set. In questo modo aumentiamo la memoria e allo stesso tempo risparmiamo sui calcoli.

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

Cos'è Java Thread Local e come usarlo

Fonte: Medium In questo articolo esamineremo Java Thread Local e come utilizzarlo in modo efficace nelle tue applicazioni Java. Java Thread Local è una potente funzionalità che consente agli sviluppatori di creare variabili solo per un thread specifico. Ciò significa che ogni thread può avere la propria copia di una variabile e le modifiche apportate a una variabile in un thread non influenzeranno il suo valore in un altro thread.

Cos'è ThreadLocal

Thread Local è una classe nell'API Java che consente di creare variabili locali su un thread specifico. Cioè, ogni thread ha la propria copia della variabile e le modifiche apportate a una variabile in un thread non influiscono sul suo valore in un altro thread. Ciò rende Thread Local una soluzione ideale per archiviare dati specifici del thread come informazioni sull'autenticazione dell'utente, connessioni al database o qualsiasi altra informazione specifica del thread.

Come funziona Thread Local in Java

Per utilizzare Thread Local nella tua applicazione Java, devi prima creare un'istanza della classe Thread Local . Questo può essere fatto chiamando il costruttore ThreadLocal , che creerà una nuova istanza di questa classe. Successivamente, creando un oggetto Thread Local , è possibile utilizzarlo per archiviare e recuperare dati specifici del thread. Ecco un esempio di come utilizzare Thread Local nella tua applicazione 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();
  }
}

In questo esempio abbiamo creato un oggetto Thread Local chiamato threadLocal di tipo String . Abbiamo anche creato due metodi: set() e get() che ci permettono di memorizzare e recuperare il valore della variabile Thread Local . Per memorizzare un valore in una variabile Thread Local , chiamiamo semplicemente il metodo set() e passiamo il valore che vogliamo memorizzare. Ad esempio, possiamo chiamare MyThreadLocalClass.set("Hello, World!") per memorizzare la stringa "Hello, World!" nella variabile locale del thread . Per ottenere il valore della variabile Thread Local , chiamiamo semplicemente il metodo get() . Ad esempio, possiamo chiamare String value = MyThreadLocalClass.get() per ottenere il valore della variabile Thread Local .

Consigli per lavorare con Thread Local

Sebbene Thread Local possa essere uno strumento potente nelle tue applicazioni Java, è importante utilizzarlo correttamente per evitare potenziali problemi. Ecco alcune linee guida da tenere a mente quando si utilizza Thread Local :

1. Utilizza Thread Local solo quando necessario: solo per dati specifici del thread. Se i dati non sono specifici del thread, devono essere archiviati in un altro modo.
2. Evita un utilizzo eccessivo della memoria: Thread Local può consumare una quantità significativa di memoria se non utilizzato con attenzione. Assicurati di deselezionare le variabili locali del thread quando non sono più necessarie per evitare un utilizzo eccessivo della memoria.
3. Utilizzare Thread Local con cautela in ambienti multi-thread: è importante comprendere i potenziali rischi e limitazioni. Assicurati di testare accuratamente il tuo codice per assicurarti che Thread Local funzioni come previsto nel tuo ambiente specifico.

Conclusione

Java Thread Local è un ottimo strumento che consente agli sviluppatori di creare variabili solo per un thread specifico. Utilizzando Thread Local , è possibile archiviare dati specifici del thread, come informazioni sull'autenticazione dell'utente, connessioni al database o altre informazioni specifiche del thread. Sebbene Thread Local possa essere uno strumento potente, è importante utilizzarlo correttamente per evitare potenziali problemi. Seguendo le migliori pratiche e testando il codice, puoi utilizzarlo in modo efficace per migliorare le prestazioni e l'affidabilità delle tue applicazioni Java.