Werken met streams, deel 2

1. Gegevensconversie

De Stream<T>klasse heeft ook een methode waarmee u gegevens van het ene type naar het andere kunt converteren. Deze methode is map().

Het retourneert ook een stream, maar met elementen van een ander type. De map()methode neemt als methodeargument een functie die het ene gegevenstype naar het andere converteert.

Voorbeelden:

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

Het functieargument dat aan de map()methode wordt doorgegeven, krijgt een getal xen retourneert de tekenreeksrepresentatie. Je kunt deze code trouwens compacter schrijven:

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

Een tekenreeks omzetten in een getal

Op dezelfde manier kun je code schrijven om een ​​string naar een getal te converteren - dit is ook niet ingewikkeld:

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

Een tekenreeks omzetten in eenURI

Gegevensconversiebewerkingen kunnen veel middelen en tijd vergen. Stel dat we een verzameling tekenreeksen willen converteren naar URI-objecten. Dit is heel gemakkelijk te doen, omdat de URI-constructor een string als argument gebruikt.

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

We hebben een verzameling gemaakt en deze gevuld met 3 webadressen. Toen kregen we een Stream<String>object uit de collectie, en op onze beurt kregen we uit die stroom een Stream<URI>​​object. We hebben de kaartmethode een verwijzing gegeven naar de methode die zal worden gebruikt om elke string naar een URI te converteren.

Deze methode (constructor) moet a Stringals argument hebben. Alles lijkt perfect te zijn...

2. Uitzonderingen

We zouden kunnen verwachten dat de bovenstaande code zou moeten werken, maar dat is niet het geval - het programma zal niet compileren. En niet omdat we ergens een fout hebben gemaakt, maar omdat de makers van Java het verprutst hebben.

Er was eens een briljant idee om een ​​gecontroleerde uitzondering ( URISyntaxException) toe te voegen aan de URIklassenconstructor! En dergelijke uitzonderingen moeten in een try-catch.

Dus de laatste regel van onze code ziet er als volgt uit:

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

Wat kunnen we zeggen? U moet twee keer nadenken voordat u een gecontroleerde uitzondering gebruikt . En denk drie keer na voordat je ze in een constructor gebruikt.