06_java_array-and-arraylist.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ebfa9ced",
   "metadata": {},
   "source": [
    "# Array and ArrayList"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "240eb1b1",
   "metadata": {},
   "source": [
    "## Understanding Java Arrays\n",
    "An *Array* is an object in *heap memory* which holds space for a specified number of ordered elements. A String is essentially an array of characters with some additional useful methods added. \n",
    "\n",
    "### Creating Arrays of Primitives\n",
    "You create an *array* object in a very similar fashion to other objects but using square brackets `[]` rather than the word \"array\":\n",
    "<br>`int [] intArr;`\n",
    "\n",
    "Above we declare a variable of type `int []` but we haven't actually initialized an array yet. We can do so like this:\n",
    "<br>`intArr = new int[12];`\n",
    "\n",
    "Where `12` is the number of items in the array. To initialise an array you must either provide the length of the array (i.e. the number of items it will hold) like this:\n",
    "<br>`int [] intArr = new int [4];`\n",
    "\n",
    "The above creates a variable named `intArr` which is *array* that holds four (as yet undeclared) `int` primitives. To populate this array with `int` primitives we use index notation:\n",
    "<br>`intArr[0] = 1;`\n",
    "\n",
    "Now we've added the primitive `1` at index 0 of `intArr`.\n",
    "\n",
    "Or you can declare and populate an array in one line by enclosing the elements you want in the array in *curly braces*:\n",
    "<br>`int [] intArr = new int[] {0, 1, 2}`\n",
    "\n",
    "That can be abbreviated even further by excluding the `new int[]` from the right hand side of the expression (this is referred to as an *anonymous array* as we haven't specified the type or size):\n",
    "<br>`int []intArr = {0, 1, 2};`\n",
    "\n",
    "__NOTE__: you can place the square brackets anywhere after the type and before the equals sign. The following are all valid:\n",
    "<br>`int intArr[];`\n",
    "<br>`int[] intArr;`\n",
    "<br>`int []intArr;`\n",
    "<br>`int intArr [];`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "81053e48",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n",
      "161\n",
      "83\n",
      "[24, 161, 83]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int [] intArr = {24, 161, 83};\n",
    "System.out.println(intArr[0]);\n",
    "System.out.println(intArr[1]);\n",
    "System.out.println(intArr[2]);\n",
    "System.out.println(java.util.Arrays.toString(intArr));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3424845",
   "metadata": {},
   "source": [
    "### Mixing variable declarations\n",
    "Java permits you to create primitive and primitive-array variables on one line, however, it's not an advisable practice and shouldn't be used. It's worth knowing that this is permitted though."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "bea61c67",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Double variable: 3.4\n",
      "Double Array item: 3.4\n",
      "Double Array item: 6.8\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "double dArray[], dub; // this creates one double-array \"dArray\" and one double \"dub\";\n",
    "\n",
    "dub = 3.4D;\n",
    "dArray = new double [2];\n",
    "\n",
    "dArray[0] = dub;\n",
    "dArray[1] = dub+dub;\n",
    "\n",
    "System.out.println(\"Double variable: \" + dub);\n",
    "for (double d: dArray) {\n",
    "    System.out.println(\"Double Array item: \" + d);\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69771f5f",
   "metadata": {},
   "source": [
    "### Creating an Array of reference variables\n",
    "We're not limited solely to primitives with *arrays*; we can also create an array of object references. For example, String references:\n",
    "<br>`String [] strArray = new String[4];`\n",
    "\n",
    "__NOTE__: the array doesn't hold the String objects themselves, just references to their space in memory (i.e. in the String pool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d0c63466",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Hello , World!]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "String [] strArr = new String[2];\n",
    "strArr[0] = \"Hello \";\n",
    "strArr[1] = \"World!\";\n",
    "System.out.println(java.util.Arrays.toString(strArr));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1a94988",
   "metadata": {},
   "source": [
    "### An initialized but unfilled array\n",
    "As soon as you initialize an array, even if you haven't populated it's items yet (remember, when you initialize an array you have to either state how many elements will be in it or declare the elements), it will have a length equal to the declared number of elements. If you declared the number of element but haven't populated them yet each element will simply be `null`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "67615f65",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "[null, null, null, null, null, null]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "String [] strArr = new String [6];\n",
    "System.out.println(strArr.length);\n",
    "System.out.println(java.util.Arrays.toString(strArr));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb8b40a0",
   "metadata": {},
   "source": [
    "### Sorting an array\n",
    "Java provides a `.sort()` method to allow you to easily sort arrays. Since the Arrays class isn't included in the standard library you need to import it (or use a fully qualified domain name):\n",
    "<br>`import java.util.Arrays;`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "245f5d27",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Hello , World, !!]\n",
      "[!!, Hello , World]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import java.util.Arrays; // importing like this allows us to access Arrays methods by simply called `Array.methodName()`\n",
    "\n",
    "String [] strArr = new String[3];\n",
    "strArr[0] = \"Hello \";\n",
    "strArr[1] = \"World\";\n",
    "strArr[2] = \"!!\";\n",
    "\n",
    "System.out.println(Arrays.toString(strArr));\n",
    "Arrays.sort(strArr); // sort the array in place\n",
    "System.out.println(Arrays.toString(strArr));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81106ccb",
   "metadata": {},
   "source": [
    "### Searching\n",
    "Java provides a `.binarySearch(arrayToSearch, itemToSearchFor)` which can be used to search *sorted* arrays.\n",
    "\n",
    "Use|Result\n",
    ":-|:-\n",
    "Target found in sorted array|Array index of the target element\n",
    "Target not found in sorted array|Negative value representing 1 less than the index your target would need to be inserted to preserve sorting order\n",
    "Unsorted array|Unpredictable result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "2d1a2633",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import java.util.Arrays;\n",
    "\n",
    "int [] numArr = {1, 2, 3, 4, 5};\n",
    "System.out.println(Arrays.binarySearch(numArr, 5));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6d0be4f",
   "metadata": {},
   "source": [
    "### Varargs\n",
    "We'll deal with *varargs* in more detail later but for now it's useful to know that such a thing exists and can be treated as a normal array.\n",
    "<br>`public static void main(String... args){}`\n",
    "\n",
    "Above is a *main method* where rather than the usual String array `args` we've used *varargs*."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "399c1f67",
   "metadata": {},
   "source": [
    "### Multidimensional arrays\n",
    "Multidimensional arrays are basically arrays within arrays or nested-arrays. You declare them by adding additional square-brackets `[]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "b5c29cf7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 0, 0, 0, 0, 0]\n",
      "[2, 0, 0, 0, 0, 0]\n",
      "[3, 0, 0, 0, 0, 0]\n",
      "[4, 0, 0, 0, 0, 0]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int [][] intArr = new int[4][6]; // declare an array of 4 elements each of which is an array of 6 elements\n",
    "intArr[0][0] = 1;\n",
    "intArr[1][0] = 2;\n",
    "intArr[2][0] = 3;\n",
    "intArr[3][0] = 4;\n",
    "\n",
    "for (int [] i: intArr) {\n",
    "    System.out.println(java.util.Arrays.toString(i));\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c46f82f",
   "metadata": {},
   "source": [
    "You can of course use shorthand here too:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "810fb627",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.0]\n",
      "[2.0, 2.1]\n",
      "[3.0, 3.1, 3.2]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "double [][] nestedDoubleArr = {{1.0D},{2.0D, 2.1D},{3.0D, 3.1D, 3.2D}};\n",
    "for (double [] d: nestedDoubleArr) {\n",
    "    System.out.println(java.util.Arrays.toString(d));\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e047ea02",
   "metadata": {},
   "source": [
    "You can also start by just declaring the first dimension of the array and then populate it with further arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "894d878c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[a, b]\n",
      "[c]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "char [][] chArr = new char [2][];\n",
    "chArr[0] = new char [2];\n",
    "chArr[1] = new char [1];\n",
    "chArr[0][0] = 'a';\n",
    "chArr[0][1] = 'b';\n",
    "chArr[1][0] = 'c';\n",
    "\n",
    "for (char [] ch: chArr) {\n",
    "    System.out.println(java.util.Arrays.toString(ch));\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d260bef",
   "metadata": {},
   "source": [
    "## ArrayList\n",
    "One of the problems with *arrays* is that you need to know at initialization-time how many elements your array will have and after that point it can't be changed. `ArrayList` attempts to rectify that, they can change size as needed. Like *arrays*, an *arralist* is an ordered sequence.\n",
    "\n",
    "Since *ArrayList* is in the `java.util` package, we need to either import it or use it's fully qualified name. Creating an *ArrayList* is also different from creating *Arrays* in that you need to use the class name `ArrayList` to create it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "63fc595a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import java.util.ArrayList;\n",
    "\n",
    "ArrayList myFirstAL = new ArrayList(); // creates an ArrayList of default size\n",
    "ArrayList mySecondAL = new ArrayList(5); // creates an ArrayList for 5 however will expand as you add elements\n",
    "\n",
    "System.out.println(myFirstAL.size());\n",
    "System.out.println(mySecondAL.size());"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26f9168a",
   "metadata": {},
   "source": [
    "### Generics\n",
    "Java 5 introduced the concept of *generics* which allows you to tell Java what type of class the ArrayList will contain. You declare the type by enclosing it within a *diamond-operator* (`<>`). The diamond operator should be present on both side of the equation but only needs to contain the *type* on the left hand side."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "4c74cbb3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import java.util.ArrayList;\n",
    "\n",
    "ArrayList <String> myStrAL = new ArrayList<>(); // declares an ArrayList of type String\n",
    "ArrayList <Object> myObjAl = new ArrayList<Object>(); // declares an ArrayList of type Object"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18ad9092",
   "metadata": {},
   "source": [
    "### Creating a copy of an ArrayList\n",
    "You can create a copy of an *ArrayList* by simply passing the ArrayList you want to copy as an argument to a new constructor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "95f8f01b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import java.util.ArrayList;\n",
    "\n",
    "ArrayList<String> alOriginal = new ArrayList<>();\n",
    "ArrayList<String> alCopy = new ArrayList<>(alOriginal);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf0f4da5",
   "metadata": {},
   "source": [
    "### ArrayList implements List\n",
    "ArrayList is an implementation of an *interface* called `List`. Essentially, this means that an ArrayList is a type of List with List being a *kind of* parent type. A knock-on effect of this is that you can store an *ArrayList* in a *List* reference variable but not the other way 'round."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "259f6776",
   "metadata": {},
   "outputs": [
    {
     "ename": "java.util.List is abstract; cannot be instantiated",
     "evalue": "java.util.List is abstract; cannot be instantiated",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31mjava.util.List is abstract; cannot be instantiated\u001b[0;0m",
      "\u001b[1;31m ArrayList<String> a1 = new List<>()\u001b[0;0m",
      "\u001b[1;31m                        ^           ^ \u001b[0;0m"
     ]
    }
   ],
   "source": [
    "import java.util.ArrayList;\n",
    "import java.util.List;\n",
    "\n",
    "List<String> l1 = new ArrayList<>(); // compiles\n",
    "ArrayList<String> a1 = new List<>(); // does NOT compile"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8fbe91c",
   "metadata": {},
   "source": [
    "### ArrayList methods and a note about `E`\n",
    "Below are some common ArrayList methods. Note, that `E` in these examples is a placeholder meaning \"any class this array can hold\". So, if you specified that the ArrayList holds `String` then `E` will represent `String`. If you didn't specify a type then `E` will represent `Object`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b6bfc0f",
   "metadata": {},
   "source": [
    "### `.add()` method\n",
    "The `.add()` method inserts a new value into the *ArrayList*:\n",
    "<br>`myArrayList.add(index [optional], itemToAdd);`\n",
    "\n",
    "__NOTE__: `.add()` has two possible return types - `boolean` and `void`. If you exclude the index argument the method will return `true`. If you include an index, there will be no return value (i.e. `void`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "526e06a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Pear]\n",
      "[Apple, Pear]\n",
      "[true]\n",
      "[false, true]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import java.util.ArrayList;\n",
    "\n",
    "ArrayList<String> strAL = new ArrayList<>(); // create a String ArrayList\n",
    "\n",
    "strAL.add(\"Pear\"); // add the string \n",
    "System.out.println(strAL); // print AL\n",
    "\n",
    "strAL.add(0, \"Apple\");\n",
    "System.out.println(strAL);\n",
    "\n",
    "ArrayList objAL = new ArrayList();\n",
    "objAL.add(Boolean.TRUE);\n",
    "System.out.println(objAL);\n",
    "\n",
    "objAL.add(0, Boolean.FALSE);\n",
    "System.out.println(objAL);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c4b6865",
   "metadata": {},
   "source": [
    "### `.remove()` method\n",
    "The `.remove()` method removes the first matching value in the ArrayList or at the specified index (if one is provided):\n",
    "<br>`myArrayList.remove(index);` or `myArrayList.remove(object);`\n",
    "\n",
    "__NOTE__: `.remove()` also has two possible return types - boolean (if the argument was an object, true meaning object remove, false meaning not) and `E` (representing whatever the element at the index passed was)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "0716e706",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Purple, Monkey, Dishwasher]\n",
      "[Purple, Dishwasher]\n",
      "true\n",
      "[Purple]\n",
      "Dishwasher\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import java.util.ArrayList;\n",
    "\n",
    "ArrayList <String> newAL = new ArrayList<>(); // create string arraylist\n",
    "newAL.add(\"Purple\"); // add some strings\n",
    "newAL.add(\"Monkey\");\n",
    "newAL.add(\"Dishwasher\");\n",
    "System.out.println(newAL); // print populated al\n",
    "\n",
    "boolean removedFromAL = newAL.remove(\"Monkey\"); // remove string using object argument and save return value to variable\n",
    "System.out.println(newAL); // print changed al\n",
    "System.out.println(removedFromAL); // print variable\n",
    "\n",
    "String removedStrFromAL = newAL.remove(1); // remove string using index argument and save return value to variable\n",
    "System.out.println(newAL); // print changed al\n",
    "System.out.println(removedStrFromAL); // print variable"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d5c97c1",
   "metadata": {},
   "source": [
    "### `.set() method`\n",
    "The `.set()` method changes an element of the ArrayList without changing the size of the ArrayList and returns the element that was replaced.\n",
    "<br>`set(index, newElement);`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "f39efc9a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[John, Paul, George, Pete]\n",
      "[John, Paul, George, Ringo]\n",
      "Pete\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import java.util.ArrayList;\n",
    "\n",
    "ArrayList<String> sAL = new ArrayList<>();\n",
    "sAL.add(\"John\");\n",
    "sAL.add(\"Paul\");\n",
    "sAL.add(\"George\");\n",
    "sAL.add(\"Pete\");\n",
    "System.out.println(sAL);\n",
    "\n",
    "String fifthBeatle = sAL.set(3, \"Ringo\");\n",
    "System.out.println(sAL);\n",
    "System.out.println(fifthBeatle);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58fce0c1",
   "metadata": {},
   "source": [
    "### `.isEmpty()` and `.size()` methods\n",
    "The `.isEmpty()` and `size()` methods both look at how many items are in the ArrayList and both do what they sound like:\n",
    "\n",
    "`myArrayList.isEmpty()` will return `true` or `false` depending on whether or not the AL is empty.\n",
    "\n",
    "`myArrayList.size()` will return the current size of the AL."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "3cb7287f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The arraylist is empty: true\n",
      "The arraylist has 0 items in it.\n",
      "The arraylist is empty: false\n",
      "The arraylist has 1 items in it.\n",
      "The arraylist has 2 items in it.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import java.util.ArrayList;\n",
    "\n",
    "ArrayList <String> strAL = new ArrayList<>();\n",
    "System.out.println(\"The arraylist is empty: \" + strAL.isEmpty());\n",
    "System.out.println(\"The arraylist has \" + strAL.size() + \" items in it.\");\n",
    "\n",
    "strAL.add(\"Cup\");\n",
    "System.out.println(\"The arraylist is empty: \" + strAL.isEmpty());\n",
    "System.out.println(\"The arraylist has \" + strAL.size() + \" items in it.\");\n",
    "strAL.add(\"Vase\");\n",
    "System.out.println(\"The arraylist has \" + strAL.size() + \" items in it.\");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d35e29a0",
   "metadata": {},
   "source": [
    "### `.clear()` method\n",
    "The `clear()` takes no arguments and allows you to discard all elements in an ArrayList."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "259d97ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Hello, World, !!]\n",
      "[]\n",
      "[Foo]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import java.util.ArrayList;\n",
    "\n",
    "ArrayList<String> newAL = new ArrayList<>();\n",
    "newAL.add(\"Hello\");\n",
    "newAL.add(\"World\");\n",
    "newAL.add(\"!!\");\n",
    "System.out.println(newAL);\n",
    "newAL.clear();\n",
    "System.out.println(newAL);\n",
    "\n",
    "newAL.add(\"Foo\");\n",
    "System.out.println(newAL);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be3a4128",
   "metadata": {},
   "source": [
    "### `.contains()` method\n",
    "The `.contains()` method checks if a provided element is present in the ArrayList and returns a boolean.\n",
    "<br>`arrayListToSearch.contains(elementToSearchFor);`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "443e8b0b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n",
      "false\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import java.util.ArrayList;\n",
    "\n",
    "ArrayList<String> strAL = new ArrayList<>();\n",
    "strAL.add(\"VHS\");\n",
    "strAL.add(\"Betamax\");\n",
    "strAL.add(\"DVD\");\n",
    "strAL.add(\"Laserdisk\");\n",
    "\n",
    "System.out.println(strAL.contains(\"VHS\"));\n",
    "System.out.println(strAL.contains(\"Blu-Ray\"));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c20ea37",
   "metadata": {},
   "source": [
    "### `equals()` method\n",
    "The `.equals()` method allows you to compare to ArrayLists to see if they contain the same elements in the same order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "0a772a83",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "false\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import java.util.ArrayList;\n",
    "\n",
    "ArrayList<String> smartphoneMakers1 = new ArrayList<>();\n",
    "smartphoneMakers1.add(\"Apple\");\n",
    "smartphoneMakers1.add(\"Huawei\");\n",
    "smartphoneMakers1.add(\"Nokia\");\n",
    "smartphoneMakers1.add(\"Samsung\");\n",
    "smartphoneMakers1.add(\"Sony\");\n",
    "smartphoneMakers1.add(\"Xiaomi\");\n",
    "\n",
    "ArrayList<String> smartphoneMakers2 = new ArrayList<>();\n",
    "smartphoneMakers1.add(\"Nokia\");\n",
    "smartphoneMakers2.add(\"Apple\");\n",
    "smartphoneMakers2.add(\"Xiaomi\");\n",
    "smartphoneMakers2.add(\"Samsung\");\n",
    "smartphoneMakers2.add(\"Huawei\");\n",
    "smartphoneMakers2.add(\"Sony\");\n",
    "\n",
    "\n",
    "System.out.println(smartphoneMakers1.equals(smartphoneMakers2));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a40bcbdd",
   "metadata": {},
   "source": [
    "### Adding Primitives to an ArrayList\n",
    "All primitive types have what's called a *wrapper class*, which is an object type that corresponds to the primitive. The wrapper classes have methods which allow you to convert object back to primitive such as `.parseInt()`.\n",
    "\n",
    "Primitive|Wrapper class|Construction\n",
    ":--|:--|:--\n",
    "boolean|Boolean|`new Boolean(false);`\n",
    "byte|Byte|`new Byte((byte) 2);`\n",
    "short|Short|`new Short((short) 3);`\n",
    "int|Integer|`new Integer(4);`\n",
    "long|Long|`new Long(5);`\n",
    "float|Float|`new Float(6.0);`\n",
    "double|Double|`new Double(7.0)`\n",
    "char|Character|`new Character('a');`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "1c4dc7b0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "6\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Integer five = new Integer(5);\n",
    "System.out.println(five);\n",
    "System.out.println(1+five);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45126475",
   "metadata": {},
   "source": [
    "### Converting Strings\n",
    "The following are common methods use to convert Strings to primitives and wrapper classes.\n",
    "\n",
    "Wrapper class|String to Primitive|String to Wrapper\n",
    ":--|:--|:--\n",
    "Boolean|`Boolean.parseBoolean(\"false\");`|`Boolean.valueOf(\"FALSE\");`\n",
    "Byte|`Byte.parseByte(\"2\");`|`Byte.valueOf(\"2\");`\n",
    "Short|`Short.parseShort(\"3\");`|`Short.valueOf(\"3\");`\n",
    "Integer|`Integer.parseInt(\"4\");`|`Integer.valueOf(\"4\");`\n",
    "Long|`Long.parseLong(\"5\");`|`Long.valueOf(\"5\");`\n",
    "Float|`Float.parseFloat(\"6.0\");`|`Float.valueOf(\"6.0\");`\n",
    "Double|`Double.parseDouble(\"7.0\");`|`Double.valueOf(\"7.0\");`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bc7beb6",
   "metadata": {},
   "source": [
    "## Autoboxing\n",
    "*Autoboxing* is a feature introduced in Java 5 where the JVM will automatically convert a primitive to it's relevant wrapper class (and vice-versa) when used in a context where an object is expected rather than a primitive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "1f46a7b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "6.5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import java.util.ArrayList;\n",
    "\n",
    "ArrayList<Object> myPrims = new ArrayList<>(); // create object arraylist\n",
    "myPrims.add(7); // add integer value which Java will autoconvert to wrapper class object\n",
    "myPrims.add(6.5); // add float value which Java will autoconvert to wrapper class object\n",
    "for (Object o: myPrims) {\n",
    "    System.out.println(o);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cf6835f",
   "metadata": {},
   "source": [
    "## Converting Array to ArrayList and vice-versa\n",
    "`ArrayList` includes a `.toArray()` method that allows you to convert to a standard array, however, it defaults to type `Object`. If you want to convert to a different type you can pass a wrapper class constructor to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "b1ae2c24",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import java.util.ArrayList;\n",
    "\n",
    "ArrayList <String> strAL = new ArrayList<>();\n",
    "strAL.add(\"Superman\");\n",
    "strAL.add(\"Batman\");\n",
    "strAL.add(\"Wonder Woman\");\n",
    "String [] justiceLeague = strAL.toArray(new String[0]);\n",
    "System.out.println(justiceLeague.length);\n",
    "\n",
    "ArrayList <Integer> intAL = new ArrayList<>();\n",
    "intAL.add(4);\n",
    "intAL.add(7);\n",
    "Integer [] intArr = intAL.toArray(new Integer[0]);\n",
    "System.out.println(intArr.length);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66890b98",
   "metadata": {},
   "source": [
    "Converting from `Array` to `List` can be done using the `.asList()` method, however, this creates a *fixed-size* List (known as a *backed-list*) which is linked to the original array. When a change is made to one it is also made to the other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "648b075d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Butter, Milk, Cheese]\n",
      "[Butter, Milk, Cheese]\n",
      "[Butter, Soy, Cheese]\n",
      "[Butter, Soy, Cheese]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import java.util.Arrays;\n",
    "import java.util.List;\n",
    "\n",
    "String [] strArr = {\"Butter\", \"Milk\", \"Cheese\"};\n",
    "List<String> strL = Arrays.asList(strArr);\n",
    "System.out.println(strL);\n",
    "System.out.println(Arrays.toString(strArr));\n",
    "strL.set(1, \"Soy\");\n",
    "System.out.println(strL);\n",
    "System.out.println(Arrays.toString(strArr));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f1250958",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "false\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import java.util.ArrayList;\n",
    "\n",
    "ArrayList<String> al = new ArrayList<>();\n",
    "ArrayList<String> al2 = new ArrayList<>();\n",
    "al.add(\"Hello\");\n",
    "al.add(\"World\");\n",
    "al2.add(\"World\");\n",
    "al2.add(\"Hello\");\n",
    "System.out.println(al == al2);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c1e18b25",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "codemirror_mode": "text/x-java",
   "file_extension": ".java",
   "mimetype": "",
   "name": "Java",
   "nbconverter_exporter": "",
   "version": "1.8.0_121"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": false,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": false,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}