Lavorare con i thread, parte 2

1. Conversione dei dati

La Stream<T>classe dispone anche di un metodo che consente di convertire i dati da un tipo all'altro. Questo metodo è map().

Restituisce anche un flusso, ma con elementi di tipo diverso. Il map()metodo accetta come argomento del metodo una funzione che converte un tipo di dati in un altro.

Esempi:

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
Stream<String> stream2 = stream.map((x) -> String.valueOf(x));

L'argomento della funzione passato al map()metodo accetta un numero xe ne restituisce la rappresentazione in forma di stringa. A proposito, puoi scrivere questo codice in modo più compatto:

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
Stream<String> stream2 = stream.map(String::valueOf);

Conversione di una stringa in un numero

Allo stesso modo, puoi scrivere codice per convertire una stringa in un numero — anche questo non è complicato:

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
Stream<String> stream2 = stream.map(String::valueOf);
Stream<Integer> stream3 = stream2.map(Integer::parseInt);

Conversione di una stringa in aURI

Le operazioni di conversione dei dati possono richiedere molte risorse e tempo. Supponiamo di voler convertire una raccolta di stringhe in oggetti URI. Questo è molto facile da fare, perché il costruttore di URI accetta una stringa come argomento.

ArrayList<String> list = new ArrayList<String>();
list.add("https://google.com");
list.add("https://linkedin.com");
list.add("https://yandex.com");

Stream<URI> stream = list.stream().map( URI::new );

Abbiamo creato una raccolta e l'abbiamo popolata con 3 indirizzi web. Quindi abbiamo ottenuto un Stream<String>oggetto dalla raccolta e, a sua volta, da quel flusso abbiamo ottenuto un Stream<URI>oggetto. Abbiamo passato al metodo map un riferimento al metodo che verrà utilizzato per convertire ogni stringa in un URI.

Questo metodo (costruttore) deve accettare a Stringcome argomento. Sembra tutto perfetto...

2. Eccezioni

Potremmo aspettarci che il codice qui sopra dovrebbe funzionare, ma non funzionerà: il programma non verrà compilato. E non perché abbiamo commesso un errore da qualche parte, ma perché i creatori di Java hanno sbagliato.

C'era una volta la brillante idea di aggiungere un'eccezione controllata ( URISyntaxException) al URIcostruttore della classe! E tali eccezioni devono essere racchiuse in un file try-catch.

Quindi l'ultima riga del nostro codice sarà simile a questa:

Stream<URI> stream = list.stream().map(str ->
{
  try
  {
     return new URI(str);
  }
  catch (URISyntaxException e)
  {
     e.printStackTrace();
     return null;
  }
});

Cosa possiamo dire? Dovresti pensarci due volte prima di usare un'eccezione controllata . E pensaci tre volte prima di usarli in un costruttore.