Streams.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "024ec1d5",
   "metadata": {},
   "source": [
    "# Streams \n",
    "\n",
    "\n",
    "##### Marcel Lüthi, Departement Mathematik und Informatik, Universität Basel"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2533d2af",
   "metadata": {},
   "source": [
    "Ziemlich in den Anfängen dieser Vorlesung haben wir Arrays kennengelernt. Arrays sind ein Mechanismus von Java, um eine fixe Anzahl von Daten gleichen Typs zu speichern. Arrays sind direkt in die Programmiersprache Java integriert. Sie sind extrem schnell und erfahren spezielle Unterstützung auf der Java Virtual Machine. Jedoch sind sind sie nicht sehr komfortabel zu benutzen und es fehlen einige wichtige Funktionen, die wir in der täglichen Programmierung brauchen. Zum Beispiel gibt es keine Möglichkeit, die grösse von Arrays dynamisch zu verändern. \n",
    "\n",
    "Mit `List` haben wir eine erste Abstraktion kennengelernt, die das Arbeiten mit Sequenzen von Elementen einfacher macht. Java bietet aber noch weitere Abstraktionen. `Collection` ist ein Interface, welches alle möglichen Arten von *Sammlungen* von Elementen repräsentiert (siehe [API-Doc](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collection.html). Dazu gehören nicht nur `List` sondern auch Datenstrukturen wie `Set`, `Queue` oder `Map` (siehe [Übersicht der Collection Klassen](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/doc-files/coll-overview.html)). \n",
    "\n",
    "Ein weitere Abstraktion ist `Iterable`. Iterable ist ein Interface, welches von einer Klasse implementiert werden muss, damit wir über die Elemente mit dem erweiterten for-loop iteratieren können.\n",
    "\n",
    "Auf einer noch höheren Abstraktionsebene befinden sich die Klasse `Stream` ([API-Doc](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/stream/Stream.html)). Stream repräsentiert Folgen von Elementen, die sogar im Prinzip unendlich lang sein können und jeweils nur Elementweise, in der von der Folge vorgegebenen Reihenfolge, bearbeitet werden. Streams erlauben keinen Zugriff auf die einzelnen Elemente, sondern die Elemente können nur über Operationen wie `map` und `filter` bearbeitet werden. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b998a0bb",
   "metadata": {},
   "source": [
    "### Streams erzeugen\n",
    "\n",
    "Streams werden typischerweise aus bereits vorhanden Collections, wie zum Beispiel Listen oder Arrays erzeugt. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "acd32bd6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import java.util.List;\n",
    "import java.util.LinkedList;\n",
    "import java.util.stream.Stream;\n",
    "\n",
    "\n",
    "LinkedList<Integer> l = new LinkedList<Integer>();\n",
    "for (int i = 0; i < 10; i = i + 1) {\n",
    "    l.add(i);\n",
    "}\n",
    "\n",
    "\n",
    "Stream<Integer> intStream =  l.stream();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "784b3f36",
   "metadata": {},
   "source": [
    "#### Miniübung\n",
    "\n",
    "* Geben Sie `intStream` mit `System.out.println` aus. Was beoabachten Sie? Warum ist das so?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bc0004a",
   "metadata": {},
   "source": [
    "Es gibt auch Streams, die für konkrete, primitive Datentypen spezialisiert sind. Der wichtigste ist vielleicht `IntStream`. Auf diesem ist auch eine Funktion definiert, die uns erlaubt Zahlen in einem gewissen Bereich einfach zu generieren. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "e4266be5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import java.util.stream.IntStream;\n",
    "\n",
    "IntStream intStream = IntStream.range(0, 10);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8da3c78f",
   "metadata": {},
   "source": [
    "Um einen `IntStream` in den entsprechenden Stream des zugehörigen nicht-primitiven Datentyps zu konvertieren, steht die Methode `boxed` zur Verfügung:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "1139664b",
   "metadata": {},
   "outputs": [],
   "source": [
    "Stream<Integer> integerStream = intStream.boxed();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63bf11f8",
   "metadata": {},
   "source": [
    "#### Miniübung\n",
    "\n",
    "* Was passiert, wenn Sie die obige Zelle 2 mal ausführen? Verstehen Sie die Fehlermeldung?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "044f2859",
   "metadata": {},
   "source": [
    "### Collectors"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ece5ff50",
   "metadata": {},
   "source": [
    "Streams können wir mithilfe eines `Collectors` wieder in eine Liste umwandeln. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "5545ee4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import java.util.stream.Collectors;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "872a91a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\r\n"
     ]
    }
   ],
   "source": [
    "import java.util.List;\n",
    "Stream<Integer> stream = IntStream.range(0, 10).boxed(); \n",
    "\n",
    "List<Integer> ll = stream.collect(Collectors.toList());\n",
    "System.out.println(ll);\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89093fba",
   "metadata": {},
   "source": [
    "### Arbeiten mit Streams"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd0f326d",
   "metadata": {},
   "source": [
    "Wir manipulieren die Elemente in eine Stream, indem wir Funktionen darauf ausführen. Die wichtigsten methoden in diesem Kontext sind `map` und `filter`.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "74a53834",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Stream<Integer> stream = IntStream.range(0, 10).boxed();\n",
    "\n",
    "stream.map(x -> x * x).collect(Collectors.toList())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "e2ca40e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Stream<Integer> stream = IntStream.range(0, 10).boxed();\n",
    "\n",
    "stream.filter(x -> x % 2 == 0).collect(Collectors.toList())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c90a1746",
   "metadata": {},
   "source": [
    "Es gibt aber eine Vielzahl weiterer Methoden die auf Streams definiert sind und als Argument einen Lambda-Ausdrück entgegennehmen, der auf jedem Element angewendet wird. Hier ein paar Beispiele:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "2c56f06b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Stream<Integer> stream = IntStream.range(0, 10).boxed(); // boxed um in in Integer umzuwandeln\n",
    "stream.takeWhile(i -> Math.sqrt(i) < 5).collect(Collectors.toList())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "4e097174",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Stream<Integer> stream = IntStream.range(0, 10).boxed(); \n",
    "stream.allMatch(i -> i * i > 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "411348a6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Stream<Integer> stream = IntStream.range(0, 10).boxed(); \n",
    "stream.anyMatch(i -> i * i > 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "d6fc5264",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "Stream<Integer> stream = IntStream.range(0, 10).boxed(); // boxed um in in Integer umzuwandeln\n",
    "stream.forEach(s -> System.out.println(s));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "399be051",
   "metadata": {},
   "source": [
    "### Miniübung\n",
    "\n",
    "* Was macht `anyMatch`? Was macht `allMatch`? Experimentieren Sie. \n",
    "* können Sie statt dem Lambda-Ausdruck in der Methode `forEach` eine Methodenreferenz nutzen um die Elemente auszugeben?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3fba638",
   "metadata": {},
   "source": [
    "### Streams unendlicher Länge"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2c6d51c",
   "metadata": {},
   "source": [
    "*Hinweis:*  Die Nachfolgend eingeführten Beispiele sind sehr fortgeschritten und als Ausblick zu verstehen. Sie müssen diese nicht im Detail verstehen oder selbst umsetzen können. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf87cffe",
   "metadata": {},
   "source": [
    "Wir können auch unendliche lange Sequenzen erzeugen. Hier wird ein Stream aus fortlaufenden Zahlen erzeugt. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "ebf493c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "Stream<Integer> infinitelyLongStream = Stream.iterate(1, (Integer i) -> i + 1);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74384e9f",
   "metadata": {},
   "source": [
    "Wir können wie mit endlichen Stream mittels `map`, `filter`, etc. die Elemente transformieren. \n",
    "Das folgende Beispiel berechnet alle Quadratzahlen bis 100, die durch 8 Teilbar sind.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "212f7a19",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[16, 64, 144, 256, 400, 576, 784]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Stream<Integer> infinitelyLongStream = Stream.iterate(1, (Integer i) -> i + 1);\n",
    "\n",
    "infinitelyLongStream.map(i -> (i * i)).filter(i -> i % 8 == 0).takeWhile(i -> i < 1000).collect(Collectors.toList())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92bd502d",
   "metadata": {},
   "source": [
    "Wir können auch einen unendlich lange Folge von Zusatzzahlen erzeugen. Im Folgenden erzeugen wir so lange Zufallszahlen, bis eine der Zahlen im Interval $[-10000, 10000]$ liegt. Dann zählen wir, wieviele Zahlen wir erzeugt haben, bis dies der Fall war. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "9c85c563",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32015"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import java.util.Random;\n",
    "\n",
    "Random rng = new Random();\n",
    "\n",
    "Stream<Integer> randomStream = Stream.generate(rng::nextInt);\n",
    "\n",
    "randomStream.takeWhile(i -> (i < -10000) || (i > 10000)).count()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c3131f4",
   "metadata": {},
   "source": [
    "#### Miniübung\n",
    "\n",
    "* Was für ein Funktionsobjekt nimmt `Stream.generate` entgegen (also Predicate, Consumer, Supplier, Operator)?\n",
    "* Überlegen Sie sich folgendes: Wie ist es möglich, dass wir mit einer unendlich langen Sequenz arbeiten können? Sollte das nicht unendlich lange dauern?"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "codemirror_mode": "java",
   "file_extension": ".jshell",
   "mimetype": "text/x-java-source",
   "name": "Java",
   "pygments_lexer": "java",
   "version": "18.0.1+10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}