String-Operationen mit Java-Streams

1. Übersicht

Java 8 hat eine neue Stream- API eingeführt, mit der wir Daten deklarativ verarbeiten können.

In diesem kurzen Artikel erfahren Sie, wie Sie mithilfe der Stream- API einen durch Kommas getrennten String in eine Liste von Strings aufteilen und ein String- Array zu einem durch Kommas getrennten String zusammenfügen .

Wir werden uns auch ansehen, wie ein String-Array mithilfe der Stream- API in eine Map konvertiert wird .

Fast die ganze Zeit sind wir mit Situationen konfrontiert, in denen wir einige Java-Sammlungen iterieren und die Sammlung basierend auf einer Filterlogik filtern müssen. In einem traditionellen Ansatz für diese Art von Situation würden wir viele Schleifen und If-else-Operationen verwenden, um das gewünschte Ergebnis zu erzielen.

Wenn Sie mehr über die Stream- API erfahren möchten, lesen Sie diesen Artikel.

2. Verbinden von Strings mit der Stream- API

Verwenden Sie die Stream- API, um eine Funktion zu erstellen, die ein String- Array zu einem durch Kommas getrennten String zusammenfügt :

public static String join(String[] arrayOfString){ return Arrays.asList(arrayOfString) .stream() //.map(...) .collect(Collectors.joining(",")); }

Hier zu beachtende Punkte:

  • Die Funktion stream () konvertiert jede Sammlung in einen Datenstrom
  • Mit der Funktion map () werden die Daten verarbeitet
  • Es gibt auch eine andere Funktion namens filter () , in die wir Filterkriterien aufnehmen können

Es kann Szenarien geben, in denen wir einem String mit einem festen Präfix und Postfix beitreten möchten . Mit der Stream- API können wir das folgendermaßen tun:

public static String joinWithPrefixPostfix(String[] arrayOfString){ return Arrays.asList(arrayOfString) .stream() //.map(...) .collect(Collectors.joining(",","[","]")); }

Wie wir in der Collectors.joining () -Methode sehen können, deklarieren wir unser Präfix als '[' und Postfix als ']' ; Daher wird der generierte String im deklarierten Format [… ..] erstellt .

3. Teilen von Strings mit der Stream- API

Lassen Sie uns nun eine Funktion erstellen, die ein Komma aufgeteilt würde getrennt String in eine Liste von String mit Stream - API:

public static List split(String str){ return Stream.of(str.split(",")) .map (elem -> new String(elem)) .collect(Collectors.toList()); }

Es ist auch möglich, einen String mithilfe der Stream- API direkt in eine Zeichenliste zu konvertieren :

public static List splitToListOfChar(String str) { return str.chars() .mapToObj(item -> (char) item) .collect(Collectors.toList()); }

Eine interessante Tatsache ist, dass die chars () -Methode den String in einen Integer- Stream konvertiert, wobei jeder Integer- Wert den ASCII- Wert jeder einzelnen Char- Sequenz bezeichnet. Aus diesem Grund müssen wir das Mapper-Objekt in der mapToObj () -Methode explizit typisieren .

4. String Array Karte mit Stream - API

Wir können ein String- Array auch mit split und Collectors.toMap in eine Map konvertieren , vorausgesetzt, jedes Element im Array enthält eine durch ein Trennzeichen verkettete Schlüsselwertentität:

public static Map arrayToMap(String[] arrayOfString) { return Arrays.asList(arrayOfString) .stream() .map(str -> str.split(":")) .collect(toMap(str -> str[0], str -> str[1])); }

Hier ist ":" das Schlüssel-Wert-Trennzeichen für alle Elemente im String-Array.

Bitte beachten Sie, dass wir, um Kompilierungsfehler zu vermeiden, sicherstellen müssen, dass Code mit Java 1.8 kompiliert wird . Dazu müssen wir das folgende Plugin in die pom.xml einfügen :

   org.apache.maven.plugins maven-compiler-plugin 3.3  1.8 1.8    

5. Testen

Nachdem wir die Funktionen erstellt haben, erstellen wir Testfälle, um das Ergebnis zu überprüfen.

Testen wir zunächst unsere einfache Verbindungsmethode:

@Test public void givenArray_transformedToStream_convertToString() { String[] programmingLanguages = {"java", "python", "nodejs", "ruby"}; String expectation = "java,python,nodejs,ruby"; String result = JoinerSplitter.join(programmingLanguages); assertEquals(result, expectation); }

Als nächstes erstellen wir eine weitere, um unsere einfache Aufteilungsfunktion zu testen:

@Test public void givenString_transformedToStream_convertToList() { String programmingLanguages = "java,python,nodejs,ruby"; List expectation = new ArrayList(); expectation.add("java"); expectation.add("python"); expectation.add("nodejs"); expectation.add("ruby"); List result = JoinerSplitter.split(programmingLanguages); assertEquals(result, expectation); }

Lassen Sie uns abschließend unser String- Array testen, um die Funktionalität zuzuordnen:

@Test public void givenStringArray_transformedToStream_convertToMap() { String[] programming_languages = new String[] {"language:java","os:linux","editor:emacs"}; Map expectation=new HashMap(); expectation.put("language", "java"); expectation.put("os", "linux"); expectation.put("editor", "emacs"); Map result = JoinerSplitter.arrayToMap(programming_languages); assertEquals(result, expectation); }

Auf die gleiche Weise müssen wir den Rest der Testfälle erstellen.

6. Fazit

Die Stream- API bietet uns ausgefeilte Datenverarbeitungstechniken. Diese neue Art des Codeschreibens ist im Hinblick auf die Verwaltung des Heapspeichers in einer Multithread-Umgebung sehr effizient.

Wie immer ist der vollständige Quellcode auf Github verfügbar.