_notebooks/2023-12-13-HashmapsHashsetsCollections.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "toc: true\n",
    "comments: true\n",
    "layout: post\n",
    "title: HashMaps, HashSets, Collections, SQL Student Lessons\n",
    "description: by Tirth T, Haseeb B, Sreeja G, Ekam K, Drew R, Adan R\n",
    "courses: { csa: {week: 16} }\n",
    "type: hacks\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Collections\n",
    "\n",
    "### What are collections?\n",
    "Collections are any group of individual objects that are represented as a single unit is known as a Java Collection of Objects. In Java, a separate framework named the “Collection Framework” has been defined in JDK 1.2 which holds all the Java Collection Classes and Interface in it. It works as an interface that defines the highest-level of shared collection behavior, and extends Iterable which allows usage of ForEach loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Types of Collections\n",
    "\n",
    "- **List:**  \n",
    "    - Ordered collection\n",
    "    - Allows duplicate elements\n",
    "    - Example: **ArrayList** and **LinkedList**\n",
    "\n",
    "- **Set:**  \n",
    "    - Unordered collection \n",
    "    - No duplicates\n",
    "    - Example: **HashSet** and **TreeSet**\n",
    "\n",
    "- **Map:**  \n",
    "    - Key-pair values\n",
    "    - Each key must be unique\n",
    "    - Example: **HashMap** and **TreeMap**\n",
    "\n",
    "- **Queue:**  \n",
    "    - Follows First-In-First-Out order\n",
    "    - Example: **LinkedList** and **PriorityQueue**\n",
    "\n",
    "- **Deque:**  \n",
    "    - Double ended queue\n",
    "    - Insertion and removal at both ends\n",
    "    - Example: **ArrayDeque**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Popcorn Hack!\n",
    "Come up with a real world example in which collections are used! Write your answer below:\n",
    "\n",
    "One real world example in which collections are used is managing a library’s inventory system, specifically with a List or Set. The library has a variety of books that can be sorted by attributes like title, author, and availability status. A collection like a List or Set could be used to represent the entire inventory of books and allow us to sort the books by some of these attributes."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## HashMaps \n",
    "\n",
    "#### What are they? \n",
    "\n",
    "Hash Maps are a **data structure** with keys and values; very similar to a Python dictionary. The keys in Hash Maps have a single value assigned to them, which can be accessed by calling the key: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mercury is 0.39 astronomical units away from the Sun\n"
     ]
    }
   ],
   "source": [
    "import java.util.HashMap;  //Hashmaps are part of the java.util package\n",
    "\n",
    "public class PlanetDistances {\n",
    "    public static void main(String[] args) {\n",
    "\n",
    "        HashMap<String, Double> hashMap = new HashMap<>();\n",
    "\n",
    "        // key-value pairs, where the key is the planet (a string) and the value is the double assigned to each key\n",
    "        hashMap.put(\"Mercury\", 0.39);\n",
    "        hashMap.put(\"Venus\", 0.72); //adding an element\n",
    "        hashMap.put(\"Earth\", 1.00);\n",
    "        hashMap.remove(\"Earth\", 1.00); //removing an element\n",
    "\n",
    "        // the value 0.39 can be accessed by calling the key \"Mercury\"\n",
    "        double value = hashMap.get(\"Mercury\");\n",
    "        boolean exists = hashMap.containsKey(\"Mercury\"); //you can also check if a key exists\n",
    "        System.out.println(\"Mercury is \" + value + \" astronomical units away from the Sun\");\n",
    "    }\n",
    "}\n",
    "\n",
    "PlanetDistances.main(null);"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As shown above, the data type of the keys and values must be defined when creating the Hashmap. You cannot use data types for keys or values that are different from the ones assigned to it. Also, keys must be non-null objects. However, values can be null!\n",
    "\n",
    "<br>\n",
    "\n",
    "Keys in a Hashmap must be unique. Otherwise the previous values of the key get overwritten."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A Nike shoe would cost 80.97\n"
     ]
    }
   ],
   "source": [
    "import java.util.HashMap;  \n",
    "\n",
    "public class ShoePrices {\n",
    "    public static void main(String[] args) {\n",
    "\n",
    "        HashMap<String, Double> hashMap = new HashMap<>();\n",
    "\n",
    "        hashMap.put(\"Nike\", 41.97);\n",
    "        hashMap.put(\"Nike\", 80.97); //this value replaces the previous value \n",
    "        hashMap.put(\"Adidas\", 69.99);\n",
    "        hashMap.put(\"Vans\", 55.00);\n",
    "\n",
    "        double value = hashMap.get(\"Nike\");\n",
    "        System.out.println(\"A Nike shoe would cost \" + value);\n",
    "    }\n",
    "}\n",
    "\n",
    "ShoePrices.main(null);"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Popcorn hack: what can we do if we want to assign multiple values to a single key? Do it below!: \n",
    "\n",
    "An ArrayList or Array can be used to assign multiple values to a single key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import java.util.HashMap;  \n",
    "\n",
    "public class ShoePrices {\n",
    "    public static void main(String[] args) {\n",
    "\n",
    "        HashMap<String, Double> hashMap = new HashMap<>();\n",
    "\n",
    "        hashMap.put(\"Nike\", 41.97);\n",
    "        hashMap.put(\"Nike\", 80.97);\n",
    "        hashMap.put(\"Adidas\", 69.99);\n",
    "        hashMap.put(\"Vans\", 55.00);\n",
    "\n",
    "        double value = hashMap.get(\"Nike\");\n",
    "        System.out.println(\"A Nike shoe would cost \" + value);\n",
    "    }\n",
    "}\n",
    "\n",
    "ShoePrices.main(null);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### My Code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nike shoe prices: [41.97, 80.97]\n",
      "The first price for Nike: 41.97\n"
     ]
    }
   ],
   "source": [
    "import java.util.HashMap;\n",
    "import java.util.ArrayList;\n",
    "import java.util.List;\n",
    "\n",
    "public class ShoePrices {\n",
    "    public static void main(String[] args) {\n",
    "\n",
    "        HashMap<String, List<Double>> hashMap = new HashMap<>();\n",
    "\n",
    "        // Add the first price for Nike\n",
    "        hashMap.put(\"Nike\", new ArrayList<>());\n",
    "        hashMap.get(\"Nike\").add(41.97);\n",
    "\n",
    "        // Add the second price for Nike\n",
    "        hashMap.get(\"Nike\").add(80.97);\n",
    "\n",
    "        // Add prices for other shoe brands\n",
    "        hashMap.put(\"Adidas\", new ArrayList<>());\n",
    "        hashMap.get(\"Adidas\").add(69.99);\n",
    "\n",
    "        hashMap.put(\"Vans\", new ArrayList<>());\n",
    "        hashMap.get(\"Vans\").add(55.00);\n",
    "\n",
    "        // Retrieve and print prices for Nike\n",
    "        List<Double> nikePrices = hashMap.get(\"Nike\");\n",
    "        System.out.println(\"Nike shoe prices: \" + nikePrices);\n",
    "\n",
    "        // If you want to get a specific price, you can do so by index\n",
    "        double firstNikePrice = nikePrices.get(0);\n",
    "        System.out.println(\"The first price for Nike: \" + firstNikePrice);\n",
    "    }\n",
    "}\n",
    "ShoePrices.main(null);"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that collisions can still occur when two keys produce the same hash code. Hash codes are assigned to each key through a hash function (this is called hashing). They are used to determine what the key-value pair's index should be iwthin the Hashmaps. A bad hash function may cause collisions to occur, in which case the function would need to be adjusted. "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "HashMaps do not store the input order of the key-value pairs, and there is no guarantee the pairs will always be stored in the same order. Therefore if something needs to be found within a HashMap, iteration must be used. This can be done through `keySet()`, `values()`, or `entrySet()`\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "**keySet()** -- provides access to the set of keys. Useful for if you only need to access keys w/out values "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of Oscar winners [Nomadland, Parasite, Green Book, The Shape of Water]\n"
     ]
    }
   ],
   "source": [
    "import java.util.HashMap;\n",
    "import java.util.Set;\n",
    "\n",
    "public class OscarWinners {\n",
    "    public static void main(String[] args) {\n",
    "\n",
    "        HashMap<String, Integer> oscarWinnersYear = new HashMap<>();\n",
    "\n",
    "        oscarWinnersYear.put(\"Nomadland\", 2020);\n",
    "        oscarWinnersYear.put(\"Parasite\", 2019);\n",
    "        oscarWinnersYear.put(\"Green Book\", 2018);\n",
    "        oscarWinnersYear.put(\"The Shape of Water\", 2017);\n",
    "\n",
    "        Set<String> oscarWinners = oscarWinnersYear.keySet(); //using keySet to get keys \n",
    "\n",
    "        System.out.println(\"List of Oscar winners \" + oscarWinners);\n",
    "    }\n",
    "}\n",
    "\n",
    "OscarWinners.main(null);"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**values()** -- returns set of values, without any keys "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Years movies won Oscars [2020, 2019, 2018, 2017]\n"
     ]
    }
   ],
   "source": [
    "import java.util.HashMap;\n",
    "import java.util.Set;\n",
    "\n",
    "public class OscarWinners {\n",
    "    public static void main(String[] args) {\n",
    "\n",
    "        HashMap<String, Integer> oscarWinnersYear = new HashMap<>();\n",
    "\n",
    "        oscarWinnersYear.put(\"Nomadland\", 2020);\n",
    "        oscarWinnersYear.put(\"Parasite\", 2019);\n",
    "        oscarWinnersYear.put(\"Green Book\", 2018);\n",
    "        oscarWinnersYear.put(\"The Shape of Water\", 2017);\n",
    "\n",
    "        Collection<Integer> oscarWinnerYears = oscarWinnersYear.values(); //using values to get values \n",
    "\n",
    "        System.out.println(\"Years movies won Oscars \" + oscarWinnerYears);\n",
    "    }\n",
    "}\n",
    "\n",
    "OscarWinners.main(null);"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**entryset()** -- returns keys and values in the form of objects. Useful for when working with key-value pair relationships"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Oscars and their years [Nomadland=2020, Parasite=2019, Green Book=2018, The Shape of Water=2017]\n"
     ]
    }
   ],
   "source": [
    "import java.util.HashMap;\n",
    "import java.util.Set;\n",
    "\n",
    "public class OscarWinners {\n",
    "    public static void main(String[] args) {\n",
    "\n",
    "        HashMap<String, Integer> oscarWinnersYear = new HashMap<>();\n",
    "\n",
    "        oscarWinnersYear.put(\"Nomadland\", 2020);\n",
    "        oscarWinnersYear.put(\"Parasite\", 2019);\n",
    "        oscarWinnersYear.put(\"Green Book\", 2018);\n",
    "        oscarWinnersYear.put(\"The Shape of Water\", 2017);\n",
    "\n",
    "        Set<Map.Entry<String, Integer>> oscarWinnersAndYears = oscarWinnersYear.entrySet(); //using values to get values \n",
    "\n",
    "        System.out.println(\"Oscars and their years \" + oscarWinnersAndYears);\n",
    "    }\n",
    "}\n",
    "\n",
    "OscarWinners.main(null);"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "HashMaps have a time complexity of O(1) on average!"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## HashSet\n",
    "\n",
    "### What is a hashset?\n",
    "- A hashset is a data structure that stores only unique values and does not allow duplicates. You can also think of it as a set of keys with no values.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Red, Blue, Green]\n"
     ]
    }
   ],
   "source": [
    "import java.util.HashSet;\n",
    "import java.util.Set;\n",
    "\n",
    "public class Colors{\n",
    "    static Set<String> colors = new HashSet<>();\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        colors.add(\"Red\");\n",
    "        colors.add(\"Blue\");\n",
    "        colors.add(\"Green\");\n",
    "        System.out.println(colors);\n",
    "    }\n",
    "}\n",
    "\n",
    "Colors.main(null);"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What if we add duplicates?\n",
    "- If we try add duplicates, the hashset will simply not add the duplicate value and return false as seen bellow. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n",
      "true\n",
      "false\n",
      "[Blue, Green]\n"
     ]
    }
   ],
   "source": [
    "public class ColorsButDifferent{\n",
    "    static Set<String> colors = new HashSet<>();\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        System.out.println(colors.add(\"Blue\"));\n",
    "        System.out.println(colors.add(\"Green\"));\n",
    "        System.out.println(colors.add(\"Green\"));\n",
    "        System.out.println(colors);\n",
    "    }\n",
    "}\n",
    "\n",
    "ColorsButDifferent.main(null);"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Order?\n",
    "- Hashsets are not ordered and do not store the order in which the values were added that means that if values are removed their order will not be preserved. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Apple, Orange, Banana]\n",
      "[Apple, Orange]\n"
     ]
    }
   ],
   "source": [
    "public class Fruits{\n",
    "    static Set<String> fruits = new HashSet<>();\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        fruits.add(\"Apple\");\n",
    "        fruits.add(\"Banana\");\n",
    "        fruits.add(\"Orange\");\n",
    "        System.out.println(fruits);\n",
    "\n",
    "        fruits.remove(\"Banana\");\n",
    "\n",
    "        System.out.println(fruits);\n",
    "    }\n",
    "}\n",
    "\n",
    "Fruits.main(null);"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How do you know if a value is in a hashset?\n",
    "- You can use the contains method to check if a value is in a hashset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n"
     ]
    }
   ],
   "source": [
    "public class Fruits{\n",
    "    static Set<String> fruits = new HashSet<>();\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        fruits.add(\"Apple\");\n",
    "        fruits.add(\"Banana\");\n",
    "        fruits.add(\"Orange\");\n",
    "\n",
    "        System.out.println(fruits.contains(\"Apple\"));\n",
    "    }\n",
    "}\n",
    "\n",
    "Fruits.main(null);"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other methods\n",
    "- clear() - removes all values from the hashset\n",
    "- isEmpty() - returns true if the hashset is empty\n",
    "- size() - returns the number of values in the hashset\n",
    "- toArray() - returns an array of the values in the hashset\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Apple, Orange, Banana]\n",
      "\n",
      "Length of Hashmap: 3\n",
      "\n",
      "Array Version of Hashmap: [Ljava.lang.Object;@665e264a\n",
      "\n",
      "Hashmap After Clearing []\n"
     ]
    }
   ],
   "source": [
    "public class Fruits{\n",
    "    static Set<String> fruits = new HashSet<>();\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        fruits.add(\"Apple\");\n",
    "        fruits.add(\"Banana\");\n",
    "        fruits.add(\"Orange\");\n",
    "        System.out.println(fruits);\n",
    "\n",
    "        System.out.println();\n",
    "        System.out.println(\"Length of Hashmap: \" + fruits.size());\n",
    "        \n",
    "        System.out.println();\n",
    "        System.out.println(\"Array Version of Hashmap: \" + fruits.toArray());\n",
    "\n",
    "        System.out.println();\n",
    "        fruits.clear();\n",
    "        System.out.println(\"Hashmap After Clearing \" + fruits);\n",
    "\n",
    "    }\n",
    "}\n",
    "\n",
    "Fruits.main(null);"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterations\n",
    "- You can iterate through a hashset using a for each loop or an iterator. The order of the values is not guaranteed and can change as values are removed or added.\n",
    "- These two methods are can be called using the `iterator()` and `forEach()` methods. For the `forEach()` method you can pass in a lambda expression (a lambda expression is an anonymous function) or a method reference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Apple, Orange, Banana]\n",
      "Apple\n",
      "Orange\n",
      "Banana\n"
     ]
    }
   ],
   "source": [
    "// foreach loop to iterate through a set\n",
    "\n",
    "public class Fruits{\n",
    "    static Set<String> fruits = new HashSet<>();\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        fruits.add(\"Apple\");\n",
    "        fruits.add(\"Banana\");\n",
    "        fruits.add(\"Orange\");\n",
    "        System.out.println(fruits);\n",
    "\n",
    "        // Using foreach loop to iterate through the set and print each fruit as it goes\n",
    "        fruits.forEach(fruit -> System.out.println(fruit));\n",
    "    }\n",
    "}\n",
    "\n",
    "Fruits.main(null);\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Brie, Cheddar, Gouda]\n",
      "I love Brie\n",
      "I like Cheddar\n",
      "I like Gouda\n"
     ]
    }
   ],
   "source": [
    "// Different version of foreach loop to iterate through a set\n",
    "\n",
    "public class Cheeses{\n",
    "    static Set<String> cheeses = new HashSet<>();\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        cheeses.add(\"Cheddar\");\n",
    "        cheeses.add(\"Brie\");\n",
    "        cheeses.add(\"Gouda\");\n",
    "        System.out.println(cheeses);\n",
    "\n",
    "        cheeses.forEach(cheese -> {\n",
    "            if(cheese.equals(\"Brie\")) {\n",
    "                System.out.println(\"I love \" + cheese);\n",
    "            } else {\n",
    "                System.out.println(\"I like \" + cheese);\n",
    "            }\n",
    "        });\n",
    "    }\n",
    "}\n",
    "\n",
    "Cheeses.main(null);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Sorry, Monopoly, Scrabble]\n",
      "\n",
      "Sorry\n",
      "Monopoly\n",
      "Scrabble\n"
     ]
    }
   ],
   "source": [
    "// using iterator to iterate through a set\n",
    "\n",
    "import java.util.Iterator;\n",
    "\n",
    "public class Games{\n",
    "    static Set<String> games = new HashSet<>();\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        games.add(\"Monopoly\");\n",
    "        games.add(\"Scrabble\");\n",
    "        games.add(\"Sorry\");\n",
    "        System.out.println(games);\n",
    "        System.out.println();\n",
    "\n",
    "        Iterator<String> iterator = games.iterator();\n",
    "        while(iterator.hasNext()) {\n",
    "            System.out.println(iterator.next());\n",
    "        }\n",
    "    }\n",
    "}\n",
    "\n",
    "Games.main(null);"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How to check for equality?\n",
    "- You can check if two hashsets are equal by using the `equals()` method. This method will return true if the hashsets contain the same values and false if they do not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Are the sets equal? true\n"
     ]
    }
   ],
   "source": [
    "public class Pokemon {\n",
    "    public static void main(String[] args) {\n",
    "        Set<String> pokemonSet1 = new HashSet<>();\n",
    "        Set<String> pokemonSet2 = new HashSet<>();\n",
    "\n",
    "        // Populate the sets\n",
    "        pokemonSet1.add(\"Pikachu\");\n",
    "        pokemonSet1.add(\"Charmander\");\n",
    "        pokemonSet1.add(\"Pikaman\");\n",
    "\n",
    "        pokemonSet2.add(\"Pikachu\");\n",
    "        pokemonSet2.add(\"Charmander\");\n",
    "        pokemonSet2.add(\"Pikaman\");\n",
    "\n",
    "        // Check equality\n",
    "        boolean areEqual = pokemonSet1.equals(pokemonSet2);\n",
    "        System.out.println(\"Are the sets equal? \" + areEqual);\n",
    "    }\n",
    "}\n",
    "\n",
    "Pokemon.main(null);\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other kinds of hashsets\n",
    "- There are other kinds of hashsets that are similar to the hashset but have some differences. These include the linkedhashset and the treeset. \n",
    "- The linkedhashset is similar to the hashset but it maintains the order in which the values were added. \n",
    "- The treeset is similar to the hashset but it sorts the values in ascending order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LinkedHashSet: \n",
      "Pikachu\n",
      "Charmander\n",
      "Pikaman\n",
      "\n",
      "New hashset: [Charmander, Pikaman]\n"
     ]
    }
   ],
   "source": [
    "// LinkedHashSet\n",
    "\n",
    "import java.util.LinkedHashSet;\n",
    "import java.util.Set;\n",
    "\n",
    "public class LinkedHashSetExample {\n",
    "    public static void main(String[] args) {\n",
    "        Set<String> linkedHashSet = new LinkedHashSet<>();\n",
    "\n",
    "        // Add elements\n",
    "        linkedHashSet.add(\"Pikachu\");\n",
    "        linkedHashSet.add(\"Charmander\");\n",
    "        linkedHashSet.add(\"Pikaman\");\n",
    "\n",
    "        // Iterate through the LinkedHashSet\n",
    "        System.out.println(\"LinkedHashSet: \");\n",
    "        linkedHashSet.forEach(pokemon -> System.out.println(pokemon));\n",
    "        System.out.println();\n",
    "\n",
    "        linkedHashSet.remove(\"Pikachu\");\n",
    "        System.out.println(\"New hashset: \" + linkedHashSet);\n",
    "    }\n",
    "}\n",
    "\n",
    "LinkedHashSetExample.main(null);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alberquerque, New Mexico\n",
      "Charmander\n",
      "Pikachu\n",
      "Pikaman\n"
     ]
    }
   ],
   "source": [
    "// TreeSet\n",
    "import java.util.Set;\n",
    "import java.util.TreeSet;\n",
    "\n",
    "public class TreeSetExample {\n",
    "    public static void main(String[] args) {\n",
    "        Set<String> treeSet = new TreeSet<>();\n",
    "\n",
    "        // Add elements\n",
    "        treeSet.add(\"Alberquerque, New Mexico\");\n",
    "        treeSet.add(\"Pikachu\");\n",
    "        treeSet.add(\"Charmander\");\n",
    "        treeSet.add(\"Pikaman\");\n",
    "\n",
    "        // Iterate through the TreeSet\n",
    "        treeSet.forEach(pokemon -> System.out.println(pokemon));\n",
    "        // The values for the TreeSet are sorted alphabetically\n",
    "    }\n",
    "}\n",
    "\n",
    "TreeSetExample.main(null);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SQL\n",
    "\n",
    "SQL is a programming language focused on managing and manipulating relational (table-based) databases. It acts as the backbone for many of this class's project backends, allowing users to create, read, update and delete data efficiently. To get a better idea of how data is formatted with JPA to be stored in an SQL database, we'll be looking at the `Person` object in the [lesson backend](https://github.com/Tirth-Thakkar/LessonBackend). Follow along in this notebook.\n",
    "\n",
    "### Person Object Setup\n",
    "\n",
    "(see .../mvc/person/Person.java)\n",
    "\n",
    "After the first three tags, which specify to Lombok that `@AllArgsConstructor` and `@NoArgsConstructor` methods should be created\n",
    "\n",
    "The `@Entity` tag indicates that Person objects will be stored as entities in a database. Generally, entities' attributes are represented by values in columns in the SQLite table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@Data\n",
    "@AllArgsConstructor\n",
    "@NoArgsConstructor\n",
    "@Entity\n",
    "@Convert(attributeName =\"person\", converter = JsonType.class)\n",
    "public class Person //..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `@Id` tag specifies to that this value will be used as the unique identifier for each object in the database, and `@GeneratedValue(strategy = GenerationType.AUTO)` allows these ID's to be automatically generated when a new Person is created. In order for data to be most easily differentiated and manipulated in a database, IDs are deeply important to use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@Id\n",
    "@GeneratedValue(strategy = GenerationType.AUTO)\n",
    "private Long id;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Person JPA Repository Setup\n",
    "\n",
    "(see .../mvc/person/PersonJpaRepository.java)\n",
    "\n",
    "JPA is a great asset when creating an SQL database because it can provide methods that help you modify its contents. If a specific object has a `JpaRepository` interface made that extends the base JPA repository, it allows you to access many useful JPA methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import org.springframework.data.jpa.repository.JpaRepository;\n",
    "import org.springframework.data.jpa.repository.Query;\n",
    "\n",
    "// ...\n",
    "\n",
    "public interface PersonJpaRepository extends JpaRepository<Person, Long> // ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Popcorn Hack!\n",
    "\n",
    "List all of the JPA methods that you see in the PersonJpaRepository.java file and what their purpose is.\n",
    "\n",
    "- Person findByEmail(String email):\n",
    "Retrieves data from a Person object based on the Person's email address.\n",
    "\n",
    "- List findAllByOrderByNameAsc():\n",
    "This method fetches and returns a list of all Person objects in ascending order by name. This is useful if you want to display user names in an order list.\n",
    "\n",
    "- List findByNameContainingIgnoreCaseOrEmailContainingIgnoreCase(String name, String email);\n",
    "Used to find all Person objects whose names contain the given string name (case insensitive) or whose emails contain the given string name (case insensitive).\n",
    "\n",
    "- Person findByEmailAndPassword(String email, String password):\n",
    "Retrieves the data of a Person object based on the Person's matching email and password.\n",
    "\n",
    "- List findByLikeTermNative(String term): \n",
    "The Person table is searched for any records that contain a given string (argument term in this case). It's almost like a Ctrl F (at least for me), because we can search for a specific phrase or series of characters within a large text. Similarly, this method enables us to have more complex search methods, which is especially useful in large data bases.\n",
    "\n",
    "#### Custom JPA Queries\n",
    "\n",
    "You can create custom JPA queries that utilize SQL to serve a specific purpose outside of the existing JPA methods. See the example below from PersonJpaRepository.java:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@Query(\n",
    "        value = \"SELECT * FROM Person p WHERE p.name LIKE ?1 or p.email LIKE ?1\",\n",
    "        nativeQuery = true)\n",
    "List<Person> findByLikeTermNative(String term);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Going step-by-step:\n",
    "- The `@Query` indicates a custom query is being created\n",
    "- `value` is a String containing an SQL query that will be run with the method `findByLikeTermNative`\n",
    "    - `?1` is a placeholder for a parameter (in this case the String `term` from the method declaration)\n",
    "- `nativeQuery` is set to true, indicating that the value uses native SQL rather than JPQL (Java Persistence Query Language)\n",
    "\n",
    "Using a custom SQL query like this would be a great way to show understanding on the homework."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Many-to-Many Relationship\n",
    "\n",
    "(see .../mvc/person/Person.java)\n",
    "\n",
    "A \"Many-to-Many\" relationship (shown in the @ManyToMany tag) indicates that entities on both sides of a relationship can have multiple connections with each other.\n",
    "\n",
    "This condition allows for one object to be related to multiple different objects, and those different objects on the other side of the relationship can have their own relationship to other objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@ManyToMany(fetch = EAGER)\n",
    "private Collection<PersonRole> roles = new ArrayList<>();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(fetch = EAGER) specifies that, whenever a `Person` object is loaded, its corresponding `PersonRole` objects should be loaded simultaneously.\n",
    "\n",
    "Objects in a \"many-to-many\" relationship often use \"join tables\" to represent the connections between these objects.\n",
    "\n",
    "```text\n",
    "| person_id | role_id |\n",
    "|-----------|---------|\n",
    "| 1         | 1       |\n",
    "| 1         | 2       |\n",
    "| 2         | 2       |\n",
    "| 3         | 1       |\n",
    "| 3         | 3       |\n",
    "```\n",
    "\n",
    "This is what a \"join table\" may look like with multiple interconnected people and roles. There is a table in the backend repository's SQLite.db called `person_roles` that acts as a join table for the two roles, but you'll notice that it's empty. If you can show it filled up, that sounds like a good reason to give extra points.\n",
    "\n",
    "#### Popcorn Hack!\n",
    "\n",
    "Explain in your own words what the relationship between `Person` objects and `PersonRole` objects is. Why is this relevant to collections? (Hint: In the code above, multiple `PersonRole` objects are stored within a `Person` object's roles attribute.)\n",
    "\n",
    "The many-to-many relationship between Person objects and PersonRole objects is managed in Java in this repository via the JPA (Java Persistence API) file and in the database via a join table. This is relevant to the collections we've learned about because it involves efficiently and structuredly managing groups of related data (i.e. roles for each person)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Many-to-One Relationship\n",
    "\n",
    "On the other hand, there is also a \"Many-to-One\" relationship that can exist between two objects. It means that multiple instances of one entity (the \"many\" side) are associated with a single instance of another entity (the \"one\" side). This can be seen applied to the `Note` object in relation to the `Person` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@ManyToOne(fetch = FetchType.LAZY, optional = false)\n",
    "@JoinColumn(name = \"tutorial_id\", nullable = false) // notice this!\n",
    "@OnDelete(action = OnDeleteAction.CASCADE)\n",
    "@JsonIgnore\n",
    "private Person person;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice the `@JoinColumn(name = \"tutorial_id\", nullable = false)` tag. Then, check the `note` table in the sqlite.db file.\n",
    "\n",
    "#### Popcorn Hack!\n",
    "\n",
    "Where do you see \"tutorial_id\" on the table? What does it represent in relation to the leftmost \"id\" column?\n",
    "\n",
    "When I look inside the sqlite.db file, I can see the tutorial_id in a column of the note table. The primary key of the Note entity is typically the leftmost \"id\" column in the note table. Each note has a distinct ID (id) and is associated with a Person (for example, tutorial_id). The id column identifies each Note, while tutorial_id connects it to its corresponding Person (this is why the tutorial_id column only contains numbers)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Storing HashMaps with jsonb\n",
    "\n",
    "JSONB is a binary representation of JSON data. It is a data type used in some relational databases (such as SQL databases) to store JSON documents in a more efficient and flexible way compared to traditional JSON. Within SQL databases, this data from the JSON can often be filtered, searched and/or extracted using provided functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@JdbcTypeCode(SqlTypes.JSON)\n",
    "@Column(columnDefinition = \"jsonb\")\n",
    "private Map<String,Map<String, Object>> stats = new HashMap<>(); "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "JSONB allows for the storage of nested and dynamic data structures. In the context of `Person` object stats, it means that each person can store activity data with the formatted date as the key, and the structure of this JSON data can be modified or extended without altering the database schema.\n",
    "\n",
    "You can view the way this data is structured in the `person` sqlite.db table."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Homework\n",
    "\n",
    "- Complete all popcorn hacks throughout this lesson\n",
    "- Using the [Person](https://github.com/Tirth-Thakkar/LessonBackend/tree/master/src/main/java/com/nighthawk/spring_portfolio/mvc/person) object as inspiration, create your own UNIQUE SQL database with at least 3 object entries that incorporates either a \"many-to-many\" relationship with another object (hint: Person and PersonRole) OR uses the JSONB column definition to store more complex data (such as a HashMap) as an attribute (hint: stats in Person object).\n",
    "    - Show a clear screenshot of your SQLite table (using SQLite viewer) on your blog for credit.\n",
    "    - Using past group project materials is valid for this homework as long as the expectations are met.\n",
    "\n",
    "\n",
    "#### Ideas for 1.0/1.0\n",
    "\n",
    "- Incorporating both a \"many-to-many\" relationship and a JSONB column with information would be great.\n",
    "- Implementing JPA repository methods (think CRUD methods, custom queries, etc.) would show interest in modifying SQL database data.\n",
    "- Take extra notes on this lesson that show deeper research into Collections and SQL.\n",
    "\n",
    "Here, a many-to-many-relationship as shown between the player_id and team_id\n",
    "\n",
    "![image](https://github.com/realethantran/fastpages_EthanT/assets/109186517/a5f2b2cf-b2fc-4c77-9c8f-7900fa031708)\n",
    "\n",
    "Here is my code for this portion: \n",
    "\n",
    "```\n",
    "@ManyToMany(fetch = FetchType.LAZY)\n",
    "@JoinTable(\n",
    "  name = \"player_team\",\n",
    "  joinColumns = @JoinColumn(name = \"player_id\"),\n",
    "  inverseJoinColumns = @JoinColumn(name = \"team_id\")\n",
    ")\n",
    "```\n",
    "\n",
    "This screenshot shows the the sqlite table for the basketball players database with a JSONB column for player data\n",
    "\n",
    "![image](https://github.com/realethantran/fastpages_EthanT/assets/109186517/bd0f68b8-2f3d-4db2-865d-c1945d5da89c)\n",
    "\n",
    "Here is my code for the JSONB column: \n",
    "\n",
    "```\n",
    "@JdbcTypeCode(SqlTypes.JSON)\n",
    "    @Column(columnDefinition = \"jsonb\")\n",
    "    private Map<String, Map<String, Object>> player_data;\n",
    "```\n",
    "\n",
    "## Extra Notes\n",
    "\n",
    "### Collections Overview\n",
    "\n",
    "Collections in Java are frameworks that allow users to store and manipulate a group of objects\n",
    "\n",
    "##### Java Collections Framework (JCF)\n",
    "\n",
    "Includes interfaces (e.g., List, Set, Map) and classes (e.g., ArrayList, HashSet) to represent collections\n",
    "Allows for consistency, reusability, and interoperability among different types of collections\n",
    "\n",
    "### Common Interfaces\n",
    "\n",
    "#### List\n",
    "\n",
    "- **ArrayList**: Dynamic array implementation of List, provides fast random access\n",
    "- **LinkedList**: Doubly-linked list implementation of List, efficient for frequent insertions and deletions\n",
    "\n",
    "#### Set\n",
    "\n",
    "- **HashSet**: Unordered collection using a hash table for storage, doesn't allow duplicate elements\n",
    "- **TreeSet**: Implements a sorted set using a Red-Black tree\n",
    "\n",
    "#### Map\n",
    "\n",
    "- **HashMap**: Implements Map interface, key-value pairs stored in a hash table for fast retrieval\n",
    "- **TreeMap**: Sorted map implementation using a Red-Black tree\n",
    "\n",
    "### Key Classes\n",
    "\n",
    "ArrayList, LinkedList, HashSet, HashMap: Each class serves specific use cases based on performance and functionality requirements\n",
    "\n",
    "### Collections API Methods\n",
    "\n",
    "The Collections class provides utility methods (e.g., sort, binarySearch) for working with collections\n",
    "The Iterable interface enables the enhanced for-loop for easy iteration\n",
    "\n",
    "### SQL (Structured Query Language)\n",
    "\n",
    "#### Definition\n",
    "\n",
    "SQL is a domain-specific language for managing relational databases\n",
    "\n",
    "### Basic Statements\n",
    "\n",
    "#### SELECT\n",
    "\n",
    "Retrieves data from one or more tables.\n",
    "Supports various clauses (e.g., WHERE, ORDER BY, GROUP BY)\n",
    "\n",
    "#### INSERT, UPDATE, DELETE\n",
    "\n",
    "Manipulate data in a table\n",
    "Follows the ACID properties (Atomicity, Consistency, Isolation, Durability)\n",
    "\n",
    "### Data Types\n",
    "\n",
    "Common data types include INTEGER, VARCHAR, DATE, BOOLEAN, etc\n",
    "Choosing appropriate data types ensures efficient storage and retrieval of data\n",
    "\n",
    "### Many-to-many relationships (JPA)\n",
    "\n",
    "- @ManyToOne Annotation indicates a many-to-one relationship between entities, such as Person and PersonRole\n",
    "- @JoinColumn Annotation specifies the foreign key column (tutorial_id) in the note table linking to the Person entity\n",
    "- Primary Key vs. Foreign Key: The “id” column is the primary key of each Note, while tutorial_id establishes the relational link to Person​​\n",
    "- In a many-to-one relationship, the foreign key in the child entity (e.g., tutorial_id in Note) references the primary key of the parent entity (e.g., id in Person)\n",
    "- These relationships ensure data integrity and enforce referential integrity within the database\n",
    "- The @OnDelete(action = OnDeleteAction.CASCADE) annotation indicates cascade operations, such as deleting all child entities (i.e. notes) when the parent entity (person) is deleted\n",
    "- This relationship pattern efficiently organizes data, especially in scenarios where one entity (i.e. person or tv show) is associated with multiple dependent entities (notes or genres)\n",
    "- The @JsonIgnore annotation often used in many-to-one relationships helps optimize data queries by preventing unnecessary data loading."
   ]
  }
 ],
 "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": "17.0.8.1+1-Ubuntu-0ubuntu120.04"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}