02 Arrays and Pairs.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 02. Arrays and Pairs\n",
    "(배열과 순서쌍)\n",
    "\n",
    "배열은 기본적으로 자바 언어와 관련 표준라이브러리에서 지원한다.\n",
    "하지만 안타깝게도 순서쌍은 그렇지가 못하기 때문에 자바 표준라이브러리 혹은 Java JDK외에 몇몇 다른 라이브러리에서 제공하는 것을 필요에 따라 활용해서 가장 표준적인 것이 딱 하나로 제시되지 않는다.\n",
    "우리는 그 중에서 많이들 쓰는\n",
    "[Apache Commons Library에서 제공되는 순서쌍](https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/tuple/package-summary.html)을 활용하기로 한다.\n",
    "이런 순서쌍 라이브러리를 활용하기 위헤서는 제너릭(generic) 및 인터페이스(interface)에 대한 이해가 있으면 좋지만\n",
    "어떻게 활용하는지를 먼저 살펴보면서 용법에 익숙해진 다음에 제너릭이나 인터페이스 등에 대한 내용을 그 다음에 자세히 다루기로 하겠다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arrays\n",
    "배열"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "int[] arr1 = new int[] {1,2,3};\n",
    "int[] arr2 = {1,2,3}; // 초기화할 때는 new int[]를 생략하고 줄여 쓸 수 있음\n",
    "int arr3[] = {1,2,3,4}; // []를 변수명 뒤에다 적어도 됨"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[I@6f209243"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1 instanceof int[]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1 instanceof Object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[I@6f209243"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1.toString() // 배열에서 기본으로 제공하는 toString은 별로 유용하지 않다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Arrays.toString(arr2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Arrays.toString(arr3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(new int[] {1,2,3})[2] // 배열변수 초기화가 아닌 배열 인스턴스를 식으로 만들어내기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m(\u001b[0m\u001b[1m\u001b[30m\u001b[41m\u001b[0m\u001b[1m\u001b[30m{1,2,3})[2] // 배열변수 초기화가 아니므로 new int[] 생략 불가능\u001b[0m",
      "\u001b[1m\u001b[31millegal start of expression\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "({1,2,3})[2] // 배열변수 초기화가 아니므로 new int[] 생략 불가능"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Arrays.toString( new int[] {1,2,3} ) // 단독으로 식으로 작성 가능한 형태"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30mArrays.toString( \u001b[0m\u001b[1m\u001b[30m\u001b[41m\u001b[0m\u001b[1m\u001b[30m{1,2,3} ) // 변수 초가화가 아니면 new int[] 생략 불가\u001b[0m",
      "\u001b[1m\u001b[31millegal start of expression\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "Arrays.toString( {1,2,3} ) // 변수 초가화가 아니면 new int[] 생략 불가"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "int[]     arr4 = new int[4];     // 원소값 초기화하지 않고 배열 공간만 생성해 0이 4개 들어가 있음\n",
    "Integer[] arr5 = new Integer[5]; // 원소값 초기화하지 않고 배열 공간만 생성해 null이 5개 들어가 있음"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 0, 0, 0]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Arrays.toString(arr4); // 기본타입의 배열은 원소를 초기화하지 않으면 0과 같은 값으로 채워짐"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[null, null, null, null, null]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Arrays.toString(arr5); // 오브젝트의 배열은 원소를 초기화하지 않으면 null"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "null\n"
     ]
    }
   ],
   "source": [
    "// 배열 원소를 초기화하지 않았을 때의 결과는 변수 한개를 초기화하지 않았을 때를 보면 알 수 있다\n",
    "int i1;\n",
    "Integer i2;\n",
    "\n",
    "System.out.println(i1);\n",
    "System.out.println(i2);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "null\n",
      "null\n"
     ]
    }
   ],
   "source": [
    "int[] arr6;     // 배열도 오브젝트이므로 초기화하지 않으면 null\n",
    "Integer[] arr7; // 배열도 오브젝트이므로 초기화하지 않으면 null\n",
    "\n",
    "System.out.println(arr6);\n",
    "System.out.println(arr7);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "// 배열의 배열 - 각각의 배열 길이는 같지 않아도 됨\n",
    "int[][] arrarr = { arr2, arr3, {1,2,3,4,5} };"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[I@479e8c67"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2.toString()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[I@479e8c67, [I@3d52f73f, [I@4f6bc100]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Arrays.toString(arrarr); // 배열의 toString 때문에 참 귀찮을 따름이다 :("
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], [1, 2, 3, 4], [1, 2, 3, 4, 5]]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Arrays.deepToString(arrarr); // 다중배열의 경우 요걸 사용한다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[[1, 2], [2, 3]], [[1, 2, 3], [1, 2, 3, 4], [1, 2, 3, 4, 5]]]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Arrays.deepToString( new int[][][] { {{1,2}, {2,3}}, arrarr } ); // 3중배열에도 동작함"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "방금 활용한 `Arrays.toString`나 `Arrays.deepToString` 메소드는 오브젝트를 만들지 않고 그냥 클래스 이름인 `Arrays`다음에 점을 찍고 호출하였다.\n",
    "이와 같이 오브젝트 없이 클래스 이름으로 활용할 수 있는 메소드를 **클래스 메소드**라고 하며 마찬가지로 변수의 경우도 오브젝트 없이 활용할 수 있는 **클래스 변수**가 있다.\n",
    "다음의 예제를 통해 클래스 변수와 메소드에 대해 알아보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyArrays {\n",
    "    // 클래스 변수\n",
    "    static String world = \"world\";\n",
    "    // 클래스 메소드\n",
    "    static String helloString() { return \"hello\"; }\n",
    "    \n",
    "    /* // HW?에서 작성해볼 클래스 메소드\n",
    "    static String toString(int[] arr) {\n",
    "        return \"...\"\n",
    "    }\n",
    "    */\n",
    "\n",
    "    /* // HW?에서 작성해볼 클래스 메소드\n",
    "    static String deepToString(Object[] arr) {\n",
    "        return \"...\"\n",
    "    }\n",
    "    */\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "world"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MyArrays.world"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "hello"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MyArrays.helloString()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "world"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new MyArrays().world // 클래스 변수를 오브젝트를 통해 활용하는 것도 가능하다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "hello"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new MyArrays().helloString()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "MyArrays mas1 = new MyArrays();\n",
    "MyArrays mas2 = new MyArrays();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "world"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mas1.world"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "world"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mas2.world"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "myworld"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mas1.world = \"myworld\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "myworld"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mas1.world"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "myworld"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mas2.world // world는 클래스 변수이므로 하나의 클래스를 대표하는 딱 하나의 변수 (모든 인스턴스가 공유하는 속성)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "참고로 클래스 변수는 `final` 키워드를 함께 이용해서 상수로 정의하는 경우도 많다.\n",
    "\n",
    "`final` 키워드에 대한 내용은 두잇 자바 교재를 찾아볼 것."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "배열을 정의하는 법만 다루고 활용하는 예를 하나도 강의노트에서 다루지 않아서 간단히만 알아봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "String[] arr6 = {\"hello\", \"world\", \"bye\", \"sky\"};\n",
    "\n",
    "arr6.length // 배열의 길이는 length 인스턴스 변수로 확인"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[hello, world, bye, sky]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Arrays.toString(arr6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "hello"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr6[0] // 첫번째 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bye"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr6[2] // 세번째"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "earth"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr6[1] = \"earth\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[hello, earth, bye, sky]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Arrays.toString(arr6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello earth bye sky "
     ]
    }
   ],
   "source": [
    "for (int i = 0; i < arr6.length; ++i) {\n",
    "    System.out.print(arr6[i] + \" \"); // 배열의 내용을 하나씩 출력\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello earth bye sky "
     ]
    }
   ],
   "source": [
    "for (String v : arr6) { // v에는 인덱스가 아니라 arr6 배열에 들어있는 값을 하나씩 얻어옴\n",
    "    System.out.print(v + \" \"); // 배열의 내용을 하나씩 출력    \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "import org.apache.commons.lang3.tuple.*;\n",
    "\n",
    "// new를 직접 쓰지 않고 of와 같은 메소드로 인스턴스를 생성하는 것을 팩토리 메소드 라고도 부릅니다\n",
    "Pair<Integer,Integer> p1 = Pair.of(150,100);   // of라는 클래스 메소드로 인스턴스 생성\n",
    "Pair<Integer,String> p2 = Pair.of(99,\"hello\"); // of라는 클래스 메소드로 인스턴스 생성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(150,100)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(99,hello)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "150"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1.getLeft()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "hello"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p2.getRight()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "Pair.of는 Pair라는 추상 부모 클래스의 구체적 자녀 클래스인 ImmutablePair의 인스턴스를 생성했음을\n",
    "getClass 메소드로 확인해 볼 수 있다.\n",
    "\n",
    "getClass로 얻어오는 동적인 클래스 정보에는 순서쌍의 원소가 무슨 타입인지 좀더 자세한 정보는 빠져 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "class org.apache.commons.lang3.tuple.ImmutablePair"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1.getClass()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "class org.apache.commons.lang3.tuple.ImmutablePair"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p2.getClass()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "Pair< Pair<Double,Double>, Pair<String,Integer> > p3 =\n",
    "    Pair.of( Pair.of(3.141592,2.718281), Pair.of(\"hello\",999) );"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((3.141592,2.718281),(hello,999))"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3.141592,2.718281)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p3.getLeft()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.718281"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p3.getLeft().getRight()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(hello,999)"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p3.getRight()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "hello"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p3.getRight().getLeft()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generics\n",
    "\n",
    "자바 언어에서 자체적으로 제공하는 배열의 경우 배열을 나타내는 대괄호 `[]` 앞에다 타입을 쓰기만 하면 어떤 종류의 배열이든 쓸 수 있다.\n",
    "`Integer[]`를 쓰는 거나 `String[]`을 쓰는거나 같은 배열을 다룬다는 점에서는 동일하다. 이와 같이 배열에 담는 자료의 종류를 나타내는 타입만 달리 적어주면 배열이라는 똑같은 데이타 구조를 여러 타입에 대해 일반적으로 동일한 방법으로 사용할 수 있다.\n",
    "\n",
    "제너릭 없이 클래스 상속 같은 걸로 배열과 같은 일반적인 구조를 종류에 따라 만들어야 한다면 얼마나 귀찮을까?\n",
    "예를 들어 자바 언어에서 배열이 기본으로 제공되지 않아서 클래스로 구현해야 하는 상황을 상상해 보자.\n",
    "그리고 우선 공통적인 배열 부모 클래스를 `class CommonArray {...}`로 정의할 수 있다고 가정하자.\n",
    "그럼 그 다음엔 어떻게 해야 할까?\n",
    " * 정수를 담는 배열은 `class IntegerArray extends CommonArray {...}`로 상속해서 하나 만들고,\n",
    " * 문자열을 담는 배열은 `class StringArray extends CommonArray {...}` 로 상속해서 하나 더 만들고,\n",
    " * 도형을 담는 배열은 `class ShapeArray extends CommonArray {...}`로 상속해서 또 하나 더 만들고,\n",
    " * ...\n",
    "\n",
    "아 이건 좀 아닌데 ... 하는 생각이 들 것이다. 그래서 그런 방법이 아닌 클래스를 한번만 정의하고\n",
    "거기에 붙이는 타입만 그때그때 바꿔 써주면 다양한 타입에 대해 활용할 수 있도록 지원하는 기능이 바로 Java의 제네릭이다.\n",
    "\n",
    "여기서는 배열로 예를 들어 설명했지만 \n",
    "***Do it! 자바 프로그래밍 입문*** 교재의 12-1에서는 제네릭(generic)에 대해 어떻게 설명하는지 참고해 보라."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "제네릭과 같은 기능은 Java에만 있는 것이 아니라 현업에서 널리 활용되는 현대적인 정적 타입 언어라면 이제는 갖추지 않으면 안되는 뭐 그런 분위기라고 할 수 있다.\n",
    "이런 분위기가 만들어진 것은 C++을 시작으로 한다. 물론 C++에도 처음에는 템플릿(template)이 없었다가 STL이라는 라이브러리가 많은 관심을 받으면서\n",
    "STL을 구현하기 위한 C++ 언어의 확장 기능으로 템플릿이라는 언어 요소가 설계되었다. 이러한 라이브러리의 장점이 표준화하기에 충분한 가치가 있다고 판단되어\n",
    "템플릿이 C++ 언어 표준 포함됨과 함께 C++ 표준라이브러리 STL의 이터레이터, 컨테이너(자바에서는 컬렉션에 해당) 등이 녹아들어가게 되었다.\n",
    "이렇게 템플릿을 활용한 C++ 표준라이브러리가 추구하는 *제네릭 프로그래밍*이 멋져 보이게 되자 다른 현업에서 많이 쓰는 언어들도 비슷한 기능을 뒤따라 추가하였다.\n",
    "C++에 템플릿이 표준으로 추가된 이후로 한동안 Java에는 제네릭이 없던 시절도 있었지만 결국 제네릭이라는 이름으로 추가되었다.\n",
    "참고로 Java보다 나중에 등장한 C#도 마찬가지로 처음에는 제너릭이 없었다가 얼마 후에 추가되었다.\n",
    "최근에 나온 Rust 언어의 경우는 C++의 대안을 표방하며 나온 만큼 처음부터 제네릭을 지원하고 있었다.\n",
    "또 다른 최근에 나온 Go 언어 진영의 경우는 (초창기 Java 진영에서 그랬던 것처럼) 한동안은 제네릭이 필요 없다고 이야기하다가 [이제서야 본격적으로 제네릭을 추가하려고 한다](https://blog.golang.org/generics-next-step)는 소식이 들린다.\n",
    "\n",
    "참고로 템플릿이나 제네릭 등은 프로그래밍 언어 이론에서 인자다형성(parametric polymorphism)이라는 개념을 지원한다고 볼 수 있는데,\n",
    "이는 1970년대부터 이미 함수형 언어인 ML에 들어가 있던 오래된 개념이다. 다만 현업에서 많이 쓰이는 언어들이 여기에 관심을 덜 가지다가 (왜냐하면 하드웨어의 성능이 딸리던 때라 그거에 맞게 최적화하는 게 일단 현업에서는 급했기 때문) 뒤늦게 중요성을 깨닫고 C++을 시작으로 본격적으로 도입하게 되었고 이제는 되돌릴 수 없는 대세가 되었다.\n",
    "\n",
    "그러니까 (정적 타입이 아예 없는 동적 언어를 제외한) 무슨 프로그래밍 언어를 쓰든 제네릭과 관련된 개념은 확실히 알아두어야 할 기본적인 상식이므로 Java의 제너릭을 이번 기회에 편하게 활용할 수 있도록 알아두자. 그리고 C++ 템플릿, Java 제네릭, C# 제네릭의 차이를 알아보는 것도 추천하는데, 그냥 추천만 하면 실제로 스스로 찾아볼 사람이 좀 적을 것 같으므로 이게 바로 HW0 과제다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "그럼 간단한 순서쌍 클래스를 한번 직접 작성해 보면서 Java에서 제네릭 클래스의 특징과 활용할 때 주의점을 짚어보자.\n",
    "우선 제너릭이 없던 시절에 순서쌍을 정의했다면 어떤 식으로 작성하곤 했는지 `ObjPair`라는 클래스를 살펴보고,\n",
    "다음에는 `GenPair`라는 제네릭 클래스를 작성할 것이다. 그리고 `GenPair`와 같은 제네릭 클래스를 활용할 때 주의할 점도 알아보겠다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ObjPair {\n",
    "    // 코드 양을 줄이기 위해 getter, setter 메소드 없이 그냥 인스턴스 변수에 접근할 수 있게 하자\n",
    "    Object left;\n",
    "    Object right;\n",
    "    \n",
    "    ObjPair(Object left, Object right) { // 생성자\n",
    "        this.left = left;\n",
    "        this.right = right;\n",
    "    }\n",
    "    \n",
    "    @Override // 귀찮으니 그냥 Pair 라이브러리에 있는 걸 이용하겠다\n",
    "    public String toString() { return Pair.of(left,right).toString(); }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(hello,456)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ObjPair p4 = new ObjPair(123, 456); // 처음에 (Integer, Intger) 순서쌍으로 시작했지만\n",
    "// ObjPair p4 = new ObjPair(new Integer(123), new Integer (456));\n",
    "\n",
    "p4.left = \"hello\"; // 아무 오브젝트나 넣을 수 있으니 이런 것도 막 되어서\n",
    "\n",
    "p4 // 이제는 (String, Intger) 순서쌍이 되어버렸다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GenPair<L, R> {\n",
    "    // 코드 양을 줄이기 위해 getter, setter 메소드 없이 그냥 인스턴스 변수에 접근할 수 있게 하자\n",
    "    L left;\n",
    "    R right;\n",
    "    \n",
    "    GenPair(L left, R right) { // 생성자\n",
    "        this.left = left;\n",
    "        this.right = right;\n",
    "    }\n",
    "    \n",
    "    @Override // 귀찮으니 그냥 Pair 라이브러리에 있는 걸 이용하겠다\n",
    "    public String toString() { return Pair.of(left,right).toString(); }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30mp5.left = \u001b[0m\u001b[1m\u001b[30m\u001b[41m\"hello\"\u001b[0m\u001b[1m\u001b[30m;\u001b[0m",
      "\u001b[1m\u001b[31mincompatible types: java.lang.String cannot be converted to java.lang.Integer\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "GenPair<Integer,Integer> p5 = new GenPair<Integer,Integer>(123, 456); // 처음에 (Integer, Intger) 순서쌍으로 시작하기로 했으므로\n",
    "\n",
    "p5.left = \"hello\"; // 정적 타입 검사를 통과하지 못하므로 컴파일 에러\n",
    "\n",
    "p5 // 그러니까 여기까지는 실행은 고사하고 컴파일도 안됨"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30mp5.left = \u001b[0m\u001b[1m\u001b[30m\u001b[41m\"hello\"\u001b[0m\u001b[1m\u001b[30m;\u001b[0m",
      "\u001b[1m\u001b[31mincompatible types: java.lang.String cannot be converted to java.lang.Integer\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "GenPair<Integer,Integer> p6 = new GenPair<>(123, 456); // 너무 기니까 이렇게 줄여 쓸 수도 있다\n",
    "\n",
    "p5.left = \"hello\"; // 정적 타입 검사를 통과하지 못하므로 컴파일 에러\n",
    "\n",
    "p5 // 그러니까 여기까지는 실행은 고사하고 컴파일도 안됨"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30mp6.left = \u001b[0m\u001b[1m\u001b[30m\u001b[41m\"hello\"\u001b[0m\u001b[1m\u001b[30m;\u001b[0m",
      "\u001b[1m\u001b[31mincompatible types: java.lang.String cannot be converted to java.lang.Integer\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "var p6 = new GenPair<>(123, 456); // 최근 자바에서는 이렇게까지 줄여 쓸 수도 있다\n",
    "\n",
    "p6.left = \"hello\"; // 정적 타입 검사를 통과하지 못하므로 컴파일 에러\n",
    "\n",
    "p6 // 그러니까 여기까지는 실행은 고사하고 컴파일도 안됨"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(hello,456)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var p7 = new GenPair(123, 456); // BUT 그러나 자바는 이게 된다는 게 골때리는 점이다\n",
    "\n",
    "p7.left = \"hello\"; // 어라 이게 왜 되지??\n",
    "\n",
    "p7 // 아 이게 아닌데 ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30mp8.left = \u001b[0m\u001b[1m\u001b[30m\u001b[41m\"hello\"\u001b[0m\u001b[1m\u001b[30m;\u001b[0m",
      "\u001b[1m\u001b[31mincompatible types: java.lang.String cannot be converted to java.lang.Integer\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "GenPair<Integer,Integer> p8 = new GenPair(123, 456); // 이렇게 쓸 경우에는\n",
    "\n",
    "p8.left = \"hello\"; // 예상대로 여기에서 타입 에러가 나긴 한다\n",
    "\n",
    "p8 // 그러니까 여기까지는 실행은 고사하고 컴파일도 안됨. 하지만 바람직하지 않은 방법이다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(hello,456)"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "GenPair<Integer,Integer> p9 = new GenPair(\"hello\", 456); // 처음부터 정적 타입이 무시된 의도하지 않은 초기화가 되는 문제 발생\n",
    "\n",
    "p9 // 어라 이게 왜 여기까지 컴파일되어 실행되는 것이냐?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "결론적으로 제네릭으로 선언한 클래스의 인스턴스를 new로 생성할 때는 다음 둘 중 하나의 방법으로 하되 \n",
    "  * `new GenericClass<타입1, 타입2, ...>(...)`\n",
    "  * `new GenericClass<>(...)` (생략해도 유추가 가능한 경우)\n",
    "  \n",
    "그렇다고 `<>`까지 빼놓고 쓰는 것은 Java의 정적 타입 검사를 통과하고 컴파일러가 컴파일 에러를 내지 않는다 하더라도 대부분의 경우 매우 바람직하지 않다.\n",
    "\n",
    "이게 도대체 왜 이 모냥으로 자바 제네릭이 생겨먹게 되었는지는 HW0 과제 내용을 제대로 조사하다 보면 그 이유를 스스로 파악할 수 있을 것이므로 더 이상의 자세한 설명은 생략한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### 제너릭에 대한 심화 자율학습\n",
    "\n",
    "클래스 계층구조가 추구하는 *하위타입다형성*(subtype polymorpism)과\n",
    "제너릭이 추구하는 *인자다형성*(parametric polymorphism)이 함께 있으면\n",
    "고려해야 하는 여러가지 다양한 문제가 있다.\n",
    "Java의 경우에는 다음과 같은 내용이 있으니 스스로 알아보라.\n",
    "\n",
    " * Java의 배열의 타입 인자는 공변(covariant)이라고 가정하기 때문에 생기는 문제와 Java는 그것을 어떻게 처리하는지 알아보라.\n",
    " * 자바 제네릭의 인자는 기본적으로 불변(invariant)이라서 생기는 문제와\n",
    "   이를 보완하기 위해 Java에서 공변(covariant)이나 반변(contravariant)을 나타낼 수 있도록 하는 기능에 대해 알아보라. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "name": "java"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}