jupyter/chapter09-list_and_map.ipynb

{
  "cells": [{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["# List and Map\n", "In Java, the most used data structures are List (an indexed list) and Map (a dictionary)\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## List\n", "To create a simple list\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var numbers = List.of(1, 2, 3);\n", "System.out.println(numbers);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["a list is an indexed data structure that stores object in the order of insertions\n", "get() access to an element given an index\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var firstElement = numbers.get(0);\n", "var lastElement = numbers.get(numbers.size() - 1);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["contains return true if a value is contained in the list\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["System.out.println(numbers.contains(4));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["indexOf returns the first index of the element in the list\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["System.out.println(numbers.indexOf(2));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["a list also defines the method equals()/hashCode() and toString(), so\n", "you can print a list or test if two list are equals\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var friends = List.of(\"cesar\", \"rosalie\", \"david\");\n", "System.out.println(friends);\n", "System.out.println(friends.hashCode());\n", "System.out.println(friends.equals(numbers));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Unmodifiable/modifiable list\n", "in Java, depending on how you create a data structure it can be changed\n", "after creation or not. Implementation that allow mutation after creation\n", "are called modifiable\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["by example, the list above (created with the static method of()) is not modifiable\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var countries = List.of(\"UK\", \"US\", \"France\");\n", "countries.set(0, \"Poland\"); // throws an UnsupportedOperationException\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["To create a modifiable list, we use an ArrayList, created using the operator 'new'\n", "and because because there is no element in the list, the compiler has no way to know\n", "the type of the elements so we have to provide it in between angle brackets ('<' and '>')\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var modifiableCountries = new ArrayList<String>();\n", "System.out.println(modifiableCountries);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["To add elements in a list, we have the method add()\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["modifiableCountries.add(\"UK\");\n", "modifiableCountries.add(\"US\");\n", "modifiableCountries.add(\"France\");\n", "modifiableCountries.add(\"Poland\");\n", "System.out.println(modifiableCountries);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["to remove an element, we have the method remove()\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["modifiableCountries.remove(\"UK\");\n", "System.out.println(modifiableCountries);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Iterating\n", "an unmodifiable list or a modifiable list have the same set of methods.\n", "to loop over the elements of a list, we have a special syntax using the keyword 'for'\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var countries = List.of(\"UK\", \"US\", \"France\");\n", "for(var country: countries) {\n", "  System.out.println(country);\n", "}\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["you can also loop over the elements using a method forEach\n", "if you don't understand this one, don't panic, we will see it later\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["countries.forEach(country -> System.out.println(country));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Conversions\n", "To can create an unmodifiable list from a modifiable one with List.copyOf()\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var unmodifiableList = List.copyOf(modifiableCountries);\n", "System.out.println(unmodifiableList);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["To create a modifiable list from an unmodifiable one using `new ArrayList(List)`\n", "In that case you don't have to specify the type of the elements\n", "the compiler already knows the type of list hence the <> (diamond)\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var modifiableList = new ArrayList<>(unmodifiableList);\n", "System.out.println(modifiableList);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Useful patterns\n", "To remove some elements depending on a predicate (if something is true)\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var elements = new ArrayList<>(List.of(\"table\", \"chair\", \"stool\"));\n", "elements.removeIf(element -> element.charAt(0) == 'c');\n", "System.out.println(elements);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Map\n", "A Map associate a value to a key\n", "To create a simple Map\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var petCost = Map.of(\"cat\", 200, \"dog\", 350, \"lion\", 5000);\n", "System.out.println(petCost);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["to get the value from a key\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var costOfADog = petCost.get(\"dog\");\n", "System.out.println(costOfADog);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["__Warning__! __warning__! asking for a key which is not in the map will return null\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var costOfAGirafe = petCost.get(\"girafe\");\n", "System.out.println(costOfAGirafe);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["to avoid null, use the method `getOrDefault()` that let you specify a default value\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var costOfAGirafe = petCost.getOrDefault(\"girafe\", 0);\n", "System.out.println(costOfAGirafe);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["And like a list, a map defines the method `equals()`/`hashCode()` and `toString()`\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var lighter = Map.of(\"blue\", \"lightblue\", \"gray\", \"white\");\n", "var darker = Map.of(\"blue\", \"darkblue\", \"gray\", \"black\");\n", "System.out.println(lighter);\n", "System.out.println(darker.hashCode());\n", "System.out.println(lighter.equals(darker));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Unmodifiable/modifiable\n", "The Map create by Map.of() are non modifiable\n", "To create a modifiable map, we use new HashMap to create the map\n", "and map.put to put key/value in it\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var modifiableMap = new HashMap<String, String>();\n", "modifiableMap.put(\"blue\", \"lightblue\");\n", "modifiableMap.put(\"gray\", \"white\");\n", "System.out.println(modifiableMap);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["Removing the key, remove the couple key/value\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["modifiableMap.remove(\"blue\");\n", "System.out.println(modifiableMap);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Iterating on `keySet()` or `entrySet()`\n", "you can not use a for loop directly on a Map\n", "but you can do it on the set of keys\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var petCost = Map.of(\"cat\", 200, \"dog\", 350, \"lion\", 5000);\n", "for(var pet: petCost.keySet()) {\n", "  System.out.println(pet);\n", "}\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["or on the set of couples key/value (a `Map.Entry`)\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["for(var entry: petCost.entrySet()) {\n", "  var pet = entry.getKey();\n", "  var cost = entry.getValue();\n", "  System.out.println(pet + \" \" + cost);\n", "}\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["You can also loop over the entries using the method `forEach()`\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["petCost.forEach((pet, cost) -> {\n", "  System.out.println(pet + \" \" + cost);\n", "});\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Conversions\n", "To create a unmodifiableMap from a modifiable map, use `Map.copyOf()`\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var modifiableMap = new HashMap<String, String>();\n", "modifiableMap.put(\"jack sparrow\", \"pirate\");\n", "modifiableMap.put(\"hector barbossa\", \"pirate\");\n", "var unmodifiableMap = Map.copyOf(modifiableMap);\n", "System.out.println(unmodifiableMap);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["To create a modifiableMap from an unmodifiable map, use `new HashMap<>()`\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var unmodifiableMap = Map.of(\"jack sparrow\", \"pirate\", \"hector barbossa\", \"pirate\");\n", "var modifiableMap = new HashMap<>(unmodifiableMap);\n", "System.out.println(modifiableMap);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Useful patterns\n", "To make the Map acts as a cache, use `computeIfAbsent()`\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["record Person(String name, int age) { }\n", "var persons = List.of(new Person(\"Bob\", 23), new Person(\"Anna\", 32), new Person(\"Bob\", 12));\n", "var group = new HashMap<String, List<Person>>();\n", "persons.forEach(person -> group.computeIfAbsent(person.name(), name -> new ArrayList<>())\n", "                                .add(person));\n", "System.out.println(group);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["to count the number of occurrence, use `merge()` that takes a key, a value and the function\n", "to call if there is already an existing value to combine them\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var letters = List.of(\"a\", \"b\", \"e\", \"b\");\n", "var occurrenceMap = new HashMap<String, Integer>();\n", "letters.forEach(letter -> occurrenceMap.merge(letter, 1, Integer::sum));\n", "System.out.println(occurrenceMap);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### More on transformations\n", "To do more transformations of lists and maps, use the Stream API.\n"]
}
],
  "metadata": {
    "kernelspec": {
      "display_name": "Java",
      "language": "java",
      "name": "java"
    },
    "language_info": {
      "codemirror_mode": "java",
      "file_extension": ".java",
      "mimetype": "text/x-java-source",
      "name": "Java",
      "pygments_lexer": "java",
      "version": "15"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}