j_6_datastructure.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 6. 데이터구조\n",
    "\n",
    "Last updated 20190506MON 20180622FRI1800 20180512SUN1600 20180329THR1730\n",
    "\n",
    "## 6.1 학습내용\n",
    "\n",
    "### 6.1.1 목표\n",
    "\n",
    "* 요구사항에 적합한 데이터구조를 선택하여 사용할 수 있다.\n",
    "* 데이터구조를 함수에 전달하여 사용할 수 있다.\n",
    "* Generic 타잎을 사용할 수 있다.\n",
    "* 데이터구조에서 원하는 데이터를 찾을 수 있다 (iterator).\n",
    "* 데이터구조를 정렬할 수 있다 (compareTo())\n",
    "* 배열에 객체를 저장하여 호출할 수 있다.\n",
    "* 목차\n",
    "    * 6.2 데이터구조란?\n",
    "    * 6.3 Java Collections Framework\n",
    "    * 6.4 Array\n",
    "    * 6.5 ArrayList\n",
    "    * 6.6 복사의 문제, shallow vs deep\n",
    "    * 6.7 Map\n",
    "    * 6.8 Set \n",
    "    * 6.9 Queue\n",
    "    * 6.10 Generic Type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 6.1.2 문제\n",
    "\n",
    "* 데이터구조-1: 문장을 생성하기 (Array)\n",
    "* 데이터구조-2: [문자열 'hello' 뒤집기](#DS-2) (Array)\n",
    "* 데이터구조-3: 4로 나누어지고 5로 나누어지지 않는 수 합산 (Array, ArrayList)\n",
    "* 데이터구조-4: 거북이 트랙을 저장하기 (Array, ArrayList)\n",
    "* 데이터구조-5: 도형을 데이터구조로 저장하고 그리기\n",
    "* 데이터구조-6: 거북이가 걸어간 트랙을 다시 걷게 하기\n",
    "* 데이터구조-7: 서울에 거주하는 남녀의 구별 합계와 평균구하기 (2차원 데이터)\n",
    "* 데이터구조-8: 커피에 Milk를 추가하는 비율 구하기 (2차원 데이터)\n",
    "* 데이터구조-9: 성적 평균, 합계 구하기. (mixed type)\n",
    "* 데이터구조-10: 문자열에서 문자를 세기 (Map)\n",
    "* 데이터구조-11: 문자열에 포함된 문자와 숫자의 개수 세기 (Map)\n",
    "* 데이터구조-12: 서울 경복궁 입구에서 제일 가까운 지하철 역 찾기.\n",
    "* 데이터구조-13: 비틀즈 랫잇비 가사에 자주 등장하는 단어 구하기. (map, variable length of 2d arrays)\n",
    "* 데이터구조-14: 자신과 친구의 방에 있는 가전제품을 10개 이상 나열해서, 차이 구하기. (Set)\n",
    "* 데이터구조-15: '학생' 객체를 정렬하기 (compuareTo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 6.1.3 연습문제\n",
    "\n",
    "* 서울 학교생활 만족도 평균 구하기.\n",
    "* 대통령 연설에서 자주 등장하는 단어 차이 분석하기. 단어빈도 그래프 그리기.\n",
    "* (자습) 이메일 자주 보내는 사람 찾기.\n",
    "* mini: **heroku**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 6.2 데이터구조란?\n",
    "\n",
    "데이터구조는 **데이터가 저장되어 있는 방식**을 말한다.\n",
    "즉, 정해진 방식에 따라 데이터를 저장하고, 데이터 간의 **관계**를 정하고, 이를 효과적으로 **사용할 수 있는 방법**을 정하고 있다.\n",
    "데이터를 **순서**대로 저장할지, **키와 값**으로 저장할 지, **계층형**으로 저장할지 다양한 방식 또는 구조가 고안되어 있다.\n",
    "데이터가 어떻게 저장되어 있는지 그 구조에 따라 **데이터를 사용하는 방법**도 다르게 된다.\n",
    "\n",
    "\n",
    "구조의 예 | 설명 | 예\n",
    "-----|-----|-----\n",
    "순서에 따른 구조 | 데이터를 순서에 따라 연결되는 구조, 인덱스로 데이터를 저장하고, 읽을 수 있다. | 배열이나 리스트\n",
    "키에 따라 읽는 구조 | 고유의 키에 대응하는 데이터를 가지는 구조, 키가 서로 중복되지 않아야 한다. 키로 데이터를 읽는다. | Hashmap, json\n",
    "집합 구조 | 데이터를 순서없이 저장, 동일한 데이터는 하나만 존재하고 중복은 허용되지 않는 구조 | Set \n",
    "계층에 따라 읽는 구조 | 데이터가 하위 데이터를 가지는 계층적 구조, 연결경로에 따라 데이터를 저장하고, 이동하여 읽을 수 있다. | tree, graph\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 6.2.1 왜 필요할까?\n",
    "\n",
    "데이터가 1개 있을 경우에는 구조를 만들어 조직화 할 필요가 없다.\n",
    "2개 이상의 서로 연관된 데이터가 있는 경우, 구조를 만들어 체계적으로 저장해야 효과적으로 사용할 수 있게 된다.\n",
    "프로그래밍에서 1개의 데이터는 변수에 저장될 수 있다. **변수는 2개 이상의 값을 동시에 저장하지 못한다**. 변수를 사용하면, 데이터 수만큼 변수가 필요하다. **데이터구조를 사용하면, 동일한 변수명으로 2개 이상을 저장**할 수 있다. 즉 서로 관련이 있는 데이터를 동일한 변수명으로 체계적으로 저장하고 사용할 수 있게 되는 것이다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "프로그램으로 데이터 구조의 필요성을 설명해 보자.\n",
    "1~5까지 값을 출력한다고 하자. for문을 사용하면 2줄이면 쉽게 할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(int i=0;i<5;i++)\r\n",
      "     System.out.print(i+1);\r\n",
      "12345\r\n"
     ]
    }
   ],
   "source": [
    "for(int i=0;i<5;i++)\n",
    "    System.out.print(i+1);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "앞의 for문에서 출력한 1~5까지의 데이터는 저장되지 않았다. 1~5까지의 숫자를 저장해서 다시 사용한다고 생각해보자.\n",
    "어떻게 저장할 것인가? 앞서 배웠던 변수를 사용해보자. 그렇다면 **데이터 수만큼의 5개 변수**가 필요하다.\n",
    "변수를 선언해서 저장하는 수만큼 즉 5줄의 명령문이 필요하다.\n",
    "변수명은 저장하는 숫자만큼 5개가 필요하고 i0, i1, i2, i3, i4라고 했다.\n",
    "이런 방식은 문제가 있다.\n",
    "* 서로 **데이터가 연관**되어 있을 경우, **동일한 변수명**을 사용할 수 없다.\n",
    "* 데이터 항목 하나 하나에 일괄적으로 연산을 할 경우 **반복문**을 사용하는 것이 쉽지 않다.\n",
    "\n",
    "예를 들어, 데이터 개별 값이 원의 반지름이라고 하자. 서로 다른 변수명으로 반복문을 사용하여 면적연산을 한다면 매우 부자연스럽다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " int i0=1;\r\n",
      "|  Added variable i0 of type int with initial value 1\r\n",
      "\r\n",
      " int i1=2;\r\n",
      "|  Added variable i1 of type int with initial value 2\r\n",
      "\r\n",
      " int i2=3;\r\n",
      "|  Added variable i2 of type int with initial value 3\r\n",
      "\r\n",
      " int i3=4;\r\n",
      "|  Added variable i3 of type int with initial value 4\r\n",
      "\r\n",
      " int i4=5;\r\n",
      "|  Added variable i4 of type int with initial value 5\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "int i0=1;\n",
    "int i1=2;\n",
    "int i2=3;\n",
    "int i3=4;\n",
    "int i4=5;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "i0 ~ i4, 5개의 변수를 이용해서 숫자를 저장했다.\n",
    "면적은 어떻게 출력할 것인가? 하나씩 한다면 모두 5줄의 명령어가 필요하다.\n",
    "**변수명이 서로 다르기 때문에 for문을 사용하여 줄 수를 줄이기도 어렵다**.\n",
    "중복이 많아서 낭비적이다. 중복을 줄이는 방법이 있을까? 데이터구조를 이용하면 해결할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " System.out.print(\"Area: \"+i0*i0*3.14);\r\n",
      "Area: 3.14\r\n",
      " System.out.print(\"Area: \"+i1*i1*3.14);\r\n",
      "Area: 12.56\r\n"
     ]
    }
   ],
   "source": [
    "System.out.print(\"Area: \"+i0*i0*3.14);\n",
    "System.out.print(\"Area: \"+i1*i1*3.14);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 6.2.2 데이터 구조를 사용하기\n",
    "\n",
    "데이터구조를 사용하기 위해서는 선언을 해야 한다.\n",
    "많이 사용되는 구조는 배열 Array이다. 이 데이터구조를 사용해보자.\n",
    "자료형을 선언하는 방식은 앞서 객체를 배울 때 했던 것과 같은 요령이다.\n",
    "\n",
    "```java\n",
    "int[] x=new int[10]\n",
    "```\n",
    "\n",
    "구분 | 설명\n",
    "-----|-----\n",
    "좌측 'int[] x' | 데이터 타잎과 변수의 선언. 변수 x는 배열[]로 int만을 저장할 수 있다.\n",
    "우측 'new int[10]' | int를 10개 넣겠다고 명시한다.\n",
    "\n",
    "식당예약에 비유하면, 좌측은 식당의 종류를 우측은 몇 명이나 식사를 할지 명시하는 것이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " int[] x = new int[5];\r\n",
      "|  Modified variable x of type int[] with initial value [I@56ac3a89\r\n",
      "|    Update overwrote variable x\r\n",
      "\r\n",
      " x[0]=1;x[1]=2;x[2]=3;x[3]=4;x[4]=5;\r\n",
      "|  Expression value is: 1\r\n",
      "|    assigned to temporary variable $27 of type int\r\n",
      "|  Expression value is: 2\r\n",
      "|    assigned to temporary variable $28 of type int\r\n",
      "|  Expression value is: 3\r\n",
      "|    assigned to temporary variable $29 of type int\r\n",
      "|  Expression value is: 4\r\n",
      "|    assigned to temporary variable $30 of type int\r\n",
      "|  Expression value is: 5\r\n",
      "|    assigned to temporary variable $31 of type int\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "int[] x = new int[5];\n",
    "x[0]=1;x[1]=2;x[2]=3;x[3]=4;x[4]=5;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**동일한 변수명**으로 **연관**된 값을 묶어 저장하는 것은 만족스럽지만, 아직 **필요한 수만큼 반복**하는 것은 문제이다.\n",
    "이 때 숫자를 하나씩 증가하여 저장하는 **패턴**을 볼 수 있다. **반복문**을 사용하여 중복을 제거할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " double area;\r\n",
      "|  Modified variable area of type double\r\n",
      "|    Update overwrote variable area\r\n",
      "\r\n",
      " for(int i=0; i<5; i++) {\r\n",
      "     area=x[i]*x[i]*3.14;\r\n",
      "     System.out.printf(\"r=%d area: %.2f\\n\",x[i],area);\r\n",
      " }\r\n",
      "r=1 area: 3.14\r\n",
      "r=2 area: 12.56\r\n",
      "r=3 area: 28.26\r\n",
      "r=4 area: 50.24\r\n",
      "r=5 area: 78.50\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "double area;\n",
    "for(int i=0; i<5; i++) {\n",
    "    area=x[i]*x[i]*3.14;\n",
    "    System.out.printf(\"r=%d area: %.2f\\n\",x[i],area);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "요약하면, 데이터구조는 **연관된 데이터를 저장하는 조직화**하는 방식을 말하여, 그 구조에 따라 효과적으로 데이터를 사용하는 방식이 제공된다.\n",
    "* 변수x는 1개 값만 저장. 1~10 값을 모두 저장하려면 변수로는 불가능.\n",
    "* 변수는 값을 1개만 갖는다.\n",
    "* 변수에 1 ~ 10의 값은 저장할 수 없슴. 저장공간이 1개이기 때문에, 가능하지 못함.\n",
    "* 새로운 값을 저장하면, 이전의 값은 없어짐.\n",
    "* 이런 경우 배열을 이용하면, 동일한 변수명으로 여러 값을 묶어서 저장할 수 있슴."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 6.3  Java Collections Framework\n",
    "\n",
    "### Collection 구조\n",
    "\n",
    "자바에서 데이터구조를 묶어서 JCF, **Java Collections Framework**를 제공하고 있다.\n",
    "이 프레임워크는 데이터구조를 사용할 수 있는 API를 구현한 클래스 또는 인터페이스를 가지고 있다.\n",
    "**java.util** 패키지에 구현되어 있고, 그 구조는 아래 클래스 다이어그램을 보면서 이해할 수 있다.\n",
    "\n",
    "* 최상위 **Iterable**이 있다. Collection은 데이터를 하나씩 반복해서 가져올 수 있게 Iterable 인터페이스와 상속관계를 가지고 있다.\n",
    "* 다음으로 Collection은 크게 나누어 3가지 **List**, **Queue**, **Set** 등으로 분류되고 있고, 상속한다. **모두 인터페이스로 구현**되어 있다.\n",
    "* List, Queue, Set은 구체적인 **클래스로 구현되어 있어 각 각 ArrayList, HashSet, HashMap을 사용**한다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import iplantuml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"389px\" style=\"width:583px;height:389px;\" version=\"1.1\" viewBox=\"0 0 583 389\" width=\"583px\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"><defs><filter height=\"300%\" id=\"f1\" width=\"300%\" x=\"-1\" y=\"-1\"><feGaussianBlur result=\"blurOut\" stdDeviation=\"2.0\"/><feColorMatrix in=\"blurOut\" result=\"blurOut2\" type=\"matrix\" values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 .4 0\"/><feOffset dx=\"4.0\" dy=\"4.0\" in=\"blurOut2\" result=\"blurOut3\"/><feBlend in=\"SourceGraphic\" in2=\"blurOut3\" mode=\"normal\"/></filter></defs><g><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"48\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"81\" x=\"120\" y=\"8\"/><ellipse cx=\"135\" cy=\"24\" fill=\"#B4A7E5\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M130.9219,19.7656 L130.9219,17.6094 L138.3125,17.6094 L138.3125,19.7656 L135.8438,19.7656 L135.8438,27.8438 L138.3125,27.8438 L138.3125,30 L130.9219,30 L130.9219,27.8438 L133.3906,27.8438 L133.3906,19.7656 L130.9219,19.7656 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" font-style=\"italic\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"49\" x=\"149\" y=\"28.1543\">Iterable</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"121\" x2=\"200\" y1=\"40\" y2=\"40\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"121\" x2=\"200\" y1=\"48\" y2=\"48\"/><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"48\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"93\" x=\"114\" y=\"116\"/><ellipse cx=\"129\" cy=\"132\" fill=\"#B4A7E5\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M124.9219,127.7656 L124.9219,125.6094 L132.3125,125.6094 L132.3125,127.7656 L129.8438,127.7656 L129.8438,135.8438 L132.3125,135.8438 L132.3125,138 L124.9219,138 L124.9219,135.8438 L127.3906,135.8438 L127.3906,127.7656 L124.9219,127.7656 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" font-style=\"italic\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"61\" x=\"143\" y=\"136.1543\">Collection</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"115\" x2=\"206\" y1=\"148\" y2=\"148\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"115\" x2=\"206\" y1=\"156\" y2=\"156\"/><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"48\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"53\" x=\"30\" y=\"224\"/><ellipse cx=\"45\" cy=\"240\" fill=\"#B4A7E5\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M40.9219,235.7656 L40.9219,233.6094 L48.3125,233.6094 L48.3125,235.7656 L45.8438,235.7656 L45.8438,243.8438 L48.3125,243.8438 L48.3125,246 L40.9219,246 L40.9219,243.8438 L43.3906,243.8438 L43.3906,235.7656 L40.9219,235.7656 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" font-style=\"italic\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"21\" x=\"59\" y=\"244.1543\">Set</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"31\" x2=\"82\" y1=\"256\" y2=\"256\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"31\" x2=\"82\" y1=\"264\" y2=\"264\"/><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"48\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"53\" x=\"134\" y=\"224\"/><ellipse cx=\"149\" cy=\"240\" fill=\"#B4A7E5\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M144.9219,235.7656 L144.9219,233.6094 L152.3125,233.6094 L152.3125,235.7656 L149.8438,235.7656 L149.8438,243.8438 L152.3125,243.8438 L152.3125,246 L144.9219,246 L144.9219,243.8438 L147.3906,243.8438 L147.3906,235.7656 L144.9219,235.7656 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" font-style=\"italic\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"21\" x=\"163\" y=\"244.1543\">List</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"135\" x2=\"186\" y1=\"256\" y2=\"256\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"135\" x2=\"186\" y1=\"264\" y2=\"264\"/><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"48\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"58\" x=\"258.5\" y=\"8\"/><ellipse cx=\"273.5\" cy=\"24\" fill=\"#B4A7E5\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M269.4219,19.7656 L269.4219,17.6094 L276.8125,17.6094 L276.8125,19.7656 L274.3438,19.7656 L274.3438,27.8438 L276.8125,27.8438 L276.8125,30 L269.4219,30 L269.4219,27.8438 L271.8906,27.8438 L271.8906,19.7656 L269.4219,19.7656 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" font-style=\"italic\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"26\" x=\"287.5\" y=\"28.1543\">Map</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"259.5\" x2=\"315.5\" y1=\"40\" y2=\"40\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"259.5\" x2=\"315.5\" y1=\"48\" y2=\"48\"/><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"48\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"73\" x=\"222\" y=\"224\"/><ellipse cx=\"237\" cy=\"240\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M239.9688,245.6406 Q239.3906,245.9375 238.75,246.0859 Q238.1094,246.2344 237.4063,246.2344 Q234.9063,246.2344 233.5859,244.5859 Q232.2656,242.9375 232.2656,239.8125 Q232.2656,236.6875 233.5859,235.0313 Q234.9063,233.375 237.4063,233.375 Q238.1094,233.375 238.7578,233.5313 Q239.4063,233.6875 239.9688,233.9844 L239.9688,236.7031 Q239.3438,236.125 238.75,235.8516 Q238.1563,235.5781 237.5313,235.5781 Q236.1875,235.5781 235.5,236.6484 Q234.8125,237.7188 234.8125,239.8125 Q234.8125,241.9063 235.5,242.9766 Q236.1875,244.0469 237.5313,244.0469 Q238.1563,244.0469 238.75,243.7734 Q239.3438,243.5 239.9688,242.9219 L239.9688,245.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"41\" x=\"251\" y=\"244.1543\">Queue</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"223\" x2=\"294\" y1=\"256\" y2=\"256\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"223\" x2=\"294\" y1=\"264\" y2=\"264\"/><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"48\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"85\" x=\"126\" y=\"332\"/><ellipse cx=\"141\" cy=\"348\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M143.9688,353.6406 Q143.3906,353.9375 142.75,354.0859 Q142.1094,354.2344 141.4063,354.2344 Q138.9063,354.2344 137.5859,352.5859 Q136.2656,350.9375 136.2656,347.8125 Q136.2656,344.6875 137.5859,343.0313 Q138.9063,341.375 141.4063,341.375 Q142.1094,341.375 142.7578,341.5313 Q143.4063,341.6875 143.9688,341.9844 L143.9688,344.7031 Q143.3438,344.125 142.75,343.8516 Q142.1563,343.5781 141.5313,343.5781 Q140.1875,343.5781 139.5,344.6484 Q138.8125,345.7188 138.8125,347.8125 Q138.8125,349.9063 139.5,350.9766 Q140.1875,352.0469 141.5313,352.0469 Q142.1563,352.0469 142.75,351.7734 Q143.3438,351.5 143.9688,350.9219 L143.9688,353.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"53\" x=\"155\" y=\"352.1543\">ArrayList</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"127\" x2=\"210\" y1=\"364\" y2=\"364\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"127\" x2=\"210\" y1=\"372\" y2=\"372\"/><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"48\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"85\" x=\"6\" y=\"332\"/><ellipse cx=\"21\" cy=\"348\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M23.9688,353.6406 Q23.3906,353.9375 22.75,354.0859 Q22.1094,354.2344 21.4063,354.2344 Q18.9063,354.2344 17.5859,352.5859 Q16.2656,350.9375 16.2656,347.8125 Q16.2656,344.6875 17.5859,343.0313 Q18.9063,341.375 21.4063,341.375 Q22.1094,341.375 22.7578,341.5313 Q23.4063,341.6875 23.9688,341.9844 L23.9688,344.7031 Q23.3438,344.125 22.75,343.8516 Q22.1563,343.5781 21.5313,343.5781 Q20.1875,343.5781 19.5,344.6484 Q18.8125,345.7188 18.8125,347.8125 Q18.8125,349.9063 19.5,350.9766 Q20.1875,352.0469 21.5313,352.0469 Q22.1563,352.0469 22.75,351.7734 Q23.3438,351.5 23.9688,350.9219 L23.9688,353.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"53\" x=\"35\" y=\"352.1543\">HashSet</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"90\" y1=\"364\" y2=\"364\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"90\" y1=\"372\" y2=\"372\"/><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"48\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"90\" x=\"242.5\" y=\"116\"/><ellipse cx=\"257.5\" cy=\"132\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M260.4688,137.6406 Q259.8906,137.9375 259.25,138.0859 Q258.6094,138.2344 257.9063,138.2344 Q255.4063,138.2344 254.0859,136.5859 Q252.7656,134.9375 252.7656,131.8125 Q252.7656,128.6875 254.0859,127.0313 Q255.4063,125.375 257.9063,125.375 Q258.6094,125.375 259.2578,125.5313 Q259.9063,125.6875 260.4688,125.9844 L260.4688,128.7031 Q259.8438,128.125 259.25,127.8516 Q258.6563,127.5781 258.0313,127.5781 Q256.6875,127.5781 256,128.6484 Q255.3125,129.7188 255.3125,131.8125 Q255.3125,133.9063 256,134.9766 Q256.6875,136.0469 258.0313,136.0469 Q258.6563,136.0469 259.25,135.7734 Q259.8438,135.5 260.4688,134.9219 L260.4688,137.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"58\" x=\"271.5\" y=\"136.1543\">HashMap</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"243.5\" x2=\"331.5\" y1=\"148\" y2=\"148\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"243.5\" x2=\"331.5\" y1=\"156\" y2=\"156\"/><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"48\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"72\" x=\"427.5\" y=\"8\"/><ellipse cx=\"442.5\" cy=\"24\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M445.4688,29.6406 Q444.8906,29.9375 444.25,30.0859 Q443.6094,30.2344 442.9063,30.2344 Q440.4063,30.2344 439.0859,28.5859 Q437.7656,26.9375 437.7656,23.8125 Q437.7656,20.6875 439.0859,19.0313 Q440.4063,17.375 442.9063,17.375 Q443.6094,17.375 444.2578,17.5313 Q444.9063,17.6875 445.4688,17.9844 L445.4688,20.7031 Q444.8438,20.125 444.25,19.8516 Q443.6563,19.5781 443.0313,19.5781 Q441.6875,19.5781 441,20.6484 Q440.3125,21.7188 440.3125,23.8125 Q440.3125,25.9063 441,26.9766 Q441.6875,28.0469 443.0313,28.0469 Q443.6563,28.0469 444.25,27.7734 Q444.8438,27.5 445.4688,26.9219 L445.4688,29.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"40\" x=\"456.5\" y=\"28.1543\">Object</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"428.5\" x2=\"498.5\" y1=\"40\" y2=\"40\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"428.5\" x2=\"498.5\" y1=\"48\" y2=\"48\"/><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"48\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"71\" x=\"368\" y=\"116\"/><ellipse cx=\"383\" cy=\"132\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M385.9688,137.6406 Q385.3906,137.9375 384.75,138.0859 Q384.1094,138.2344 383.4063,138.2344 Q380.9063,138.2344 379.5859,136.5859 Q378.2656,134.9375 378.2656,131.8125 Q378.2656,128.6875 379.5859,127.0313 Q380.9063,125.375 383.4063,125.375 Q384.1094,125.375 384.7578,125.5313 Q385.4063,125.6875 385.9688,125.9844 L385.9688,128.7031 Q385.3438,128.125 384.75,127.8516 Q384.1563,127.5781 383.5313,127.5781 Q382.1875,127.5781 381.5,128.6484 Q380.8125,129.7188 380.8125,131.8125 Q380.8125,133.9063 381.5,134.9766 Q382.1875,136.0469 383.5313,136.0469 Q384.1563,136.0469 384.75,135.7734 Q385.3438,135.5 385.9688,134.9219 L385.9688,137.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"39\" x=\"397\" y=\"136.1543\">Arrays</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"369\" x2=\"438\" y1=\"148\" y2=\"148\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"369\" x2=\"438\" y1=\"156\" y2=\"156\"/><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"48\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"100\" x=\"474.5\" y=\"116\"/><ellipse cx=\"489.5\" cy=\"132\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M492.4688,137.6406 Q491.8906,137.9375 491.25,138.0859 Q490.6094,138.2344 489.9063,138.2344 Q487.4063,138.2344 486.0859,136.5859 Q484.7656,134.9375 484.7656,131.8125 Q484.7656,128.6875 486.0859,127.0313 Q487.4063,125.375 489.9063,125.375 Q490.6094,125.375 491.2578,125.5313 Q491.9063,125.6875 492.4688,125.9844 L492.4688,128.7031 Q491.8438,128.125 491.25,127.8516 Q490.6563,127.5781 490.0313,127.5781 Q488.6875,127.5781 488,128.6484 Q487.3125,129.7188 487.3125,131.8125 Q487.3125,133.9063 488,134.9766 Q488.6875,136.0469 490.0313,136.0469 Q490.6563,136.0469 491.25,135.7734 Q491.8438,135.5 492.4688,134.9219 L492.4688,137.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"68\" x=\"503.5\" y=\"136.1543\">Collections</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"475.5\" x2=\"573.5\" y1=\"148\" y2=\"148\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"475.5\" x2=\"573.5\" y1=\"156\" y2=\"156\"/><path d=\"M160.5,76.024 C160.5,89.579 160.5,104.038 160.5,115.678 \" fill=\"none\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><polygon fill=\"none\" points=\"153.5,76,160.5,56,167.5,76,153.5,76\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M123.923,178.28 C109.098,193.391 92.4338,210.375 79.3816,223.678 \" fill=\"none\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><polygon fill=\"none\" points=\"118.93,173.374,137.934,164,128.923,183.179,118.93,173.374\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M160.5,184.024 C160.5,197.579 160.5,212.038 160.5,223.678 \" fill=\"none\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><polygon fill=\"none\" points=\"153.5,184,160.5,164,167.5,184,153.5,184\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M195.404,178.753 C209.263,193.744 224.767,210.514 236.939,223.678 \" fill=\"none\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><polygon fill=\"none\" points=\"190.202,183.438,181.765,164,200.482,173.934,190.202,183.438\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M163.747,292.0236 C164.77,305.5792 165.861,320.0381 166.74,331.6784 \" fill=\"none\" style=\"stroke: #A80036; stroke-width: 1.0; stroke-dasharray: 7.0,7.0;\"/><polygon fill=\"none\" points=\"156.761,292.4705,162.236,272,170.721,291.4169,156.761,292.4705\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M53.2529,292.0236 C52.2299,305.5792 51.1386,320.0381 50.2601,331.6784 \" fill=\"none\" style=\"stroke: #A80036; stroke-width: 1.0; stroke-dasharray: 7.0,7.0;\"/><polygon fill=\"none\" points=\"46.2787,291.4169,54.7641,272,60.239,292.4705,46.2787,291.4169\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M287.5,76.024 C287.5,89.579 287.5,104.038 287.5,115.678 \" fill=\"none\" style=\"stroke: #A80036; stroke-width: 1.0; stroke-dasharray: 7.0,7.0;\"/><polygon fill=\"none\" points=\"280.5,76,287.5,56,294.5,76,280.5,76\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M440.511,73.613 C432.454,87.848 423.682,103.345 416.701,115.678 \" fill=\"none\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><polygon fill=\"none\" points=\"434.537,69.957,450.481,56,446.721,76.854,434.537,69.957\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M486.872,73.613 C495.063,87.848 503.982,103.345 511.079,115.678 \" fill=\"none\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><polygon fill=\"none\" points=\"480.645,76.826,476.736,56,492.779,69.844,480.645,76.826\" style=\"stroke: #A80036; stroke-width: 1.0;\"/></g></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "interface Iterable\n",
    "interface Collection\n",
    "interface Set\n",
    "interface List\n",
    "interface Map\n",
    "Iterable <|-- Collection\n",
    "Collection <|-- Set\n",
    "Collection <|-- List\n",
    "Collection <|-- Queue\n",
    "List <|.. ArrayList\n",
    "Set <|.. HashSet\n",
    "Map <|.. HashMap\n",
    "class Object\n",
    "class Arrays\n",
    "class Collections\n",
    "Object <|-- Arrays\n",
    "Object <|-- Collections\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 많이 사용하는 3가지 Collection\n",
    "\n",
    "Collection은 3가지 구조로 크게 구분할 수 있다.\n",
    "* **리스트**는 데이터를 순서대로 저장하고, 저장된 순서에 따라 데이터를 가져올 수 있다. ArrayList 또는 Queue를 예로 들 수 있다.\n",
    "* **맵**은 키를 사용해서 저장하거나 읽는다.\n",
    "* **세트**는 순서가 없는 데이터 구조를 말한다. 중복된 데이터가 허용되지 않는다.\n",
    "\n",
    "데이터구조 | 종류 | 특징\n",
    "------|------|------\n",
    "List| ArrayList, LinkedList | List는 순서가 있어서, 인덱스를 사용하여 읽거나, 수정할 수 있다. Queue는 LinkedList로 FIFO 순위가 있어서 순서가 정해지면 수정할 수 없다.\n",
    "Set | HashSet, TreeSet, LinkedHashSet | Set은 순서가 없어 인덱스를 사용하지 못한다. 데이터중복이 없고 하나만 있다는 점에서 key와 같은 의미 (key로만 구성이 된 dictionary)\n",
    "Map | HashMap, TreeMap, LinkedHashMap | Map은 key-value가 1:1로 구성함. 특정 key가 어떤 값을 갖는지 사전식으로 저장.문자를 인덱스로 사용할 수 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### API\n",
    "\n",
    "JCF에서 List, Set, Map에서 제공하는 데이터 관련 API를 살펴 보자.\n",
    "* 앞서 각 데이터구조의 특징을 살펴보았다. 입력, 읽기, 수정, 삭제와 같은 API를 사용하면서 **순서가 있는 경우에는 인덱스**로, **순서가 없는 경우는 키**를 사용한다.\n",
    "* 데이터가 많아지면서 생기는 검색, 정렬, 복사\n",
    "    * 그러나 **검색 API는 Iterator를 사용**한다 . 앞서 살펴본 바와 같이, Iterable을 상속하므로 Iterator패턴을 사용할 수 있다.\n",
    "    * **정렬** 역시 **comparable**, **comparator**를 사용할 수 있다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "데이터구조 | 입력 | 읽기 | 수정 | 삭제 | 크기\n",
    "-------|-------|-------|-------|-------|-------\n",
    "ArrayList | add() | get(index) | set(index, new value) | remove(index) | size()\n",
    "Queue | add(), offer() | peek() | 우선순위이기 때문에 remove and reinsert | poll(), remove() | size()\n",
    "Set | add() | 유일한 값이므로 순서대로 읽지 못함 | remove and insert | remove() | size()\n",
    "Map | put() | get(key), values() | put(key, new value) | remove(key) | size()\n",
    "\n",
    "* 여기서는 배열과 Collection의 ArrayList, Queue, Map, Set을 소개한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Array\n",
    "\n",
    "클래스 관계를 살펴보면, 배열, Array는 Collection에 속하지 않는다.\n",
    "Collection은 '객체'를 요소로 가지는 데이터구조이다. **원시타잎은 가질 수 없다**.\n",
    "Array는 Collection에 속하지 않으므로 원시타잎을 가질 수 있다.\n",
    "또한 배열과 Collection은 다음 차이가 있다.\n",
    "\n",
    "구분 | Collection | Array\n",
    "----------|----------|----------\n",
    "원시타잎 | 원시타잎을 가질 수 없다. **객체만** 가진다.  | **원시타잎과 객체 모두** 가질 수 있다.\n",
    "크기 | **늘어날 수 있다**. | 미리 정해야 한다. 정하면 **변경할 수 없다**.\n",
    "사용성 | 편리하다. | 불편하다. toString, sort, iterator를 사용할 수 없다. 사용하려면 Arrays.asList(array).iterator();\n",
    "성능 | 메모리는 적게 쓰지만, 성능은 상대적으로 떨어진다 | 메모리는 많이 쓰지만, 성능은 상대적으로 좋다\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Arrays, Collections\n",
    "\n",
    "배열과 Collection에 대해 **정렬 sort**, **복사 copy**, **찾기 search** 등 유틸리티 기능을 제공하는 클래스가 있다.\n",
    "Arrays, Collections는 **static함수**로 객체를 만들지 않고, 직접 함수를 호출하여 사용할 수 있다.\n",
    "\n",
    "유틸리티 클래스 구분 | 설명\n",
    "-----|-----\n",
    "Arrays | 배열에 대해 제공하는 유틸리티\n",
    "Collections | List, Queue, Set 등 java collection에 대해 제공되는 유틸리티"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 6.4 Array\n",
    "\n",
    "배열을 사용하려면, 다른 데이터타잎과 마찬가지로, 선언부터 해야 한다.\n",
    "* 데이터구조의 선언은 여러 데이터를 저장하는 방식을 정하는 것이다.\n",
    "* 자료형 (data type)을 미리 선언하고, 필요한 메모리공간을 확보한다.\n",
    "* 데이터구조는 사용하기 전 선언을 해야 한다. 물론 변수도 선언을 한다.\n",
    "* 배열은 고정크기이며, 인덱스 방식으로 사용한다. 가변적일 경우 List를 사용한다.\n",
    "\n",
    "```java\n",
    "데이터타잎[] 변수명=new 데이터타잎[크기] 또는\n",
    "데이터타잎[] 변수명=new 생성자\n",
    "```\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 자료에 저장되는 데이터형을 명시한다.\n",
    "```java\n",
    "int[] arr;\n",
    "```\n",
    "\n",
    "선언 방식 | 설명 | 구분\n",
    "-----|-----|-----\n",
    "int arr[] | 변수 뒤에 []를 쓴다 | c 방식\n",
    "int[] arr | 데이터타잎 뒤에 []를 쓴다 | java 방식"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 원시타잎 Array\n",
    "\n",
    "배열을 선언한 후, 초기화를 따로 하거나, 같이 할 수 있다.\n",
    "다음은 원시타잎 int를 4개 선언하고 초기화는 하지 않는 예이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " int[] a=new int[4];\r\n",
      "|  Modified variable a of type int[] with initial value [I@1ce92674\r\n",
      "|    Update overwrote variable a\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "int[] a=new int[4];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "선언과 초기화를 같이 하는 경우이다. 이럴 경우 배열의 크기는 자동으로 할당된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " int[] a = {1, 2, 3, 4};\r\n",
      "|  Modified variable a of type int[] with initial value [I@6fd02e5\r\n",
      "|    Update overwrote variable a\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "int[] a = {1, 2, 3, 4};"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "저장된 데이터 갯수는 **인덱스**를 이용하여 출력한다. 총개수는 **length**로 알 수 있다.\n",
    "**인덱스**는 데이터를 여러 개를 저장할 경우, 그 순서를 말한다.\n",
    "이 인덱스는 0부터 시작하며, 사람은 1부터 숫자를 세는 것과 다르다는 점에 주의한다.\n",
    "양의 정수 값을 사용하며, 음수 또는 소수를 사용하지 못한다.\n",
    "\n",
    "> 연관 배열\n",
    "> **Associative Array**\n",
    ">\n",
    "> Associative array는 문자를 인덱스로 사용한다.\n",
    "> 예를 들어, 축구경기의 선수는 11명을 나타낼 경우 sports[\"football\"]=11\n",
    "> Java map, Python dictionary, Javascript JSON 등이다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(int i=0;i<4;i++)\r\n",
      "     System.out.print(a[i]);\r\n",
      "1234\r\n"
     ]
    }
   ],
   "source": [
    "for(int i=0;i<4;i++)\n",
    "    System.out.print(a[i]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(int i=0;i<a.length;i++)\r\n",
      "     System.out.print(a[i]);\r\n",
      "1234\r\n"
     ]
    }
   ],
   "source": [
    "for(int i=0;i<a.length;i++)\n",
    "    System.out.print(a[i]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 인덱스가 저장된 범위를 넘어가면 오류가 발생한다. IndexOutOfBoundsException"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " System.out.print(a[5]);\r\n",
      "|  java.lang.ArrayIndexOutOfBoundsException thrown: 5\r\n",
      "|        at (#26:1)\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "System.out.print(a[5]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 객체 Array\n",
    "\n",
    "배열은 객체를 요소로 가질 수 있다.\n",
    "예를 들어, 문자열을 요소로 가지는 **문자열 배열** 역시 앞의 경우와 유사하게 선언할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " String[] strArr=new String[3];\r\n",
      "|  Added variable strArr of type String[] with initial value [Ljava.lang.String;@cd2dae5\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "String[] strArr=new String[3];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " String[] strArr={\"Seoul\", \"New York\", \"Tokyo\"};\r\n",
      "|  Modified variable strArr of type String[] with initial value [Ljava.lang.String;@3a883ce7\r\n",
      "|    Update overwrote variable strArr\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "String[] strArr={\"Seoul\", \"New York\", \"Tokyo\"};"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "데이터를 저장하고 문자열에 \"Paris\"가 있다면 출력하는 반복문을 사용해 보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " strArr.length\r\n",
      "|  Expression value is: 3\r\n",
      "|    assigned to temporary variable $2 of type int\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "strArr.length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(int i=0;i<strArr.length;i++) {\r\n",
      "     if(strArr[i].equals(\"Paris\")) {\r\n",
      "         System.out.printf(\"%d %s\\n\",i,strArr[i]);\r\n",
      "     } else {\r\n",
      "         System.out.printf(\"%d not found\\n\",i);\r\n",
      "     }\r\n",
      " }\r\n",
      "0 not found\r\n",
      "1 not found\r\n",
      "2 not found\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for(int i=0;i<strArr.length;i++) {\n",
    "    if(strArr[i].equals(\"Paris\")) {\n",
    "        System.out.printf(\"%d %s\\n\",i,strArr[i]);\n",
    "    } else {\n",
    "        System.out.printf(\"%d not found\\n\",i);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(String s:strArr) {\r\n",
      "     if(s.equals(\"Seoul\")) {\r\n",
      "         System.out.println(s);\r\n",
      "     } else {\r\n",
      "         System.out.println(\"Not Found\");\r\n",
      "     }\r\n",
      " }\r\n",
      "Seoul\r\n",
      "Not Found\r\n",
      "Not Found\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for(String s:strArr) {\n",
    "    if(s.equals(\"Seoul\")) {\n",
    "        System.out.println(s);\n",
    "    } else {\n",
    "        System.out.println(\"Not Found\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 다차원 배열\n",
    "\n",
    "**2차원 이상의 배열**을 다차원 배열이라고 한다.\n",
    "데이터는 **행별로 열의 수가 동일**하게 만든다.\n",
    "**괄호 {{},{}...}를 중첩**하여 요소를 넣고 생성한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " int[][] marks={{50,60,55,67,70},{62,65,70,70,81},{72,66,77,80,69}};\r\n",
      "|  Added variable marks of type int[][] with initial value [[I@f6c48ac\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "int[][] marks={{50,60,55,67,70},{62,65,70,70,81},{72,66,77,80,69}};"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "2차원 데이터에 대한 중첩반복문을 사용하여 출력할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(int[] mArr:marks) {             //각 행을 반복\r\n",
      "     System.out.printf(\"\\n행 출력: \");\r\n",
      "     for(int m:mArr)                 //열을 반복\r\n",
      "         System.out.printf(\"%d \",m);\r\n",
      " \r\n",
      " }\r\n",
      "\r\n",
      "행 출력: 50 60 55 67 70 \r\n",
      "행 출력: 62 65 70 70 81 \r\n",
      "행 출력: 72 66 77 80 69 \r\n"
     ]
    }
   ],
   "source": [
    "for(int[] mArr:marks) {             //각 행을 반복\n",
    "    System.out.printf(\"\\n행 출력: \");\n",
    "    for(int m:mArr)                 //열을 반복\n",
    "        System.out.printf(\"%d \",m);\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 연관배열 parallel array\n",
    "\n",
    "* 서로 연관되어 있는 배열 2개를 말한다.\n",
    "* 세계공항의 기온 [항공기상청 공항](http://amo.kma.go.kr/)\n",
    "    * 공항명은 문자열, 온드는 정수이다. 서로 데이터 타잎이 다른 경우 사용할 수 있다.\n",
    "    * 연관배열은 동일한 인덱스를 가지고 연결될 수 있다.\n",
    "\n",
    "공항 | 기온 (섭씨)\n",
    "-------|-------\n",
    "도쿄국제공항 | 13\n",
    "베이징 수도 국제공항 | 06\n",
    "런던히드로공항 | 05\n",
    "시드니 공항 | 18\n",
    "존.F.케네디 | 17\n",
    "조모케냐타국제공항 | 17\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " String[] names={\"동경국제공항\", \"베이징국제공항\",\"런던히드로공항\",\"시드니공항\",\"존.F.케네디\", \"조모케냐타국제공항\"} \r",
      ";\r\n",
      "|  Added variable names of type String[] with initial value [Ljava.lang.String;@f6c48ac\r\n",
      "\r\n",
      " int[] temp={13,6,5,18,17,17};\r\n",
      "|  Added variable temp of type int[] with initial value [I@598067a5\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "String[] names={\"동경국제공항\", \"베이징국제공항\",\"런던히드로공항\",\"시드니공항\",\"존.F.케네디\", \"조모케냐타국제공항\"};\n",
    "int[] temp={13,6,5,18,17,17};\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(int i=0;i<names.length;i++)\r\n",
      "     System.out.printf(\"공항:%-25s\\t온도:%3d\\n\",names[i],temp[i])\r\n",
      "공항:동경국제공항                   \t온도: 13\r\n",
      "공항:베이징국제공항                  \t온도:  6\r\n",
      "공항:런던히드로공항                  \t온도:  5\r\n",
      "공항:시드니공항                    \t온도: 18\r\n",
      "공항:존.F.케네디                  \t온도: 17\r\n",
      "공항:조모케냐타국제공항                \t온도: 17\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for(int i=0;i<names.length;i++)\n",
    "    System.out.printf(\"공항:%-25s\\t온도:%3d\\n\",names[i],temp[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 데이터구조-1 : 문장을 생성하기\n",
    "\n",
    "### 문제\n",
    "문장을 만드는 프로그램은 복잡하다. 상황에 맞는 단어, 문장, 주제를 선별하기 위해서는 상당한 인공지능이 필요할 것이다.\n",
    "**채팅봇**이란 사람과 대화를 할 수 있는 로봇을 말한다. 심심이는 2002년 개발한 인공지능 대화 엔진으로 일상에서 심심할 때 대화를 나눌 수 있다. 비행기 예약과 같은 업무에서도 활용할 수 있다. 여기서는 매우 단순한 영어 문장을 무작위로 만들어 보자.\n",
    "한글은 조사와 동사의 변화가 있어 문장을 만들기 쉽지 않다.\n",
    "\n",
    "### 해결\n",
    "단어를 주어, 목적어, 동사로 나누어 저장해 놓고, 불러서 문장을 생성한다.\n",
    "단어를 저장하기 위해 배열을 사용한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class SentenceBuilder {\r\n",
      "     public StringBuilder build() {\r\n",
      "         StringBuilder sb=new StringBuilder();\r\n",
      "         String[] subjects = {\"I\", \"You\",\"We\", \"A friend of mine\"};\r\n",
      "         String[] verbs = {\"play\",\"love\",\"eat\"};\r\n",
      "         String[] objects = {\"a football\", \"to cook\"};\r\n",
      "         int rand1 = (int) (Math.random() * subjects.length);\r\n",
      "         int rand2 = (int) (Math.random() * verbs.length);\r\n",
      "         int rand3 = (int) (Math.random() * objects.length);\r\n",
      " \r\n",
      "         sb.append(subjects[rand1]);\r\n",
      "         sb.append(\" \");\r\n",
      "         sb.append(verbs[rand2]);\r\n",
      "         sb.append(\" \");\r\n",
      "         sb.append(objects[rand3]);\r\n",
      "         return sb;\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added class SentenceBuilder\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class SentenceBuilder {\n",
    "    public StringBuilder build() {\n",
    "        StringBuilder sb=new StringBuilder();\n",
    "        String[] subjects = {\"I\", \"You\",\"We\", \"A friend of mine\"};\n",
    "        String[] verbs = {\"play\",\"love\",\"eat\"};\n",
    "        String[] objects = {\"a football\", \"to cook\"};\n",
    "        int rand1 = (int) (Math.random() * subjects.length);\n",
    "        int rand2 = (int) (Math.random() * verbs.length);\n",
    "        int rand3 = (int) (Math.random() * objects.length);\n",
    "\n",
    "        sb.append(subjects[rand1]);\n",
    "        sb.append(\" \");\n",
    "        sb.append(verbs[rand2]);\n",
    "        sb.append(\" \");\n",
    "        sb.append(objects[rand3]);\n",
    "        return sb;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " SentenceBuilder sb=new SentenceBuilder();\r\n",
      "|  Added variable sb of type SentenceBuilder with initial value SentenceBuilder@cb644e\r\n",
      "|    Update modified class SentenceBuilder\r\n",
      "|    Update modified class SentenceBuilderMain\r\n",
      "\r\n",
      " System.out.println(sb.build());\r\n",
      "A friend of mine play a football\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "SentenceBuilder sb=new SentenceBuilder();\n",
    "System.out.println(sb.build());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 클래스의 메인함수를 별도로 만들어 본다.\n",
    "\n",
    "main()함수는 클래스에 포함하여 만들기도 하지만, **분리**할 수도 있다.\n",
    "분리할 경우, 서로 **인식**하는 문제가 있다.\n",
    "즉 서로 다른 자바파일인 SentenceBuilderMain에서 SentenceBuilder를 사용할 수 있는지의 문제인데,\n",
    "서로 **동일한 디렉토리**에 클래스가 있으면 문제가 없다.\n",
    "\n",
    "\n",
    "```java\n",
    "class SentenceBuilderMain {\n",
    "    public static void main(String[] args) {\n",
    "        SentenceBuilder sb=new SentenceBuilder();\n",
    "        System.out.println(sb.build());       \n",
    "    }\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 데이터구조-2: 문자열 'hello' 뒤집기\n",
    "\n",
    "<a id='DS-2'></a>\n",
    "\n",
    "### 문제\n",
    "문자열을 거울에 비추는 것처럼 거꾸로 뒤집는 문제이다.\n",
    "\n",
    "### 해결\n",
    "이 문제는 문자열을 하나씩 추출하는 charAt() 함수와 StringBuffer를 사용해서 뒤집을 수 있다.\n",
    "여기서는 문자배열을 생성해서 풀기로 한다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 문자배열로 만들어 뒤집기\n",
    "\n",
    "줄 | 설명\n",
    "-----|-----\n",
    "2 | 문자열을 toCharArray()함수를 사용해서 문자배열 chArr로 변환\n",
    "4 | 문자배열 chArr을 거꾸로 하나씩 가져오는 반복문\n",
    "5 | StringBuilder에 append()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " String hello=\"hello\";\r\n",
      "|  Added variable hello of type String with initial value \"hello\"\r\n",
      "\r\n",
      " char[] chArr=hello.toCharArray();\r\n",
      "|  Added variable chArr of type char[] with initial value [C@6e06451e\r\n",
      "\r\n",
      " StringBuilder olleh=new StringBuilder();\r\n",
      "|  Added variable olleh of type StringBuilder with initial value \r\n",
      "\r\n",
      " for(int i=chArr.length-1;i>=0;i--)\r\n",
      "     olleh.append(chArr[i]);\r\n",
      "\r\n",
      " System.out.println(olleh);\r\n",
      "olleh\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "String hello=\"hello\";\n",
    "char[] chArr=hello.toCharArray();\n",
    "StringBuilder olleh=new StringBuilder();\n",
    "for(int i=chArr.length-1;i>=0;i--)\n",
    "    olleh.append(chArr[i]);\n",
    "System.out.println(olleh);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 클래스로 만들기\n",
    "\n",
    "* String mirror(String)함수, 클래스 StringMirror 만들기 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "public class StringMirrorMain {\n",
    "    static String mirror(String hello) {\n",
    "        //String hello=\"hello\";\n",
    "        char[] chArr=hello.toCharArray();\n",
    "        StringBuilder olleh=new StringBuilder();\n",
    "        for(int i=chArr.length-1;i>=0;i--)\n",
    "            olleh.append(chArr[i]);\n",
    "        //System.out.println(olleh);\n",
    "        return olleh.toString();\n",
    "    }\n",
    "    public static void main(String[] args) {\n",
    "        System.out.println(mirror(\"sangmyung\"));\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 6.5 ArrayList\n",
    "\n",
    "앞서 배운 배열과 ArrayList를 비교해 보자.\n",
    "배열은 크기가 **고정**되어 있는 반면, ArrayList는 **가변적**이다.\n",
    "또한 배열에는 원시타잎과 객체를 모두 저장할 수 있는 반면, ArrayList는 원시타잎을 저장하지 못한다.\n",
    "데이터는 모두 **순서대로 저장**되어 있어, **인덱스**를 통해서 가져온다.\n",
    "\n",
    "기능 | ArrayList | Array\n",
    "-----|-----|-----\n",
    "생성 | ArrayList<String> strList=ArrayList<String>();  | String[] strArr=new String[3];\n",
    "크기변경 | ArrayList는 크기를 변경할 수 있다 | Array는 크기 변경 불가\n",
    "저장대상 | ArrayList에는 **Object만** 넣을 수 있슴, **원시타잎 불가** | Array는 **원시타잎, Object 모두** 가능.\n",
    "사용 | ArrayList는 **size()**,  get(i) | Array는 **length**, [i] (인덱스방식)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### ArrayList 생성\n",
    "\n",
    "다음과 같이 선언한다. 배열과 달리 크기를 정하지 않는다. \n",
    "\n",
    "```java\n",
    "import java.util.ArrayList;\n",
    "ArrayList arr=new ArrayList();\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ArrayList strList=new ArrayList();\r\n",
      "|  Modified variable strList of type ArrayList with initial value []\r\n",
      "|    Update overwrote variable strList\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "ArrayList strList=new ArrayList();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### ArrayList 데이터 저장\n",
    "\n",
    "ArrayList에 add()함수를 사용하여 데이터를 저장한다.\n",
    "넣을 **데이터 타잎을 정하지 않으면, 오류**가 발생할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " strList.add(\"Seoul\");\r\n",
      "|  Warning:\r\n",
      "|  unchecked call to add(E) as a member of the raw type java.util.ArrayList\r\n",
      "|  strList.add(\"Seoul\");\r\n",
      "|  ^------------------^\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $9 of type boolean\r\n",
      "\r\n",
      " strList.add(new String(\"Tokyo\"));\r\n",
      "|  Warning:\r\n",
      "|  unchecked call to add(E) as a member of the raw type java.util.ArrayList\r\n",
      "|  strList.add(new String(\"Tokyo\"));\r\n",
      "|  ^------------------------------^\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $10 of type boolean\r\n",
      "\r\n",
      " strList.add(new String(\"New York\"));\r\n",
      "|  Warning:\r\n",
      "|  unchecked call to add(E) as a member of the raw type java.util.ArrayList\r\n",
      "|  strList.add(new String(\"New York\"));\r\n",
      "|  ^---------------------------------^\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $11 of type boolean\r\n",
      "\r\n",
      " strList.add(new String(\"Sydney\"));\r\n",
      "|  Warning:\r\n",
      "|  unchecked call to add(E) as a member of the raw type java.util.ArrayList\r\n",
      "|  strList.add(new String(\"Sydney\"));\r\n",
      "|  ^-------------------------------^\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $12 of type boolean\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "strList.add(\"Seoul\");\n",
    "strList.add(new String(\"Tokyo\"));\n",
    "strList.add(new String(\"New York\"));\n",
    "strList.add(new String(\"Sydney\"));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### ArrayList 데이터 읽기\n",
    "\n",
    "데이터는 인덱스를 이용해서 get()한다.\n",
    "크기는 size()로 알 수 있다.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " strList.get(0);\r\n",
      "|  Expression value is: \"Seoul\"\r\n",
      "|    assigned to temporary variable $13 of type Object\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "strList.get(0);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(int i=0;i<strList.size();i++)\r\n",
      "     System.out.println(strList.get(i));\r\n",
      "Seoul\r\n",
      "Tokyo\r\n",
      "New York\r\n",
      "Sydney\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for(int i=0;i<strList.size();i++)\n",
    "    System.out.println(strList.get(i));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Array로 ArrayList add() 흉내내기\n",
    "\n",
    "* Array 배열에 add()함수를 사용하기\n",
    "* Array를 add()에서 변경하고, 함수를 벗어나도 저장된 값을 유지한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " String[] strArr=new String[3];\r\n",
      "|  Added variable strArr of type String[] with initial value [Ljava.lang.String;@3c0ecd4b\r\n",
      "\r\n",
      " int index=0;\r\n",
      "|  Added variable index of type int with initial value 0\r\n",
      "\r\n",
      " void add(String s) {\r\n",
      "     if(index<strArr.length) {\r\n",
      "         strArr[index]=s;\r\n",
      "         System.out.println(s+\" added\");\r\n",
      "         index++;\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added method add(String)\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " add(new String(\"Seoul\"));\r\n",
      "Seoul added\r\n",
      "\r\n",
      " System.out.println(strArr)\r\n",
      "[Ljava.lang.String;@3c0ecd4b\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "String[] strArr=new String[3];\n",
    "int index=0;\n",
    "void add(String s) {\n",
    "    if(index<strArr.length) {\n",
    "        strArr[index]=s;\n",
    "        System.out.println(s+\" added\");\n",
    "        index++;\n",
    "    }\n",
    "}\n",
    "\n",
    "add(new String(\"Seoul\"));\n",
    "System.out.println(strArr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Generics\n",
    "\n",
    "자바 1.5에 추가되어 **타잎 또는 함수에 적용**하여 **컴파일시점의 오류**를 막기 위해 사용한다.\n",
    "자바 Collection과 함께 사용할 수 있다.\n",
    "예를 들어 Collection의 하나인 **ArrayList**에 문자열 **String 타잎**만 허용할 경우 다음과 같이 선언한다.\n",
    "**다이어몬드 표기 ```<>```**로 표현하며 허용되는 타잎을 그 안에 적어준다.\n",
    "\n",
    "```java\n",
    "ArrayList<String>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "문자열 \"foo\"이든지 숫자 123이든지 가리지 않고 **모두 객체이므로 ArrayList에 저장**할 수 있다.\n",
    "앞서 설명한 바와 같이 원시타잎은 저장할 수 없지만, 객체는 모두 허용된다.\n",
    "그러나 사용할 경우, 타잎이 섞여 있으므로 **컴파일 오류가 발생**할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " List list = new ArrayList();\r\n",
      "|  Added variable list of type List with initial value []\r\n",
      "\r\n",
      " list.add(\"foo\");              //문자 \"foo\"를 저장\r\n",
      "|  Warning:\r\n",
      "|  unchecked call to add(E) as a member of the raw type java.util.List\r\n",
      "|  list.add(\"foo\");              //문자 \"foo\"를 저장\r\n",
      "|  ^-------------^\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $155 of type boolean\r\n",
      "\r\n",
      " list.add(new Integer(123));   //숫자 123이든지 문자 \"foo\"이든지 저장할 수 있다.\r\n",
      "|  Warning:\r\n",
      "|  unchecked call to add(E) as a member of the raw type java.util.List\r\n",
      "|  list.add(new Integer(123));   //숫자 123이든지 문자 \"foo\"이든지 저장할 수 있다.\r\n",
      "|  ^------------------------^\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $156 of type boolean\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "List list = new ArrayList();\n",
    "list.add(\"foo\");              //문자 \"foo\"를 저장\n",
    "list.add(new Integer(123));   //숫자 123이든지 문자 \"foo\"이든지 저장할 수 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "데이터타잎을 섞어서 저장하였으므로, **Object**로 읽고 원하는 데이터타잎으로 **강제변환**을 해야 한다.\n",
    "그럼에도 불구하고 데이터타잎이 불일치하면 오류가 당연히 발생하게 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(Object obj : list)\r\n",
      "     String str=(String) obj;  //사용할 경우, casting이 문제. 숫자를 casting하면 오류\r\n",
      "|  Error:\r\n",
      "|  variable declaration not allowed here\r\n",
      "|      String str=(String) obj;  //사용할 경우, casting이 문제. 숫자를 casting하면 오류\r\n",
      "|      ^----------------------^\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for(Object obj : list)\n",
    "    String str=(String) obj;  //사용할 경우, casting이 문제. 숫자를 casting하면 오류"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "따라서 저장할 **데이터타잎을 먼저 지정**해 주어야 한다. **Generics**로 타잎을 지정해 주면 위에서 발생했던 컴파일 오류를 막을 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "List<String> list = new ArrayList<>(); //우측 generics의 <>안 타잎을 생략할 수 있다.\n",
    "list.add(\"foo\");\n",
    "//list.add(new Integer(123));          //숫자 123을 저장할 수 없다.\n",
    "\n",
    "for(String obj : list)                 //String으로 \n",
    "    System.out.println(obj);           //casting할 필요가 없다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 원시타잎은 저장할 수 없다\n",
    "\n",
    "앞서 설명한 바와 같이, ArrayList에 **원시타잎을 넣으면 오류**가 발생한다.\n",
    "사용할 데이터를 Generics로 정해서 오류가 발생하는지 보자.\n",
    "```ArryList<int>```로 원시타잎 int를 지정해 보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ArrayList<int> numlist=new ArrayList<int>();\r\n",
      "|  Error:\r\n",
      "|  unexpected type\r\n",
      "|    required: reference\r\n",
      "|    found:    int\r\n",
      "|  ArrayList<int> numlist=new ArrayList<int>();\r\n",
      "|            ^-^\r\n",
      "|  Error:\r\n",
      "|  unexpected type\r\n",
      "|    required: reference\r\n",
      "|    found:    int\r\n",
      "|  ArrayList<int> numlist=new ArrayList<int>();\r\n",
      "|                                       ^-^\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "ArrayList<int> numlist=new ArrayList<int>();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "ArrayList에는 원시타잎 대신에 **객체 타잎**을 저장하자.\n",
    "Autoboxing은 자연스럽게 문제를 일으키지 않는다.\n",
    "* 원시타잎에서 해당클래스 (Wrapper class)로 자동 변환.\n",
    "* 다이어몬드 표기 $\\lt$Integer$\\gt$로 선언하고, int를 넣어도 자동 변환한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ArrayList<Integer> numList=new ArrayList<Integer>();\r\n",
      "|  Modified variable numList of type ArrayList<Integer> with initial value []\r\n",
      "|    Update overwrote variable numList\r\n",
      "\r\n",
      " numList.add(1);\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $6 of type boolean\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "ArrayList<Integer> numList=new ArrayList<Integer>();\n",
    "numList.add(1);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 선언은 넓게한다.\n",
    "\n",
    "* 프로그래밍 원칙 \"program to an interface and not to implementations\"에 따라 부모 List를 선언할 수 있다.\n",
    "* 앞서 배웠듯이 List는 ArrayList의 상위 클래스이다. **좌측에 상위**를, **우측에 상위부모를 상속받는 하위클래스**를 사용할 경우, 변경이 용이해 질 수 있다.\n",
    "\n",
    "선언을 넓게 | 선언을 좁게\n",
    "----------|----------\n",
    "List<E> list = new ArrayList<E>(); | ArrayList<E> list = new ArrayList<E>();\n",
    "Map<K, V> map = new HashMap<K, V>(); | HashMap<K, V> map = new HashMap<K, V>();\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " List<Integer> list=new ArrayList<Integer>();\r\n",
      "|  Modified variable list of type List<Integer> with initial value []\r\n",
      "|    Update overwrote variable list\r\n",
      "\r\n",
      " for(int i=0;i<10;i++)\r\n",
      "     list.add(i);\r\n",
      "\r\n",
      " System.out.println(list);\r\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "List<Integer> list=new ArrayList<Integer>();\n",
    "for(int i=0;i<10;i++)\n",
    "    list.add(i);\n",
    "System.out.println(list);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " List<String> cities = new ArrayList<String>();\r\n",
      "|  Modified variable cities of type List<String> with initial value []\r\n",
      "|    Update overwrote variable cities\r\n",
      "\r\n",
      " cities.add(\"Seoul\");\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $9 of type boolean\r\n",
      "\r\n",
      " cities.add(\"NY\");\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $10 of type boolean\r\n",
      "\r\n",
      " cities.add(\"Sydney\");\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $11 of type boolean\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " System.out.println(cities);\r\n",
      "[Seoul, NY, Sydney]\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "List<String> cities = new ArrayList<String>();\n",
    "cities.add(\"Seoul\");\n",
    "cities.add(\"NY\");\n",
    "cities.add(\"Sydney\");\n",
    "\n",
    "System.out.println(cities);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 배열을 List로 타잎 변환\n",
    "\n",
    "* Arrays 유틸리티 클래스로 변경할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Integer[] a={1,2,3};\r\n",
      "|  Added variable a of type Integer[] with initial value [Ljava.lang.Integer;@589838eb\r\n",
      "\r\n",
      " List<Integer> aList=Arrays.asList(a);\r\n",
      "|  Added variable aList of type List<Integer> with initial value [1, 2, 3]\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Integer[] a={1,2,3};\n",
    "List<Integer> aList=Arrays.asList(a);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ArrayList arrList=new ArrayList(aList);\r\n",
      "|  Warning:\r\n",
      "|  unchecked call to ArrayList(java.util.Collection<? extends E>) as a member of the raw type java.util.ArrayList\r\n",
      "|  ArrayList arrList=new ArrayList(aList);\r\n",
      "|                    ^------------------^\r\n",
      "|  Added variable arrList of type ArrayList with initial value [1, 2, 3] this error is corrected: \r\n",
      "|      unchecked call to ArrayList(java.util.Collection<? extends E>) as a member of the raw type java.util.ArrayList\r\n",
      "|      ArrayList arrList=new ArrayList(aList);\r\n",
      "|                        ^------------------^\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "ArrayList arrList=new ArrayList(aList);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 데이터 타잎을 사전에 정하지 않으면 오류가 발생한다 (Generics설명 참조)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(Integer a:arrList)\r\n",
      "     System.out.print(a);\r\n",
      "|  Error:\r\n",
      "|  incompatible types: java.lang.Object cannot be converted to java.lang.Integer\r\n",
      "|  for(Integer a:arrList)\r\n",
      "|                ^-----^\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for(Integer a:arrList)\n",
    "    System.out.print(a);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ArrayList<Integer> arrList=new ArrayList<Integer>(aList);\r\n",
      "|  Modified variable arrList of type ArrayList<Integer> with initial value [1, 2, 3]\r\n",
      "|    Update overwrote variable arrList\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "ArrayList<Integer> arrList=new ArrayList<Integer>(aList);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(Integer a:arrList)\r\n",
      "     System.out.print(a);\r\n",
      "123\r\n"
     ]
    }
   ],
   "source": [
    "for(Integer a:arrList)\n",
    "    System.out.print(a);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### iterator\n",
    "\n",
    "앞서 Array, ArrayList에 저장된 데이터를 반복문으로 읽어올 경우, **명령문에 차이가 있어 불편함**이 있었다.\n",
    "예를 들어 데이터 갯수는 length 또는 size()를 사용하고,\n",
    "다음 데이터를 가져오는 방식도 인덱스를 직접 사용하거나 또는 get()함수를 사용했다.\n",
    "iterator를 사용하면 이러한 **차이를 통일**할 수 있다.\n",
    "\n",
    "구분 | iterator | Array | ArrayList\n",
    "-----|-----|-----|-----\n",
    "데이터 갯수 | hasNext() | length | size()\n",
    "다음 데이터 가져오기 | next() | [인덱스] | get(인덱스)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "iterator를 사용하면 hasNext(), next() 함수를 사용해서 반복문을 만든다.\n",
    "\n",
    "함수 | 설명\n",
    "-----|-----\n",
    "hasNext() | 다음 데이터가 존재하는지 확인, ```boolean hasNext()```\n",
    "next() | 다음 데이터를 가져오기, ```E next()``` 이 함수는 Object를 반환하므로, 캐스팅을 해야 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Iterator iter = cities.iterator();\r\n",
      "|  Modified variable iter of type Iterator with initial value java.util.ArrayList$Itr@72d818d1\r\n",
      "|    Update overwrote variable iter\r\n",
      "\r\n",
      " while(iter.hasNext()) {\r\n",
      "     String s = (String)iter.next();\r\n",
      "     System.out.println(s);\r\n",
      " }\r\n",
      "Seoul\r\n",
      "NY\r\n",
      "Sydney\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Iterator iter = cities.iterator();\n",
    "while(iter.hasNext()) {\n",
    "    String s = (String)iter.next();\n",
    "    System.out.println(s);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 데이터구조-3: 4로 나누어지고 5로 나누어지지 않는 수 합계\n",
    "\n",
    "### 문제\n",
    "\n",
    "1 ~ 1000 범위에 4로 나누어지고 5로 나누어지지 않는 수를 골라서 합계를 계산한다.\n",
    "수 하나씩 판단해서 적합하면 합계를 계산할 수 있다.\n",
    "앞 장에서 배열을 사용하지 않고 풀었지만, 학습을 위해 배열을 사용하기로 한다.\n",
    "\n",
    "### 해결\n",
    "\n",
    "해당하는 수를 골라내어 배열에 저장하고, 그 배열로부터 합계를 구하기로 한다.\n",
    "배열에 저장될 데이터 개수는 계산을 하고 나서야 알 수 있다.\n",
    "미리 개수를 정할 수 없다면 ArrayList를 사용하기로 한다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"893px\" style=\"width:274px;height:893px;\" version=\"1.1\" viewBox=\"0 0 274 893\" width=\"274px\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"><defs><filter height=\"300%\" id=\"f1\" width=\"300%\" x=\"-1\" y=\"-1\"><feGaussianBlur result=\"blurOut\" stdDeviation=\"2.0\"/><feColorMatrix in=\"blurOut\" result=\"blurOut2\" type=\"matrix\" values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 .4 0\"/><feOffset dx=\"4.0\" dy=\"4.0\" in=\"blurOut2\" result=\"blurOut3\"/><feBlend in=\"SourceGraphic\" in2=\"blurOut3\" mode=\"normal\"/></filter></defs><g><ellipse cx=\"146\" cy=\"20\" fill=\"#000000\" filter=\"url(#f1)\" rx=\"10\" ry=\"10\" style=\"stroke: none; stroke-width: 1.0;\"/><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"34.1328\" rx=\"12.5\" ry=\"12.5\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"62\" x=\"115\" y=\"50\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"42\" x=\"125\" y=\"71.6016\">set i=0</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"34.1328\" rx=\"12.5\" ry=\"12.5\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"87\" x=\"102.5\" y=\"104.1328\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"67\" x=\"112.5\" y=\"125.7344\">initialize list</text><polygon fill=\"#FEFECE\" filter=\"url(#f1)\" points=\"81.5,202.2656,210.5,202.2656,222.5,214.2656,210.5,226.2656,81.5,226.2656,69.5,214.2656,81.5,202.2656\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"129\" x=\"81.5\" y=\"218.4229\">i divisable by 4, not by 5</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"34.1328\" rx=\"12.5\" ry=\"12.5\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"99\" x=\"10\" y=\"236.2656\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"79\" x=\"20\" y=\"257.8672\">add i to array</text><polygon fill=\"#FEFECE\" filter=\"url(#f1)\" points=\"146,276.3984,158,288.3984,146,300.3984,134,288.3984,146,276.3984\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"34.1328\" rx=\"12.5\" ry=\"12.5\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"77\" x=\"107.5\" y=\"335.3984\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"57\" x=\"117.5\" y=\"357\">add 1 to i</text><polygon fill=\"#FEFECE\" filter=\"url(#f1)\" points=\"146,158.2656,158,170.2656,146,182.2656,134,170.2656,146,158.2656\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><polygon fill=\"#FEFECE\" filter=\"url(#f1)\" points=\"129.5,389.5313,162.5,389.5313,174.5,401.5313,162.5,413.5313,129.5,413.5313,117.5,401.5313,129.5,389.5313\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"33\" x=\"129.5\" y=\"405.6885\">i&lt;101</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"34.1328\" rx=\"12.5\" ry=\"12.5\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"67\" x=\"112.5\" y=\"433.5313\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"47\" x=\"122.5\" y=\"455.1328\">print list</text><rect fill=\"#FFFFFF\" filter=\"url(#f1)\" height=\"367.5313\" style=\"stroke: #000000; stroke-width: 2.0;\" width=\"173.5\" x=\"54.5\" y=\"478.6641\"/><path d=\"M87.5,479.6641 L87.5,485.6641 L77.5,495.6641 L54.5,495.6641 \" fill=\"#FFFFFF\" style=\"stroke: #000000; stroke-width: 2.0;\"/><text fill=\"#000000\" font-family=\"Serif\" font-size=\"14\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"23\" x=\"57.5\" y=\"490.1641\">sum</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"34.1328\" rx=\"12.5\" ry=\"12.5\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"62\" x=\"115\" y=\"512.6641\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"42\" x=\"125\" y=\"534.2656\">sum=0</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"34.1328\" rx=\"12.5\" ry=\"12.5\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"144\" x=\"74\" y=\"581.7969\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"124\" x=\"84\" y=\"603.3984\">maxiter=length of list</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"34.1328\" rx=\"12.5\" ry=\"12.5\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"115\" x=\"88.5\" y=\"698.9297\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"95\" x=\"98.5\" y=\"720.5313\">sum=sum+list[i]</text><polygon fill=\"#FEFECE\" filter=\"url(#f1)\" points=\"119.5,650.9297,172.5,650.9297,184.5,662.9297,172.5,674.9297,119.5,674.9297,107.5,662.9297,119.5,650.9297\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"53\" x=\"119.5\" y=\"667.0869\">i&lt;maxiter</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"34.1328\" rx=\"12.5\" ry=\"12.5\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"75\" x=\"108.5\" y=\"792.0625\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"55\" x=\"118.5\" y=\"813.6641\">print sum</text><ellipse cx=\"146\" cy=\"876.1953\" fill=\"none\" filter=\"url(#f1)\" rx=\"10\" ry=\"10\" style=\"stroke: #000000; stroke-width: 1.0;\"/><ellipse cx=\"146.5\" cy=\"876.6953\" fill=\"#000000\" filter=\"url(#f1)\" rx=\"6\" ry=\"6\" style=\"stroke: none; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"146\" x2=\"146\" y1=\"30\" y2=\"50\"/><polygon fill=\"#A80036\" points=\"142,40,146,50,150,40,146,44\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"146\" x2=\"146\" y1=\"84.1328\" y2=\"104.1328\"/><polygon fill=\"#A80036\" points=\"142,94.1328,146,104.1328,150,94.1328,146,98.1328\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"69.5\" x2=\"59.5\" y1=\"214.2656\" y2=\"214.2656\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"59.5\" x2=\"59.5\" y1=\"214.2656\" y2=\"236.2656\"/><polygon fill=\"#A80036\" points=\"55.5,226.2656,59.5,236.2656,63.5,226.2656,59.5,230.2656\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"222.5\" x2=\"232.5\" y1=\"214.2656\" y2=\"214.2656\"/><polygon fill=\"#A80036\" points=\"228.5,241.332,232.5,251.332,236.5,241.332,232.5,245.332\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"232.5\" x2=\"232.5\" y1=\"214.2656\" y2=\"288.3984\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"232.5\" x2=\"158\" y1=\"288.3984\" y2=\"288.3984\"/><polygon fill=\"#A80036\" points=\"168,284.3984,158,288.3984,168,292.3984,164,288.3984\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"59.5\" x2=\"59.5\" y1=\"270.3984\" y2=\"288.3984\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"59.5\" x2=\"134\" y1=\"288.3984\" y2=\"288.3984\"/><polygon fill=\"#A80036\" points=\"124,284.3984,134,288.3984,124,292.3984,128,288.3984\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"146\" x2=\"146\" y1=\"300.3984\" y2=\"335.3984\"/><polygon fill=\"#A80036\" points=\"142,325.3984,146,335.3984,150,325.3984,146,329.3984\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"146\" x2=\"146\" y1=\"182.2656\" y2=\"202.2656\"/><polygon fill=\"#A80036\" points=\"142,192.2656,146,202.2656,150,192.2656,146,196.2656\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"174.5\" x2=\"269.5\" y1=\"401.5313\" y2=\"401.5313\"/><polygon fill=\"#A80036\" points=\"265.5,319.8984,269.5,309.8984,273.5,319.8984,269.5,315.8984\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"269.5\" x2=\"269.5\" y1=\"170.2656\" y2=\"401.5313\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"269.5\" x2=\"158\" y1=\"170.2656\" y2=\"170.2656\"/><polygon fill=\"#A80036\" points=\"168,166.2656,158,170.2656,168,174.2656,164,170.2656\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"146\" x2=\"146\" y1=\"369.5313\" y2=\"389.5313\"/><polygon fill=\"#A80036\" points=\"142,379.5313,146,389.5313,150,379.5313,146,383.5313\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"146\" x2=\"146\" y1=\"138.2656\" y2=\"158.2656\"/><polygon fill=\"#A80036\" points=\"142,148.2656,146,158.2656,150,148.2656,146,152.2656\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"146\" x2=\"146\" y1=\"413.5313\" y2=\"433.5313\"/><polygon fill=\"#A80036\" points=\"142,423.5313,146,433.5313,150,423.5313,146,427.5313\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"146\" x2=\"146\" y1=\"546.7969\" y2=\"581.7969\"/><polygon fill=\"#A80036\" points=\"142,571.7969,146,581.7969,150,571.7969,146,575.7969\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"146\" x2=\"146\" y1=\"674.9297\" y2=\"698.9297\"/><polygon fill=\"#A80036\" points=\"142,688.9297,146,698.9297,150,688.9297,146,692.9297\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"146\" x2=\"146\" y1=\"733.0625\" y2=\"745.0625\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"146\" x2=\"215.5\" y1=\"745.0625\" y2=\"745.0625\"/><polygon fill=\"#A80036\" points=\"211.5,713.9961,215.5,703.9961,219.5,713.9961,215.5,709.9961\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"215.5\" x2=\"215.5\" y1=\"662.9297\" y2=\"745.0625\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"215.5\" x2=\"184.5\" y1=\"662.9297\" y2=\"662.9297\"/><polygon fill=\"#A80036\" points=\"194.5,658.9297,184.5,662.9297,194.5,666.9297,190.5,662.9297\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"107.5\" x2=\"76.5\" y1=\"662.9297\" y2=\"662.9297\"/><polygon fill=\"#A80036\" points=\"72.5,699.9961,76.5,709.9961,80.5,699.9961,76.5,703.9961\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"76.5\" x2=\"76.5\" y1=\"662.9297\" y2=\"757.0625\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"76.5\" x2=\"146\" y1=\"757.0625\" y2=\"757.0625\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"146\" x2=\"146\" y1=\"757.0625\" y2=\"792.0625\"/><polygon fill=\"#A80036\" points=\"142,782.0625,146,792.0625,150,782.0625,146,786.0625\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"146\" x2=\"146\" y1=\"615.9297\" y2=\"650.9297\"/><polygon fill=\"#A80036\" points=\"142,640.9297,146,650.9297,150,640.9297,146,644.9297\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"146\" x2=\"146\" y1=\"467.6641\" y2=\"512.6641\"/><polygon fill=\"#A80036\" points=\"142,502.6641,146,512.6641,150,502.6641,146,506.6641\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"146\" x2=\"146\" y1=\"826.1953\" y2=\"866.1953\"/><polygon fill=\"#A80036\" points=\"142,856.1953,146,866.1953,150,856.1953,146,860.1953\" style=\"stroke: #A80036; stroke-width: 1.0;\"/></g></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "start\n",
    ":set i=0;\n",
    ":initialize list;\n",
    "repeat\n",
    "if(i divisable by 4, not by 5)\n",
    ":add i to array;\n",
    "endif\n",
    ":add 1 to i;\n",
    "repeat while(i<101)\n",
    ":print list;\n",
    "partition sum {\n",
    "    :sum=0;\n",
    "    :maxiter=length of list;\n",
    "    while(i<maxiter)\n",
    "    :sum=sum+list[i];\n",
    "    endwhile\n",
    "    :print sum;\n",
    "}\n",
    "stop\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### ArrayList에 저장\n",
    "\n",
    "줄 | 설명\n",
    "-----|-----\n",
    "1 | 크기를 미리 정하지 않아도 되는 ArrayList를 사용한다. 정수를 저장하므로 ```<Integer>```로 선언한다.\n",
    "4 | add()함수로 데이터를 저장한다. 저장하는 수는 원시타잎 int이고, Integer로 autoboxing 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ArrayList<Integer> mylist=new ArrayList<Integer>();\r\n",
      "|  Modified variable mylist of type ArrayList<Integer> with initial value []\r\n",
      "|    Update overwrote variable mylist\r\n",
      "\r\n",
      " for(int x=0; x<100;x++) {\r\n",
      "     if(x%4==0 && x%5!=0) {\r\n",
      "         mylist.add(x);\r\n",
      "     }\r\n",
      " }\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " System.out.print(mylist);\r\n",
      "[4, 8, 12, 16, 24, 28, 32, 36, 44, 48, 52, 56, 64, 68, 72, 76, 84, 88, 92, 96]\r\n"
     ]
    }
   ],
   "source": [
    "ArrayList<Integer> mylist=new ArrayList<Integer>();\n",
    "for(int x=0; x<100;x++) {\n",
    "    if(x%4==0 && x%5!=0) {\n",
    "        mylist.add(x);\n",
    "    }\n",
    "}\n",
    "\n",
    "System.out.print(mylist);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### ArrayList에 저장된 수의 합계\n",
    "\n",
    "ArrayList에 저장된 수를 모두 합계내려면, 반복문을 사용한다.\n",
    "합계를 구하려면, 데이터구조에 저장된 갯수를 알아야 한다.\n",
    "아래 물음표 자리에 그 개수를 넣어야 한다.\n",
    "다행히도 size()함수를 사용하면 데이터를 가지고 있는지, 몇 개 있는지 알 수 있다.\n",
    "\n",
    "```java\n",
    "for(int j=0;j<??;j++)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "합계를 구해보자.\n",
    "\n",
    "줄 | 설명\n",
    "-----|-----\n",
    "2 | ArrayList의 size()를 가져와 maxiter에 저장.\n",
    "3 | for문에 총 개수에 maxiter를 사용.\n",
    "4 | get(인덱스)로 하나씩 가져와서 합계 계산.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " int sum=0;\r\n",
      "|  Modified variable sum of type int with initial value 0\r\n",
      "|    Update overwrote variable sum\r\n",
      "\r\n",
      " int maxiter=mylist.size();\r\n",
      "|  Modified variable maxiter of type int with initial value 20\r\n",
      "|    Update overwrote variable maxiter\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " for(int i=0;i<maxiter;i++)\r\n",
      "     sum=sum+mylist.get(i);\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " System.out.print(sum);\r\n",
      "1000\r\n"
     ]
    }
   ],
   "source": [
    "int sum=0;\n",
    "int maxiter=mylist.size();\n",
    "\n",
    "for(int i=0;i<maxiter;i++)\n",
    "    sum=sum+mylist.get(i);\n",
    "\n",
    "System.out.print(sum);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 보다 간단하게. 길이를 별도로 세지 않음."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " int sum=0;\r\n",
      "|  Modified variable sum of type int with initial value 0\r\n",
      "|    Update overwrote variable sum\r\n",
      "\r\n",
      " for(int i:mylist)\r\n",
      "     sum+=i;\r\n",
      "\r\n",
      " System.out.print(sum);\r\n",
      "1000\r\n"
     ]
    }
   ],
   "source": [
    "int sum=0;\n",
    "for(int i:mylist)\n",
    "    sum+=i;\n",
    "System.out.print(sum);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 함수로 만들기\n",
    "\n",
    "함수로 만들어 보자. 어느 List나 입력하면 합계 출력한다.\n",
    "발생할 수 있는 오류도 생각하는 것이 좋다. 배열이 아니거나, 배열이 비어 있는 경우를 생각해 보자.\n",
    "* 함수이름 **sumList**\n",
    "* 입력 ArrayList 리스트: **상위클래스 List**로 argument를 넘겨 주는 편이 좋다.\n",
    "* 출력 int 합계값\n",
    "\n",
    "```java\n",
    "int sumList(ArrayList<Integer> aList)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " int sumList(List<Integer> aList) {\r\n",
      "     int sum=0;\r\n",
      "     for(int i:aList)\r\n",
      "         sum+=i;\r\n",
      "     return sum;\r\n",
      " }\r\n",
      "|  Modified method sumList(List<Integer>)\r\n",
      "|    Update overwrote method sumList(List<Integer>)\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " System.out.print(sumList(mylist));\r\n",
      "1000\r\n"
     ]
    }
   ],
   "source": [
    "int sumList(List<Integer> aList) {\n",
    "    int sum=0;\n",
    "    for(int i:aList)\n",
    "        sum+=i;\n",
    "    return sum;\n",
    "}\n",
    "\n",
    "System.out.print(sumList(mylist));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 클래스로 만들어 보기\n",
    "\n",
    "객체지향을 배우면서 클래스가 **테스트용**으로 만들고 있다.\n",
    "자바의 문법을 배우고 나서는, **클래스를 목적에 맞게 설계**하고 구현해야 한다.\n",
    "여기서는 숫자를 저장하고, 합계를 계산하는 목적에 따라 class명을 Numbers로 정한다.\n",
    "\n",
    "설계에 필요한 항목 | 설명\n",
    "-----|-----\n",
    "생성자 | 데이터는 나중에라도 저장할 수 있으므로, default 생성자를 사용한다. 즉 데이터를 초기화하지 않는다.\n",
    "setNumbers() | 데이터는 1~1000까지 저장하기로 사전에 정해져 있다. 매개변수 없이 구현한다.\n",
    "sumList() | 앞서 구현했던 함수에서 **argument가 사라진다**. setNumbers()에서 저장한 mylist가 속성이 되고 이를 사용한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import iplantuml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"103px\" style=\"width:173px;height:103px;\" version=\"1.1\" viewBox=\"0 0 173 103\" width=\"173px\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"><defs><filter height=\"300%\" id=\"f1\" width=\"300%\" x=\"-1\" y=\"-1\"><feGaussianBlur result=\"blurOut\" stdDeviation=\"2.0\"/><feColorMatrix in=\"blurOut\" result=\"blurOut2\" type=\"matrix\" values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 .4 0\"/><feOffset dx=\"4.0\" dy=\"4.0\" in=\"blurOut2\" result=\"blurOut3\"/><feBlend in=\"SourceGraphic\" in2=\"blurOut3\" mode=\"normal\"/></filter></defs><g><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"86.4141\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"158\" x=\"6\" y=\"8\"/><ellipse cx=\"52.75\" cy=\"24\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M55.7188,29.6406 Q55.1406,29.9375 54.5,30.0859 Q53.8594,30.2344 53.1563,30.2344 Q50.6563,30.2344 49.3359,28.5859 Q48.0156,26.9375 48.0156,23.8125 Q48.0156,20.6875 49.3359,19.0313 Q50.6563,17.375 53.1563,17.375 Q53.8594,17.375 54.5078,17.5313 Q55.1563,17.6875 55.7188,17.9844 L55.7188,20.7031 Q55.0938,20.125 54.5,19.8516 Q53.9063,19.5781 53.2813,19.5781 Q51.9375,19.5781 51.25,20.6484 Q50.5625,21.7188 50.5625,23.8125 Q50.5625,25.9063 51.25,26.9766 Q51.9375,28.0469 53.2813,28.0469 Q53.9063,28.0469 54.5,27.7734 Q55.0938,27.5 55.7188,26.9219 L55.7188,29.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"56\" x=\"73.25\" y=\"28.1543\">Numbers</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"163\" y1=\"40\" y2=\"40\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"146\" x=\"12\" y=\"54.2104\">mylist:ArrayList&lt;Integer&gt;</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"163\" y1=\"60.8047\" y2=\"60.8047\"/><ellipse cx=\"17\" cy=\"72.707\" fill=\"#84BE84\" rx=\"3\" ry=\"3\" style=\"stroke: #038048; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"105\" x=\"26\" y=\"75.0151\">setNumbers():void</text><ellipse cx=\"17\" cy=\"85.5117\" fill=\"#84BE84\" rx=\"3\" ry=\"3\" style=\"stroke: #038048; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"71\" x=\"26\" y=\"87.8198\">sumList():int</text></g></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "class Numbers {\n",
    "    mylist:ArrayList<Integer>\n",
    "    +setNumbers():void\n",
    "    +sumList():int\n",
    "}\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Numbers {\r\n",
      "     ArrayList<Integer> mylist=new ArrayList<Integer>();\r\n",
      "     public void setNumbers() {\r\n",
      "         for(int x=0; x<1000;x++) {\r\n",
      "             if(x%4==0 && x%5!=0) {\r\n",
      "                 mylist.add(x);\r\n",
      "             }\r\n",
      "         }\r\n",
      "     }\r\n",
      "     public int sumList() {\r\n",
      "         int sum=0;\r\n",
      "         for(int i:mylist) {\r\n",
      "             System.out.printf(\"%d..\",i);\r\n",
      "             sum+=i;\r\n",
      "         }\r\n",
      "         return sum;\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added class Numbers\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Numbers {\n",
    "    ArrayList<Integer> mylist=new ArrayList<Integer>();\n",
    "    public void setNumbers() {\n",
    "        for(int x=0; x<1000;x++) {\n",
    "            if(x%4==0 && x%5!=0) {\n",
    "                mylist.add(x);\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "    public int sumList() {\n",
    "        int sum=0;\n",
    "        for(int i:mylist) {\n",
    "            System.out.printf(\"%d..\",i);\n",
    "            sum+=i;\n",
    "        }\n",
    "        return sum;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Numbers n=new Numbers();\r\n",
      "|  Modified variable n of type Numbers with initial value Numbers@4566e5bd\r\n",
      "|    Update overwrote variable n\r\n",
      "\r\n",
      " n.setNumbers();\r\n",
      "\r\n",
      " System.out.print(\"\\n합계: \"+n.sumList());\r\n",
      "4..8..12..16..24..28..32..36..44..48..52..56..64..68..72..76..84..88..92..96..104..108..112..116..124..128..132..136..144..148..152..156..164..168..172..176..184..188..192..196..204..208..212..216..224..228..232..236..244..248..252..256..264..268..272..276..284..288..292..296..304..308..312..316..324..328..332..336..344..348..352..356..364..368..372..376..384..388..392..396..404..408..412..416..424..428..432..436..444..448..452..456..464..468..472..476..484..488..492..496..504..508..512..516..524..528..532..536..544..548..552..556..564..568..572..576..584..588..592..596..604..608..612..616..624..628..632..636..644..648..652..656..664..668..672..676..684..688..692..696..704..708..712..716..724..728..732..736..744..748..752..756..764..768..772..776..784..788..792..796..804..808..812..816..824..828..832..836..844..848..852..856..864..868..872..876..884..888..892..896..904..908..912..916..924..928..932..936..944..948..952..956..964..968..972..976..984..988..992..996..\r\n",
      "합계: 100000\r\n"
     ]
    }
   ],
   "source": [
    "Numbers n=new Numbers();\n",
    "n.setNumbers();\n",
    "System.out.print(\"\\n합계: \"+n.sumList());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 다차원 ArrayList\n",
    "\n",
    "앞서 다차원배열을 배웠다.\n",
    "ArrayList를 사용하여 다차원 데이터를 만들어 보자.\n",
    "\n",
    "### 생성\n",
    "\n",
    "ArrayList로 생성할 경우, 내부 타잎 Double[]을 정확히 적어준다.\n",
    "경로tracks는 위치의 집합으로, 2차원 데이터이다. ArrayList<Double[]>는 경로로서 배열의 ArrayList, 즉 2차원으로 선언한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ArrayList<Double[]> tracks=new ArrayList<Double[]>();\r\n",
      "|  Modified variable tracks of type ArrayList<Double[]> with initial value []\r\n",
      "|    Update overwrote variable tracks\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "ArrayList<Double[]> tracks=new ArrayList<Double[]>();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 저장 및 조회\n",
    "\n",
    "내부 타잎 Double[]에 맞게 각 요소를 저장한다.\n",
    "저장된 데이터를 조회하려면, 2차원 데이터에 맞게 중첩 반복문을 사용한다.\n",
    "\n",
    "줄 | 설명\n",
    "-----|-----\n",
    "1 | Double[]에는 x,y 쌍으로 저장. 위치는 x,y로 구성된 데이터이다.\n",
    "2 | ArryList에 저장\n",
    "3 | ArryList의 각 요소 Double[]를 반복\n",
    "4 | Double[]의 각 요소 Double을 반복"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ArrayList<Double[]> tracks=new ArrayList<Double[]>();\r\n",
      "|  Added variable tracks of type ArrayList<Double[]> with initial value []\r\n",
      "\r\n",
      " Double[] pos={100.,100.};\r\n",
      "|  Added variable pos of type Double[] with initial value [Ljava.lang.Double;@5cb9f472\r\n",
      "\r\n",
      " tracks.add(pos);\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $20 of type boolean\r\n",
      "\r\n",
      " for(Double[] t:tracks)\r\n",
      "     for(Double p:t)\r\n",
      "         System.out.println(p);\r\n",
      "100.0\r\n",
      "100.0\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Double[] pos={100.,100.};      //위치 데이터\n",
    "tracks.add(pos);               //위치 데이터를 ArrayList에 저장\n",
    "for(Double[] t:tracks)\n",
    "    for(Double p:t)\n",
    "        System.out.println(p);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 데이터구조-4: 거북이 트랙을 저장하기\n",
    "\n",
    "### 문제\n",
    "\n",
    "거북이가 이동하는 경로를 저장해 보자.\n",
    "경로는 **정지한 위치**만으로 구성하고 **이동 중에는 저장하지 않기로** 하자."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 해결\n",
    "\n",
    "* 위치는 좌표(x,y)를 가지고, 트랙은 위치를 가지고 있는 **2차원 데이터**이다.\n",
    "* **2차원 데이터**는 **ArrayList<Double[]>**로 구성한다.\n",
    "    * 정지 위치는 하나씩 저장하면서, 자료목록이 늘어난다.\n",
    "    * 리스트는 **가변적**이어서 자료가 추가되면서, 고무줄처럼 늘어날 수 있다.\n",
    "* 앞 장에서 만들었던 함수 drawSquareAt()을 수정해서, 거북이가 간 위치를 저장한다.\n",
    "* 함수 drawSquareAtSave()\n",
    "    * 입력\n",
    "        * 그림의 크기 size\n",
    "        * 위치 pos\n",
    "    * 출력 tracks\n",
    "* 생각해보기\n",
    "    * tracks를 전역으로 할지, 지역으로 할지\n",
    "    * list를 반환하면 출력을 어떻게 하는지?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "거북이 라이브러리 aplu5.jar를 classpath에 추가한다.\n",
    "그리고 ```import ch.aplu.turtle.*```로 거북이를 가져온다.\n",
    "\n",
    "```java\n",
    "/classpath lib/aplu5.jar\n",
    "또는\n",
    "/env -class-path lib/aplu5.jar\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " /classpath lib/aplu5.jar\r\n",
      "|  Path 'lib/aplu5.jar' added to classpath\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "/classpath lib/aplu5.jar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " import ch.aplu.turtle.*;\r\n",
      "|    Update modified method printf(String,Object...)\r\n",
      "|    Update modified variable pos of type Double[] with initial value \r\n",
      "\r\n",
      " Turtle t1=new Turtle();\r\n",
      "|  Added variable t1 of type Turtle with initial value Turtle(Position=(0,0), Heading=0)\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "import ch.aplu.turtle.*;\n",
    "Turtle t1=new Turtle();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "위치를 2차원 배열 ```ArrayList<Double[]>()```를 생성해 보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ArrayList<Double[]> posArr = new ArrayList<Double[]>();\r\n",
      "|  Modified variable posArr of type ArrayList<Double[]> with initial value []\r\n",
      "|    Update overwrote variable posArr\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "ArrayList<Double[]> posArr = new ArrayList<Double[]>();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "사각형을 그리면서 정지위치 좌표를 저장한다.\n",
    "\n",
    "줄 | 설명\n",
    "-----|-----\n",
    "1 | 좌표를 저장하는 배열 선언\n",
    "2 | 4각형을 그리는 반복\n",
    "3~4 | 현재 거북이 좌표를 저장. 거북이 위치는 getPos() 또는 getX(), getY() 함수로 위치를 읽는다.\n",
    "5 | ArrayList에 좌표를 저장. 거북이가 사각형 모서리에 멈추는 때 정지위치를 저장한다.\n",
    "6~7 | 사각형의 한 변씩 그림.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Double[] pos=new Double[2];\r\n",
      "|  Modified variable pos of type Double[] with initial value [Ljava.lang.Double;@5ccddd20\r\n",
      "|    Update overwrote variable pos\r\n",
      "\r\n",
      " for (int i=0;i<4;i++) {\r\n",
      "     pos[0]=t1.getX();\r\n",
      "     pos[1]=t1.getY();\r\n",
      "     System.out.println(pos[0]+\" \"+pos[1]);\r\n",
      "     //System.out.printf(\"saving %s,%s\\n\",Double.toString(pos[0]),Double.toStr \r",
      "ing(pos[1]));\r\n",
      "     posArr.add(pos);\r\n",
      "     t1.forward(100);\r\n",
      "     t1.right(90);\r\n",
      " }\r\n",
      "4.263256414560601E-14 -2.1656954846272547E-13\r\n",
      "-3.084624380323518E-14 99.99999999999979\r\n",
      "99.99999999999997 99.99999999999969\r\n",
      "99.9999999999997 -3.126388037344441E-13\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Double[] pos=new Double[2];\n",
    "for (int i=0;i<4;i++) {\n",
    "    pos[0]=t1.getX();\n",
    "    pos[1]=t1.getY();\n",
    "    System.out.println(pos[0]+\" \"+pos[1]);\n",
    "    //System.out.printf(\"saving %s,%s\\n\",Double.toString(pos[0]),Double.toString(pos[1]));\n",
    "    posArr.add(pos);\n",
    "    t1.forward(100);\n",
    "    t1.right(90);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(Double[] d:posArr)\r\n",
      "     System.out.printf(\"(%.1f,%.1f)\", d[0],d[1]);\r\n",
      "(100.0,-0.0)(100.0,-0.0)(100.0,-0.0)(100.0,-0.0)\r\n"
     ]
    }
   ],
   "source": [
    "for(Double[] d:posArr)\n",
    "    System.out.printf(\"(%.1f,%.1f)\", d[0],d[1]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "잠깐! 저장된 데이터를 보자. 좌표의 **마지막 값으로 모두 변경**되어 저장되어 있다.\n",
    "이런 오류를 고치려면 어떻게 해야 하는가?\n",
    "**call by value는 for문에도 적용**되기 때문이다.\n",
    "ArrayList<Double[]>는 Wrapper클래스에 대한 ref를 가지고 있다.\n",
    "\n",
    "함수로 만들어 보자. 출력은 ```ArrayList<Double[]>```이차원으로 선언한다.\n",
    "```java\n",
    "ArrayList<Double[]> drawSquareAtAndSave(int size, double x, double y)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![alt text](figures/6_referenceProblem.png \"Reference Problem\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ArrayList<Double[]> drawSquareAtAndSave(int size, double x, double y) {\r\n",
      "     t1.penUp();\r\n",
      "     t1.setPos(x,y);\r\n",
      "     t1.penDown();\r\n",
      "     ArrayList<Double[]> posArr = new ArrayList<Double[]>();\r\n",
      "     Double[] pos=new Double[2];\r\n",
      "     for (int i=0;i<4;i++) {\r\n",
      "         pos[0]=t1.getX();\r\n",
      "         pos[1]=t1.getY();\r\n",
      "         posArr.add(pos);\r\n",
      "         t1.forward(size);\r\n",
      "         t1.right(90);\r\n",
      "     }\r\n",
      "     return posArr;\r\n",
      " }\r\n",
      "|  Added method drawSquareAtAndSave(int,double,double)\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "ArrayList<Double[]> drawSquareAtAndSave(int size, double x, double y) {\n",
    "    t1.penUp();\n",
    "    t1.setPos(x,y);\n",
    "    t1.penDown();\n",
    "    ArrayList<Double[]> posArr = new ArrayList<Double[]>();\n",
    "    Double[] pos=new Double[2];\n",
    "    for (int i=0;i<4;i++) {\n",
    "        pos[0]=t1.getX();\n",
    "        pos[1]=t1.getY();\n",
    "        posArr.add(pos);\n",
    "        t1.forward(size);\n",
    "        t1.right(90);\n",
    "    }\n",
    "    return posArr;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ArrayList<Double[]> posArr=new ArrayList<Double[]>();\r\n",
      "|  Modified variable posArr of type ArrayList<Double[]> with initial value []\r\n",
      "|    Update overwrote variable posArr\r\n",
      "\r\n",
      " posArr=drawSquareAtAndSave(50, 10.0, 20.0);\r\n",
      "|  Variable posArr has been assigned the value [[Ljava.lang.Double;@363ee3a2, [Ljava.lang.Double;@363ee3a2, [Ljava.lang.Double;@363ee3a2, [Ljava.lang.Double;@363ee3a2]\r\n",
      "\r\n",
      " for(Double[] d:posArr)\r\n",
      "     System.out.printf(\"(%.1f,%.1f)\\n\", d[0],d[1]);\r\n",
      "(60.0,20.0)\r\n",
      "(60.0,20.0)\r\n",
      "(60.0,20.0)\r\n",
      "(60.0,20.0)\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "ArrayList<Double[]> posArr=new ArrayList<Double[]>();\n",
    "posArr=drawSquareAtAndSave(50, 10.0, 20.0);\n",
    "for(Double[] d:posArr)\n",
    "    System.out.printf(\"(%.1f,%.1f)\\n\", d[0],d[1]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 데이터구조-5: 도형을 데이터구조로 저장하고 그리기\n",
    "\n",
    "### 문제\n",
    "도형을 저장한다고 해보자. 도형을 구성하는 하나 하나 **모든 화소를 저장한다면 매우 비효율적**이다.\n",
    "화소를 모두 저장하므로 저장공간뿐만 아니라 프로그램 실행시간도 오래 걸린다.\n",
    "도형의 특징만을 저장하면 효율적이다.\n",
    "예를 들어, 사각형을 그리려면:\n",
    "* 점, 너비, 높이 또는\n",
    "* 두 점만 필요하다.\n",
    "\n",
    "이 문제는 도형을 디지털화 하고, 디지털 도형에서 복원하는 문제이다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 해결\n",
    "\n",
    "저장한 데이터구조를 사용해서 사각형을 그린다.\n",
    "* 함수\n",
    "    * 함수명 drawSquareFrom()\n",
    "    * 입력 argument\n",
    "        * 4점을 가지고 있는 구조 tracks 사각형 위치가 저장된 데이터구조\n",
    "    * 출력 none\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 도형을 데이터구조로 저장하기\n",
    "\n",
    "자신이 사각형 위치를 임의로 생성하여, 데이터구조에 저장한다.\n",
    "데이터구조는 2차원 배열 ```double[][]``` 로 구성하였다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " double[][] tracks={{100,100},{200,100},{200,200},{100,200},{100,100}};\r\n",
      "|  Replaced variable tracks of type double[][] with initial value [[D@73846619\r\n",
      "|    Update overwrote variable tracks\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "double[][] tracks={{100,100},{200,100},{200,200},{100,200},{100,100}};"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* tracks는 2차원 데이터구조를 사용하고 있다.\n",
    "* tracks를 출력해보자\n",
    "    * 객체를 사용하면, 시작-끝이 변해도 사용할 수 있다는 장점이 있다.\n",
    "    * 2차원 구조를 출력하려면, for문도 2개가 필요하다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(double[] t:tracks)\r\n",
      "     System.out.println(t)\r\n",
      "[D@27c20538\r\n",
      "[D@72d818d1\r\n",
      "[D@6e06451e\r\n",
      "[D@59494225\r\n",
      "[D@6e1567f1\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for(double[] t:tracks)\n",
    "    System.out.println(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(double[] t:tracks)\r\n",
      "     for(double p:t)\r\n",
      "         System.out.printf(\" %.1f \",p)\r\n",
      " 100.0  100.0  200.0  100.0  200.0  200.0  100.0  200.0  100.0  100.0 \r\n"
     ]
    }
   ],
   "source": [
    "for(double[] t:tracks)\n",
    "    for(double p:t)\n",
    "        System.out.printf(\" %.1f \",p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 함수로 만들어 본다.\n",
    "* 자바는 값이 전달된다 (pass by value). 참조 값이 전달되는 것과 (pass by reference)와 구별한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " void drawSquareFrom(double[][] tracks) {\r\n",
      "     t1.penUp();\r\n",
      "     t1.penDown();\r\n",
      "     for(double[] t:tracks)\r\n",
      "         //for(double p:t)\r\n",
      "         //    System.out.printf(\" %.1f \",p);\r\n",
      "         t1.setPos(t[0],t[1]);\r\n",
      " }\r\n",
      "|  Added method drawSquareFrom(double[][])\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "void drawSquareFrom(double[][] tracks) {\n",
    "    t1.penUp();\n",
    "    t1.penDown();\n",
    "    for(double[] t:tracks) {\n",
    "        t1.moveTo(t[0],t[1]);\n",
    "        System.out.printf(\" %.1f %.1f\",t[0],t[1]);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 클래스로 만들어 실행\n",
    "\n",
    "컴파일하고 실행할 경우, 외부 라이브러리를 반드시 classpath에 추가한다.\n",
    "\n",
    "구분 | 명령어\n",
    "-----|-----\n",
    "컴파일 | javac -classpath lib/aplu5.jar -d classes/ p3_TurtleTracksMain.java\n",
    "실행 | java -classpath lib/aplu5.jar:./classes/ p3_TurtleTracksMain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting p3_TurtleTracksMain.java\n"
     ]
    }
   ],
   "source": [
    "%%writefile p3_TurtleTracksMain.java\n",
    "import ch.aplu.turtle.*;\n",
    "\n",
    "public class p3_TurtleTracksMain {\n",
    "    static Turtle t1=new Turtle();\n",
    "    static void drawSquareFrom(double[][] tracks) {\n",
    "        //t1.penDown();\n",
    "        for(double[] t:tracks) {\n",
    "            t1.moveTo(t[0],t[1]);\n",
    "            System.out.printf(\" %.1f %.1f\",t[0],t[1]);\n",
    "        }\n",
    "    }\n",
    "    public static void main(String[] args) {\n",
    "        double[][] tracks={{100,100},{200,100},{200,200},{100,200},{100,100}};\n",
    "        drawSquareFrom(tracks);\n",
    "    }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 데이터구조-6: 거북이가 걸어간 트랙을 다시 걷게 하기\n",
    "\n",
    "### 문제\n",
    "\n",
    "앞의 문제와 비슷하게, 이동경로를 저장하려면 모든 화소를 저장하는 방법이 있다.\n",
    "보다 효율적인 방법은 정지위치만을 저장한다. 경로는 그 정지위치를 연결하면 된다.\n",
    "\n",
    "### 해결\n",
    "이차원 배열로 저장하고, 저장된 데이터를 읽어 이동명령으로 사용한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 트랙을 저장하기\n",
    "\n",
    "'미로찾기'에서 거북이가 이동했던 경로를 저장한다.\n",
    "saveTracks() 함수를 구현해 Double[]로 경로를 저장해 반환한다.\n",
    "\n",
    "구분 | 설명\n",
    "-----|-----\n",
    "입력 | none\n",
    "출력 | Double[] 위치를 저장한다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "Double[] savePos() {\n",
    "    Double[] d=new Double[2];\n",
    "    d[0]=t1.getX();\n",
    "    d[1]=t1.getY();\n",
    "    return d;   \n",
    "}\n",
    "\n",
    "ArrayList<Double[]> saveTracks() {\n",
    "    ArrayList<Double[]> mytracks=new ArrayList<Double[]>();\n",
    "    Double[] d=new Double[2];\n",
    "    t1.speed(1);\n",
    "    t1.moveTo(-400,300);\n",
    "    mytracks.add(savePos());\n",
    "    t1.penDown();\n",
    "    t1.setColor(\"Red\");\n",
    "    t1.right(90);\n",
    "    t1.fd(400);\n",
    "    mytracks.add(savePos());\n",
    "    t1.bk(150);\n",
    "    mytracks.add(savePos());\n",
    "    t1.left(90);\n",
    "    t1.fd(300);\n",
    "    mytracks.add(savePos());\n",
    "    t1.left(90);\n",
    "    t1.fd(300);\n",
    "    mytracks.add(savePos());\n",
    "    t1.back(150);\n",
    "    mytracks.add(savePos());\n",
    "    t1.right(90);\n",
    "    t1.fd(300);\n",
    "    mytracks.add(savePos());\n",
    "    t1.left(90);\n",
    "    t1.right(90);\n",
    "    t1.right(90);\n",
    "    t1.fd(200);\n",
    "    mytracks.add(savePos());\n",
    "    t1.fd(300);\n",
    "    mytracks.add(savePos());\n",
    "    t1.back(100);\n",
    "    mytracks.add(savePos());\n",
    "    t1.left(90);\n",
    "    t1.fd(200);\n",
    "    mytracks.add(savePos());\n",
    "    return mytracks;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 트랙을 자동으로 걷게 하기\n",
    "\n",
    "* 앞서 저장된 트랙을 걷게 한다.\n",
    "* 함수 replayTracks(tracks)\n",
    "    * 입력 mytracks\n",
    "    * 출력\n",
    "* 저장된 위치가 몇 개인지 어떻게 알 수 있을까?\n",
    "    * tracks라는 데이터 구조명을 사용한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Double[] savePos() {\r\n",
      "     Double[] d=new Double[2];\r\n",
      "     d[0]=t1.getX();\r\n",
      "     d[1]=t1.getY();\r\n",
      "     return d;   \r\n",
      " }\r\n",
      "|  Modified method savePos()\r\n",
      "|    Update overwrote method savePos()\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " ArrayList<Double[]> saveTracks() {\r\n",
      "     ArrayList<Double[]> mytracks=new ArrayList<Double[]>();\r\n",
      "     Double[] d=new Double[2];\r\n",
      "     t1.speed(1);\r\n",
      "     t1.moveTo(-400,300);\r\n",
      "     mytracks.add(savePos());\r\n",
      "     t1.penDown();\r\n",
      "     t1.setColor(\"Red\");\r\n",
      "     t1.right(90);\r\n",
      "     t1.fd(400);\r\n",
      "     mytracks.add(savePos());\r\n",
      "     t1.bk(150);\r\n",
      "     mytracks.add(savePos());\r\n",
      "     t1.left(90);\r\n",
      "     t1.fd(300);\r\n",
      "     mytracks.add(savePos());\r\n",
      "     t1.left(90);\r\n",
      "     t1.fd(300);\r\n",
      "     mytracks.add(savePos());\r\n",
      "     t1.back(150);\r\n",
      "     mytracks.add(savePos());\r\n",
      "     t1.right(90);\r\n",
      "     t1.fd(300);\r\n",
      "     mytracks.add(savePos());\r\n",
      "     t1.left(90);\r\n",
      "     t1.right(90);\r\n",
      "     t1.right(90);\r\n",
      "     t1.fd(200);\r\n",
      "     mytracks.add(savePos());\r\n",
      "     t1.fd(300);\r\n",
      "     mytracks.add(savePos());\r\n",
      "     t1.back(100);\r\n",
      "     mytracks.add(savePos());\r\n",
      "     t1.left(90);\r\n",
      "     t1.fd(200);\r\n",
      "     mytracks.add(savePos());\r\n",
      "     return mytracks;\r\n",
      " }\r\n",
      "|  Added method saveTracks()\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " void replayTracks(ArrayList<Double[]> mytracks) {\r\n",
      "     t1.home();\r\n",
      "     t1.clear();\r\n",
      "     for(Double[] t:mytracks) {\r\n",
      "         t1.moveTo(t[0],t[1]);\r\n",
      "         System.out.printf(\" %.1f %.1f\",t[0],t[1]);\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added method replayTracks(ArrayList<Double[]>)\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "void replayTracks(ArrayList<Double[]> mytracks) {\n",
    "    t1.home();\n",
    "    t1.clear();\n",
    "    for(Double[] t:mytracks) {\n",
    "        t1.moveTo(t[0],t[1]);\n",
    "        System.out.printf(\" %.1f %.1f\",t[0],t[1]);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "ArrayList<Double[]> mytracks;\n",
    "mytracks=saveTracks();\n",
    "replayTracks(mytracks);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 데이터구조-7: 서울에 거주하는 남녀의 구별 합계와 평균구하기\n",
    "\n",
    "### 문제\n",
    "\n",
    "정량데이터를 그룹별 평균, 표준편차, 최소, 최대 등 서술통계값을 계산한다.\n",
    "* 아래 자료에서 남녀별, 구별 합계와 평균을 구하기\n",
    "* 자료는 서울 열린데이터 광장 http://data.seoul.go.kr에서 가져온 서울시 주민등록 구별/성별 통계 (2015년 3월 30일)\n",
    "\n",
    "```java\n",
    "구    남     여\n",
    "종로구  74,425 76,326\n",
    "중구    61,164 61,636\n",
    "용산구  109,688 115,744\n",
    "성동구  144,796 146,776\n",
    "광진구  174,996 181,676\n",
    "동대문구        177,841 177,434\n",
    "중랑구  204,630 205,980\n",
    "성북구  223,373 232,245\n",
    "강북구  161,055 166,130\n",
    "도봉구  171,576 176,735\n",
    "노원구  279,169 293,772\n",
    "은평구  239,450 251,066\n",
    "서대문구        148,690 156,510\n",
    "마포구  182,977 196,992\n",
    "양천구  237,792 242,641\n",
    "강서구  283,869 296,762\n",
    "구로구  209,344 210,282\n",
    "금천구  118,965 114,441\n",
    "영등포구        186,503 186,856\n",
    "동작구  195,734 203,014\n",
    "관악구  254,381 249,472\n",
    "서초구  212,401 229,111\n",
    "강남구  271,654 295,354\n",
    "송파구  319,197 335,045\n",
    "강동구  229,829 231,671\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 해결\n",
    "\n",
    "컬럼과 행에 명칭이 붙어있다.\n",
    "다행히 행은 모두 중복이 없다. 즉, 모든 행정구가 하나의 행을 가지고 있어서 서로 합산할 필요가 없다.\n",
    "다음 문제에서는 행별로 커피의 종류를 별도로 계산하고 있으니 참고하자.\n",
    "2차원 데이터 구조를 사용할 수 있다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 데이터구조 생성\n",
    "\n",
    "데이터 특징을 살펴보면 모두 정수이고 그 숫자 크기의 범위가 6자리를 넘어가지 않고 있다.\n",
    "```int[][]```으로 선언한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " int[][] data={\r\n",
      "     {74425, 76326},\r\n",
      "     {61164, 61636},\r\n",
      "     {109688, 115744},\r\n",
      "     {144796, 146776},\r\n",
      "     {174996, 181676},\r\n",
      "     {177841, 177434},\r\n",
      "     {204630, 205980},\r\n",
      "     {223373, 232245},\r\n",
      "     {161055, 166130},\r\n",
      "     {171576, 176735},\r\n",
      "     {279169, 293772},\r\n",
      "     {239450, 251066},\r\n",
      "     {148690, 156510},\r\n",
      "     {182977, 196992},\r\n",
      "     {237792, 242641},\r\n",
      "     {283869, 296762},\r\n",
      "     {209344, 210282},\r\n",
      "     {118965, 114441},\r\n",
      "     {186503, 186856},\r\n",
      "     {195734, 203014},\r\n",
      "     {254381, 249472},\r\n",
      "     {212401, 229111},\r\n",
      "     {271654, 295354},\r\n",
      "     {319197, 335045},\r\n",
      "     {229829, 231671}\r\n",
      " };\r\n",
      "|  Added variable data of type int[][] with initial value [[I@f6c48ac\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "int[][] data={\n",
    "    {74425, 76326},\n",
    "    {61164, 61636},\n",
    "    {109688, 115744},\n",
    "    {144796, 146776},\n",
    "    {174996, 181676},\n",
    "    {177841, 177434},\n",
    "    {204630, 205980},\n",
    "    {223373, 232245},\n",
    "    {161055, 166130},\n",
    "    {171576, 176735},\n",
    "    {279169, 293772},\n",
    "    {239450, 251066},\n",
    "    {148690, 156510},\n",
    "    {182977, 196992},\n",
    "    {237792, 242641},\n",
    "    {283869, 296762},\n",
    "    {209344, 210282},\n",
    "    {118965, 114441},\n",
    "    {186503, 186856},\n",
    "    {195734, 203014},\n",
    "    {254381, 249472},\n",
    "    {212401, 229111},\n",
    "    {271654, 295354},\n",
    "    {319197, 335045},\n",
    "    {229829, 231671}\n",
    "};"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 데이터구조에서 읽으면서 연산\n",
    "\n",
    "2차원 데이터의 크기는 주의해야 한다.\n",
    "**열의 크기 data[0].length** 및 **행의 크기 data.length**를 알아 보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " System.out.printf(\"열:%d 행: %d\",data[0].length,data.length);\r\n",
      "열:2 행: 25|  Expression value is: java.io.PrintStream@1e127982\r\n",
      "|    assigned to temporary variable $32 of type PrintStream\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "System.out.printf(\"열:%d 행: %d\",data[0].length,data.length);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "이차원 데이터를 읽으려면 배열을 겹쳐쓰고, 인덱스를 적는다. **앞은 행, 뒤는 열**을 의미한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " data[0][1];\r\n",
      "|  Expression value is: 76326\r\n",
      "|    assigned to temporary variable $33 of type int\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "data[0][1];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "데이터 구조의 차원만큼 반복문을 사용하는 것이 좋다. 1차원은 for문 1개, 2차원은 for문 중첩."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(int[] i:data)\r\n",
      "     for(int j:i)\r\n",
      "         System.out.print(j);\r\n",
      "74425763266116461636109688115744144796146776174996181676177841177434204630205980223373232245161055166130171576176735279169293772239450251066148690156510182977196992237792242641283869296762209344210282118965114441186503186856195734203014254381249472212401229111271654295354319197335045229829231671\r\n"
     ]
    }
   ],
   "source": [
    "for(int[] i:data)\n",
    "    for(int j:i)\n",
    "        System.out.print(j);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(int i=0;i<data.length;i++) {\r\n",
      "     System.out.print(\"[\");\r\n",
      "     for(int j=0;j<data[i].length;j++) {\r\n",
      "         System.out.printf(\" %d \",data[i][j]);\r\n",
      "     }\r\n",
      "     System.out.print(\"]\\n\");\r\n",
      " }\r\n",
      "[ 74425  76326 ]\r\n",
      "[ 61164  61636 ]\r\n",
      "[ 109688  115744 ]\r\n",
      "[ 144796  146776 ]\r\n",
      "[ 174996  181676 ]\r\n",
      "[ 177841  177434 ]\r\n",
      "[ 204630  205980 ]\r\n",
      "[ 223373  232245 ]\r\n",
      "[ 161055  166130 ]\r\n",
      "[ 171576  176735 ]\r\n",
      "[ 279169  293772 ]\r\n",
      "[ 239450  251066 ]\r\n",
      "[ 148690  156510 ]\r\n",
      "[ 182977  196992 ]\r\n",
      "[ 237792  242641 ]\r\n",
      "[ 283869  296762 ]\r\n",
      "[ 209344  210282 ]\r\n",
      "[ 118965  114441 ]\r\n",
      "[ 186503  186856 ]\r\n",
      "[ 195734  203014 ]\r\n",
      "[ 254381  249472 ]\r\n",
      "[ 212401  229111 ]\r\n",
      "[ 271654  295354 ]\r\n",
      "[ 319197  335045 ]\r\n",
      "[ 229829  231671 ]\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for(int i=0;i<data.length;i++) {\n",
    "    System.out.print(\"[\");\n",
    "    for(int j=0;j<data[i].length;j++) {\n",
    "        System.out.printf(\" %d \",data[i][j]);\n",
    "    }\n",
    "    System.out.print(\"]\\n\");\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(int gu=0;gu<data.length;gu++)\r\n",
      "     System.out.printf(\"(%d,%d)\\n\",data[gu][0], data[gu][1]);\r\n",
      "(74425,76326)\r\n",
      "(61164,61636)\r\n",
      "(109688,115744)\r\n",
      "(144796,146776)\r\n",
      "(174996,181676)\r\n",
      "(177841,177434)\r\n",
      "(204630,205980)\r\n",
      "(223373,232245)\r\n",
      "(161055,166130)\r\n",
      "(171576,176735)\r\n",
      "(279169,293772)\r\n",
      "(239450,251066)\r\n",
      "(148690,156510)\r\n",
      "(182977,196992)\r\n",
      "(237792,242641)\r\n",
      "(283869,296762)\r\n",
      "(209344,210282)\r\n",
      "(118965,114441)\r\n",
      "(186503,186856)\r\n",
      "(195734,203014)\r\n",
      "(254381,249472)\r\n",
      "(212401,229111)\r\n",
      "(271654,295354)\r\n",
      "(319197,335045)\r\n",
      "(229829,231671)\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for(int gu=0;gu<data.length;gu++)\n",
    "    System.out.printf(\"(%d,%d)\\n\",data[gu][0], data[gu][1]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(int[] gu:data)\r\n",
      "     System.out.printf(\"(%d,%d)\\n\",gu[0], gu[1]);\r\n",
      "(74425,76326)\r\n",
      "(61164,61636)\r\n",
      "(109688,115744)\r\n",
      "(144796,146776)\r\n",
      "(174996,181676)\r\n",
      "(177841,177434)\r\n",
      "(204630,205980)\r\n",
      "(223373,232245)\r\n",
      "(161055,166130)\r\n",
      "(171576,176735)\r\n",
      "(279169,293772)\r\n",
      "(239450,251066)\r\n",
      "(148690,156510)\r\n",
      "(182977,196992)\r\n",
      "(237792,242641)\r\n",
      "(283869,296762)\r\n",
      "(209344,210282)\r\n",
      "(118965,114441)\r\n",
      "(186503,186856)\r\n",
      "(195734,203014)\r\n",
      "(254381,249472)\r\n",
      "(212401,229111)\r\n",
      "(271654,295354)\r\n",
      "(319197,335045)\r\n",
      "(229829,231671)\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for(int[] gu:data)\n",
    "    System.out.printf(\"(%d,%d)\\n\",gu[0], gu[1]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "남녀별 합계를 계산해 보자. 합계는 남녀 별도로 계산한다.\n",
    "배열에서 데이터를 꺼내는 것이 조금 어렵고, 계산식은 단순하다.\n",
    "다음으로는 ```int[] getSumbyMF()```로 만들어 보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " int sumM=0;\r\n",
      "|  Added variable sumM of type int with initial value 0\r\n",
      "\r\n",
      " int sumF=0;\r\n",
      "|  Added variable sumF of type int with initial value 0\r\n",
      "\r\n",
      " for(int[] gu:data) {\r\n",
      "     sumM+=gu[0];\r\n",
      "     sumF+=gu[1];\r\n",
      " }\r\n",
      "\r\n",
      " System.out.printf(\"sumM:%d, sumF:%d\",sumM,sumF);\r\n",
      "sumM:4873499, sumF:5033671|  Expression value is: java.io.PrintStream@59ec2012\r\n",
      "|    assigned to temporary variable $5 of type PrintStream\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "int sumM=0;\n",
    "int sumF=0;\n",
    "for(int[] gu:data) {\n",
    "    sumM+=gu[0];\n",
    "    sumF+=gu[1];\n",
    "}\n",
    "System.out.printf(\"sumM:%d, sumF:%d\",sumM,sumF);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " int[] getSumbyMF() {\r\n",
      "     int[] sumMF={0,0};\r\n",
      "     for(int[] gu:data) {\r\n",
      "         sumMF[0]+=gu[0];\r\n",
      "         sumMF[1]+=gu[1];\r\n",
      "     }\r\n",
      "     System.out.printf(\"sumM:%d, sumF:%d\",sumM,sumF);\r\n",
      "     return sumMF;\r\n",
      " }\r\n",
      "|  Added method getSumbyMF()\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "int[] getSumbyMF() {\n",
    "    int[] sumMF={0,0};\n",
    "    for(int[] gu:data) {\n",
    "        sumMF[0]+=gu[0];\n",
    "        sumMF[1]+=gu[1];\n",
    "    }\n",
    "    System.out.printf(\"sumM:%d, sumF:%d\",sumM,sumF);\n",
    "    return sumMF;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " int[] sumMF=getSumbyMF();\r\n",
      "sumM:4873499, sumF:5033671|  Modified variable sumMF of type int[] with initial value [I@6fd02e5\r\n",
      "|    Update overwrote variable sumMF\r\n",
      "\r\n",
      " System.out.printf(\"sumM:%d sumF:%d\",sumMF[0],sumMF[1]);\r\n",
      "sumM:4873499 sumF:5033671|  Expression value is: java.io.PrintStream@59ec2012\r\n",
      "|    assigned to temporary variable $13 of type PrintStream\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "int[] sumMF=getSumbyMF();\n",
    "System.out.printf(\"sumM:%d sumF:%d\",sumMF[0],sumMF[1]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  클래스 만들기\n",
    "\n",
    "int[] getSumbyMF()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 6.6 복사의 문제\n",
    "\n",
    "배열, 리스트 등을 복사하는 경우 다음을 구분할 필요가 있다.\n",
    "\n",
    "복사 구분 | 설명 | Object.clone()의 경우\n",
    "-----|-----|-----\n",
    "shallow copy | 데이터 참조 값을 복사 | Object.clone()은 얕은 복사가 기본임.\n",
    "deep copy | 데이터 값을 복사. | 깊은 복사를 하려면 Object.clone()을 재정의."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "간단한 테스트를 위해 **printArr()** 함수를 구현해 놓는다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " void printArr(int[] n) {\r\n",
      "     for(int i:n)\r\n",
      "         System.out.printf(\"%d \",i);\r\n",
      " }\r\n",
      "|  Added method printArr(int[])\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "void printArr(int[] n) {\n",
    "    for(int i:n)\n",
    "        System.out.printf(\"%d \",i);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "setArr0() 안에서 값을 변경하면 그 효과가 함수 밖에서도 지속된다.\n",
    "이를 앞서 배웠듯이 **call by value**라고 한다.\n",
    "즉 배열의 복사본이 전달되고, 그 복사본이 가리키는 값이 변경되므로 함수 밖에서도 변경된 값을 볼 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " int[] x={1,2,3};\r\n",
      "|  Modified variable x of type int[] with initial value [I@29ca901e\r\n",
      "|    Update overwrote variable x\r\n",
      "\r\n",
      " void setArr0(int[] n, int i) {\r\n",
      "     n[0]=i;\r\n",
      " }\r\n",
      "|  Modified method setArr0(int[],int)\r\n",
      "|    Update overwrote method setArr0(int[],int)\r\n",
      "\r\n",
      " setArr0(x,55);\r\n",
      "\r\n",
      " printArr(x);\r\n",
      "55 2 3 \r\n"
     ]
    }
   ],
   "source": [
    "int[] x={1,2,3};\n",
    "void setArr0(int[] n, int i) {\n",
    "    n[0]=i;\n",
    "}\n",
    "setArr0(x,55);\n",
    "printArr(x);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 배열을 복사하면 값이 복사되는 것이 아니라, 'x'의 참조 값이 'y'로 복사된다.\n",
    "* 따라서 원본 'x'가 변경되면, 복사본 'y'도 변경된다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "정수배열 x를 y에 복사하면 **y에는 x의 참조값이 저장**된다.\n",
    "따라서 x가 가리키는 정수배열의 값이 변경되면, y도 당연히 변경된다.\n",
    "y에는 x의 참조값이 저장되어 있고 **동일한 정수배열을 보고** 있기 때문이다.\n",
    "\n",
    "![alt text](figures/6_deepCopy.png \"Shallow and Deep Copy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " int[] y;\r\n",
      "|  Added variable y of type int[]\r\n",
      "\r\n",
      " y=x;\r\n",
      "|  Variable y has been assigned the value [I@a7e666\r\n",
      "\r\n",
      " printArr(y);\r\n",
      "55 2 3 \r\n",
      " setArr0(x,66);\r\n",
      "\r\n",
      " printArr(y);\r\n",
      "66 2 3 \r\n"
     ]
    }
   ],
   "source": [
    "int[] y;\n",
    "y=x;            //배열x를 y로 shallow 복사\n",
    "printArr(y);\n",
    "setArr0(x,66);  //x를 변경하더라도 y도 변경됨\n",
    "printArr(y);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 데이터구조-8: 커피에 Milk를 추가하는 비율 구하기\n",
    "\n",
    "\n",
    "### 문제\n",
    "\n",
    "* 문자로 구성된 2차원 데이터구조의 빈도를 세어서, 백분율을 구하기\n",
    "* 데이터\n",
    "```java\n",
    "\"Coffee\",\"Water\",\"Milk\",\"Icecream\"\n",
    "\"Espresso\",\"No\",\"No\",\"No\"\n",
    "\"Long Black\",\"Yes\",\"No\",\"No\"\n",
    "\"Flat White\",\"No\",\"Yes\",\"No\"\n",
    "\"Cappuccino\",\"No\",\"Yes - Frothy\",\"No\"\n",
    "\"Affogato\",\"No\",\"No\",\"Yes\"\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 해결\n",
    "\n",
    "* 2차원 list\n",
    "* 문자열 데이터의 평균은 빈도를 세어서 한다. 숫자 데이터는 합계를 갯수로 나누어서 구하는 것과 다르다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 문자열 데이터 선언\n",
    "\n",
    "행은 6, 열은 4개인 2차원 문자열 데이터이다.\n",
    "행과 열 모두 이름이 있지만, 열의 이름은 제거하기로 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " String[][] allData={\r\n",
      "     {\"Coffee\",\"Water\",\"Milk\",\"Icecream\"},\r\n",
      "     {\"Espresso\",\"No\",\"No\",\"No\"},\r\n",
      "     {\"Long Black\",\"Yes\",\"No\",\"No\"},\r\n",
      "     {\"Flat White\",\"No\",\"Yes\",\"No\"},\r\n",
      "     {\"Cappuccino\",\"No\",\"Yes\",\"No\"},\r\n",
      "     {\"Affogato\",\"No\",\"No\",\"Yes\"}\r\n",
      " }\r\n",
      "|  Added variable allData of type String[][] with initial value [[Ljava.lang.String;@1ce92674\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "String[][] allData={\n",
    "    {\"Coffee\",\"Water\",\"Milk\",\"Icecream\"},\n",
    "    {\"Espresso\",\"No\",\"No\",\"No\"},\n",
    "    {\"Long Black\",\"Yes\",\"No\",\"No\"},\n",
    "    {\"Flat White\",\"No\",\"Yes\",\"No\"},\n",
    "    {\"Cappuccino\",\"No\",\"Yes\",\"No\"},\n",
    "    {\"Affogato\",\"No\",\"No\",\"Yes\"}\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 첫 행은 이름을 가지고 있으므로 제거한다.\n",
    "\n",
    "2차원 데이터의 첫 행은 이름에 해당하므로 제거하고 복사해서 사용한다.\n",
    "우선 데이터의 길이를 확인한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " System.out.printf(\"열:%d 행: %d\",allData[0].length,allData.length);\r\n",
      "열:4 행: 6|  Expression value is: java.io.PrintStream@73ad2d6\r\n",
      "|    assigned to temporary variable $11 of type PrintStream\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "System.out.printf(\"열:%d 행: %d\",allData[0].length,allData.length);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 인덱스를 이용하여 전체 데이터에서 첫 행만 제거하고 **복사**한다.\n",
    "\n",
    "줄 | 설명\n",
    "-----|-----|\n",
    "1 | 2차원 복사데이터를 선언한다. 행의 수는 전체 6에서 1을 뺀 5로 한다.\n",
    "2 | 2차원 데이터이므로 중첩 for문을 이용해서 저장할 수 있다. 외부 for문은 행의 수를 반복하므로 1부터 시작.\n",
    "3 | 모든 열에 대해 반복\n",
    "4 | 행은 하나씩 좌로 이동해서 복사"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " String[][] copied=new String[5][4];\r\n",
      "|  Added variable copied of type String[][] with initial value [[Ljava.lang.String;@5bcab519\r\n",
      "\r\n",
      " for(int i=1;i<allData.length;i++)\r\n",
      "     for(int j=0;j<allData[i].length;j++)\r\n",
      "         copied[i-1][j]=allData[i][j]\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "String[][] copied=new String[5][4];\n",
    "for(int i=1;i<allData.length;i++)\n",
    "    for(int j=0;j<allData[i].length;j++)\n",
    "        copied[i-1][j]=allData[i][j]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 2차원 데이터 slicing\n",
    "\n",
    "2차원 데이터로 부터 원하는 항목을 잘라내어 slicing 보자.\n",
    "* 2번째 배열인덱스를 고정하면 열데이터를 읽을 수 있슴\n",
    "* 1번째 배열인덱스를 고정하면 행데이터를 읽을 수 있슴.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "복사가 잘 되었는지 전체 데이터를 출력해서 확인해 보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(String[] r:copied) {\r\n",
      "     for(String c:r)\r\n",
      "         System.out.printf(\"%s \",c);\r\n",
      "     System.out.printf(\"\\n\");\r\n",
      " }\r\n",
      "Espresso No No No \r\n",
      "Long Black Yes No No \r\n",
      "Flat White No Yes No \r\n",
      "Cappuccino No Yes No \r\n",
      "Affogato No No Yes \r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for(String[] r:copied) {\n",
    "    for(String c:r)\n",
    "        System.out.printf(\"%s \",c);\n",
    "    System.out.printf(\"\\n\");\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 커피 종류를 출력해 본다.\n",
    "    * 커피 종류는 첫째 열에 있다. 출력하려면 인덱스 0을 사용한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(String[] r:copied)\r\n",
      "     System.out.printf(\"%s\\n\",r[0]);\r\n",
      "Espresso\r\n",
      "Long Black\r\n",
      "Flat White\r\n",
      "Cappuccino\r\n",
      "Affogato\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for(String[] r:copied)\n",
    "    System.out.printf(\"%s\\n\",r[0]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 커피에 우유를 넣는지 확인해 본다.\n",
    "    * 우유를 넣는지는 2번째 열에 있다. Yes는 우유를 넣고, No는 넣지 않는다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(String[] r:copied)\r\n",
      "     System.out.printf(\"%s\\n\",r[2]);\r\n",
      "No\r\n",
      "No\r\n",
      "Yes\r\n",
      "Yes\r\n",
      "No\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for(String[] r:copied)\n",
    "    System.out.printf(\"%s\\n\",r[2]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 우유를 넣는 커피를 출력해 본다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "String s=\"he\";\n",
    "s.toUpperCase();\n",
    "\n",
    "for(String[] r:copied)\n",
    "    if(r[2].equals(\"Yes\"))\n",
    "        System.out.printf(\"%s %s\\n\",r[0],r[2]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 커피에 밀크를 추가하는 비율 구하기\n",
    "```java\n",
    "(float)100*count/copied.length;\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " int count=0;\r\n",
      "|  Added variable count of type int with initial value 0\r\n",
      "\r\n",
      " for(String[] r:copied)\r\n",
      "     if(r[2].equals(\"Yes\"))\r\n",
      "         count+=1;\r\n",
      "\r\n",
      " System.out.printf(\"Number of Coffee adding Milk: %d\",count);\r\n",
      "Number of Coffee adding Milk: 2|  Expression value is: java.io.PrintStream@73ad2d6\r\n",
      "|    assigned to temporary variable $20 of type PrintStream\r\n",
      "\r\n",
      " System.out.printf(\"밀크를 넣는 커피 비율: %.1f\",(float)100*count/copied.length);\r\n",
      "밀크를 넣는 커피 비율: 40.0|  Expression value is: java.io.PrintStream@73ad2d6\r\n",
      "|    assigned to temporary variable $21 of type PrintStream\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "int count=0;\n",
    "for(String[] r:copied)\n",
    "    if(r[2].equals(\"Yes\"))\n",
    "        count+=1;\n",
    "System.out.printf(\"Number of Coffee adding Milk: %d\",count);\n",
    "System.out.printf(\"밀크를 넣는 커피 비율: %.1f\",(float)100*count/copied.length);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 데이터구조-9: 성적데이터의 평균/합계를 구하기.\n",
    "\n",
    "### 문제\n",
    "\n",
    "과목의 평균과 합계를 구하는 문제이다.\n",
    "단 숫자와 문자가 혼합된 데이터라는 점에 주의한다.\n",
    "```java\n",
    "Subject,scores\n",
    "English, 100\n",
    "Math, 80\n",
    "English, 70\n",
    "Math, 100\n",
    "English, 82.3\n",
    "Math, 98.5\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 해결\n",
    "\n",
    "데이터 타잎이 섞인 경우 mixed type, 형변환에 주의한다.\n",
    "다음과 같이 클래스를 별도로 만들거나 또는 parallel array로 처리할 수 있다.\n",
    "\n",
    "```java\n",
    "class {\n",
    "    String subj;\n",
    "    double marks;\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    ":read data;\n",
    ":engSum=0;\n",
    ":mathSum=0;\n",
    ":engCnt=0;\n",
    ":mathCnt=0;\n",
    "while(i<=eof)\n",
    ":read a line;\n",
    "if (eng)\n",
    ":engSum+=mark;\n",
    ":engCnt+=1;\n",
    "elseif (math)\n",
    ":mathSum+=mark;\n",
    ":mathCnt+=1;\n",
    "endif\n",
    "endwhile\n",
    ":print engSum,mathSum;\n",
    ":print engSum/engCnt,mathSum/mathCnt;\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### mixed type 데이터 선언\n",
    "\n",
    "과목명은 문자열, 성적은 정수 또는 소수를 가질 수 있다.\n",
    "**동일한 열에 정수, 소수를 섞어쓰면** 처리가 더욱 어려워지게 된다.\n",
    "이 경우 소수로 통일하여 double로 만든다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Object[][] marks = {\r\n",
      "     {\"English\", 100.0},\r\n",
      "     {\"Math\", 80.0},\r\n",
      "     {\"English\", 70.0},\r\n",
      "     {\"Math\", 100.0},\r\n",
      "     {\"English\", 82.3},\r\n",
      "     {\"Math\", 98.5}\r\n",
      " }\r\n",
      "|  Added variable marks of type Object[][] with initial value [[Ljava.lang.Object;@6e1567f1\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Object[][] marks = {\n",
    "    {\"English\", 100.0},\n",
    "    {\"Math\", 80.0},\n",
    "    {\"English\", 70.0},\n",
    "    {\"Math\", 100.0},\n",
    "    {\"English\", 82.3},\n",
    "    {\"Math\", 98.5}\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 평균계산\n",
    "\n",
    "우선 데이터를 읽어보자. 문자열로 읽거나, 형변환을 하고나서 출력할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(Object[] obj:marks) {\r\n",
      "     System.out.printf(\"과목: %s 점수: %s\\n\", obj[0], obj[1]);\r\n",
      " }\r\n",
      "과목: English 점수: 100.0\r\n",
      "과목: Math 점수: 80.0\r\n",
      "과목: English 점수: 70.0\r\n",
      "과목: Math 점수: 100.0\r\n",
      "과목: English 점수: 82.3\r\n",
      "과목: Math 점수: 98.5\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for(Object[] obj:marks) {\n",
    "    System.out.printf(\"과목: %s 점수: %s\\n\", obj[0], obj[1]);\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(Object[] obj:marks) {\r\n",
      "     System.out.printf(\"과목: %s 점수: %.1f\\n\", (String)obj[0], (double)obj[1]);\r\n",
      " }\r\n",
      "과목: English 점수: 100.0\r\n",
      "과목: Math 점수: 80.0\r\n",
      "과목: English 점수: 70.0\r\n",
      "과목: Math 점수: 100.0\r\n",
      "과목: English 점수: 82.3\r\n",
      "과목: Math 점수: 98.5\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for(Object[] obj:marks) {\n",
    "    System.out.printf(\"과목: %s 점수: %.1f\\n\", (String)obj[0], (double)obj[1]);\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "평균은 합계, 갯수를 구해서 나누면 계산된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " double englishSum=0\r\n",
      "|  Modified variable englishSum of type double with initial value 0.0\r\n",
      "|    Update overwrote variable englishSum\r\n",
      "\r\n",
      " double mathSum=0\r\n",
      "|  Modified variable mathSum of type double with initial value 0.0\r\n",
      "|    Update overwrote variable mathSum\r\n",
      "\r\n",
      " int englishCount=0\r\n",
      "|  Modified variable englishCount of type int with initial value 0\r\n",
      "|    Update overwrote variable englishCount\r\n",
      "\r\n",
      " int mathCount=0\r\n",
      "|  Modified variable mathCount of type int with initial value 0\r\n",
      "|    Update overwrote variable mathCount\r\n",
      "\r\n",
      " for(Object[] obj:marks) {\r\n",
      "     String subj = (String) obj[0];       //문자열로 형변환\r\n",
      "     double mark = (double)obj[1];        //소수로 형변환\r\n",
      "     if(subj.equals(\"English\")) {\r\n",
      "         englishSum+=mark;\r\n",
      "         englishCount+=1;\r\n",
      "     } else if(subj.equals(\"Math\")) {\r\n",
      "         mathSum+=mark;\r\n",
      "         mathCount+=1;\r\n",
      "     }\r\n",
      " }\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "double englishSum=0\n",
    "double mathSum=0\n",
    "int englishCount=0\n",
    "int mathCount=0\n",
    "for(Object[] obj:marks) {\n",
    "    String subj = (String) obj[0];       //문자열로 형변환\n",
    "    double mark = (double)obj[1];        //소수로 형변환\n",
    "    if(subj.equals(\"English\")) {\n",
    "        englishSum+=mark;\n",
    "        englishCount+=1;\n",
    "    } else if(subj.equals(\"Math\")) {\n",
    "        mathSum+=mark;\n",
    "        mathCount+=1;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " System.out.printf(\"English: %.1f %.1f %d\",englishSum/englishCount,englishSum, \r",
      "englishCount);\r\n",
      "English: 84.1 252.3 3|  Expression value is: java.io.PrintStream@5649fd9b\r\n",
      "|    assigned to temporary variable $13 of type PrintStream\r\n",
      "\r\n",
      " System.out.printf(\"Math: %.1f %.1f %d\",mathSum/mathCount,mathSum,mathCount);\r\n",
      "Math: 92.8 278.5 3|  Expression value is: java.io.PrintStream@5649fd9b\r\n",
      "|    assigned to temporary variable $14 of type PrintStream\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "System.out.printf(\"English: %.1f %.1f %d\",englishSum/englishCount,englishSum,englishCount);\n",
    "System.out.printf(\"Math: %.1f %.1f %d\",mathSum/mathCount,mathSum,mathCount);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "* 클래스로 만들어 보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Grade {\r\n",
      "     Object[][] marks = {\r\n",
      "         {\"English\", 100.0},\r\n",
      "         {\"Math\", 80.0},\r\n",
      "         {\"English\", 70.0},\r\n",
      "         {\"Math\", 100.0},\r\n",
      "         {\"English\", 82.3},\r\n",
      "         {\"Math\", 98.5}\r\n",
      "     };\r\n",
      "     public double[] getAvg() {\r\n",
      "         double[] avg={0.0,0.0};\r\n",
      "         int englishCount=0;\r\n",
      "         int mathCount=0;\r\n",
      "         for(Object[] obj:marks) {\r\n",
      "             String subj = (String)obj[0];\r\n",
      "             double mark = (double)obj[1];\r\n",
      "             if(subj.equals(\"English\")) {\r\n",
      "                 avg[0]+=mark;\r\n",
      "                 englishCount+=1;\r\n",
      "             }\r\n",
      "             else if(subj.equals(\"Math\")) {\r\n",
      "                 avg[1]+=mark;\r\n",
      "                 mathCount+=1;\r\n",
      "             }\r\n",
      "         }\r\n",
      "         avg[0]/=englishCount;\r\n",
      "         avg[1]/=mathCount;\r\n",
      "         //System.out.printf(\"English avg: %.1f Math avg: %.1f\",avg[0], avg[1] \r",
      ");\r\n",
      "         return avg;\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Modified class Grade\r\n",
      "|    Update overwrote class Grade\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Grade {\n",
    "    Object[][] marks = {\n",
    "        {\"English\", 100.0},\n",
    "        {\"Math\", 80.0},\n",
    "        {\"English\", 70.0},\n",
    "        {\"Math\", 100.0},\n",
    "        {\"English\", 82.3},\n",
    "        {\"Math\", 98.5}\n",
    "    };\n",
    "    public double[] getAvg() {\n",
    "        double[] avg={0.0,0.0};\n",
    "        int englishCount=0;\n",
    "        int mathCount=0;\n",
    "        for(Object[] obj:marks) {\n",
    "            String subj = (String)obj[0];\n",
    "            double mark = (double)obj[1];\n",
    "            if(subj.equals(\"English\")) {\n",
    "                avg[0]+=mark;\n",
    "                englishCount+=1;\n",
    "            }\n",
    "            else if(subj.equals(\"Math\")) {\n",
    "                avg[1]+=mark;\n",
    "                mathCount+=1;\n",
    "            }\n",
    "        }\n",
    "        avg[0]/=englishCount;\n",
    "        avg[1]/=mathCount;\n",
    "        //System.out.printf(\"English avg: %.1f Math avg: %.1f\",avg[0], avg[1]);\n",
    "        return avg;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Grade g=new Grade();\r\n",
      "|  Modified variable g of type Grade with initial value Grade@72d818d1\r\n",
      "|    Update overwrote variable g\r\n",
      "\r\n",
      " double[] avg=g.getAvg();\r\n",
      "|  Modified variable avg of type double[] with initial value [D@6e06451e\r\n",
      "|    Update overwrote variable avg\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Grade g=new Grade();\n",
    "double[] avg=g.getAvg();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " System.out.printf(\"English avg: %.1f Math avg: %.1f\",avg[0], avg[1]);\r\n",
      "English avg: 84.1 Math avg: 92.8|  Expression value is: java.io.PrintStream@27c20538\r\n",
      "|    assigned to temporary variable $11 of type PrintStream\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "System.out.printf(\"English avg: %.1f Math avg: %.1f\",avg[0], avg[1]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 6.8 Map\n",
    "\n",
    "HashMap은 **키와 값**으로 구성한다. 키는 당연히 유일한 값이어야 한다.\n",
    "또한 키에 따라 데이터를 사용하므로 배열, 리스트와 같은 구조에서 **순서**는 의미가 없다.\n",
    "javascript의 JSON, Python의 dictionary 등과 같이 HashMap이다.\n",
    "또한 Python과 같은 언어에서 지원하는 associative array를 자바에서는 지원하지 않는다. Map으로 흉내낼 수 있다.\n",
    "사용하는 경우는:\n",
    "* 자료가 필드, 값으로 구성된 경우\n",
    "    * 예: 이름-'홍길동'. key -> '이름', value -> '홍길동'. key-value는 수, 문자 모두 가능.\n",
    "* 자료의 갯수를 세는 경우\n",
    "    * 데이터에 각 단어가 발생하는 빈도수를 세는 경우\n",
    "\n",
    "HashMap | HashSet\n",
    "----------|----------\n",
    "Map interface | Set Interface\n",
    "key-value pair | objects\n",
    "put() | add()\n",
    "key 객체로 hash code생성 | 멤버 객체로 hash code 생성\n",
    "key가 있어서 빠름 | hash map보다 느림"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "key 문자열, 값 문자열로 HashMap을 만들어 보자.\n",
    "Windows key로 \"2000\"을 저장한다.\n",
    "동일 key로 \"XP\"를 저장하면 동일 key의 값이 갱신된다.\n",
    "key는 중복되어서는 안되기 때문이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Map<String, String> m1 = new HashMap<String, String>(); // or new TreeMap() w \r",
      "ill order based on keys\r\n",
      "|  Added variable m1 of type Map<String, String> with initial value {}\r\n",
      "\r\n",
      " m1.put(\"Windows\", \"2000\");\r\n",
      "|  Expression value is: null\r\n",
      "|    assigned to temporary variable $2 of type String\r\n",
      "\r\n",
      " m1.put(\"Windows\", \"XP\");\r\n",
      "|  Expression value is: \"2000\"\r\n",
      "|    assigned to temporary variable $3 of type String\r\n",
      "\r\n",
      " m1.put(\"Language\", \"Java\");\r\n",
      "|  Expression value is: null\r\n",
      "|    assigned to temporary variable $4 of type String\r\n",
      "\r\n",
      " System.out.print(m1);\r\n",
      "{Language=Java, Windows=XP}\r\n"
     ]
    }
   ],
   "source": [
    "Map<String, String> m1 = new HashMap<String, String>(); // or new TreeMap() will order based on keys\n",
    "m1.put(\"Windows\", \"2000\");\n",
    "m1.put(\"Windows\", \"XP\");\n",
    "m1.put(\"Language\", \"Java\");\n",
    "System.out.print(m1);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "국제전화 코드를 구성해보자.\n",
    "물론 이차원 배열로 만들어도 된다.\n",
    "\n",
    "2016년 현재 코드는 지역 1부터 9까지 아홉 개로 나뉘어 그 지역코드로 시작한다.\n",
    "\n",
    "코드구분 | 해당 국가들\n",
    "-----|-----\n",
    "지역 1 | 북아메리카, 카리브 제도 일부 국가\n",
    "지역 2 | 아프리카, 일부 대서양 국가\n",
    "지역 3, 4 | 유럽 국가\n",
    "지역 5 | 멕시코, 중앙 및 남아메리카 지역, 서인도 제도의 국가\n",
    "지역 6 | 남태평양과 오세아니아 국가\n",
    "지역 7 | 러시아 및 소비에트 연방 국가\n",
    "지역 8 | 동아시아 국가\n",
    "지역 9 | 서아시아, 남아시아, 중앙아시아, 중동 지역 국가"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " String[][] callingCodes = {\r\n",
      "     {\"82\",\"South Korea\"},{\"81\",\"Japan\"},\r\n",
      "     {\"1\",\"United States of America\"},{\"44\",\"United Kingdom\"}\r\n",
      " };\r\n",
      "|  Added variable callingCodes of type String[][] with initial value [[Ljava.lang.String;@f6c48ac\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "String[][] callingCodes = {\n",
    "    {\"82\",\"South Korea\"},{\"81\",\"Japan\"},\n",
    "    {\"1\",\"United States of America\"},{\"44\",\"United Kingdom\"}\n",
    "};"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " callingCodes[0][0];\r\n",
      "|  Expression value is: \"82\"\r\n",
      "|    assigned to temporary variable $7 of type String\r\n",
      "\r\n",
      " callingCodes[1][0];\r\n",
      "|  Expression value is: \"81\"\r\n",
      "|    assigned to temporary variable $8 of type String\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "callingCodes[0][0];\n",
    "callingCodes[1][0];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(String[] c:callingCodes)\r\n",
      "     System.out.println(c[0]);\r\n",
      "82\r\n",
      "81\r\n",
      "1\r\n",
      "44\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for(String[] c:callingCodes)\n",
    "    System.out.println(c[0]);\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Map을 사용해서 2차원 구조를 표현할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Map<Integer, String> callCodes = new HashMap<Integer, String>();\r\n",
      "|  Added variable callCodes of type Map<Integer, String> with initial value {}\r\n",
      "\r\n",
      " callCodes.put(81, \"Japan\");\r\n",
      "|  Expression value is: null\r\n",
      "|    assigned to temporary variable $3 of type String\r\n",
      "\r\n",
      " callCodes.put(1, \"USA\");\r\n",
      "|  Expression value is: null\r\n",
      "|    assigned to temporary variable $4 of type String\r\n",
      "\r\n",
      " callCodes.put(82, \"Korea\");\r\n",
      "|  Expression value is: null\r\n",
      "|    assigned to temporary variable $5 of type String\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Map<Integer, String> callCodes = new HashMap<Integer, String>();\n",
    "callCodes.put(81, \"Japan\");\n",
    "callCodes.put(1, \"USA\");\n",
    "callCodes.put(82, \"Korea\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Map에 저장된 국가코드를 출력해 보자.\n",
    "2016년 현재 코드는 지역 1부터 9까지 아홉 개로 나뉘어 그 지역코드로 시작한다.\n",
    "\n",
    "코드구분 | 해당 국가들\n",
    "-----|-----\n",
    "지역 1 | 북아메리카, 카리브 제도 일부 국가\n",
    "지역 2 | 아프리카, 일부 대서양 국가\n",
    "지역 3, 4 | 유럽 국가\n",
    "지역 5 | 멕시코, 중앙 및 남아메리카 지역, 서인도 제도의 국가\n",
    "지역 6 | 남태평양과 오세아니아 국가\n",
    "지역 7 | 러시아 및 소비에트 연방 국가\n",
    "지역 8 | 동아시아 국가\n",
    "지역 9 | 서아시아, 남아시아, 중앙아시아, 중동 지역 국가\n",
    "\n",
    "동아시아 국가를 출력해 보자.\n",
    "\n",
    "줄 | 설명\n",
    "-----|-----\n",
    "2 | key를 읽는다.\n",
    "3 | key는 정수이므로 문자열로 바꾸어 첫 문자 char를 읽어서 '8'로 시작하는지 비교한다.\n",
    "4 | 해당 key의 value를 읽는다.\n",
    "5 | key, value를 출력한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for (Map.Entry<Integer, String> entry : callCodes.entrySet()) {\r\n",
      "     Integer code=entry.getKey();\r\n",
      "     if(code.toString().charAt(0) == '8') {\r\n",
      "         String country = entry.getValue();\r\n",
      "         System.out.printf(\"%s:%s\\n\",code,country);\r\n",
      "         \r\n",
      "     }\r\n",
      " }\r\n",
      "81:Japan\r\n",
      "82:Korea\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for (Map.Entry<Integer, String> entry : callCodes.entrySet()) {\n",
    "    Integer code=entry.getKey();\n",
    "    if(code.toString().charAt(0) == '8') {\n",
    "        String country = entry.getValue();\n",
    "        System.out.printf(\"%s:%s\\n\",code,country);\n",
    "        \n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Iterator를 사용해보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Set<Integer> setCodes = callCodes.keySet();\r\n",
      "|  Modified variable setCodes of type Set<Integer> with initial value [81, 1, 82]\r\n",
      "|    Update overwrote variable setCodes\r\n",
      "\r\n",
      " Iterator<Integer> iterator = setCodes.iterator();\r\n",
      "|  Modified variable iterator of type Iterator<Integer> with initial value java.util.HashMap$KeyIterator@3159c4b8\r\n",
      "|    Update overwrote variable iterator\r\n",
      "\r\n",
      "  \r\n",
      "\r\n",
      " while (iterator.hasNext()) {\r\n",
      "     Integer code = iterator.next();\r\n",
      "     if(code.toString().charAt(0) == '8') {\r\n",
      "         String country = callCodes.get(code);\r\n",
      "         System.out.printf(\"%d:%s\\n\",code,country);\r\n",
      "     }\r\n",
      " }\r\n",
      "81:Japan\r\n",
      "82:Korea\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Set<Integer> setCodes = callCodes.keySet();\n",
    "Iterator<Integer> iterator = setCodes.iterator();\n",
    " \n",
    "while (iterator.hasNext()) {\n",
    "    Integer code = iterator.next();\n",
    "    if(code.toString().charAt(0) == '8') {\n",
    "        String country = callCodes.get(code);\n",
    "        System.out.printf(\"%d:%s\\n\",code,country);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "\n",
    "함수로 만들어 보자.\n",
    "Map getCountries(char region)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Set<Integer> setCodes = callCodes.keySet();\r\n",
      "|  Modified variable setCodes of type Set<Integer> with initial value [81, 1, 82]\r\n",
      "|    Update overwrote variable setCodes\r\n",
      "\r\n",
      " Iterator<Integer> iterator = setCodes.iterator();\r\n",
      "|  Modified variable iterator of type Iterator<Integer> with initial value java.util.HashMap$KeyIterator@4bec1f0c\r\n",
      "|    Update overwrote variable iterator\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " Map getCountries(char region) {\r\n",
      "     Map<Integer, String> countries = new HashMap<Integer, String>();\r\n",
      "     while (iterator.hasNext()) {\r\n",
      "         Integer code = iterator.next();\r\n",
      "         if(code.toString().charAt(0) == region) {\r\n",
      "             String country = callCodes.get(code);\r\n",
      "             countries.put(code,country);\r\n",
      "             System.out.printf(\"%d:%s\\n\",code,country);\r\n",
      "         }\r\n",
      "     }\r\n",
      "     return countries;\r\n",
      " }\r\n",
      "|  Added method getCountries(char)\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " System.out.println(getCountries('8'));\r\n",
      "81:Japan\r\n",
      "82:Korea\r\n",
      "{81=Japan, 82=Korea}\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Set<Integer> setCodes = callCodes.keySet();\n",
    "Iterator<Integer> iterator = setCodes.iterator();\n",
    "\n",
    "Map getCountries(char region) {\n",
    "    Map<Integer, String> countries = new HashMap<Integer, String>();\n",
    "    while (iterator.hasNext()) {\n",
    "        Integer code = iterator.next();\n",
    "        if(code.toString().charAt(0) == region) {\n",
    "            String country = callCodes.get(code);\n",
    "            countries.put(code,country);\n",
    "            System.out.printf(\"%d:%s\\n\",code,country);\n",
    "        }\n",
    "    }\n",
    "    return countries;\n",
    "}\n",
    "\n",
    "System.out.println(getCountries('8'));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 데이터구조-10: 문자열에서 문자를 세기\n",
    "\n",
    "### 문제\n",
    "문자열에서 문자를 세는 기능은 비밀번호 등과 같이 검증하는 목적으로 사용된다.\n",
    "텍스트를 분석할 경우, 문자 또는 단어의 빈도를 세는 것이 반드시 필요하다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 해결\n",
    "\n",
    "문자열을 입력 받아서, 각 문자의 갯수를 계산한다.\n",
    "배열보다 map을 사용한다. 그 이유는 배열은 key가 없고, 정수인덱스로 값을 읽어 오는 특성이므로 매우 불편하다.\n",
    "주의! **존재하지 않는 key의 값을 넣을 경우: +1은 불가능**하다. 없는 값에 '더하기 1'은 안 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"553px\" style=\"width:324px;height:553px;\" version=\"1.1\" viewBox=\"0 0 324 553\" width=\"324px\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"><defs><filter height=\"300%\" id=\"f1\" width=\"300%\" x=\"-1\" y=\"-1\"><feGaussianBlur result=\"blurOut\" stdDeviation=\"2.0\"/><feColorMatrix in=\"blurOut\" result=\"blurOut2\" type=\"matrix\" values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 .4 0\"/><feOffset dx=\"4.0\" dy=\"4.0\" in=\"blurOut2\" result=\"blurOut3\"/><feBlend in=\"SourceGraphic\" in2=\"blurOut3\" mode=\"normal\"/></filter></defs><g><ellipse cx=\"141.5\" cy=\"20\" fill=\"#000000\" filter=\"url(#f1)\" rx=\"10\" ry=\"10\" style=\"stroke: none; stroke-width: 1.0;\"/><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"34.1328\" rx=\"12.5\" ry=\"12.5\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"209\" x=\"37\" y=\"50\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"189\" x=\"47\" y=\"71.6016\">set word='sangmyung university'</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"34.1328\" rx=\"12.5\" ry=\"12.5\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"127\" x=\"78\" y=\"104.1328\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"107\" x=\"88\" y=\"125.7344\">initialize dictionary</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"34.1328\" rx=\"12.5\" ry=\"12.5\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"49\" x=\"117\" y=\"158.2656\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"29\" x=\"127\" y=\"179.8672\">i = 0</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"34.1328\" rx=\"12.5\" ry=\"12.5\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"149\" x=\"67\" y=\"256.3984\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"129\" x=\"77\" y=\"278\">get ith char from word</text><polygon fill=\"#FEFECE\" filter=\"url(#f1)\" points=\"70,310.5313,213,310.5313,225,322.5313,213,334.5313,70,334.5313,58,322.5313,70,310.5313\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"143\" x=\"70\" y=\"326.6885\">char does not exist in keys</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"34.1328\" rx=\"12.5\" ry=\"12.5\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"76\" x=\"10\" y=\"344.5313\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"56\" x=\"20\" y=\"366.1328\">value = 1</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"34.1328\" rx=\"12.5\" ry=\"12.5\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"124\" x=\"173\" y=\"344.5313\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"104\" x=\"183\" y=\"366.1328\">value = value + 1</text><polygon fill=\"#FEFECE\" filter=\"url(#f1)\" points=\"141.5,384.6641,153.5,396.6641,141.5,408.6641,129.5,396.6641,141.5,384.6641\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"34.1328\" rx=\"12.5\" ry=\"12.5\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"77\" x=\"103\" y=\"428.6641\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"57\" x=\"113\" y=\"450.2656\">add 1 to i</text><polygon fill=\"#FEFECE\" filter=\"url(#f1)\" points=\"141.5,212.3984,153.5,224.3984,141.5,236.3984,129.5,224.3984,141.5,212.3984\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><polygon fill=\"#FEFECE\" filter=\"url(#f1)\" points=\"83,482.7969,200,482.7969,212,494.7969,200,506.7969,83,506.7969,71,494.7969,83,482.7969\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"117\" x=\"83\" y=\"498.9541\">i &lt;= last char of word</text><ellipse cx=\"141.5\" cy=\"536.7969\" fill=\"none\" filter=\"url(#f1)\" rx=\"10\" ry=\"10\" style=\"stroke: #000000; stroke-width: 1.0;\"/><ellipse cx=\"142\" cy=\"537.2969\" fill=\"#000000\" filter=\"url(#f1)\" rx=\"6\" ry=\"6\" style=\"stroke: none; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"141.5\" x2=\"141.5\" y1=\"30\" y2=\"50\"/><polygon fill=\"#A80036\" points=\"137.5,40,141.5,50,145.5,40,141.5,44\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"141.5\" x2=\"141.5\" y1=\"84.1328\" y2=\"104.1328\"/><polygon fill=\"#A80036\" points=\"137.5,94.1328,141.5,104.1328,145.5,94.1328,141.5,98.1328\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"141.5\" x2=\"141.5\" y1=\"138.2656\" y2=\"158.2656\"/><polygon fill=\"#A80036\" points=\"137.5,148.2656,141.5,158.2656,145.5,148.2656,141.5,152.2656\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"58\" x2=\"48\" y1=\"322.5313\" y2=\"322.5313\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"48\" x2=\"48\" y1=\"322.5313\" y2=\"344.5313\"/><polygon fill=\"#A80036\" points=\"44,334.5313,48,344.5313,52,334.5313,48,338.5313\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"225\" x2=\"235\" y1=\"322.5313\" y2=\"322.5313\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"235\" x2=\"235\" y1=\"322.5313\" y2=\"344.5313\"/><polygon fill=\"#A80036\" points=\"231,334.5313,235,344.5313,239,334.5313,235,338.5313\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"48\" x2=\"48\" y1=\"378.6641\" y2=\"396.6641\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"48\" x2=\"129.5\" y1=\"396.6641\" y2=\"396.6641\"/><polygon fill=\"#A80036\" points=\"119.5,392.6641,129.5,396.6641,119.5,400.6641,123.5,396.6641\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"235\" x2=\"235\" y1=\"378.6641\" y2=\"396.6641\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"235\" x2=\"153.5\" y1=\"396.6641\" y2=\"396.6641\"/><polygon fill=\"#A80036\" points=\"163.5,392.6641,153.5,396.6641,163.5,400.6641,159.5,396.6641\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"141.5\" x2=\"141.5\" y1=\"290.5313\" y2=\"310.5313\"/><polygon fill=\"#A80036\" points=\"137.5,300.5313,141.5,310.5313,145.5,300.5313,141.5,304.5313\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"141.5\" x2=\"141.5\" y1=\"408.6641\" y2=\"428.6641\"/><polygon fill=\"#A80036\" points=\"137.5,418.6641,141.5,428.6641,145.5,418.6641,141.5,422.6641\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"141.5\" x2=\"141.5\" y1=\"236.3984\" y2=\"256.3984\"/><polygon fill=\"#A80036\" points=\"137.5,246.3984,141.5,256.3984,145.5,246.3984,141.5,250.3984\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"212\" x2=\"319\" y1=\"494.7969\" y2=\"494.7969\"/><polygon fill=\"#A80036\" points=\"315,393.5977,319,383.5977,323,393.5977,319,389.5977\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"319\" x2=\"319\" y1=\"224.3984\" y2=\"494.7969\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"319\" x2=\"153.5\" y1=\"224.3984\" y2=\"224.3984\"/><polygon fill=\"#A80036\" points=\"163.5,220.3984,153.5,224.3984,163.5,228.3984,159.5,224.3984\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"141.5\" x2=\"141.5\" y1=\"462.7969\" y2=\"482.7969\"/><polygon fill=\"#A80036\" points=\"137.5,472.7969,141.5,482.7969,145.5,472.7969,141.5,476.7969\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"141.5\" x2=\"141.5\" y1=\"192.3984\" y2=\"212.3984\"/><polygon fill=\"#A80036\" points=\"137.5,202.3984,141.5,212.3984,145.5,202.3984,141.5,206.3984\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"141.5\" x2=\"141.5\" y1=\"506.7969\" y2=\"526.7969\"/><polygon fill=\"#A80036\" points=\"137.5,516.7969,141.5,526.7969,145.5,516.7969,141.5,520.7969\" style=\"stroke: #A80036; stroke-width: 1.0;\"/></g></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "start\n",
    ":set word='sangmyung university';\n",
    ":initialize dictionary;\n",
    ":i = 0;\n",
    "repeat\n",
    ":get ith char from word;\n",
    "if (char does not exist in keys)\n",
    ":value = 1;\n",
    "else\n",
    ":value = value + 1;\n",
    "endif\n",
    ":add 1 to i;\n",
    "repeat while(i <= last char of word)\n",
    "stop\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 문자열의 문자 갯수 세기\n",
    "\n",
    "* 문자 갯수를 세려면, 문자열을 문자로 분리한다.\n",
    "* 분리한 문자열의 문자갯수를 세기\n",
    "    * 문자를 키, 문자의 갯수를 값으로 저장하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " String[] words = \"He and his brother playing football.\".split(\"\\\\s+\");\r\n",
      "|  Added variable words of type String[] with initial value [Ljava.lang.String;@57fffcd7\r\n",
      "\r\n",
      " for (int i = 0; i < words.length-1; i++)\r\n",
      "         System.out.println(words[i] + \" \" + words[i + 1]);\r\n",
      "He and\r\n",
      "and his\r\n",
      "his brother\r\n",
      "brother playing\r\n",
      "playing football.\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "String[] words = \"He and his brother playing football.\".split(\"\\\\s+\");\n",
    "for (int i = 0; i < words.length-1; i++)\n",
    "        System.out.println(words[i] + \" \" + words[i + 1]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " String[] words = \"Sangmyung university.\".split(\"\\\\s+\");\r\n",
      "|  Modified variable words of type String[] with initial value [Ljava.lang.String;@490ab905\r\n",
      "|    Update overwrote variable words\r\n",
      "\r\n",
      " for (int i = 0;i<words.length; i++)\r\n",
      "         System.out.println(words[i]);\r\n",
      "Sangmyung\r\n",
      "university.\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "String[] words = \"Sangmyung university.\".split(\"\\\\s+\");\n",
    "for (int i = 0;i<words.length; i++)\n",
    "        System.out.println(words[i]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " char[] letters = \"sangmyung university\".toCharArray();\r\n",
      "|  Modified variable letters of type char[] with initial value [C@64bfbc86\r\n",
      "|    Update overwrote variable letters\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "char[] letters = \"sangmyung university\".toCharArray();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for(char c:letters)\n",
    "    System.out.println(c);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Map 으로 단어빈도 계산\n",
    "\n",
    "Map의 키는 **원시 타잎을 사용할 수 없다**. 내부적으로 객체를 사용하여 키를 생성하기 때문이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Map<char, int> m = new HashMap<char, int>();\r\n",
      "|  Error:\r\n",
      "|  unexpected type\r\n",
      "|    required: reference\r\n",
      "|    found:    char\r\n",
      "|  Map<char, int> m = new HashMap<char, int>();\r\n",
      "|      ^--^\r\n",
      "|  Error:\r\n",
      "|  unexpected type\r\n",
      "|    required: reference\r\n",
      "|    found:    int\r\n",
      "|  Map<char, int> m = new HashMap<char, int>();\r\n",
      "|            ^-^\r\n",
      "|  Error:\r\n",
      "|  unexpected type\r\n",
      "|    required: reference\r\n",
      "|    found:    char\r\n",
      "|  Map<char, int> m = new HashMap<char, int>();\r\n",
      "|                                 ^--^\r\n",
      "|  Error:\r\n",
      "|  unexpected type\r\n",
      "|    required: reference\r\n",
      "|    found:    int\r\n",
      "|  Map<char, int> m = new HashMap<char, int>();\r\n",
      "|                                       ^-^\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Map<char, int> m = new HashMap<char, int>();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Map으로 단어빈도를 계산하는 프로그램을 만들어 보자.\n",
    "\n",
    "줄 | 설명\n",
    "-----|-----\n",
    "1 | key,value의 Map생성\n",
    "2 | 문자열을 문자배열로 변환\n",
    "4 | 문자별로 반복\n",
    "5 | 문자는 equals()를 사용할 수 없으므로, 문자열로 변환해서 equals()\n",
    "6 ~ 10 | 키가 있으면 현재 키 값에 +1, 없으면 1<br>map의 **```containsKey(키)```**, map의 **```get(키)```**를 사용한다 (아래)\n",
    "\n",
    "```java\n",
    "if (wc.containsKey(\"s\")) {\n",
    "    wc.put(\"s\",wc.get(\"s\")+1);\n",
    "}\n",
    "```\n",
    "\n",
    "* java 8\n",
    "```java\n",
    "Map<String, Integer> words = new HashMap<>();\n",
    "words.put(\"hello\", 3);\n",
    "words.put(\"world\", 4);\n",
    "words.computeIfPresent(\"hello\", (k, v) -> v + 1);\n",
    "System.out.println(words.get(\"hello\"));\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Map<String, Integer> wc = new HashMap<String, Integer>();\r\n",
      "|  Modified variable wc of type Map<String, Integer> with initial value {}\r\n",
      "|    Update overwrote variable wc\r\n",
      "\r\n",
      " char[] letters = \"sangmyung university\".toCharArray();\r\n",
      "|  Added variable letters of type char[] with initial value [C@5f2108b5\r\n",
      "\r\n",
      " String s;\r\n",
      "|  Added variable s of type String\r\n",
      "\r\n",
      " for(char c:letters) {\r\n",
      "     s=Character.toString(c);\r\n",
      "     //System.out.printf(\"%c %s\\n\",c,s);\r\n",
      "     if (wc.containsKey(s)) {\r\n",
      "         wc.put(s,wc.get(s)+1);\r\n",
      "     } else {\r\n",
      "         wc.put(s,1);\r\n",
      "     }\r\n",
      " }\r\n",
      "\r\n",
      " System.out.print(wc);\r\n",
      "{ =1, a=1, e=1, g=2, i=2, m=1, n=3, r=1, s=2, t=1, u=2, v=1, y=2}\r\n"
     ]
    }
   ],
   "source": [
    "Map<String, Integer> wc = new HashMap<String, Integer>();\n",
    "char[] letters = \"sangmyung university\".toCharArray();\n",
    "String s;\n",
    "for(char c:letters) {\n",
    "    s=Character.toString(c);\n",
    "    //System.out.printf(\"%c %s\\n\",c,s);\n",
    "    if (wc.containsKey(s)) {\n",
    "        wc.put(s,wc.get(s)+1);\n",
    "    } else {\n",
    "        wc.put(s,1);\n",
    "    }\n",
    "}\n",
    "System.out.print(wc);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Map countChars(String str) {\r\n",
      "     Map<String, Integer> wc = new HashMap<String, Integer>();\r\n",
      "     char[] letters = str.toCharArray();\r\n",
      "     String s;\r\n",
      "     for(char c:letters) {\r\n",
      "         s=Character.toString(c);\r\n",
      "         //System.out.printf(\"%c %s\\n\",c,s);\r\n",
      "         if (wc.containsKey(s)) {\r\n",
      "             wc.put(s,wc.get(s)+1);\r\n",
      "         } else {\r\n",
      "             wc.put(s,1);\r\n",
      "         }\r\n",
      "     }\r\n",
      "     return wc;\r\n",
      " }\r\n",
      "|  Added method countChars(String)\r\n",
      "\r\n",
      " System.out.print(countChars(\"sangmyung university\"));\r\n",
      "{ =1, a=1, e=1, g=2, i=2, m=1, n=3, r=1, s=2, t=1, u=2, v=1, y=2}\r\n",
      " System.out.print(countChars(\"Seoul is so beautiful and lovely\"));\r\n",
      "{ =5, a=2, b=1, d=1, e=3, f=1, i=2, l=4, n=1, o=3, S=1, s=2, t=1, u=3, v=1, y=1}\r\n"
     ]
    }
   ],
   "source": [
    "Map countChars(String str) {\n",
    "    Map<String, Integer> wc = new HashMap<String, Integer>();\n",
    "    char[] letters = str.toCharArray();\n",
    "    String s;\n",
    "    for(char c:letters) {\n",
    "        s=Character.toString(c);\n",
    "        //System.out.printf(\"%c %s\\n\",c,s);\n",
    "        if (wc.containsKey(s)) {\n",
    "            wc.put(s,wc.get(s)+1);\n",
    "        } else {\n",
    "            wc.put(s,1);\n",
    "        }\n",
    "    }\n",
    "    return wc;\n",
    "}\n",
    "System.out.print(countChars(\"sangmyung university\"));\n",
    "System.out.print(countChars(\"Seoul is so beautiful and lovely\"));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 데이터구조-11: 문자열에 포함된 문자와 숫자의 개수 세기\n",
    "\n",
    "### 문제\n",
    "문자열을 입력받고, 그 문자열에 포함된 숫자, 문자를 구분하여 저장하기\n",
    "\n",
    "### 해결\n",
    "컴퓨터가 문자를 식별하는 방식을 이해한다.\n",
    "key, value를 사용하여 빈도를 계산할 수 있다.\n",
    "함수:\n",
    "* 함수명 countDigitsLetters\n",
    "* 입력 문자열 word\n",
    "* 출력 HashMap"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Character.isDigit()\n",
    "\n",
    "문자가 숫자Digit인지 아닌지 판별한다.\n",
    "아래 'c'는 문자이므로 false, '5'는 true이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " System.out.println(Character.isDigit('c'));\r\n",
      "false\r\n",
      "\r\n",
      " System.out.println(Character.isDigit('5'));\r\n",
      "true\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "System.out.println(Character.isDigit('c'));\n",
    "System.out.println(Character.isDigit('5'));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Map<String, Integer> wc = new HashMap<String, Integer>();\r\n",
      "|  Added variable wc of type Map<String, Integer> with initial value {}\r\n",
      "\r\n",
      " char[] letters = \"sangmyung1 university2\".toCharArray();\r\n",
      "|  Added variable letters of type char[] with initial value [C@31ef45e3\r\n",
      "\r\n",
      " String s;\r\n",
      "|  Added variable s of type String\r\n",
      "\r\n",
      " String keyName;\r\n",
      "|  Added variable keyName of type String\r\n",
      "\r\n",
      " for(char c:letters) {\r\n",
      "     if(Character.isDigit(c)) {\r\n",
      "         keyName=\"DIGITS\";\r\n",
      "     } else {\r\n",
      "         keyName=\"LETTERS\";\r\n",
      "     }\r\n",
      "     s=Character.toString(c);\r\n",
      "     //System.out.printf(\"%c %s\\n\",c,s);\r\n",
      "     if (wc.containsKey(keyName)) {\r\n",
      "         wc.put(keyName,wc.get(keyName)+1);\r\n",
      "     } else {\r\n",
      "         wc.put(keyName,1);\r\n",
      "     }\r\n",
      " }\r\n",
      "\r\n",
      " System.out.print(wc);\r\n",
      "{LETTERS=20, DIGITS=2}\r\n"
     ]
    }
   ],
   "source": [
    "Map<String, Integer> wc = new HashMap<String, Integer>();\n",
    "char[] letters = \"sangmyung1 university2\".toCharArray();\n",
    "String s;\n",
    "String keyName;\n",
    "for(char c:letters) {\n",
    "    if(Character.isDigit(c)) {\n",
    "        keyName=\"DIGITS\";\n",
    "    } else {\n",
    "        keyName=\"LETTERS\";\n",
    "    }\n",
    "    s=Character.toString(c);\n",
    "    //System.out.printf(\"%c %s\\n\",c,s);\n",
    "    if (wc.containsKey(keyName)) {\n",
    "        wc.put(keyName,wc.get(keyName)+1);\n",
    "    } else {\n",
    "        wc.put(keyName,1);\n",
    "    }\n",
    "}\n",
    "System.out.print(wc);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### isDigit()의 구현원리\n",
    "\n",
    "* ascii문자표의 숫자 영역(48-57)에 있는지 확인\n",
    "* space 코드 값은 32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " char character = \"hello\".charAt(0);\r\n",
      "|  Modified variable character of type char with initial value 'h'\r\n",
      "|    Update overwrote variable character\r\n",
      "\r\n",
      " int ascii = (int) character;\r\n",
      "|  Modified variable ascii of type int with initial value 104\r\n",
      "|    Update overwrote variable ascii\r\n",
      "\r\n",
      " ascii;\r\n",
      "|  Variable ascii of type int has value 104\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "char character = \"hello\".charAt(0);\n",
    "int ascii = (int) character;\n",
    "ascii;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 대소문자의 변환원리는 32를 더하거나 뺀다.\n",
    "* 소문자 'a'의 코드 값은 97, 대문자 'A'는 65이다.\n",
    "* ord, chr함수를 이용하면 코드 값을 확인할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " (int) 'a';\r\n",
      "|  Expression value is: 97\r\n",
      "|    assigned to temporary variable $9 of type int\r\n",
      "\r\n",
      " (int) 'A';\r\n",
      "|  Expression value is: 65\r\n",
      "|    assigned to temporary variable $10 of type int\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "(int) 'a';\n",
    "(int) 'A';"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " (char) 97;\r\n",
      "|  Expression value is: 'a'\r\n",
      "|    assigned to temporary variable $11 of type char\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "(char) 97;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " (char) (int)'A'+32;\r\n",
      "|  Expression value is: 97\r\n",
      "|    assigned to temporary variable $12 of type int\r\n",
      "\r\n",
      " //print chr(ord('a')-32)\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "(char) (int)'A'+32;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " (int)' ';\r\n",
      "|  Expression value is: 32\r\n",
      "|    assigned to temporary variable $1 of type int\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "(int)' ';"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "65부터 97까지의 정수에 해당하는 문자를 **```%c```**로 형식을 맞추어 출력한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(int i=65;i<97;i++)\r\n",
      "     System.out.printf(\"%c\",i);\r\n",
      "ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`\r\n"
     ]
    }
   ],
   "source": [
    "for(int i=65;i<97;i++)\n",
    "    System.out.printf(\"%c\",i);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " String letters = \"sangmyung university\";\r\n",
      "|  Modified variable letters of type String with initial value \"sangmyung university\"\r\n",
      "|    Update overwrote variable letters\r\n",
      "\r\n",
      " char character;\r\n",
      "|  Modified variable character of type char\r\n",
      "|    Update overwrote variable character\r\n",
      "\r\n",
      " int ascii;\r\n",
      "|  Modified variable ascii of type int\r\n",
      "|    Update overwrote variable ascii\r\n",
      "\r\n",
      " for(int i=0;i<letters.length();i++) {\r\n",
      "     char character = letters.charAt(i);\r\n",
      "     int ascii = (int) character;\r\n",
      "     System.out.printf(\"%c:%d \",character,ascii);\r\n",
      " }\r\n",
      "s:115 a:97 n:110 g:103 m:109 y:121 u:117 n:110 g:103  :32 u:117 n:110 i:105 v:118 e:101 r:114 s:115 i:105 t:116 y:121 \r\n"
     ]
    }
   ],
   "source": [
    "String letters = \"sangmyung university\";\n",
    "char character;\n",
    "int ascii;\n",
    "for(int i=0;i<letters.length();i++) {\n",
    "    char character = letters.charAt(i);\n",
    "    int ascii = (int) character;\n",
    "    System.out.printf(\"%c:%d \",character,ascii);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 문자열, 숫자를 저장하는 ArrayList 생성\n",
    "\n",
    "구분 | 설명 | 사용\n",
    "-----|-----|-----\n",
    "배열 | 갯수를 알 수 없으므로, 배열을 사용하지 않는다. | No\n",
    "ArrayList<int>, ArrayList<char> | 원시타잎은 허용 불가 | No\n",
    "ArrayList<Integer>, ArrayList<String> | 숫자 및 문자열을 저장하는 ArrayList | Yes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " int[] numList=new int[];\r\n",
      "|  Error:\r\n",
      "|  array dimension missing\r\n",
      "|  int[] numList=new int[];\r\n",
      "|                ^-------^\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "int[] numList=new int[];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " int[] numList=new int[3];\r\n",
      "|  Modified variable numList of type int[] with initial value [I@4566e5bd\r\n",
      "|    Update overwrote variable numList\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "int[] numList=new int[3];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* ArrayList에는 원시 타잎을 넣지 못한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ArrayList<int> numList=new ArrayList<int>();\r\n",
      "|  Error:\r\n",
      "|  unexpected type\r\n",
      "|    required: reference\r\n",
      "|    found:    int\r\n",
      "|  ArrayList<int> numList=new ArrayList<int>();\r\n",
      "|            ^-^\r\n",
      "|  Error:\r\n",
      "|  unexpected type\r\n",
      "|    required: reference\r\n",
      "|    found:    int\r\n",
      "|  ArrayList<int> numList=new ArrayList<int>();\r\n",
      "|                                       ^-^\r\n",
      "\r\n",
      " ArrayList<char> charList=new ArrayList<char>();\r\n",
      "|  Error:\r\n",
      "|  unexpected type\r\n",
      "|    required: reference\r\n",
      "|    found:    char\r\n",
      "|  ArrayList<char> charList=new ArrayList<char>();\r\n",
      "|            ^--^\r\n",
      "|  Error:\r\n",
      "|  unexpected type\r\n",
      "|    required: reference\r\n",
      "|    found:    char\r\n",
      "|  ArrayList<char> charList=new ArrayList<char>();\r\n",
      "|                                         ^--^\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "ArrayList<int> numList=new ArrayList<int>();\n",
    "ArrayList<char> charList=new ArrayList<char>();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ArrayList<Integer> numList=new ArrayList<Integer>();\r\n",
      "|  Replaced variable numList of type ArrayList<Integer> with initial value []\r\n",
      "|    Update overwrote variable numList\r\n",
      "\r\n",
      " ArrayList<String> charList=new ArrayList<String>();\r\n",
      "|  Added variable charList of type ArrayList<String> with initial value []\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "ArrayList<Integer> numList=new ArrayList<Integer>();\n",
    "ArrayList<String> charList=new ArrayList<String>();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 문자, 숫자 빈도를 저장하는 Map 생성\n",
    "\n",
    "문자, 숫자 빈도를 집계한다. 결과는 아래와 같이 key,value로 출력할 수 있다.\n",
    "\n",
    "```java\n",
    "LETTERS=9, DIGITS=6\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Map<String, Integer> wc = new HashMap<String, Integer>();\r\n",
      "|  Added variable wc of type Map<String, Integer> with initial value {}\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Map<String, Integer> wc = new HashMap<String, Integer>();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* isDigit대신 ascii 값으로 분별한다. \n",
    "    * 48~57 수 (0~9)\n",
    "    * 65~90 대문자\n",
    "    * 97~122 소문자"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 데이터 형 변환에 주의한다.\n",
    "\n",
    "구분 | 설명 | 예제\n",
    "-----|-----|-----|\n",
    "String -> char | 문자열을 문자로 변환 | \"hello\".toCharArray()\n",
    "char -> String | 문자를 문자열로 변환 | Character.toString('a')\n",
    "char -> int | '수' 문자를 '수'로 변환 | Character.getNumericValue('1')\n",
    "int -> Integer | 원시타잎을 클래스로 변환 | autoboxing 1 -> Integer(1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Character.getNumericValue('1');\r\n",
      "|  Expression value is: 1\r\n",
      "|    assigned to temporary variable $35 of type int\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Character.getNumericValue('1');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Map<String, Integer> wc = new HashMap<String, Integer>();\r\n",
      "|  Modified variable wc of type Map<String, Integer> with initial value {}\r\n",
      "|    Update overwrote variable wc\r\n",
      "\r\n",
      " ArrayList<Integer> numList=new ArrayList<Integer>();\r\n",
      "|  Modified variable numList of type ArrayList<Integer> with initial value []\r\n",
      "|    Update overwrote variable numList\r\n",
      "\r\n",
      " ArrayList<String> charList=new ArrayList<String>();\r\n",
      "|  Modified variable charList of type ArrayList<String> with initial value []\r\n",
      "|    Update overwrote variable charList\r\n",
      "\r\n",
      " String s;\r\n",
      "|  Modified variable s of type String\r\n",
      "|    Update overwrote variable s\r\n",
      "\r\n",
      " String s=\"hello123with456\";\r\n",
      "|  Modified variable s of type String with initial value \"hello123with456\"\r\n",
      "|    Update overwrote variable s\r\n",
      "\r\n",
      " char[] letters = s.toCharArray();\r\n",
      "|  Modified variable letters of type char[] with initial value [C@5702b3b1\r\n",
      "|    Update overwrote variable letters\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " String keyName;\r\n",
      "|  Modified variable keyName of type String\r\n",
      "|    Update overwrote variable keyName\r\n",
      "\r\n",
      " int ascii;\r\n",
      "|  Modified variable ascii of type int\r\n",
      "|    Update overwrote variable ascii\r\n",
      "\r\n",
      " for(char c:letters) {\r\n",
      "     ascii=(int)c;\r\n",
      "     //print c,asciicode\r\n",
      "     if (ascii>=48 && ascii<=57) {\r\n",
      "         keyName=\"DIGITS\";\r\n",
      "         numList.add(Character.getNumericValue(c));\r\n",
      "     } else if (ascii>=65 && ascii<=90 || ascii>=97 && ascii<=122) {\r\n",
      "         keyName=\"LETTERS\";\r\n",
      "         charList.add(Character.toString(c)); \r\n",
      "     }\r\n",
      "     s=Character.toString(c);\r\n",
      "     //System.out.printf(\"%c %s\\n\",c,s);\r\n",
      "     if (wc.containsKey(keyName)) {\r\n",
      "         wc.put(keyName,wc.get(keyName)+1);\r\n",
      "     } else {\r\n",
      "         wc.put(keyName,1);\r\n",
      "     }\r\n",
      " }\r\n",
      "\r\n",
      " System.out.print(wc);\r\n",
      "{LETTERS=9, DIGITS=6}\r\n",
      " System.out.print(numList);\r\n",
      "[1, 2, 3, 4, 5, 6]\r\n",
      " System.out.print(charList);\r\n",
      "[h, e, l, l, o, w, i, t, h]\r\n"
     ]
    }
   ],
   "source": [
    "Map<String, Integer> wc = new HashMap<String, Integer>();\n",
    "ArrayList<Integer> numList=new ArrayList<Integer>();\n",
    "ArrayList<String> charList=new ArrayList<String>();\n",
    "\n",
    "String s=\"hello123with456\";\n",
    "char[] letters = s.toCharArray();\n",
    "\n",
    "String keyName;\n",
    "int ascii;\n",
    "for(char c:letters) {\n",
    "    ascii=(int)c;\n",
    "    //print c,asciicode\n",
    "    if (ascii>=48 && ascii<=57) {\n",
    "        keyName=\"DIGITS\";\n",
    "        numList.add(Character.getaNumericValue(c));\n",
    "    } else if (ascii>=65 && ascii<=90 || ascii>=97 && ascii<=122) {\n",
    "        keyName=\"LETTERS\";\n",
    "        charList.add(Character.toString(c)); \n",
    "    }\n",
    "    s=Character.toString(c);\n",
    "    //System.out.printf(\"%c %s\\n\",c,s);\n",
    "    if (wc.containsKey(keyName)) {\n",
    "        wc.put(keyName,wc.get(keyName)+1);\n",
    "    } else {\n",
    "        wc.put(keyName,1);\n",
    "    }\n",
    "}\n",
    "System.out.print(wc);\n",
    "System.out.print(numList);\n",
    "System.out.print(charList);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 대소문자 판별\n",
    "\n",
    "* 문자의 대소문자를 판별한다.\n",
    "* 문자는 single quotation을 사용한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Character.isUpperCase('A');\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $1 of type boolean\r\n",
      "\r\n",
      " Character.isLowerCase('a');\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $2 of type boolean\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Character.isUpperCase('A');\n",
    "Character.isLowerCase('a');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 주의: 문자열을 문자로 변환하면 '수'도 문자가 된다.\n",
    "* 문자열에 수가 있는지 isDigit()을 사용한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " !Character.isDigit('1');\r\n",
      "|  Expression value is: false\r\n",
      "|    assigned to temporary variable $23 of type boolean\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Character.isDigit('1');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " String s=\"hello123with456 HELLO\";\r\n",
      "|  Modified variable s of type String with initial value \"hello123with456 HELLO\"\r\n",
      "|    Update overwrote variable s\r\n",
      "\r\n",
      " char[] letters = s.toCharArray();\r\n",
      "|  Modified variable letters of type char[] with initial value [C@5cb9f472\r\n",
      "|    Update overwrote variable letters\r\n",
      "\r\n",
      " for(char c:letters) {\r\n",
      "     if (Character.isDigit(c)) {\r\n",
      "         System.out.printf(\"%c\",c);\r\n",
      "     }\r\n",
      " }\r\n",
      "123456\r\n"
     ]
    }
   ],
   "source": [
    "String s=\"hello123with456 HELLO\";\n",
    "char[] letters = s.toCharArray();\n",
    "for(char c:letters) {\n",
    "    if (Character.isDigit(c)) {\n",
    "        System.out.printf(\"%c\",c);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " String s=\"hello123with456 HELLO\";\r\n",
      "|  Modified variable s of type String with initial value \"hello123with456 HELLO\"\r\n",
      "|    Update overwrote variable s\r\n",
      "\r\n",
      " char[] letters = s.toCharArray();\r\n",
      "|  Modified variable letters of type char[] with initial value [C@5025a98f\r\n",
      "|    Update overwrote variable letters\r\n",
      "\r\n",
      " for(char c:letters) {\r\n",
      "     if (!Character.isDigit(c) && Character.isUpperCase(c)) {\r\n",
      "         System.out.printf(\"1 %c\\n\",c);\r\n",
      "     } else if (!Character.isDigit(c) && Character.isLowerCase(c)) {\r\n",
      "         System.out.printf(\"2 %c\\n\",c);\r\n",
      "     }\r\n",
      " }\r\n",
      "2 h\r\n",
      "2 e\r\n",
      "2 l\r\n",
      "2 l\r\n",
      "2 o\r\n",
      "2 w\r\n",
      "2 i\r\n",
      "2 t\r\n",
      "2 h\r\n",
      "1 H\r\n",
      "1 E\r\n",
      "1 L\r\n",
      "1 L\r\n",
      "1 O\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "String s=\"hello123with456 HELLO\";\n",
    "char[] letters = s.toCharArray();\n",
    "for(char c:letters) {\n",
    "    if (!Character.isDigit(c) && Character.isUpperCase(c)) {\n",
    "        System.out.printf(\"1 %c\\n\",c);\n",
    "    } else if (!Character.isDigit(c) && Character.isLowerCase(c)) {\n",
    "        System.out.printf(\"2 %c\\n\",c);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 왜 소문자가 16개 - '수'까지 포함??"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Map<String, Integer> wc = new HashMap<String, Integer>();\r\n",
      "|  Modified variable wc of type Map<String, Integer> with initial value {}\r\n",
      "|    Update overwrote variable wc\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " String s=\"hello123with456 HELLO\";\r\n",
      "|  Modified variable s of type String with initial value \"hello123with456 HELLO\"\r\n",
      "|    Update overwrote variable s\r\n",
      "\r\n",
      " char[] letters = s.toCharArray();\r\n",
      "|  Modified variable letters of type char[] with initial value [C@72d818d1\r\n",
      "|    Update overwrote variable letters\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " String keyName;\r\n",
      "|  Modified variable keyName of type String\r\n",
      "|    Update overwrote variable keyName\r\n",
      "\r\n",
      " for(char c:letters) {\r\n",
      "     if (!Character.isDigit(c) && Character.isUpperCase(c)) {\r\n",
      "         keyName=\"UPPER\";\r\n",
      "     } else if (!Character.isDigit(c) && Character.isLowerCase(c)) {\r\n",
      "         keyName=\"LOWER\";\r\n",
      "     }\r\n",
      "     s=Character.toString(c);\r\n",
      "     if (wc.containsKey(keyName)) {\r\n",
      "         wc.put(keyName,wc.get(keyName)+1);\r\n",
      "     } else {\r\n",
      "         wc.put(keyName,1);\r\n",
      "     }\r\n",
      " }\r\n",
      "\r\n",
      " System.out.print(wc);\r\n",
      "{UPPER=5, LOWER=16}\r\n"
     ]
    }
   ],
   "source": [
    "Map<String, Integer> wc = new HashMap<String, Integer>();\n",
    "\n",
    "String s=\"hello123with456 HELLO\";\n",
    "char[] letters = s.toCharArray();\n",
    "\n",
    "String keyName;\n",
    "for(char c:letters) {\n",
    "    if (!Character.isDigit(c) && Character.isUpperCase(c)) {\n",
    "        keyName=\"UPPER\";\n",
    "    } else if (!Character.isDigit(c) && Character.isLowerCase(c)) {\n",
    "        keyName=\"LOWER\";\n",
    "    }\n",
    "    s=Character.toString(c);\n",
    "    if (wc.containsKey(keyName)) {\n",
    "        wc.put(keyName,wc.get(keyName)+1);\n",
    "    } else {\n",
    "        wc.put(keyName,1);\n",
    "    }\n",
    "}\n",
    "System.out.print(wc);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 데이터구조-12: 서울 경복궁 입구에서 제일 가까운 지하철 역 찾기\n",
    "\n",
    "* 지도에서 경복궁과 인근 지하철역 5개의 위치를 수집한다.\n",
    "* 거리 계산을 하여, 경복궁과 제일 가까운 역을 찾는다.\n",
    "\n",
    "* 프로그래밍 요소\n",
    "    * 배열을 사용할 수 있다.\n",
    "    * 위치를 배열로 가진 2차원 구조를 사용할 수 있다.\n",
    "    * 거리 계산을 할 수 있다.\n",
    "    * 최소 값을 구할 수 있다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 좌표 구하기 - 구글 지도 > 마우스 오른쪽 버튼 > 화면 하단에 좌표 표시됨.\n",
    "    * 경복궁 ky 37.575869, 126.976637\n",
    "    * 안국역 ak 37.576549, 126.985520\n",
    "    * 광화문역 kw 37.571618, 126.976551\n",
    "    * 독립문역 37.574577, 126.957754"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 2차원 구조는 가로축, 세로축이 있는 2차원 데이터 구조\n",
    "* 반복문을 이용하여 세로축 출력하기\n",
    "* 반복문은 파이프에 자료를 넣고 꺼내는 것으로 이해\n",
    "    * 첫째 반복문은 위치객체가 파이프에 차례로 들어간다\n",
    "        * 따라서 위치 (X,Y)의 각 값을 얻기 위해서 인덱스를 사용해야 한다.\n",
    "    * 두번째는 인덱스가 파이프에 들어가 있다고 생각하면 된다.\n",
    "        * 따라서 인덱스를 중첩해서 자료를 꺼내온다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* (1,2) (3,4)의 거리\n",
    "\n",
    "```java\n",
    "Math.sqrt((1-3)**2 + (2-4)**2)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "37.575869\n",
      "[(37.576549, 126.98552), (37.571618, 126.976551), (37.574577, 126.957754)]\n",
      "[0.008908989224370846, 0.004251869823967939, 0.018927148570244013]\n",
      "0.00425186982397\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "#위치측정\n",
    "myloc=(37.575869, 126.976637)\n",
    "print myloc[0]\n",
    "locations=[(37.576549, 126.985520),\n",
    "    (37.571618, 126.976551),\n",
    "    (37.574577, 126.957754)]\n",
    "print locations\n",
    "\n",
    "#거리 측정\n",
    "dist=[]\n",
    "for (x,y) in locations:\n",
    "    dist.append(math.sqrt((myloc[0]-x)**2 + (myloc[1]-y)**2))\n",
    "print dist\n",
    "\n",
    "# 최소값\n",
    "print min(dist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.00425186982397\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "def getNearLocation(myLoc,locations):\n",
    "    #거리 측정\n",
    "    dist=[]\n",
    "    for (x,y) in locations:\n",
    "        dist.append(math.sqrt((myloc[0]-x)**2 + (myloc[1]-y)**2))\n",
    "    return min(dist)\n",
    "myLoc=(37.575869, 126.976637)\n",
    "locations=[(37.576549, 126.985520),\n",
    "    (37.571618, 126.976551),\n",
    "    (37.574577, 126.957754)]\n",
    "print getNearLocation(myLoc,Locations)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* distance between two points\n",
    "* distance between two gps points\n",
    "    * longitude\n",
    "    * latitude\n",
    "    * altitude"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " import java.awt.geom.Point2D;\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " Point2D.Double p1=new Point2D.Double(10.0,20.0);\r\n",
      "|  Modified variable p1 of type Point2D.Double with initial value Point2D.Double[10.0, 20.0]\r\n",
      "|    Update overwrote variable p1\r\n",
      "\r\n",
      " Point2D.Double p2=new Point2D.Double(30.0,40.0);\r\n",
      "|  Modified variable p2 of type Point2D.Double with initial value Point2D.Double[30.0, 40.0]\r\n",
      "|    Update overwrote variable p2\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " double d = 0.0;\r\n",
      "|  Modified variable d of type double with initial value 0.0\r\n",
      "|    Update overwrote variable d\r\n",
      "\r\n",
      " d+=Math.pow(p1.getX()-p2.getX(),2.0);\r\n",
      "|  Expression value is: 400.0\r\n",
      "|    assigned to temporary variable $116 of type double\r\n",
      "\r\n",
      " d+=Math.pow(p1.getY()-p2.getY(),2.0);\r\n",
      "|  Expression value is: 800.0\r\n",
      "|    assigned to temporary variable $117 of type double\r\n",
      "\r\n",
      " Math.sqrt(d);\r\n",
      "|  Expression value is: 28.284271247461902\r\n",
      "|    assigned to temporary variable $118 of type double\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "import java.awt.geom.Point2D;\n",
    "\n",
    "Point2D.Double p1=new Point2D.Double(10.0,20.0);\n",
    "Point2D.Double p2=new Point2D.Double(30.0,40.0);\n",
    "\n",
    "double d = 0.0;\n",
    "d+=Math.pow(p1.getX()-p2.getX(),2.0);\n",
    "d+=Math.pow(p1.getY()-p2.getY(),2.0);\n",
    "Math.sqrt(d);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* convertion degrees and radians\n",
    "    * 위경도는 0~360 값을 가진다.\n",
    "    * radian은 0~2$\\pi$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Math.toRadians(10);\r\n",
      "|  Expression value is: 0.17453292519943295\r\n",
      "|    assigned to temporary variable $99 of type double\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Math.toRadians(10);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " double d2r = Math.PI / 180;\r\n",
      "|  Modified variable d2r of type double with initial value 0.017453292519943295\r\n",
      "|    Update overwrote variable d2r\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "double d2r = Math.PI / 180;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "double d2r = (180 / Math.PI);\n",
    "double distance = 0;\n",
    "\n",
    "try{\n",
    "    double dlong = (endpoint.getLon() - startpoint.getLon()) * d2r;\n",
    "    double dlat = (endpoint.getLat() - startpoint.getLat()) * d2r;\n",
    "    double a =\n",
    "        Math.pow(Math.sin(dlat / 2.0), 2)\n",
    "            + Math.cos(startpoint.getLat() * d2r)\n",
    "            * Math.cos(endpoint.getLat() * d2r)\n",
    "            * Math.pow(Math.sin(dlong / 2.0), 2);\n",
    "    double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));\n",
    "    double d = 6367 * c;\n",
    "\n",
    "    return d;\n",
    "\n",
    "} catch(Exception e){\n",
    "    e.printStackTrace();\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "public static double distance(double lat1, double lat2, double lon1,\n",
    "        double lon2, double el1, double el2) {\n",
    "\n",
    "    final int R = 6371; // Radius of the earth\n",
    "\n",
    "    Double latDistance = Math.toRadians(lat2 - lat1);\n",
    "    Double lonDistance = Math.toRadians(lon2 - lon1);\n",
    "    Double a = Math.sin(latDistance / 2) * Math.sin(latDistance / 2)\n",
    "            + Math.cos(Math.toRadians(lat1)) * Math.cos(Math.toRadians(lat2))\n",
    "            * Math.sin(lonDistance / 2) * Math.sin(lonDistance / 2);\n",
    "    Double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));\n",
    "    double distance = R * c * 1000; // convert to meters\n",
    "\n",
    "    double height = el1 - el2;\n",
    "\n",
    "    distance = Math.pow(distance, 2) + Math.pow(height, 2);\n",
    "\n",
    "    return Math.sqrt(distance);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 데이터구조-13: The Beatles 'Let it be' 가사에 자주 등장하는 단어는?\n",
    "\n",
    "* 20번 이상 사용된 단어를 출력\n",
    "* 프로그래밍 요소\n",
    "    * dict, list\n",
    "* 주의\n",
    "    * 텍스트 처리: 단어 -> 문장 -> 문서"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"917px\" style=\"width:339px;height:917px;\" version=\"1.1\" viewBox=\"0 0 339 917\" width=\"339px\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"><defs><filter height=\"300%\" id=\"f1\" width=\"300%\" x=\"-1\" y=\"-1\"><feGaussianBlur result=\"blurOut\" stdDeviation=\"2.0\"/><feColorMatrix in=\"blurOut\" result=\"blurOut2\" type=\"matrix\" values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 .4 0\"/><feOffset dx=\"4.0\" dy=\"4.0\" in=\"blurOut2\" result=\"blurOut3\"/><feBlend in=\"SourceGraphic\" in2=\"blurOut3\" mode=\"normal\"/></filter></defs><g><ellipse cx=\"181\" cy=\"20\" fill=\"#000000\" filter=\"url(#f1)\" rx=\"10\" ry=\"10\" style=\"stroke: none; stroke-width: 1.0;\"/><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"34.1328\" rx=\"12.5\" ry=\"12.5\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"67\" x=\"147.5\" y=\"50\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"47\" x=\"157.5\" y=\"71.6016\">set data</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"34.1328\" rx=\"12.5\" ry=\"12.5\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"139\" x=\"111.5\" y=\"104.1328\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"119\" x=\"121.5\" y=\"125.7344\">initialize dictionary d</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"34.1328\" rx=\"12.5\" ry=\"12.5\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"134\" x=\"114\" y=\"202.2656\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"114\" x=\"124\" y=\"223.8672\">get a line from data</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"34.1328\" rx=\"12.5\" ry=\"12.5\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"132\" x=\"115\" y=\"300.3984\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"112\" x=\"125\" y=\"322\">split line into words</text><polygon fill=\"#FEFECE\" filter=\"url(#f1)\" points=\"153,354.5313,209,354.5313,221,366.5313,209,378.5313,153,378.5313,141,366.5313,153,354.5313\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"56\" x=\"153\" y=\"370.6885\">words in d</text><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"18\" x=\"123\" y=\"364.2109\">yes</text><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"14\" x=\"221\" y=\"364.2109\">no</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"34.1328\" rx=\"12.5\" ry=\"12.5\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"87\" x=\"87.5\" y=\"388.5313\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"67\" x=\"97.5\" y=\"410.1328\">count += 1</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"34.1328\" rx=\"12.5\" ry=\"12.5\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"73\" x=\"194.5\" y=\"388.5313\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"53\" x=\"204.5\" y=\"410.1328\">count =1</text><polygon fill=\"#FEFECE\" filter=\"url(#f1)\" points=\"181,428.6641,193,440.6641,181,452.6641,169,440.6641,181,428.6641\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><polygon fill=\"#FEFECE\" filter=\"url(#f1)\" points=\"169,256.3984,193,256.3984,205,268.3984,193,280.3984,169,280.3984,157,268.3984,169,256.3984\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"19\" x=\"171.5\" y=\"272.5557\">line</text><polygon fill=\"#FEFECE\" filter=\"url(#f1)\" points=\"169,158.2656,193,158.2656,205,170.2656,193,182.2656,169,182.2656,157,170.2656,169,158.2656\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"23\" x=\"169.5\" y=\"174.4229\">data</text><rect fill=\"#FFFFFF\" filter=\"url(#f1)\" height=\"362.3984\" style=\"stroke: #000000; stroke-width: 2.0;\" width=\"322\" x=\"10\" y=\"507.6641\"/><path d=\"M76,508.6641 L76,514.6641 L66,524.6641 L10,524.6641 \" fill=\"#FFFFFF\" style=\"stroke: #000000; stroke-width: 2.0;\"/><text fill=\"#000000\" font-family=\"Serif\" font-size=\"14\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"56\" x=\"13\" y=\"519.1641\">frequency</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"34.1328\" rx=\"12.5\" ry=\"12.5\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"81\" x=\"140.5\" y=\"541.6641\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"61\" x=\"150.5\" y=\"563.2656\">set criteria</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"34.1328\" rx=\"12.5\" ry=\"12.5\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"99\" x=\"131.5\" y=\"658.7969\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"79\" x=\"141.5\" y=\"680.3984\">get frequency</text><polygon fill=\"#FEFECE\" filter=\"url(#f1)\" points=\"99,727.9297,263,727.9297,275,739.9297,263,751.9297,99,751.9297,87,739.9297,99,727.9297\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"164\" x=\"99\" y=\"744.0869\">frequency greater than criteria</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"34.1328\" rx=\"12.5\" ry=\"12.5\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"46\" x=\"54\" y=\"761.9297\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"26\" x=\"64\" y=\"783.5313\">save</text><polygon fill=\"#FEFECE\" filter=\"url(#f1)\" points=\"181,802.0625,193,814.0625,181,826.0625,169,814.0625,181,802.0625\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><polygon fill=\"#FEFECE\" filter=\"url(#f1)\" points=\"169,610.7969,193,610.7969,205,622.7969,193,634.7969,169,634.7969,157,622.7969,169,610.7969\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"7\" x=\"177.5\" y=\"626.9541\">d</text><ellipse cx=\"181\" cy=\"900.0625\" fill=\"none\" filter=\"url(#f1)\" rx=\"10\" ry=\"10\" style=\"stroke: #000000; stroke-width: 1.0;\"/><ellipse cx=\"181.5\" cy=\"900.5625\" fill=\"#000000\" filter=\"url(#f1)\" rx=\"6\" ry=\"6\" style=\"stroke: none; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"181\" x2=\"181\" y1=\"30\" y2=\"50\"/><polygon fill=\"#A80036\" points=\"177,40,181,50,185,40,181,44\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"181\" x2=\"181\" y1=\"84.1328\" y2=\"104.1328\"/><polygon fill=\"#A80036\" points=\"177,94.1328,181,104.1328,185,94.1328,181,98.1328\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"141\" x2=\"131\" y1=\"366.5313\" y2=\"366.5313\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"131\" x2=\"131\" y1=\"366.5313\" y2=\"388.5313\"/><polygon fill=\"#A80036\" points=\"127,378.5313,131,388.5313,135,378.5313,131,382.5313\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"221\" x2=\"231\" y1=\"366.5313\" y2=\"366.5313\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"231\" x2=\"231\" y1=\"366.5313\" y2=\"388.5313\"/><polygon fill=\"#A80036\" points=\"227,378.5313,231,388.5313,235,378.5313,231,382.5313\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"131\" x2=\"131\" y1=\"422.6641\" y2=\"440.6641\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"131\" x2=\"169\" y1=\"440.6641\" y2=\"440.6641\"/><polygon fill=\"#A80036\" points=\"159,436.6641,169,440.6641,159,444.6641,163,440.6641\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"231\" x2=\"231\" y1=\"422.6641\" y2=\"440.6641\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"231\" x2=\"193\" y1=\"440.6641\" y2=\"440.6641\"/><polygon fill=\"#A80036\" points=\"203,436.6641,193,440.6641,203,444.6641,199,440.6641\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"181\" x2=\"181\" y1=\"334.5313\" y2=\"354.5313\"/><polygon fill=\"#A80036\" points=\"177,344.5313,181,354.5313,185,344.5313,181,348.5313\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"181\" x2=\"181\" y1=\"280.3984\" y2=\"300.3984\"/><polygon fill=\"#A80036\" points=\"177,290.3984,181,300.3984,185,290.3984,181,294.3984\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"181\" x2=\"181\" y1=\"452.6641\" y2=\"462.6641\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"181\" x2=\"289.5\" y1=\"462.6641\" y2=\"462.6641\"/><polygon fill=\"#A80036\" points=\"285.5,367.0313,289.5,357.0313,293.5,367.0313,289.5,363.0313\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"289.5\" x2=\"289.5\" y1=\"268.3984\" y2=\"462.6641\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"289.5\" x2=\"205\" y1=\"268.3984\" y2=\"268.3984\"/><polygon fill=\"#A80036\" points=\"215,264.3984,205,268.3984,215,272.3984,211,268.3984\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"157\" x2=\"65.5\" y1=\"268.3984\" y2=\"268.3984\"/><polygon fill=\"#A80036\" points=\"61.5,353.0313,65.5,363.0313,69.5,353.0313,65.5,357.0313\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"65.5\" x2=\"65.5\" y1=\"268.3984\" y2=\"474.6641\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"65.5\" x2=\"301.5\" y1=\"474.6641\" y2=\"474.6641\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"301.5\" x2=\"301.5\" y1=\"170.2656\" y2=\"474.6641\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"301.5\" x2=\"205\" y1=\"170.2656\" y2=\"170.2656\"/><polygon fill=\"#A80036\" points=\"215,166.2656,205,170.2656,215,174.2656,211,170.2656\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"181\" x2=\"181\" y1=\"236.3984\" y2=\"256.3984\"/><polygon fill=\"#A80036\" points=\"177,246.3984,181,256.3984,185,246.3984,181,250.3984\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"181\" x2=\"181\" y1=\"182.2656\" y2=\"202.2656\"/><polygon fill=\"#A80036\" points=\"177,192.2656,181,202.2656,185,192.2656,181,196.2656\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"157\" x2=\"41.5\" y1=\"170.2656\" y2=\"170.2656\"/><polygon fill=\"#A80036\" points=\"37.5,321.4648,41.5,331.4648,45.5,321.4648,41.5,325.4648\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"41.5\" x2=\"41.5\" y1=\"170.2656\" y2=\"496.6641\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"41.5\" x2=\"181\" y1=\"496.6641\" y2=\"496.6641\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"181\" x2=\"181\" y1=\"496.6641\" y2=\"541.6641\"/><polygon fill=\"#A80036\" points=\"177,531.6641,181,541.6641,185,531.6641,181,535.6641\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"181\" x2=\"181\" y1=\"138.2656\" y2=\"158.2656\"/><polygon fill=\"#A80036\" points=\"177,148.2656,181,158.2656,185,148.2656,181,152.2656\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"87\" x2=\"77\" y1=\"739.9297\" y2=\"739.9297\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"77\" x2=\"77\" y1=\"739.9297\" y2=\"761.9297\"/><polygon fill=\"#A80036\" points=\"73,751.9297,77,761.9297,81,751.9297,77,755.9297\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"275\" x2=\"285\" y1=\"739.9297\" y2=\"739.9297\"/><polygon fill=\"#A80036\" points=\"281,766.9961,285,776.9961,289,766.9961,285,770.9961\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"285\" x2=\"285\" y1=\"739.9297\" y2=\"814.0625\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"285\" x2=\"193\" y1=\"814.0625\" y2=\"814.0625\"/><polygon fill=\"#A80036\" points=\"203,810.0625,193,814.0625,203,818.0625,199,814.0625\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"77\" x2=\"77\" y1=\"796.0625\" y2=\"814.0625\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"77\" x2=\"169\" y1=\"814.0625\" y2=\"814.0625\"/><polygon fill=\"#A80036\" points=\"159,810.0625,169,814.0625,159,818.0625,163,814.0625\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"181\" x2=\"181\" y1=\"692.9297\" y2=\"727.9297\"/><polygon fill=\"#A80036\" points=\"177,717.9297,181,727.9297,185,717.9297,181,721.9297\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"181\" x2=\"181\" y1=\"634.7969\" y2=\"658.7969\"/><polygon fill=\"#A80036\" points=\"177,648.7969,181,658.7969,185,648.7969,181,652.7969\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"181\" x2=\"181\" y1=\"826.0625\" y2=\"838.0625\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"181\" x2=\"322\" y1=\"838.0625\" y2=\"838.0625\"/><polygon fill=\"#A80036\" points=\"318,740.4297,322,730.4297,326,740.4297,322,736.4297\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"322\" x2=\"322\" y1=\"622.7969\" y2=\"838.0625\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"322\" x2=\"205\" y1=\"622.7969\" y2=\"622.7969\"/><polygon fill=\"#A80036\" points=\"215,618.7969,205,622.7969,215,626.7969,211,622.7969\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"157\" x2=\"32\" y1=\"622.7969\" y2=\"622.7969\"/><polygon fill=\"#A80036\" points=\"28,726.4297,32,736.4297,36,726.4297,32,730.4297\" style=\"stroke: #A80036; stroke-width: 1.5;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"32\" x2=\"32\" y1=\"622.7969\" y2=\"850.0625\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"32\" x2=\"181\" y1=\"850.0625\" y2=\"850.0625\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"181\" x2=\"181\" y1=\"850.0625\" y2=\"890.0625\"/><polygon fill=\"#A80036\" points=\"177,880.0625,181,890.0625,185,880.0625,181,884.0625\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"181\" x2=\"181\" y1=\"575.7969\" y2=\"610.7969\"/><polygon fill=\"#A80036\" points=\"177,600.7969,181,610.7969,185,600.7969,181,604.7969\" style=\"stroke: #A80036; stroke-width: 1.0;\"/></g></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "start\n",
    ":set data;\n",
    ":initialize dictionary d;\n",
    "while(data)\n",
    ":get a line from data;\n",
    "while(line)\n",
    ":split line into words;\n",
    "if (words in d) then(yes)\n",
    ":count += 1;\n",
    "else (no)\n",
    ":count =1;\n",
    "endif\n",
    "endwhile\n",
    "endwhile\n",
    "partition frequency {\n",
    "    :set criteria;\n",
    "    while(d)\n",
    "        :get frequency;\n",
    "        if(frequency greater than criteria)\n",
    "            :save;\n",
    "        endif\n",
    "    endwhile\n",
    "}\n",
    "stop\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Let it be 가사"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " String doc[]={\r\n",
      "     \"When I find myself in times of trouble\",\r\n",
      "     \"Mother Mary comes to me\",\r\n",
      "     \"Speaking words of wisdom, let it be\",\r\n",
      "     \"And in my hour of darkness\",\r\n",
      "     \"She is standing right in front of me\",\r\n",
      "     \"Speaking words of wisdom, let it be\",\r\n",
      "     \"Let it be\",\r\n",
      "     \"Let it be\",\r\n",
      "     \"Let it be\",\r\n",
      "     \"Let it be\",\r\n",
      "     \"Whisper words of wisdom, let it be\"\r\n",
      " }\r\n",
      "|  Added variable doc of type String[] with initial value [Ljava.lang.String;@148080bb\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "String doc[]={\n",
    "    \"When I find myself in times of trouble\",\n",
    "    \"Mother Mary comes to me\",\n",
    "    \"Speaking words of wisdom, let it be\",\n",
    "    \"And in my hour of darkness\",\n",
    "    \"She is standing right in front of me\",\n",
    "    \"Speaking words of wisdom, let it be\",\n",
    "    \"Let it be\",\n",
    "    \"Let it be\",\n",
    "    \"Let it be\",\n",
    "    \"Let it be\",\n",
    "    \"Whisper words of wisdom, let it be\"\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(String sentence: doc)\r\n",
      "     System.out.printf(\"%s\", sentence);\r\n",
      "When I find myself in times of troubleMother Mary comes to meSpeaking words of wisdom, let it beAnd in my hour of darknessShe is standing right in front of meSpeaking words of wisdom, let it beLet it beLet it beLet it beLet it beWhisper words of wisdom, let it be\r\n"
     ]
    }
   ],
   "source": [
    "for(String sentence: doc)\n",
    "    System.out.printf(\"%s\", sentence);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " String[][] doc1={\r\n",
      "     {\"When I find myself in times of trouble\"},\r\n",
      "     {\"Mother Mary comes to me\"},\r\n",
      "     {\"Speaking words of wisdom, let it be\"},\r\n",
      "     {\"And in my hour of darkness\"},\r\n",
      "     {\"She is standing right in front of me\"},\r\n",
      "     {\"Speaking words of wisdom, let it be\"},\r\n",
      "     {\"Let it be\"},\r\n",
      "     {\"Let it be\"},\r\n",
      "     {\"Let it be\"},\r\n",
      "     {\"Let it be\"},\r\n",
      "     {\"Whisper words of wisdom, let it be\"}\r\n",
      " }\r\n",
      "|  Added variable doc1 of type String[][] with initial value [[Ljava.lang.String;@f6c48ac\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "String[][] doc1={\n",
    "    {\"When I find myself in times of trouble\"},\n",
    "    {\"Mother Mary comes to me\"},\n",
    "    {\"Speaking words of wisdom, let it be\"},\n",
    "    {\"And in my hour of darkness\"},\n",
    "    {\"She is standing right in front of me\"},\n",
    "    {\"Speaking words of wisdom, let it be\"},\n",
    "    {\"Let it be\"},\n",
    "    {\"Let it be\"},\n",
    "    {\"Let it be\"},\n",
    "    {\"Let it be\"},\n",
    "    {\"Whisper words of wisdom, let it be\"}\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 문서의 문장, 문장의 단어로 분리하기\n",
    "* variable length, dynamic array\n",
    "    * 각 문장은 단어의 수가 서로 다르다.\n",
    "    * 2차원이지만 맨 안쪽의 문자열은 1개 뿐이 없다.\n",
    "    * 분리는 어디에서????"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " String s = \"I want to walk my dog\";\r\n",
      "|  Added variable s of type String with initial value \"I want to walk my dog\"\r\n",
      "\r\n",
      " StringTokenizer tokenizer = new StringTokenizer(s);\r\n",
      "|  Added variable tokenizer of type StringTokenizer with initial value java.util.StringTokenizer@5bcab519\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " while(tokenizer.hasMoreTokens()) {\r\n",
      "     System.out.println(tokenizer.nextToken());\r\n",
      " }\r\n",
      "I\r\n",
      "want\r\n",
      "to\r\n",
      "walk\r\n",
      "my\r\n",
      "dog\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "String s = \"I want to walk my dog\";\n",
    "StringTokenizer tokenizer = new StringTokenizer(s);\n",
    "\n",
    "while(tokenizer.hasMoreTokens()) {\n",
    "    System.out.println(tokenizer.nextToken());\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " String sentence=doc1[0][0];\r\n",
      "|  Added variable sentence of type String with initial value \"When I find myself in times of trouble\"\r\n",
      "\r\n",
      " String[] words=sentence.split(\"\\\\s+\");\r\n",
      "|  Added variable words of type String[] with initial value [Ljava.lang.String;@1e397ed7\r\n",
      "\r\n",
      " for(String word:words)\r\n",
      "     System.out.println(word);\r\n",
      "When\r\n",
      "I\r\n",
      "find\r\n",
      "myself\r\n",
      "in\r\n",
      "times\r\n",
      "of\r\n",
      "trouble\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "String sentence=doc1[0][0];\n",
    "String[] words=sentence.split(\"\\\\s+\");\n",
    "for(String word:words)\n",
    "    System.out.println(word);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "List<List<String>> words=new ArrayList<List<String>>();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(String[] sentence:doc1) {\r\n",
      "     for(String s:sentence) {\r\n",
      "         String[] words=s.split(\"\\\\s+\");\r\n",
      "         for(String word:words)\r\n",
      "             System.out.printf(\"/%s/\",word);\r\n",
      "     }\r\n",
      " }\r\n",
      "/When//I//find//myself//in//times//of//trouble//Mother//Mary//comes//to//me//Speaking//words//of//wisdom,//let//it//be//And//in//my//hour//of//darkness//She//is//standing//right//in//front//of//me//Speaking//words//of//wisdom,//let//it//be//Let//it//be//Let//it//be//Let//it//be//Let//it//be//Whisper//words//of//wisdom,//let//it//be/\r\n"
     ]
    }
   ],
   "source": [
    "for(String[] sentence:doc1) {\n",
    "    for(String s:sentence) {\n",
    "        String[] words=s.split(\"\\\\s+\");\n",
    "        for(String word:words)\n",
    "            System.out.printf(\"/%s/\",word);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "ArrayList<ArrayList<String>> docList=new ArrayList<ArrayList<String>>();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for(String[] sentence:doc1) {\n",
    "    for(String s:sentence) {\n",
    "        String[] words=s.split(\"\\\\s+\");\n",
    "        ArrayList<String> wordsList=new ArrayList<String>();\n",
    "        wordsList.addAll(Arrays.asList(words));\n",
    "        docList.add(wordsList);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```\n",
    "-> docList\n",
    "|  Variable docList of type ArrayList<ArrayList<String>> has value [[When, I, find, myself, in, times, of, trouble], [Mother, Mary, comes, to, me], [Speaking, words, of, wisdom,, let, it, be], [And, in, my, hour, of, darkness], [She, is, standing, right, in, front, of, me], [Speaking, words, of, wisdom,, let, it, be], [Let, it, be], [Let, it, be], [Let, it, be], [Let, it, be], [Whisper, words, of, wisdom,, let, it, be]]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* tokenizer를 사용???\n",
    "* ArrayList에 저장하지 않고, 바로 word count할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Map<String, Integer> wc = new HashMap<String, Integer>();\r\n",
      "|  Modified variable wc of type Map<String, Integer> with initial value {}\r\n",
      "|    Update overwrote variable wc\r\n",
      "\r\n",
      " for(String[] sentence:doc1) {\r\n",
      "     for(String s:sentence) {\r\n",
      "         String[] words=s.split(\"\\\\s+\");\r\n",
      "         for(String word:words) {\r\n",
      "             System.out.printf(\"/%s/\",word);\r\n",
      "             if (wc.containsKey(word)) {\r\n",
      "                 wc.put(word,wc.get(word)+1);\r\n",
      "             } else {\r\n",
      "                 wc.put(word,1);\r\n",
      "             }\r\n",
      "         }\r\n",
      "     }\r\n",
      " }\r\n",
      "/When//I//find//myself//in//times//of//trouble//Mother//Mary//comes//to//me//Speaking//words//of//wisdom,//let//it//be//And//in//my//hour//of//darkness//She//is//standing//right//in//front//of//me//Speaking//words//of//wisdom,//let//it//be//Let//it//be//Let//it//be//Let//it//be//Let//it//be//Whisper//words//of//wisdom,//let//it//be/\r\n",
      " System.out.println(wc);\r\n",
      "{be=7, comes=1, I=1, She=1, Whisper=1, times=1, Mother=1, hour=1, find=1, of=6, me=2, trouble=1, let=3, darkness=1, Mary=1, in=3, myself=1, words=3, is=1, it=7, right=1, my=1, Speaking=2, standing=1, When=1, And=1, Let=4, to=1, front=1, wisdom,=3}\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Map<String, Integer> wc = new HashMap<String, Integer>();\n",
    "for(String[] sentence:doc1) {\n",
    "    for(String s:sentence) {\n",
    "        String[] words=s.split(\"\\\\s+\");\n",
    "        for(String word:words) {\n",
    "            System.out.printf(\"/%s/\",word);\n",
    "            if (wc.containsKey(word)) {\n",
    "                wc.put(word,wc.get(word)+1);\n",
    "            } else {\n",
    "                wc.put(word,1);\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "}\n",
    "System.out.println(wc);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 3회 이상 등장한 단어?\n",
    "    * 정렬하지 않고\n",
    "    ['be', 'it', 'in', 'wisdom,', 'Let', 'let', 'words', 'of']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for (Map.Entry<String, Integer> entry : wc.entrySet()) {\r\n",
      "     System.out.println(\"Key = \" + entry.getKey() + \", Value = \" + entry.getVa \r",
      "lue());\r\n",
      " }\r\n",
      "Key = be, Value = 7\r\n",
      "Key = comes, Value = 1\r\n",
      "Key = I, Value = 1\r\n",
      "Key = She, Value = 1\r\n",
      "Key = Whisper, Value = 1\r\n",
      "Key = times, Value = 1\r\n",
      "Key = Mother, Value = 1\r\n",
      "Key = hour, Value = 1\r\n",
      "Key = find, Value = 1\r\n",
      "Key = of, Value = 6\r\n",
      "Key = me, Value = 2\r\n",
      "Key = trouble, Value = 1\r\n",
      "Key = let, Value = 3\r\n",
      "Key = darkness, Value = 1\r\n",
      "Key = Mary, Value = 1\r\n",
      "Key = in, Value = 3\r\n",
      "Key = myself, Value = 1\r\n",
      "Key = words, Value = 3\r\n",
      "Key = is, Value = 1\r\n",
      "Key = it, Value = 7\r\n",
      "Key = right, Value = 1\r\n",
      "Key = my, Value = 1\r\n",
      "Key = Speaking, Value = 2\r\n",
      "Key = standing, Value = 1\r\n",
      "Key = When, Value = 1\r\n",
      "Key = And, Value = 1\r\n",
      "Key = Let, Value = 4\r\n",
      "Key = to, Value = 1\r\n",
      "Key = front, Value = 1\r\n",
      "Key = wisdom,, Value = 3\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for (Map.Entry<String, Integer> entry : wc.entrySet()) {\n",
    "    System.out.println(\"Key = \" + entry.getKey() + \", Value = \" + entry.getValue());\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'right': 1, 'be': 7, 'is': 1, 'When': 1, 'it': 7, 'in': 3, 'Mary': 1, 'Speaking': 2, 'standing': 1, 'darkness': 1, 'find': 1, 'wisdom,': 3, 'to': 1, 'Let': 4, 'And': 1, 'I': 1, 'let': 3, 'She': 1, 'words': 3, 'Mother': 1, 'front': 1, 'trouble': 1, 'me': 2, 'myself': 1, 'hour': 1, 'of': 6, 'times': 1, 'Whisper': 1, 'my': 1, 'comes': 1}\n"
     ]
    }
   ],
   "source": [
    "print d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Map countWords(String[][] doc) {\r\n",
      "     Map<String, Integer> wc = new HashMap<String, Integer>();\r\n",
      "     for(String[] sentence:doc) {\r\n",
      "         for(String s:sentence) {\r\n",
      "             String[] words=s.split(\"\\\\s+\");\r\n",
      "             for(String word:words) {\r\n",
      "                 //System.out.printf(\"/%s/\",word);\r\n",
      "                 if (wc.containsKey(word)) {\r\n",
      "                     wc.put(word,wc.get(word)+1);\r\n",
      "                 } else {\r\n",
      "                     wc.put(word,1);\r\n",
      "                 }\r\n",
      "             }\r\n",
      "         }\r\n",
      "     }\r\n",
      "     return wc;\r\n",
      " }\r\n",
      "|  Modified method countWords(String[][])\r\n",
      "|    Update overwrote method countWords(String[][])\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " Map getWordsFreqGreater(int c,Map<K,V> wc){\r\n",
      "     Map<String, Integer> fc = new HashMap<String, Integer>();\r\n",
      "     for (Map.Entry<String, Integer> entry : wc.entrySet()) {\r\n",
      "         System.out.println(\"Key = \" + entry.getKey() + \", Value = \" + entry.g \r",
      "etValue());\r\n",
      "         if(entry.getValue()>c) {\r\n",
      "             fc.put(entry.getKey(),entry.getValue());\r\n",
      "         }\r\n",
      "     }\r\n",
      "     return fc;\r\n",
      " }\r\n",
      "|  Added method getWordsFreqGreater(int,Map<K,V>), however, it cannot be referenced until class K, and class V are declared\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Map countWords(String[][] doc) {\n",
    "    Map<String, Integer> wc = new HashMap<String, Integer>();\n",
    "    for(String[] sentence:doc) {\n",
    "        for(String s:sentence) {\n",
    "            String[] words=s.split(\"\\\\s+\");\n",
    "            for(String word:words) {\n",
    "                //System.out.printf(\"/%s/\",word);\n",
    "                if (wc.containsKey(word)) {\n",
    "                    wc.put(word,wc.get(word)+1);\n",
    "                } else {\n",
    "                    wc.put(word,1);\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "    return wc;\n",
    "}\n",
    "\n",
    "Map getWordsFreqGreater(int c,Map<K,V> wc){\n",
    "    Map<String, Integer> fc = new HashMap<String, Integer>();\n",
    "    for (Map.Entry<String, Integer> entry : wc.entrySet()) {\n",
    "        System.out.println(\"Key = \" + entry.getKey() + \", Value = \" + entry.getValue());\n",
    "        if(entry.getValue()>c) {\n",
    "            fc.put(entry.getKey(),entry.getValue());\n",
    "        }\n",
    "    }\n",
    "    return fc;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Map<String, Integer> wordDict = new HashMap<String, Integer>();\r\n",
      "|  Modified variable wordDict of type Map<String, Integer> with initial value {}\r\n",
      "|    Update overwrote variable wordDict\r\n",
      "\r\n",
      " wordDict=countWords(doc1);\r\n",
      "|  Warning:\r\n",
      "|  unchecked conversion\r\n",
      "|    required: java.util.Map<java.lang.String,java.lang.Integer>\r\n",
      "|    found:    java.util.Map\r\n",
      "|  wordDict=countWords(doc1);\r\n",
      "|           ^--------------^\r\n",
      "|  Variable wordDict has been assigned the value {be=7, comes=1, I=1, She=1, Whisper=1, times=1, Mother=1, hour=1, find=1, of=6, me=2, trouble=1, let=3, darkness=1, Mary=1, in=3, myself=1, words=3, is=1, it=7, right=1, my=1, Speaking=2, standing=1, When=1, And=1, Let=4, to=1, front=1, wisdom,=3}\r\n",
      "\r\n",
      " System.out.println(wordDict);\r\n",
      "{be=7, comes=1, I=1, She=1, Whisper=1, times=1, Mother=1, hour=1, find=1, of=6, me=2, trouble=1, let=3, darkness=1, Mary=1, in=3, myself=1, words=3, is=1, it=7, right=1, my=1, Speaking=2, standing=1, When=1, And=1, Let=4, to=1, front=1, wisdom,=3}\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Map<String, Integer> wordDict = new HashMap<String, Integer>();\n",
    "wordDict=countWords(doc1);\n",
    "System.out.println(wordDict);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "scrolled": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Map<String, Integer> freqWordsList = new HashMap<String, Integer>();\r\n",
      "|  Modified variable freqWordsList of type Map<String, Integer> with initial value {}\r\n",
      "|    Update overwrote variable freqWordsList\r\n",
      "\r\n",
      " freqWordsList=getWordsFreqGreater(2,wordDict);\r\n",
      "|  Error:\r\n",
      "|  cannot find symbol\r\n",
      "|    symbol:   method getWordsFreqGreater(int,java.util.Map<java.lang.String,java.lang.Integer>)\r\n",
      "|  freqWordsList=getWordsFreqGreater(2,wordDict);\r\n",
      "|                ^-----------------^\r\n",
      "\r\n",
      " System.out.println(freqWordsList);\r\n",
      "{}\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Map<String, Integer> freqWordsList = new HashMap<String, Integer>();\n",
    "freqWordsList=getWordsFreqGreater(2,wordDict);\n",
    "System.out.println(freqWordsList);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 6.7 Set\n",
    "\n",
    "* HashSet (or new TreeSet() will order the elements)\n",
    "* set은 데이터를 추가할 때는 add()를 사용한다.\n",
    "* 순서가 없기 때문에 add()를 사용한다.\n",
    "* set은 key값을 저장한다.\n",
    "* key값이란 unique, 중복 값이 존재하지 않는다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Set<String> colors = new HashSet<String>();\r\n",
      "|  Modified variable colors of type Set<String> with initial value []\r\n",
      "|    Update overwrote variable colors\r\n",
      "\r\n",
      " colors.add(\"red\");\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $93 of type boolean\r\n",
      "\r\n",
      " colors.add(\"green\");\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $94 of type boolean\r\n",
      "\r\n",
      " colors.add(\"red\");\r\n",
      "|  Expression value is: false\r\n",
      "|    assigned to temporary variable $95 of type boolean\r\n",
      "\r\n",
      " colors.add(\"blue\");\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $96 of type boolean\r\n",
      "\r\n",
      " colors.add(\"blue\");\r\n",
      "|  Expression value is: false\r\n",
      "|    assigned to temporary variable $97 of type boolean\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " System.out.print(colors + \"-\"+colors.size());\r\n",
      "[red, green, blue]-3\r\n"
     ]
    }
   ],
   "source": [
    "Set<String> colors = new HashSet<String>();\n",
    "colors.add(\"red\");\n",
    "colors.add(\"green\");\n",
    "colors.add(\"red\");\n",
    "colors.add(\"blue\");\n",
    "colors.add(\"blue\");\n",
    "\n",
    "System.out.print(colors + \"-\"+colors.size());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 데이터구조-14: 우리 집에 없지만 친구 집에 있는 가전제품 찾기.\n",
    "\n",
    "### 문제\n",
    "어느 가정이나 가전제품이 있다.\n",
    "우리 집에는 없지만 친구 집에는 있는 가전제품을 찾으려고 한다.\n",
    "그러면 하나씩 모두 비교해야 한다. 보다 쉽게 하는 방법이 없을까?\n",
    "\n",
    "* 8-1 한 집에만 있는 제품을 나열하기\n",
    "* 8-2 모든 집에 같이 있는 제품 나열하기\n",
    "* 8-3 어느 집에라도 있는 제품을 나열하기\n",
    "* 8-4 모든 가전제품의 갯수를 세어보기 (집이 2개이므로, 갯수는 1 또는 2)\n",
    "\n",
    "* 자신의 방과 친구의 방에 있는 가전제품을 10개 이상 나열하여 자료구조로 만들기 (영어).\n",
    "    * 우리 집: TV, phone, camera, fridger, mixer, audio, cd player, light, computer, notebook, recorder\n",
    "    * 친구 집: coffee machine, radio, camera, running machine, ramp, computer, notebook, recorder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 해결\n",
    "\n",
    "머리 속에 쉽게 떠오르는 해결 방법이 list, compare를 사용하는 것이다.\n",
    "한 요소를 선택하고 다른 모든 요소와 비교해서 존재 여부를 확인한다.\n",
    "이 방식은 중첩for문과 같은 비교횟수가 필요하다.\n",
    "\n",
    "가전제품을 하나의 집합으로 정의하면 합집합, 교차집합 등 집합연산을 쉽게 할 수 있다.\n",
    "```java\n",
    "X = {1, 3, 5} and Y = {1, 2, 4} then X ∪ Y = {1, 2, 3, 4, 5}.\n",
    "```\n",
    "\n",
    "* 주의\n",
    "    * set은 인덱스가 없다.\n",
    "    * set의 합집합은 중복을 제외한다. 가전제품의 합집합은 두 집에 있는 가전제품의 갯수를 2로 표현하지 않는다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Set에 하나씩 추가하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Set<String> cities = new HashSet<String>(); // or new TreeSet() will order th \r",
      "e elements;\r\n",
      "|  Added variable cities of type Set<String> with initial value []\r\n",
      "\r\n",
      " cities.add(\"Seoul\");\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $100 of type boolean\r\n",
      "\r\n",
      " cities.add(\"NY\");\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $101 of type boolean\r\n",
      "\r\n",
      " cities.add(\"Sydney\");\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $102 of type boolean\r\n",
      "\r\n",
      " cities.add(\"Seoul\");\r\n",
      "|  Expression value is: false\r\n",
      "|    assigned to temporary variable $103 of type boolean\r\n",
      "\r\n",
      " cities.add(\"NY\");\r\n",
      "|  Expression value is: false\r\n",
      "|    assigned to temporary variable $104 of type boolean\r\n",
      "\r\n",
      " System.out.println(\"Set Elements\");\r\n",
      "Set Elements\r\n",
      "\r\n",
      " System.out.print(\"\\t\" + cities + \"\\n\");\r\n",
      "\t[Seoul, NY, Sydney]\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Set<String> cities = new HashSet<String>(); // or new TreeSet() will order the elements;\n",
    "cities.add(\"Seoul\");\n",
    "cities.add(\"NY\");\n",
    "cities.add(\"Sydney\");\n",
    "cities.add(\"Seoul\");\n",
    "cities.add(\"NY\");\n",
    "System.out.println(\"Set Elements\");\n",
    "System.out.print(\"\\t\" + cities + \"\\n\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Set을 생성하고 데이터 일괄 넣기\n",
    "\n",
    "* 원시타잎은 Set에 넣을 수 없다. 객체 Integer를 만들어 넣는다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Set<int> s1=new HashSet<int>();\r\n",
      "|  Error:\r\n",
      "|  unexpected type\r\n",
      "|    required: reference\r\n",
      "|    found:    int\r\n",
      "|  Set<int> s1=new HashSet<int>();\r\n",
      "|      ^-^\r\n",
      "|  Error:\r\n",
      "|  unexpected type\r\n",
      "|    required: reference\r\n",
      "|    found:    int\r\n",
      "|  Set<int> s1=new HashSet<int>();\r\n",
      "|                          ^-^\r\n",
      "|    Update overwrote variable s1\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Set<int> s1=new HashSet<int>();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Integer[] a={1,2,3,4,5,6};\r\n",
      "|  Modified variable a of type Integer[] with initial value [Ljava.lang.Integer;@887af79\r\n",
      "|    Update overwrote variable a\r\n",
      "\r\n",
      " Set<Integer> s1=new HashSet<Integer>();\r\n",
      "|  Added variable s1 of type Set<Integer> with initial value []\r\n",
      "\r\n",
      " s1.addAll(Arrays.asList(a));\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $112 of type boolean\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Integer[] a={1,2,3,4,5,6};\n",
    "Set<Integer> s1=new HashSet<Integer>();\n",
    "s1.addAll(Arrays.asList(a));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " String[] myHome={\"TV\", \"TV\",\"phone\", \"camera\", \"fridger\", \"mixer\", \"audio\", \" \r",
      "cd player\", \"light\", \"computer\", \"notebook\", \"recorder\"}\r\n",
      "|  Added variable myHome of type String[] with initial value [Ljava.lang.String;@6e0e048a\r\n",
      "\r\n",
      " String[] yourHome={\"coffee machine\", \"radio\", \"camera\", \"running machine\", \"r \r",
      "amp\", \"computer\", \"notebook\", \"recorder\"}\r\n",
      "|  Added variable yourHome of type String[] with initial value [Ljava.lang.String;@47ef968d\r\n",
      "\r\n",
      " Set<String> me=new HashSet<String>();\r\n",
      "|  Added variable me of type Set<String> with initial value []\r\n",
      "\r\n",
      " Set<String> u=new HashSet<String>();\r\n",
      "|  Added variable u of type Set<String> with initial value []\r\n",
      "\r\n",
      " me.addAll(Arrays.asList(myHome));\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $117 of type boolean\r\n",
      "\r\n",
      " u.addAll(Arrays.asList(yourHome));\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $118 of type boolean\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "String[] myHome={\"TV\", \"TV\",\"phone\", \"camera\", \"fridger\", \"mixer\", \"audio\", \"cd player\", \"light\", \"computer\", \"notebook\", \"recorder\"}\n",
    "String[] yourHome={\"coffee machine\", \"radio\", \"camera\", \"running machine\", \"ramp\", \"computer\", \"notebook\", \"recorder\"}\n",
    "Set<String> me=new HashSet<String>();\n",
    "Set<String> u=new HashSet<String>();\n",
    "me.addAll(Arrays.asList(myHome));\n",
    "u.addAll(Arrays.asList(yourHome));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Set에 데이터를 넣으면 중복된 항목이 제거된다.\n",
    "\n",
    "* retainAll()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(String e:me)\r\n",
      "     System.out.printf(\"%s\\n\",e)\r\n",
      "TV\r\n",
      "cd player\r\n",
      "computer\r\n",
      "recorder\r\n",
      "phone\r\n",
      "light\r\n",
      "fridger\r\n",
      "mixer\r\n",
      "audio\r\n",
      "camera\r\n",
      "notebook\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " me.removeAll(u);\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $120 of type boolean\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for(String e:me)\n",
    "    System.out.printf(\"%s\\n\",e)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* removeAll()은 차이를 구한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(String e:me)\r\n",
      "     System.out.printf(\"%s\\n\",e)\r\n",
      "TV\r\n",
      "cd player\r\n",
      "phone\r\n",
      "light\r\n",
      "fridger\r\n",
      "mixer\r\n",
      "audio\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "me.removeAll(u);\n",
    "for(String e:me)\n",
    "    System.out.printf(\"%s\\n\",e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " me.retainAll(u);\r\n",
      "|  Expression value is: false\r\n",
      "|    assigned to temporary variable $124 of type boolean\r\n",
      "\r\n",
      " for(String e:me)\r\n",
      "     System.out.printf(\"%s\\n\",e)\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "me.retainAll(u);\n",
    "for(String e:me)\n",
    "    System.out.printf(\"%s\\n\",e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 양쪽에 적어도 하나씩 이상 있는 모든 기기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set<String> allSet=new HashSet<String>();\n",
    "allSet.addAll(me);\n",
    "allSet.addAll(u);\n",
    "for(String e:allSet)\n",
    "    System.out.printf(\"%s\\n\",e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 기기의 댓수를 세기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "//String[] myHome={\"TV\", \"TV\",\"phone\", \"camera\", \"fridger\", \"mixer\", \"audio\", \"cd player\", \"light\", \"computer\", \"notebook\", \"recorder\"}\n",
    "//String[] yourHome={\"coffee machine\", \"radio\", \"camera\", \"running machine\", \"ramp\", \"computer\", \"notebook\", \"recorder\"}\n",
    "ArrayList<String> allList=new ArrayList<String>();\n",
    "allList.addAll(Arrays.asList(myHome));\n",
    "allList.addAll(Arrays.asList(yourHome));\n",
    "\n",
    "Map<String, Integer> wc = new HashMap<String, Integer>();\n",
    "for(String e:allList)\n",
    "    if (wc.containsKey(e)) {\n",
    "        wc.put(e,wc.get(e)+1);\n",
    "    } else {\n",
    "        wc.put(e,1);\n",
    "    }\n",
    "System.out.print(wc);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 6.10 Generic type\n",
    "\n",
    "* generic type은 데이터 타잎의 한 종류.\n",
    "* generic type에는 Box class를 사용해서 특정 데이터 타잎을 대신할 수 있다.\n",
    "* Box class의 변수는 한글자, 대문자로 표현한다.\n",
    "* 다이어몬드 <> 표기법을 사용해서 데이터 타잎을 생성할 수 있다.\n",
    "* Collection에도 generic을 사용할 수 있다.\n",
    "* Generics를 사용하면, 데이터 타잎을 제한해서 컴파일 오류를 줄일 수 있다.\n",
    "\n",
    "Box | 설명\n",
    "-----|-----\n",
    "E | Element\n",
    "K | Key\n",
    "N | Number\n",
    "T | Type\n",
    "V | Value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " <E> void printArr(E[] arr) {\r\n",
      "     for(E element:arr) {\r\n",
      "         System.out.printf(\"%s\\n\", element);\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added method printArr(E[])\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "<E> void printArr(E[] arr) {\n",
    "    for(E element:arr) {\n",
    "        System.out.printf(\"%s\\n\", element);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Integer[] numbers = {1, 2, 3};\r\n",
      "|  Added variable numbers of type Integer[] with initial value [Ljava.lang.Integer;@35d176f7\r\n",
      "\r\n",
      " Double[] temperatures = {11.2, 21.3, 31.4};\r\n",
      "|  Added variable temperatures of type Double[] with initial value [Ljava.lang.Double;@6ebc05a6\r\n",
      "\r\n",
      " String[] cities={\"Seoul\",\"NY\",\"Tokyo\"};\r\n",
      "|  Replaced variable cities of type String[] with initial value [Ljava.lang.String;@50b494a6\r\n",
      "|    Update overwrote variable cities\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " printArr(numbers);\r\n",
      "1\r\n",
      "2\r\n",
      "3\r\n",
      "\r\n",
      " printArr(temperatures);\r\n",
      "11.2\r\n",
      "21.3\r\n",
      "31.4\r\n",
      "\r\n",
      " printArr(cities);\r\n",
      "Seoul\r\n",
      "NY\r\n",
      "Tokyo\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Integer[] numbers = {1, 2, 3};\n",
    "Double[] temperatures = {11.2, 21.3, 31.4};\n",
    "String[] cities={\"Seoul\",\"NY\",\"Tokyo\"};\n",
    "\n",
    "printArr(numbers);\n",
    "printArr(temperatures);\n",
    "printArr(cities);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 데이터구조-15: '학생' 객체를 정렬하기\n",
    "\n",
    "### 문제\n",
    "\n",
    "객체를 정렬하는 것은 생각해 볼 측면이 있다.\n",
    "원시데이터에 해당하는 Wrapper클래스는 문제가 없다.\n",
    "예를 들어, Integer(1), Integer(2) 등은 정렬이 쉽다.\n",
    "그러나 Student 클래스는 이름, 생년월일, 키 등 정렬하려면 기준을 정해야 한다.\n",
    "\n",
    "### 해결\n",
    "객체를 Collection으로 만들고, 유틸리티 클래스 Collections.sort()를 사용하여 정렬한다.\n",
    "단 객체를 정렬할 경우에는 compareTo()함수를 구현해 놓아야 한다.\n",
    "\n",
    "old | new\n",
    "------|-----\n",
    "ArrayList$\\lt$String$\\gt$ | ArrayList$\\lt$Student$\\gt$\n",
    "stduentNameList.add(student.getName()) | studentList.add(student)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 1-1 학생 객체 만들기\n",
    "\n",
    "Student 객체는 name, studentNum과 같이 속성을 가지고 있다. 정렬할 경우에는 name으로 하든지, studentNum으로 하든지 결정해 놓아야 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " // %load src/com/sd/dao/v1/Student.java\r\n",
      "\r\n",
      " public class Student {\r\n",
      "    private String name;\r\n",
      "    private int studentNum;\r\n",
      " \r\n",
      "    Student(String name, int sNum){\r\n",
      "       this.name = name;\r\n",
      "       this.studentNum = studentNum;\r\n",
      "    }\r\n",
      "    public String getName() {\r\n",
      "       return name;\r\n",
      "    }\r\n",
      " }\r\n",
      "|  Warning:\r\n",
      "|  Modifier 'public'  not permitted in top-level declarations, ignored\r\n",
      "|  public class Student {\r\n",
      "|  ^----^\r\n",
      "|  Replaced class Student this error is corrected: \r\n",
      "|      Modifier 'public'  not permitted in top-level declarations, ignored\r\n",
      "|      public class Student {\r\n",
      "|      ^----^\r\n",
      "|    Update modified variable studentList of type ArrayList<Student> with initial value \r\n",
      "|    Update replaced variable s1, reset to null\r\n",
      "|    Update modified variable _studentList of type ArrayList<Student> with initial value \r\n",
      "|    Update replaced variable s5, reset to null\r\n",
      "|    Update replaced variable s3, reset to null\r\n",
      "|    Update overwrote class Student\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "// %load src/com/sd/dao/v1/Student.java\n",
    "public class Student {\n",
    "   private String name;\n",
    "   private int studentNum;\n",
    "\n",
    "   Student(String name, int sNum){\n",
    "      this.name = name;\n",
    "      this.studentNum = studentNum;\n",
    "   }\n",
    "   public String getName() {\n",
    "      return name;\n",
    "   }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 1-2 학생 이름을 정렬하기\n",
    "\n",
    "#### 버전 1: 학생이름만을 정렬\n",
    "\n",
    "ArrayList<String>로 name만을 넣어서 정렬한다.\n",
    "단 객체의 정렬은 아니다. 즉 학생 name으로 순서대로 정렬하는 것이다.\n",
    "Collections 유틸리티 클래스를 사용하면 간편하게 정렬할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ArrayList<String> studentNametList = new ArrayList<String>();\r\n",
      "|  Modified variable studentNametList of type ArrayList<String> with initial value []\r\n",
      "|    Update overwrote variable studentNametList\r\n",
      "\r\n",
      " Student s1=new Student(\"js 1\", 1);\r\n",
      "|  Modified variable s1 of type Student with initial value Student@31610302\r\n",
      "|    Update overwrote variable s1\r\n",
      "\r\n",
      " Student s5=new Student(\"js 5\", 5);\r\n",
      "|  Modified variable s5 of type Student with initial value Student@71318ec4\r\n",
      "|    Update overwrote variable s5\r\n",
      "\r\n",
      " Student s3=new Student(\"js 3\", 3);\r\n",
      "|  Modified variable s3 of type Student with initial value Student@21213b92\r\n",
      "|    Update overwrote variable s3\r\n",
      "\r\n",
      " studentNametList.add(s1.getName());\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $47 of type boolean\r\n",
      "\r\n",
      " studentNametList.add(s5.getName());\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $48 of type boolean\r\n",
      "\r\n",
      " studentNametList.add(s3.getName());\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $49 of type boolean\r\n",
      "\r\n",
      " Collections.sort(studentNametList);\r\n",
      "\r\n",
      " System.out.println(studentNametList);\r\n",
      "[js 1, js 3, js 5]\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "ArrayList<String> studentNametList = new ArrayList<String>();\n",
    "Student s1=new Student(\"js 1\", 1);\n",
    "Student s5=new Student(\"js 5\", 5);\n",
    "Student s3=new Student(\"js 3\", 3);\n",
    "studentNametList.add(s1.getName());\n",
    "studentNametList.add(s5.getName());\n",
    "studentNametList.add(s3.getName());\n",
    "Collections.sort(studentNametList);\n",
    "System.out.println(studentNametList);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 버전 2: 객체의 정렬\n",
    "\n",
    "앞서 **```ArrayList<String>```**로 했지만, 여기서는 **```ArrayList<Student>```**를 생성하여 정렬한다.\n",
    "단, Collections.sort()를 사용하기 위해서는 **compareTo()**를 구현해야 한다.\n",
    "\n",
    "compareTo()는 인자가 T. 즉 Student 또는 Object로 해도 좋다.\n",
    "\n",
    "```java\n",
    "int\tcompareTo(T o)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ArrayList<Student> _studentList = new ArrayList<Student>();\r\n",
      "|  Modified variable _studentList of type ArrayList<Student> with initial value []\r\n",
      "|    Update overwrote variable _studentList\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " _studentList.add(s1);\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $54 of type boolean\r\n",
      "\r\n",
      " _studentList.add(s5);\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $55 of type boolean\r\n",
      "\r\n",
      " _studentList.add(s3);\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $56 of type boolean\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "ArrayList<Student> _studentList = new ArrayList<Student>();\n",
    "\n",
    "_studentList.add(s1);\n",
    "_studentList.add(s5);\n",
    "_studentList.add(s3);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 학생객체를 정렬하면 오류가 발생한다. 그 이유는 정렬방법이 정해지지 않았기 때문이다. **compareTo()를 구현하여 정렬방법**을 정의해야 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Collections.sort(_studentList);\r\n",
      "|  Error:\r\n",
      "|  no suitable method found for sort(java.util.ArrayList<Student>)\r\n",
      "|      method java.util.Collections.<T>sort(java.util.List<T>) is not applicable\r\n",
      "|        (inference variable T has incompatible bounds\r\n",
      "|          equality constraints: Student\r\n",
      "|          upper bounds: java.lang.Comparable<? super T>)\r\n",
      "|      method java.util.Collections.<T>sort(java.util.List<T>,java.util.Comparator<? super T>) is not applicable\r\n",
      "|        (cannot infer type-variable(s) T\r\n",
      "|          (actual and formal argument lists differ in length))\r\n",
      "|  Collections.sort(_studentList);\r\n",
      "|  ^--------------^\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Collections.sort(_studentList);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "학생객체를 정렬할 수 있게 수정한다.\n",
    "**compareTo()**함수를 추가해야 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " public class Student implements Comparable<Student>{\r\n",
      "    private String name;\r\n",
      "    private int studentNum;\r\n",
      " \r\n",
      "    Student(String name, int sNum){\r\n",
      "       this.name = name;\r\n",
      "       this.studentNum = sNum;\r\n",
      "    }\r\n",
      "    public String getName() {\r\n",
      "       return name;\r\n",
      "    }\r\n",
      "    public void setName(String name) {\r\n",
      "       this.name = name;\r\n",
      "    }\r\n",
      "    @Override\r\n",
      "    public int compareTo(Student s) {\r\n",
      "         return name.compareTo(s.getName());\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Warning:\r\n",
      "|  Modifier 'public'  not permitted in top-level declarations, ignored\r\n",
      "|  public class Student implements Comparable<Student>{\r\n",
      "|  ^----^\r\n",
      "|  Replaced class Student this error is corrected: \r\n",
      "|      Modifier 'public'  not permitted in top-level declarations, ignored\r\n",
      "|      public class Student implements Comparable<Student>{\r\n",
      "|      ^----^\r\n",
      "|    Update modified variable studentList of type ArrayList<Student> with initial value \r\n",
      "|    Update replaced variable s1, reset to null\r\n",
      "|    Update modified variable _studentList of type ArrayList<Student> with initial value \r\n",
      "|    Update replaced variable s5, reset to null\r\n",
      "|    Update replaced variable s3, reset to null\r\n",
      "|    Update overwrote class Student\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "public class Student implements Comparable<Student>{\n",
    "   private String name;\n",
    "   private int studentNum;\n",
    "\n",
    "   Student(String name, int sNum){\n",
    "      this.name = name;\n",
    "      this.studentNum = sNum;\n",
    "   }\n",
    "   public String getName() {\n",
    "      return name;\n",
    "   }\n",
    "   public void setName(String name) {\n",
    "      this.name = name;\n",
    "   }\n",
    "   @Override\n",
    "   public int compareTo(Student s) {\n",
    "        return name.compareTo(s.getName());\n",
    "    }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ArrayList<Student> studentList = new ArrayList<Student>();\r\n",
      "|  Modified variable studentList of type ArrayList<Student> with initial value []\r\n",
      "|    Update overwrote variable studentList\r\n",
      "\r\n",
      " Student s1=new Student(\"js 1\", 1);\r\n",
      "|  Modified variable s1 of type Student with initial value Student@3108bc\r\n",
      "|    Update overwrote variable s1\r\n",
      "\r\n",
      " Student s5=new Student(\"js 5\", 5);\r\n",
      "|  Modified variable s5 of type Student with initial value Student@370736d9\r\n",
      "|    Update overwrote variable s5\r\n",
      "\r\n",
      " Student s3=new Student(\"js 3\", 3);\r\n",
      "|  Modified variable s3 of type Student with initial value Student@5f9d02cb\r\n",
      "|    Update overwrote variable s3\r\n",
      "\r\n",
      " studentList.add(s1);\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $62 of type boolean\r\n",
      "\r\n",
      " studentList.add(s5);\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $63 of type boolean\r\n",
      "\r\n",
      " studentList.add(s3);\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $64 of type boolean\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "ArrayList<Student> studentList = new ArrayList<Student>();\n",
    "Student s1=new Student(\"js 1\", 1);\n",
    "Student s5=new Student(\"js 5\", 5);\n",
    "Student s3=new Student(\"js 3\", 3);\n",
    "studentList.add(s1);\n",
    "studentList.add(s5);\n",
    "studentList.add(s3);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "임의의 student 객체를 서로 비교해 보자.\n",
    "**compareTo()에서 정해진 정렬방법에 따라** \"js 1\"과 \"js 5\"의 차이를 알 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " s1.compareTo(s5);\r\n",
      "|  Expression value is: -4\r\n",
      "|    assigned to temporary variable $65 of type int\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "s1.compareTo(s5);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "Collections.sort() 함수를 사용하여 정렬하고, 출력해 보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Collections.sort(studentList);\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Collections.sort(studentList);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(Student e:studentList)\r\n",
      "     System.out.println(e.getName());\r\n",
      "js 1\r\n",
      "js 3\r\n",
      "js 5\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for(Student e:studentList)\n",
    "    System.out.println(e.getName());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 6.9 Queue\n",
    "\n",
    "* Queue는 인터페이스라서, 사용하려면 구현하는 클래스가 필요하다.\n",
    "* **LinkedList**로 구현한다 (singly linked list)\n",
    "* Stack은 Lifo, Queue는 Fifo\n",
    "* 들여다 보기\n",
    "```java\n",
    "E peek()\n",
    "```\n",
    "\n",
    "* 하나 꺼내기\n",
    "```java\n",
    "E poll()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "import java.util.LinkedList;\n",
    "Queue cities = new LinkedList();\n",
    "\n",
    "cities.add(\"Seoul\");\n",
    "cities.add(\"NY\");\n",
    "cities.add(\"Tokyo\");\n",
    "\n",
    "System.out.println(cities);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "cities.peek();\n",
    "System.out.println(cities.poll());\n",
    "cities.peek();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 연습문제\n",
    "\n",
    "* 2차원 데이터 - 시간표 복사?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 문제 6-1: 색을 목록으로 만들고 출력하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " /set feedback off\r\n"
     ]
    }
   ],
   "source": [
    "/set feedback off"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " import java.util.*;\r\n",
      "\r\n",
      " class p6_1_Colors {\r\n",
      "     void setColors() {\r\n",
      "         List<String> ColorList = new ArrayList<String>();\r\n",
      "         ColorList.add(\"Red\");\r\n",
      "         ColorList.add(\"Green\");\r\n",
      "         ColorList.add(\"Blue\");\r\n",
      "         ColorList.add(\"White\");\r\n",
      "         System.out.println(ColorList);\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added class p6_1_Colors\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "import java.util.*;\n",
    "class p6_1_Colors {\n",
    "    void setColors() {\n",
    "        List<String> ColorList = new ArrayList<String>();\n",
    "        ColorList.add(\"Red\");\n",
    "        ColorList.add(\"Green\");\n",
    "        ColorList.add(\"Blue\");\n",
    "        ColorList.add(\"White\");\n",
    "        System.out.println(ColorList);\n",
    "    }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " p6_1_Colors c=new p6_1_Colors();\r\n",
      "|  Added variable c of type p6_1_Colors with initial value p6_1_Colors@ff5b51f\r\n",
      "\r\n",
      " c.setColors();\r\n",
      "[Red, Green, Blue, White]\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "p6_1_Colors c=new p6_1_Colors();\n",
    "c.setColors();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 문제 6-2: 위 문제를 수정해서 색을 for문으로 출력\n",
    "\n",
    "> 주의\n",
    ">\n",
    "> printColors()함수를 추가한 후, setColors()에서 생성한 데이터를 사용하려면 멤버변수로 만들었다.\n",
    "> setColors()의 println()함수는 제거하였다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " import java.util.*;\r\n",
      "\r\n",
      " class p6_2_Colors {\r\n",
      "     List<String> ColorList = new ArrayList<String>();\r\n",
      "     void setColors() {\r\n",
      "         ColorList.add(\"Red\");\r\n",
      "         ColorList.add(\"Green\");\r\n",
      "         ColorList.add(\"Blue\");\r\n",
      "         ColorList.add(\"White\");\r\n",
      "     }\r\n",
      "     void printColors() {\r\n",
      "         for (String element : ColorList)\r\n",
      "             System.out.println(element);\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Modified class p6_2_Colors\r\n",
      "|    Update overwrote class p6_2_Colors\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "import java.util.*;\n",
    "class p6_2_Colors {\n",
    "    List<String> ColorList = new ArrayList<String>();\n",
    "    void setColors() {\n",
    "        ColorList.add(\"Red\");\n",
    "        ColorList.add(\"Green\");\n",
    "        ColorList.add(\"Blue\");\n",
    "        ColorList.add(\"White\");\n",
    "    }\n",
    "    void printColors() {\n",
    "        for (String element : ColorList)\n",
    "            System.out.println(element);\n",
    "    }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " p6_2_Colors c=new p6_2_Colors();\r\n",
      "|  Replaced variable c of type p6_2_Colors with initial value p6_2_Colors@20398b7c\r\n",
      "|    Update overwrote variable c\r\n",
      "\r\n",
      " c.setColors();\r\n",
      "\r\n",
      " c.printColors();\r\n",
      "Red\r\n",
      "Green\r\n",
      "Blue\r\n",
      "White\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "p6_2_Colors c=new p6_2_Colors();\n",
    "c.setColors();\n",
    "c.printColors();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 문제 6-3: 배열에 데이터를 추가해 보세요.\n",
    "\n",
    "* 데이터를 특정 인덱스에 추가. \"Black\"을 3번째에 추가."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " import java.util.*;\r\n",
      "\r\n",
      " class p6_3_Colors {\r\n",
      "     List<String> colorList = new ArrayList<String>();\r\n",
      "     void setColors() {\r\n",
      "         colorList.add(\"Red\");\r\n",
      "         colorList.add(\"Green\");\r\n",
      "         colorList.add(\"Blue\");\r\n",
      "         colorList.add(\"White\");\r\n",
      "     }\r\n",
      "     void printColors() {\r\n",
      "         for (String element : colorList)\r\n",
      "             System.out.println(element);\r\n",
      "     }\r\n",
      "     void addTo(int i, String element) {\r\n",
      "         colorList.add(i,element);\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Modified class p6_3_Colors\r\n",
      "|    Update overwrote class p6_3_Colors\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "import java.util.*;\n",
    "class p6_3_Colors {\n",
    "    List<String> colorList = new ArrayList<String>();\n",
    "    void setColors() {\n",
    "        colorList.add(\"Red\");\n",
    "        colorList.add(\"Green\");\n",
    "        colorList.add(\"Blue\");\n",
    "        colorList.add(\"White\");\n",
    "    }\n",
    "    void printColors() {\n",
    "        for (String element : colorList)\n",
    "            System.out.println(element);\n",
    "    }\n",
    "    void addTo(int i, String element) {\n",
    "        colorList.add(i,element);\n",
    "    }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " p6_3_Colors c=new p6_3_Colors();\r\n",
      "|  Modified variable c of type p6_3_Colors with initial value p6_3_Colors@5ec0a365\r\n",
      "|    Update overwrote variable c\r\n",
      "\r\n",
      " c.setColors();\r\n",
      "\r\n",
      " c.addTo(3,\"Black\");\r\n",
      "\r\n",
      " c.printColors();\r\n",
      "Red\r\n",
      "Green\r\n",
      "Blue\r\n",
      "Black\r\n",
      "White\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "p6_3_Colors c=new p6_3_Colors();\n",
    "c.setColors();\n",
    "c.addTo(3,\"Black\");\n",
    "c.printColors();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 문제 6-4: 정렬\n",
    "\n",
    "* 정렬하려면 Collections를 사용한다.\n",
    "* 정렬하고 나면 결과로 엎어쓴다.\n",
    "\n",
    "> Collections는 List, Array는 배열\n",
    ">\n",
    "> List | 배열\n",
    "> -----|-----\n",
    "> Collections.sort() | Arrays.sort()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " import java.util.*;\r\n",
      "\r\n",
      " class p6_4_Colors {\r\n",
      "     List<String> colorList = new ArrayList<String>();\r\n",
      "     void setColors() {\r\n",
      "         colorList.add(\"Red\");\r\n",
      "         colorList.add(\"Green\");\r\n",
      "         colorList.add(\"Blue\");\r\n",
      "         colorList.add(\"White\");\r\n",
      "     }\r\n",
      "     void printColors() {\r\n",
      "         for (String element : colorList)\r\n",
      "             System.out.println(element);\r\n",
      "     }\r\n",
      "     void sort() {\r\n",
      "         Collections.sort(colorList);\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added class p6_4_Colors\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "import java.util.*;\n",
    "class p6_4_Colors {\n",
    "    List<String> colorList = new ArrayList<String>();\n",
    "    void setColors() {\n",
    "        colorList.add(\"Red\");\n",
    "        colorList.add(\"Green\");\n",
    "        colorList.add(\"Blue\");\n",
    "        colorList.add(\"White\");\n",
    "    }\n",
    "    void printColors() {\n",
    "        for (String element : colorList)\n",
    "            System.out.println(element);\n",
    "    }\n",
    "    void sort() {\n",
    "        Collections.sort(colorList);\n",
    "    }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " p6_4_Colors c=new p6_4_Colors();\r\n",
      "|  Replaced variable c of type p6_4_Colors with initial value p6_4_Colors@4e9ba398\r\n",
      "|    Update overwrote variable c\r\n",
      "\r\n",
      " c.setColors();\r\n",
      "\r\n",
      " c.sort();\r\n",
      "\r\n",
      " c.printColors();\r\n",
      "Blue\r\n",
      "Green\r\n",
      "Red\r\n",
      "White\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "p6_4_Colors c=new p6_4_Colors();\n",
    "c.setColors();\n",
    "c.sort();\n",
    "c.printColors();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 배열을 정렬할 경우에는, Arrays sort()를 사용한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " String[] colors={\"Red\",\"Green\",\"Blue\"};\r\n",
      "|  Added variable colors of type String[] with initial value [Ljava.lang.String;@402a079c\r\n",
      "\r\n",
      " Arrays.sort(colors);\r\n",
      "\r\n",
      " for(String s:colors)\r\n",
      "     System.out.println(s);\r\n",
      "Blue\r\n",
      "Green\r\n",
      "Red\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "String[] colors={\"Red\",\"Green\",\"Blue\"};\n",
    "Arrays.sort(colors);\n",
    "for(String s:colors)\n",
    "    System.out.println(s);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 문제 6-5: 비교\n",
    "\n",
    "List a.retainAll(List b)\n",
    "isEqual\n",
    "\n",
    "> 주의\n",
    "> 함수이름이 equals()를 사용하면 overriding으로 \n",
    "> Object 클래스의 boolean equals(Object obj)를 사용한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " import java.util.*;\r\n",
      "\r\n",
      " class p6_5_Colors {\r\n",
      "     List<String> colorList = new ArrayList<String>();\r\n",
      "     void setColors() {\r\n",
      "         colorList.add(\"Red\");\r\n",
      "         colorList.add(\"Green\");\r\n",
      "         colorList.add(\"Blue\");\r\n",
      "         colorList.add(\"White\");\r\n",
      "     }\r\n",
      "     boolean retainAll(List another) {\r\n",
      "         return colorList.retainAll(another);\r\n",
      "     }\r\n",
      "     //boolean equals(Object another) {\r\n",
      "     boolean isEqual(List another) {\r\n",
      "         return colorList.equals(another);\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added class p6_5_Colors\r\n",
      "|    Update replaced variable c, reset to null\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "import java.util.*;\n",
    "class p6_5_Colors {\n",
    "    List<String> colorList = new ArrayList<String>();\n",
    "    void setColors() {\n",
    "        colorList.add(\"Red\");\n",
    "        colorList.add(\"Green\");\n",
    "        colorList.add(\"Blue\");\n",
    "        colorList.add(\"White\");\n",
    "    }\n",
    "    boolean retainAll(List another) {\n",
    "        return colorList.retainAll(another);\n",
    "    }\n",
    "    //boolean equals(Object another) {\n",
    "    boolean isEqual(List another) {\n",
    "        return colorList.equals(another);\n",
    "    }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " List<String> colorListB = new ArrayList<String>();\r\n",
      "|  Modified variable colorListB of type List<String> with initial value []\r\n",
      "|    Update overwrote variable colorListB\r\n",
      "\r\n",
      " colorListB.add(\"Red\");\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $52 of type boolean\r\n",
      "\r\n",
      " colorListB.add(\"Green\");\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $53 of type boolean\r\n",
      "\r\n",
      " colorListB.add(\"Blue\");\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $54 of type boolean\r\n",
      "\r\n",
      " p6_5_Colors c=new p6_5_Colors();\r\n",
      "|  Modified variable c of type p6_5_Colors with initial value p6_5_Colors@49993335\r\n",
      "|    Update overwrote variable c\r\n",
      "\r\n",
      " c.setColors();\r\n",
      "\r\n",
      " c.retainAll(colorListB);\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $57 of type boolean\r\n",
      "\r\n",
      " c.isEqual(colorListB);\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $58 of type boolean\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "List<String> colorListB = new ArrayList<String>();\n",
    "colorListB.add(\"Red\");\n",
    "colorListB.add(\"Green\");\n",
    "colorListB.add(\"Blue\");\n",
    "p6_5_Colors c=new p6_5_Colors();\n",
    "c.setColors();\n",
    "c.retainAll(colorListB);\n",
    "c.isEqual(colorListB);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 과제\n",
    "\n",
    "* 1. '서울시 학교생활 만족도 통계' 평균을 구하는 프로그램 작성\n",
    "    * 서울열린데이터광장 data.seoul.go.kr > 검색 '통계학교생활'\n",
    "    * 매우만족+만족 평균, 불만족+매우불만족 평균\n",
    "\n",
    "* 2 . 대통령 연설 2개를 분석해서 빈번한 단어의 차이를 보여주는 프로그램 작성\n",
    "    * 미국대통령 취임연설 (한글처리가능하면 한국대통령 취임연설) 가운데 최근 것과 과거 것 1개씩 선택\n",
    "    * 가장 많이 등장하는 단어 10개씩을 추출하여 비교.\n",
    "    * http://www.infoplease.com/t/hist/inaugural/\n",
    "\n",
    "* 제출기한\n",
    "    * 금요일 오후 5시\n"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Java 9",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "file_extension": ".class",
   "mimetype": "application/java-vm",
   "name": "java"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}