Courses/Mathesis/Intro2ProgrammingWithJava/Week6/6.2-UsefulClasses/6.2-UsefulClasses.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3e3d0e1c-13f4-44a2-9df3-c75a4374120f",
   "metadata": {},
   "source": [
    "# 6.2 Χρήσιμες κλάσεις\n",
    "© Γιάννης Κωστάρας\n",
    "\n",
    "---\n",
    "\n",
    "[<](../6.1-Exceptions/6.1-Exceptions.ipynb) | [Δ](../../TOC.ipynb) | [>](../6.3-BuildTools/6.3-BuildTools.ipynb)  \n",
    " \n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5c3fb9d-d871-4c9e-9bef-3be048430dd9",
   "metadata": {},
   "source": [
    "Σ' αυτό το μάθημα θα δούμε κάποιες χρήσιμες κλάσεις της γλώσσας.\n",
    "\n",
    "## ```StringBuilder``` και ```StringJoiner```\n",
    "Όπως μάθαμε στα μαθήματα της πρώτης εβδομάδας, η κλάση ```String``` είναι αμετάβλητη (immutable). Κάθε φορά που εκχωρείτε κάποια τιμή σε μια συμβολοσειρά, δημιουργείται ένα νέο αντικείμενο της κλάσης (δεν τροποποιείται το προηγούμενο). Π.χ. στο ακόλουθο παράδειγμα δημιουργείται κάθε φορά ένα νέο αντικείμενο ```String```:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "eec1846c-6593-4c99-bf7a-d82ef8ca3c93",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hello World"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "String s1 = \"Hello \";\n",
    "String s2 = \"World\";\n",
    "s1 = s1 + s2;\n",
    "s1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f44cced3-a27b-4ad4-b4d6-7ae57ce3a8db",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "This is a String "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "String[] strings = {\"This\", \"is\", \"a\", \"String\"};\n",
    "String sentence=\"\";\n",
    "for (String s : strings)\n",
    "   sentence += s + \" \";\n",
    "sentence;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcd2bd31-29b6-45fe-bdf1-68864fb40a28",
   "metadata": {},
   "source": [
    "Μέσα στο βρόγχο ```for``` δημιουργείται κάθε φορά ένα νέο ```String``` που αποθηκεύει το αποτέλεσμα της συνένωσης (```s + \" \"```), ένα για την συγχώνευση με το ```sentence``` (```+=```) και τέλος ένα νέο για την εκχώρηση (δημιουργείται μια νέα θέση μνήμης που ονομάζεται πάλι ```sentence```). Καταλαβαίνετε ότι αν έχουμε έναν βρόγχο με πολλές επαναλήψεις, δημιουργούνται πολλά νέα αντικείμενα χωρίς λόγο πράγμα που έχει επίπτωση στην απόδοση του προγράμματός μας. Να θυμάστε ότι κάθε φορά που συνενώνετε δυο αλφαριθημτικά, δημιουργούνται νέα αντίγραφα αυτών καθώς η κλάση ```String``` είναι immutable. \n",
    "\n",
    "Η γλώσσα παρέχει μια μεταβαλλόμενη (mutable) έκδοση της ```String```, την ```StringBuilder``` (και την παρωχημένη ```StringBuffer```). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "63777f9a-8e9f-4322-9357-974d0319c6af",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "This is a String "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "StringBuilder sb = new StringBuilder(4);\n",
    "for (String s : strings)\n",
    "   sb.append(s).append(\" \");\n",
    "sb.toString();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a09e9db-547e-4016-86bf-e6d33cdc6354",
   "metadata": {},
   "source": [
    "Από την έκδοση 9 και μετά, η απόδοση της κλάσης ```String``` έχει βελτιωθεί πολύ με αποτέλεσμα ο τελεστής συγχώνευσης ```+``` να είναι πιο αποτελεσματικός από τη χρήση της ```StringBuilder```. Χρησιμοποιήστε την ```StringBuilder``` μόνο όταν χρειάζεται να συγχωνεύσετε αλφαριθμητικά μέσα σε βρόγχους. Σε όλες τις άλλες περιπτώσεις, ο τελεστής ```+``` είναι πλέον πολύ αποδοτικός.\n",
    "\n",
    "Η κλάση ```StringJoiner``` εισήχθηκε στην έκδοση 8 και επιτρέπει τη δημιουργία αλφαριθμητικών συνενώνοντας άλλα αλφαριθμητικά:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "09fb9d73-5d45-4167-b4e4-0557a58bd850",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[α, β, γ]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "StringJoiner sj = new StringJoiner(\", \", \"[\", \"]\");  // StringJoiner(CharSequence delimiter, CharSequence prefix, CharSequence suffix)\n",
    "for (String s : new String[]{\"α\", \"β\", \"γ\"}) {\n",
    "    sj.add(s);\n",
    "}\n",
    "sj"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "820c0428-3405-477c-9be2-98cc07eb8c6f",
   "metadata": {},
   "source": [
    "Για να διαχωρίσουμε αλφαριθμητικά:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f468f8db-fb37-410a-8cce-8e64f09fed9e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ιαν\n",
      "Φεβ\n",
      "Μάρ\n"
     ]
    }
   ],
   "source": [
    "String s = \"Ιαν Φεβ Μάρ\";\n",
    "StringTokenizer st = new StringTokenizer(s, \" \");\n",
    "while (st.hasMoreTokens()) {\n",
    "    System.out.println(st.nextToken());\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d2ca9b29-beb3-4cc7-b39a-4b318ea52c7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ιαν\n",
      "Φεβ\n",
      "Μάρ\n"
     ]
    }
   ],
   "source": [
    "String[] split = s.split(\" \");\n",
    "for (String str : split)\n",
    "    System.out.println(str);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc3ebe30-2788-47f0-9884-5eaa041ca906",
   "metadata": {},
   "source": [
    "Μπορείτε να πειραματιστείτε περαιτέρω εδώ <a href=\"sandbox/string.html\" target=\"_blank\"><img src=\"../../../assets/javaalmanac.svg\" alt=\"javaalmanac.io\" style=\"width:5%; height:5%;\"></a>."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6aa15578-98fc-43d6-a7a4-fab191fc8cd3",
   "metadata": {},
   "source": [
    "## ```Formatter, NumberFormat, System.out.printf()```\n",
    "Έχουμε μάθει ότι οι\t```System.out.print()``` και ```System.out.println()``` εμφανίζουν τα ορίσματά τους στη μονάδα εξόδου (συνήθως οθόνη). Η ```System.out.printf()``` λειτουργεί όπως η ```printf()``` της C και παρέχει περισσότερες δυνατότητες μορφοποίησης με τη βοήθεια της ```Formatter```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "20d64bca-cd04-413a-9ea1-472ae35abe1c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Όνομα: Νίκος, ηλικία: 1\n"
     ]
    }
   ],
   "source": [
    "Formatter f = new Formatter();\n",
    "System.out.print(f.format(\"Όνομα: %s, ηλικία: %d%n\", \"Νίκος\", 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "c2faca9f-a8a3-4160-870c-b37c07f2c8b0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Όνομα: Νίκος, ηλικία: 1\n"
     ]
    }
   ],
   "source": [
    "System.out.print(String.format(\"Όνομα: %s, ηλικία: %d%n\", \"Νίκος\", 1));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "ae08e7c8-3f64-49f5-a5d4-7da73bc3e90f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Όνομα: Νίκος, ηλικία: 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "java.io.PrintStream@414570d8"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "System.out.printf(\"Όνομα: %s, ηλικία: %d%n\", \"Νίκος\", 1);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec42f159-2800-4838-9b4c-536fdfe41850",
   "metadata": {},
   "source": [
    "Τα ```%s, %d``` είναι ειδικοί χαρακτήρες μορφοποίησης που δηλώνουν ότι τα ορίσματα που ακολουθούν είναι αλφαριθμητικό και ακέραιος αριθμός (decimal) αντίστοιχα, ενώ ο ```%n``` δηλώνει το χαρακτήρα αλλαγής γραμμής. \n",
    "\n",
    "Το πρώτο όρισμα ονομάζεται αλφαριθμητικό μορφοποίησης (format string) και έχει τη γενική μορφή:\n",
    "\n",
    "```\n",
    "%[argument_index$][flags][width][.precision]conversion\n",
    "```\n",
    "\n",
    "Το ```[argument_index$]``` είναι προαιρετικό και δηλώνει τη θέση το κάθε ορίσματος, π.χ. ```1$``` είναι το 1ο όρισμα κλπ. Π.χ.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "37366d63-582a-41f8-9b61-5ed5a1a4bba5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Όνομα: Νίκος, ηλικία: 1\n"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = new Formatter();\n",
    "f.format(\"Όνομα: %2$s, ηλικία: %1$d%n\", 1, \"Νίκος\");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c2fa443-3b72-43e2-a272-9687401f1f14",
   "metadata": {},
   "source": [
    "Το προαιρετικό ```flags``` είναι ένα σύνολο από χαρακτήρες που εξαρτώνται από τη μετατροπή (conversion) και μορφοποιούν ανάλογα το όρισμα.\n",
    "\n",
    "| Flag | Μορφή |\n",
    "|---|---|\n",
    "| - | Αριστερή στοίχιση |\n",
    "| + | Με πρόσημο |\n",
    "|   | κενό πριν |\n",
    "| 0 | συμπλήρωμα με 0 πριν |\n",
    "| , | διαχωριστικό |\n",
    "| ( | οι αρνητικοί αριθμοί μέσα σε παρενθέσεις |\n",
    "\n",
    "Το προαιρετικό ```width``` είναι ένας θετικός αριθμός που δηλώνει τον ελάχιστο αριθμό χαρακτήρων που θα εμφανιστούν στην έξοδο (οθόνη).\n",
    "\n",
    "Το προαιρετικό ```precision``` είναι ένας θετικός ακέραιος που περιορίζει τον αριθμό των χαρακτήρων (π.χ. αρ. δεκαδικών ψηφίων). Για αλφαριθμητικά δηλώνει τον αριθμό χαρακτήρων που θα εξάγει από το αλφαριθμητικό.\n",
    "\n",
    "Το ```conversion``` είναι ένας ειδικός χαρακτήρας που δηλώνει πως θα μορφοποιηθεί το όρισμα, π.χ. ```s```. Συνοπτικά:\n",
    "\n",
    "| Conversion | Μορφή |\n",
    "|---|---|\n",
    "| ```a``` | δεκαεξαδικός δεκαδικός αριθμός |\n",
    "| ```b, B``` | ```boolean``` |\n",
    "| ```c, C``` | χαρακτήρας |\n",
    "| ```d``` | ακέραιος αριθμός |\n",
    "| ```e``` | επιστημονική μορφή ακεραίου π.χ. 2Ε-2 |\n",
    "| ```f``` | δεκαδικός αριθμός (```float```) |\n",
    "| ```g``` | επιστημονική μορφή δεκαδικού |\n",
    "| ```h``` | ```Integer.toHexString(αριθμός.hashCode())``` |\n",
    "| ```n``` | αλλαγή γραμμής |\n",
    "| ```o``` | οκταδικός αριθμός |\n",
    "| ```s, S``` | αλφαριθμητικό ```String``` |\n",
    "| ```t, T``` | ημερομηνία/ώρα |\n",
    "| ```x``` | δεκαεξαδικός αριθμός (```hexadecimal```) |\n",
    "| ```%``` | % |\n",
    "\n",
    "Για μια πλήρη περιγραφή βλ. [Formatter ΑΡΙ](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Formatter.html).\n",
    "\n",
    "Π.χ.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c9f0cbf1-173a-43c1-8d2f-5fe93141908c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "e=   +2.7183"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = new Formatter();\n",
    "f.format(\"e=%+10.4f\", Math.E);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f83df3e-fad7-4f77-9960-d484128b4c00",
   "metadata": {},
   "source": [
    "όπου ```Math.E``` είναι το e (η βάση των φυσικών λογαρίθμων). Στο αλφαριθμητικό μορφοποίησης θέλουμε να υπάρχει πρόσημο, το μήκος να είναι 10 χαρακτήρες και 4 δεκαδικά ψηφία, ενώ αναπαριστούμε δεκαδικό αριθμό (```f```)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "c7c1857b-c52e-4911-8ad4-1bec82cfd8fc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1,850.36) €"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = new Formatter();\n",
    "f.format(\"%(,.2f €\", -1850.362);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91799c19-9ae9-40dc-81e0-490922e09dc7",
   "metadata": {},
   "source": [
    "Οι αρνητικοί αριθμοί εμφανίζονται μέσα σε παρενθέσεις, χρησιμοποιούμε την υποδιαστολή σύμφωνα με το εκάστοτε ```Locale``` και επιτρέπουμε 2 δεκαδικά ψηφία.\n",
    "\n",
    "Ίδιοι κανόνες ισχύουν και για την ```printf()```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "60c643de-6417-4b5f-a801-4d21ff32a937",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "false\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "java.io.PrintStream@414570d8"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "System.out.printf(\"%b%n\", null); "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "22b8e5de-5824-4add-847c-08b69683db51",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FALSE\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "java.io.PrintStream@414570d8"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "System.out.printf(\"%B%n\", false);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e9fc7d45-6839-415a-b637-7de51ec44a9c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "α\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "java.io.PrintStream@414570d8"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "System.out.printf(\"%c%n\", 'α');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "6e4b151b-57be-41e9-8e7a-feae7e625e70",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Α\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "java.io.PrintStream@414570d8"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "System.out.printf(\"%C%n\", 'α'); "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "fcb30d40-69c4-4fd3-aab2-4a7e87da1c34",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Γιάννης\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "java.io.PrintStream@414570d8"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "System.out.printf(\"%s%n\", \"Γιάννης\"); "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "f3863b79-643c-433a-9a94-9f0dc28129f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ΓΙΆΝΝΗΣ\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "java.io.PrintStream@414570d8"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "System.out.printf(\"%S%n\", \"Γιάννης\"); "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "38e95f34-af55-450a-93cd-51dcbd9cf533",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'Γιάννης   ' \n"
     ]
    }
   ],
   "source": [
    "printf(\"'%-10s' %n\", \"Γιάννης\"); "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "723e1de2-7b60-4864-9f75-e480890d74e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Το αλφαριθμητικό Hello World έχει hash code cc969a84\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "java.io.PrintStream@414570d8"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "String s = \"Hello World\";\n",
    "System.out.printf(\"Το αλφαριθμητικό %s έχει hash code %h%n\", s, s);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "b13d2d0c-c8b7-474e-9097-3f367737d503",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   2"
     ]
    },
    {
     "data": {
      "text/plain": [
       "java.io.PrintStream@414570d8"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "System.out.printf(\"% 4d\", 2);       // συμπλήρωση με κενά "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "81d042d9-bd0a-4112-8b08-616c97fd8131",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     3.141\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "java.io.PrintStream@414570d8"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "System.out.printf(\"%10.5s%n\", Math.PI);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d29495c-db04-4b67-8da5-4416eb2d48c0",
   "metadata": {},
   "source": [
    "Στο τελευταίο παράδειγμα, προσέξτε ότι θέλουμε να εμφανίσουμε το π ως αλφαριθμητικό αντί για δεκαδικό αριθμό, με αποτέλεσμα η ακρίβεια εδώ να δηλώνει τον αριθμό των χαρακτήρων που θέλουμε να κρατήσουμε από το π (δηλ. 5 χαρακτήρες). Το ```3.141``` είναι ακριβώς 5 χαρακτήρες και το συνολικό μήκος 10 χαρακτήρες.\n",
    "\n",
    "### Μορφοποίηση ώρας\n",
    "\n",
    "|![]()|![]()|\n",
    "|---|---|\n",
    "| H, M, S | εξάγουν ώρες, λεπτά, δευτερόλεπτα αντίστοιχα\n",
    "| L, N | αναπαριστούν την ώρα σε milliseconds και nanoseconds αντίστοιχα\n",
    "| p |  am/pm\n",
    "| z | timezone offset\n",
    "\n",
    "(Αναφέρεται στην κλάση ```java.time.LocalTime```)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "715350bf-31ff-4300-b7d4-96e22d9cf460",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23:29:15.757080"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import java.time.*;\n",
    "LocalTime t = LocalTime.now();\n",
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "a28ebd2e-e6f9-49c9-b79a-c1282ece1982",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hours 23: minutes 29: seconds 15\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "java.io.PrintStream@414570d8"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "System.out.printf(\"hours %tH: minutes %tM: seconds %tS%n\", t, t, t);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "9ebc382f-bc96-4968-9010-4783275b70b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23:29:15 pm 757 757080000 \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "java.io.PrintStream@414570d8"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "System.out.printf(\"%1$tH:%1$tM:%1$tS %1$tp %1$tL %1$tN %n\", t);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54ec3a62-2f91-4b3e-9131-ba6a570ad673",
   "metadata": {},
   "source": [
    "### Μορφοποίηση ημερομηνίας\n",
    "\n",
    "|![]()|![]()|\n",
    "|---|---|\n",
    "| A | ημέρα της εβδομάδας\n",
    "| d | ημέρα του μήνα ως αριθμός\n",
    "| B | μήνας\n",
    "| m | μήνας ως αριθμός\n",
    "| Y | έτος (τετραψήφιο)\n",
    "| y | έτος (διψήφιο)\n",
    "\n",
    "(Αναφέρεται στην κλάση ```java.time.LocalDate```)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "1883301b-3755-479f-8d41-1494d67be491",
   "metadata": {},
   "outputs": [],
   "source": [
    "import java.time.*;\n",
    "LocalDate d = LocalDate.now();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "69dac102-aca0-4662-96dc-68ad7fefe41f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tuesday, 11 October 2022 \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "java.io.PrintStream@414570d8"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "System.out.printf(\"%1$tA, %1$td %1$tB %1$tY %n\", d);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f103de3-2aaf-4fb9-92f3-ae9b612c9111",
   "metadata": {},
   "source": [
    "Μπορείτε να πειραματιστείτε περαιτέρω εδώ <a href=\"sandbox/format.html\" target=\"_blank\"><img src=\"../../../assets/javaalmanac.svg\" alt=\"javaalmanac.io\" style=\"width:5%; height:5%;\"></a>."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5165e9b-d159-4aa5-9438-e8bf4d93cae9",
   "metadata": {},
   "source": [
    "## Γεννήτριες τυχαίων αριθμών\n",
    "Αν θέλετε να παράγετε (ψευδο)τυχαίους αριθμούς, τότε η γλώσσα παρέχει μια επιλογή από κλάσεις γι' αυτό το σκοπό:\n",
    "\n",
    "* ```ThreadLocalRandom```: συνίσταται (από τη Java 7)\n",
    "* ```SecureRandom```: μια κρυπτογραφικά ισχυρή γεννήτρια τυχαίων αριθμών\n",
    "* ```Random```: Δε συνίσταται. Η υπερκλάση των ```ThreadLocalRandom``` και ```SecureRandom```\n",
    "* ```Math.random()```: παράγει τυχαίους δεκαδικούς αριθμούς ίσα κατανεμημένους μεταξύ [0, 1) αλλά είναι πιο αργή\n",
    "\n",
    "Ας δούμε τη χρήστη καθεμιάς.\n",
    "\n",
    "Η ```java.util.Random``` είναι η πρώτη υλοποίηση γεννήτριας (ψευδο)τυχαίων αριθμών. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "5320a422-2978-420f-9790-191f8f577f60",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Random random = new Random();\n",
    "int randInt = random.nextInt();\n",
    "random.nextInt(101)\t// τυχαίος ακέραιος μεταξύ 0 και 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "d961d94f-34bb-4f0c-9660-f5f84debdd59",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "86"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Math.abs(random.nextInt()) % 101;\t// άλλος τρόπος παραγωγής τυχαίου ακεραίου μεταξύ 0 και 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "1242b83b-7b5b-4a14-9691-6b6fed57e8c6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-7628061290027340174"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "long randLong = random.nextLong();\n",
    "randLong"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "3a42f8a5-38ba-42da-b414-7be000dbf444",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6339773835143824"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "double randDouble = random.nextDouble();\t// επιστρέφει μια τιμή μεταξύ [0.0, 1.0)\n",
    "randDouble"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "9b80b5e0-70ae-4597-8f0c-6f763e12ff25",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6379873"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float randFloat = random.nextFloat();\t// όπως και η προηγούμενη\n",
    "randFloat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "4dd88ed1-d591-41e0-b39b-e8de0ce24a30",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "boolean randBoolean = random.nextBoolean();\n",
    "randBoolean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "06cb8b97-06b0-45b5-97dc-a6a056e9fc06",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-62, -61, 72, -95, 111, -17, 73, -15, 11, -50, -100, -76, -15, 20, 110, -59]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "byte[] randBytes = new byte[16];\n",
    "random.nextBytes(randBytes);\t// γεμίζει μια συστοιχία από bytes με τυχαίους αριθμούς\n",
    "Arrays.toString(randBytes);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf51496b-76c3-4a28-a968-45c49196cb68",
   "metadata": {},
   "source": [
    "Η ```Random``` δεν ενδείκνυται για χρήση από εφαρμογές κρυπτογράφησης. Π.χ. η ```Math.abs(random.nextInt()) % n```, όπου ```n``` το πάνω όριο, έχει διάφορα προβλήματα:\n",
    "\n",
    "1. η ακολουθία που παράγεται δεν είναι ακριβώς τυχαία. Τα 2/3 από τους παραγόμενους αριθμούς είναι στο κάτω μισό τους εύρους τιμών της. \n",
    "2. αν το ```n``` είναι πολλ/σιο του 2 τότε η ακολουθία παραγόμενων αριθμών θα επαναληφθεί μετά από λίγο. \n",
    " \n",
    "Η ```random.nextInt(n)```, τουναντίον, συνίσταται για χρήση και προτιμάται από την ```Math.random() * n``` η οποία είναι πολύ πιο αργή σύμφωνα με αυτό το [νήμα](https://community.oracle.com/message/6596485?#6594485).\n",
    "\n",
    "Αντί για τη ```Random```, από την Java 7 και μετά, συνίσταται να χρησιμοποιείτε την ```ThreadLocalRandom```:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "dacf3608-cfe5-4df0-9696-9806ec8a85c2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Random random = ThreadLocalRandom.current();\n",
    "random.nextInt(101);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab51bf84-4878-4098-8ccc-10d3c54a0c18",
   "metadata": {},
   "source": [
    "**Σημείωση:** _η ```nextInt(int n)``` συμπεριφέρεται περίεργα όταν το ```n=2^30+1```._"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "126d650b-cc55-4e34-b3d7-f926667d3e43",
   "metadata": {},
   "source": [
    "Τόσο η ```Random``` όσο και η ```ThreadLocalRandom``` βασίζονται στη λεγόμενη [γραμμική συστοιχιακή γεννήτρια](https://en.wikipedia.org/wiki/Linear_congruential_generator) κι έτσι οι παραγόμενες τιμές μπορούν να προβλεφθούν. Για μη προβλέψιμη παραγωγή τυχαίων αριθμών, χρησιμοποιήστε την πιο αργή αλλά σίγουρη ```SecureRandom``` (έναν από τις δυο τρόπους που φαίνονται παρακάτω):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "92dab089-ae8e-4a8b-b2b3-af124aec9467",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import java.security.SecureRandom;\n",
    "\n",
    "SecureRandom number = SecureRandom.getInstanceStrong();  // throws java.security.NoSuchAlgorithmException\n",
    "number.nextInt(21);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "021d605f-95c8-4db1-8641-a0b85bccce47",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[44, -106, 73, 50]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SecureRandom rng = new SecureRandom();\n",
    "byte[] randomBytes = new byte[4];\n",
    "rng.nextBytes(randomBytes); // Fills randomBytes with random bytes\n",
    "Arrays.toString(randomBytes);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "028b50c6-1d97-4c7a-bfa2-495cb85ac448",
   "metadata": {},
   "source": [
    "Τέλος, αν θέλουμε να παράγουμε πολύ μεγάλους τυχαίους αριθμούς, μπορούμε να χρησιμοποιήσουμε την αντίστοιχη μέθοδο κατασκευής της ```BigInteger``` όπως θα δούμε παρακάτω.\n",
    "\n",
    "Μπορείτε να πειραματιστείτε περαιτέρω εδώ <a href=\"sandbox/random.html\" target=\"_blank\"><img src=\"../../../assets/javaalmanac.svg\" alt=\"javaalmanac.io\" style=\"width:5%; height:5%;\"></a>.\n",
    "\n",
    "## ```BigInteger```\n",
    "Στα μαθήματα της 1ης εβδομάδας μάθαμε για τους πρωτογενείς τύπους δεδομένων της γλώσσας ```int, long, float``` και ```double```. Εξηγήσαμε τους περιορισμούς καθενός. Είδαμε π.χ. ότι ο τύπος ```int``` μπορεί ν' αποθηκεύσει ακέραιους αριθμούς μέχρι το ```Integer.MAX =``` $2^{31}$-1 κι ότι αν οι υπολογισμοί σας τον ξεπεράσουν τότε έχουμε υπερχείλιση και λάθος αποτελέσματα. Επίσης, λόγω του [τρόπου αναπαράστασης των αριθμών κινητής υποδιαστολής](https://en.wikipedia.org/wiki/IEEE_754) από τους Η/Υ, δεν μπορείτε να βασίζεστε στην ακρίβεια των πράξεων τέτοιων αριθμών. Η Java παρέχει τις κλάσεις ([BigInteger](https://docs.oracle.com/javase/10/docs/api/java/math/BigInteger.html) και [BigDecimal](https://docs.oracle.com/javase/10/docs/api/java/math/BigDecimal.html)) γι' αυτό το σκοπό. Σημειώστε ότι και οι δυο κλάσεις είναι αμετάβλητες (immutable) (αν και δεν πληρούν όλα τα κριτήρια). Από σχεδιαστικό λάθος των ```BigInteger``` και ```BigDecimal```, έπρεπε να δηλωθούν ```final``` (άρα δεν ικανοποιούν πλήρως τα κριτήρια της αμεταβλητότητας - immutability). Δυστυχώς πλέον είναι αργά, κι έτσι κάποιος μπορεί να δημιουργήσει μια νέα κακόβουλη ```BigInteger``` η οποία κληρονομεί από την ```BigInteger``` την οποία μπορεί να χρησιμοποιήσετε κατά λάθος στο πρόγραμμά σας με καταστροφικά αποτελέσματα (βλ. [Bloch J. (2017)]).\n",
    "\n",
    "Για να μετατρέψετε έναν ακέραιο τύπου ```int``` ή ```long``` σε ```BigInteger``` προτιμήστε τη στατική μέθοδο ```valueOf```:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "5279cced-2e00-4f93-b110-df7679a4b3a1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9223372036854775807"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "long longValue = Long.MAX_VALUE;\n",
    "longValue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "c5859a94-22b4-496a-8039-dd9727e4fa57",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9223372036854775807"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BigInteger valueFromLong = BigInteger.valueOf(longValue);\n",
    "valueFromLong"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c8293ee-b5f7-43b0-846d-33d9ae36cf40",
   "metadata": {},
   "source": [
    "Για να αναπαραστήσετε αριθμούς μεγαλύτερους του ```Long.MAX_VALUE``` ή μικρότερους του ```Long.MIN_VALUE``` χρησιμοποιήστε τη μέθοδο κατασκευής που δέχεται ένα αλφαριθμητικό ως όρισμα.\n",
    "\n",
    "Μπορεί ν' αναπαραστήσει και αριθμούς διαφορετικής βάσης (```BigInteger(String val, int radix)```):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "c1ca3e0b-15b6-4913-9dea-183f38c2a31d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new BigInteger(\"10\", 2)  // το 10 στο δυαδικό σύστημα ==> 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71a33228-e014-4785-a862-a8eb57e93943",
   "metadata": {},
   "source": [
    "Μπορεί επίσης να μετατρέψει μια ακολουθία από ```bytes```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "18276b56-7d75-466c-8a72-4a24ebbb798b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-128]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "byte[] bytes = new byte[] { (byte) 0x80 };\n",
    "Arrays.toString(bytes);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "6fd020c7-26b5-460c-b64a-c7f17ee48904",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-128"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BigInteger valueFromBytes = new BigInteger(bytes);\n",
    "valueFromBytes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "2f9c97cf-79fa-4a62-b9f7-f75a01e570c6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "128"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BigInteger valueFromBytes = new BigInteger(1, bytes);    // BigInteger(int signum, byte[] magnitude)\n",
    "valueFromBytes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "880cc2b6-fdbe-4a77-a0d8-bd69d7aff482",
   "metadata": {},
   "source": [
    "Η ```BigInteger``` σας δίνει ακόμα τη δυνατότητα να παράγετε τυχαίους αριθμούς: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "4256a38d-df53-4ee0-9b17-4aed296f88f0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "388041982"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new BigInteger(32, new Random());    // BigInteger(int numBits, Random rnd)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c711f4cf-0438-4d76-8052-15551d4b8b68",
   "metadata": {},
   "source": [
    "Μπορείτε να χρησιμοποιήσετε και την ```SecureRandom()``` όπως μάθαμε προηγούμενα. \n",
    "\n",
    "### Μαθηματικοί τελεστές\n",
    "* ```add()```\n",
    "* ```subtract()```\n",
    "* ```multiply()```\n",
    "* ```divide()```\n",
    "* ```remainder()```\n",
    "* ```pow()```\n",
    "* ```max()```\n",
    "* ```min()```\n",
    "* ```gcd()```     // μέγιστος κοινός διαιρέτης \n",
    "\n",
    "### Δυαδικοί τελεστές\n",
    "* ```and()```\n",
    "* ```or()```\n",
    "* ```xor()```\n",
    "* ```not()```\n",
    "* ```andnot()```       \t\t// nand\n",
    "* ```shiftLeft()```\t\t\t// <<\n",
    "* ```shiftRight()```\t\t// >>\n",
    "\n",
    "Τέλος, αποφύγετε να δουλεύετε με πρωτογενή δυαδικά δεδομένα σα να ήταν κωδικοποιημένοι χαρακτήρες. Στο παρακάτω παράδειγμα, κάποια bytes δεν αντιπροσωπεύουν χαρακτήρες, με αποτέλεσμα με την εξ'ορισμού κωδικοποίηση US-ASCII να χάνεται πληροφορία."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "7a8a6caa-5c1b-4432-93b0-27db0ad6b671",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "530500452766"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BigInteger x = new BigInteger(\"530500452766\");\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "c2b6b171-1cd0-4d7a-8f0e-c9645742d338",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[123, -124, 74, -127, -98]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "byte[] byteArray = x.toByteArray();\n",
    "Arrays.toString(byteArray);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "16f59444-a70c-4576-8363-f247c47a8ec6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{�J��"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "String s = new String(byteArray);\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "bdca47bb-7a84-417e-b1d1-a71752c141a4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[123, -17, -65, -67, 74, -17, -65, -67, -17, -65, -67]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "byteArray = s.getBytes();\n",
    "Arrays.toString(byteArray);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "a4f077e6-4f17-4475-9131-2229807934f4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "149830058370101340468658109"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = new BigInteger(byteArray);\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "083c2c70-63b0-4bb8-852e-99961e0ca981",
   "metadata": {},
   "source": [
    "Η λύση στο παραπάνω πρόβλημα:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "6543373a-2d0b-4b38-b824-e76e147860e3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "530500452766"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BigInteger x = new BigInteger(\"530500452766\");\n",
    "String s = x.toString(); // έγκυρη μετατροπή\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "913641aa-226e-4643-abae-cc8d649e7cef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ns=530500452766\n",
      "x1=530500452766\n"
     ]
    }
   ],
   "source": [
    "try {\n",
    "    byte[] byteArray = s.getBytes(\"UTF8\");\n",
    "    String ns = new String(byteArray, \"UTF8\");\n",
    "    System.out.println(\"ns=\"+ns);\n",
    "    BigInteger x1 = new BigInteger(ns);\n",
    "    System.out.println(\"x1=\"+x1);\n",
    "} catch (UnsupportedEncodingException ex) {\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "497d1598-cc99-44bf-b531-cfd5a484f5e5",
   "metadata": {},
   "source": [
    "Μπορείτε να πειραματιστείτε περαιτέρω εδώ <a href=\"sandbox/biginteger.html\" target=\"_blank\"><img src=\"../../../assets/javaalmanac.svg\" alt=\"javaalmanac.io\" style=\"width:5%; height:5%;\"></a>.\n",
    "\n",
    "Ως άσκηση, γράψτε τη μέθοδο υπολογισμού του παραγοντικού χρησιμοποιώντας τη κλάση ```BigInteger```.\n",
    "\n",
    "## ```BigDecimal```\n",
    "Ας δούμε ένα παράδειγμα. Ας υποθέσουμε ότι έχουμε χαρτζιλίκι 1€ και θέλουμε να βρούμε πόσες καραμέλες μπορούμε να αγοράσουμε που κοστίζουν 0.10€, 0.20€, 0.30€ κλπ.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "021b68d2-e5be-44f0-947f-ac19d16cf922",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "double budget = 1.00;\n",
    "int candies = 0;\n",
    "for (double price = 0.10; budget >= price; price += 0.10) {\n",
    "    budget -= price;\n",
    "    candies++;\n",
    "}\n",
    "candies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "db29005c-467b-40bd-8883-288eb5d3fe5b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.3999999999999999"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "budget"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b61eaa9-9bf3-4334-9fdb-f206bd6304f5",
   "metadata": {},
   "source": [
    "Όταν αγοράσουμε μια καραμέλα 0.10€, μας περισσεύουν 0.90€, στη συνέχεια μια καραμέλα 0.20€, μας περισσεύουν 0.70€, στη συνέχεια μια των 0.30€, μας περισσεύουν 0.40€ και επομένως μπορούμε να αγοράσουμε ακόμα μια των 0.40€, αλλά το πρόγραμμα Java έχει άλλη γνώμη!\n",
    "\n",
    "Ας δούμε τη χρήση της ```BigDecimal```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "dc2cef28-46fd-461c-8346-dd8e15652044",
   "metadata": {},
   "outputs": [],
   "source": [
    "BigDecimal TEN_CENTS = new BigDecimal(\".10\");\n",
    "BigDecimal budget = new BigDecimal(\"1.0\");\n",
    "int candies = 0;\n",
    "for (BigDecimal price = TEN_CENTS; budget.compareTo(price) >= 0; price = price.add(TEN_CENTS)) {\n",
    "    budget = budget.subtract(price);\n",
    "    candies++;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "e67235a4-cd7f-4d75-8266-2ecbe862ac7f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "candies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "d3958253-a06e-434d-853b-7e5036fe1e28",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.00"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "budget"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d3f8ef5-d475-4784-854e-08c796b85b22",
   "metadata": {},
   "source": [
    "Δυστυχώς οι ```BigDecimal``` και ```BigInteger``` είναι λιγότερο βολικοί στη χρήση τους και πολύ πιο αργοί. Στο συγκεκριμένο παράδειγμα θα μπορούσατε να χρησιμοποιήσετε ```int``` ή ```long```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "76ebecde-b733-472e-a9cb-af2164ac7030",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int candies = 0;\n",
    "int budget = 100;\n",
    "for (int price = 10; budget >= price; price += 10) {\n",
    "    budget -= price;\n",
    "    candies++;\n",
    "}\n",
    "candies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "24da1d69-c671-46cd-bd3c-112016e5cf29",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "budget"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "815f080e-b5d9-4e7b-857e-4fd28e82865e",
   "metadata": {},
   "source": [
    "Χρησιμοποιείστε ```int``` αν οι αριθμοί σας δεν ξεπερνούν τα 9 δεκαδικά ψηφία, ```long``` αν δεν ξεπερνούν τα 18, διαφορετικά χρησιμοποιείστε ```BigDecimal```.\n",
    "\n",
    "Οι ```BigDecimal``` και ```BigInteger``` έχουν κι άλλα προβλήματα οπότε πρέπει να τους χρησιμοποιείτε με προσοχή. **Πάντα** χρησιμοποιείτε την μέθοδο κατασκευής ```BigDecimal(String)``` και **ποτέ** την ```BigDecimal(double)```. Η τελευταία δημιουργεί ένα αντικείμενο με την ακριβή τιμή του ορίσματός της, π.χ.: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "bda3e655-5015-4e77-a536-fa18af6e5b9f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1000000000000000055511151231257827021181583404541015625"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new BigDecimal(.1);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bc830fb-f9e2-409b-b1d5-dcd68409e2a6",
   "metadata": {},
   "source": [
    "ή προτιμήστε τη στατική μέθοδο ```valueOf```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "2890b5e6-dcd6-4750-8deb-e208e7bda83b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0123456789012346"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BigDecimal.valueOf(.1);\n",
    "BigDecimal a = BigDecimal.valueOf(1.01234567890123456789);\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "e15d9814-bee0-4fce-88c3-975b345d2744",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.01234567890123456789"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BigDecimal b = new BigDecimal(\"1.01234567890123456789\");\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8db80af-fbfe-4a20-8d46-85185d9c493e",
   "metadata": {},
   "source": [
    "Προσέξτε όμως ότι η μέθοδος ```valueOf()``` έχει περιορισμένη ακρίβεια (ο ```double``` έχει ακρίβεια 15-17 ψηφία).\n",
    "\n",
    "Οι μέθοδοι ```equals()``` και ```compareTo()``` της ```BigDecimal``` δεν συμφωνούν:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "3b1e6dc8-2804-4cb2-9664-01d6ea0edda6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BigDecimal one = new BigDecimal(\"1.0\");\n",
    "BigDecimal one1 = new BigDecimal(\"1.00\");\n",
    "one.equals(one1);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "5951b9e2-81e4-4383-9c4d-9765a4feb00c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one.compareTo(one1);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2b18d59-fa13-4e9d-adfe-ac0ec86a4aa7",
   "metadata": {},
   "source": [
    "Αυτό οφείλεται στο ότι η ```equals()``` λαμβάνει υπόψιν τον αριθμό δεκαδικών ψηφίων (```scale```). Γι' αυτό χρησιμοποιείτε **πάντα** την ```compareTo()```.\n",
    "\n",
    "Κάποιοι μπορεί να δοκιμάσουν την μέθοδο ```round(new MathContext(precision, roundingMode))``` για να στρογγυλοποιήσουν έναν ```BigDecimal```:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "63336422-6193-4058-af49-6c4aa658c434",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.2E+2"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BigDecimal x = new BigDecimal(\"123.456\");\n",
    "x = x.round(new MathContext(2, RoundingMode.HALF_UP));\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "69ea1019-56d1-41f9-ada6-b8cb0fbe4483",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.toPlainString();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "ccb0e11d-c5f0-4898-a206-0bdc9e60642f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.scale();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c7fcd3e-9fab-4adc-87ab-558b9afedcc3",
   "metadata": {},
   "source": [
    "αντί για ```123.46```. Αυτό οφείλεται στο ότι αντί να στρογγυλοποιήσει το δεκαδικό μέρος, στρογγυλοποιεί τον αριθμό από αριστερά προς τα δεξιά, επομένως ακρίβεια ```2``` σημαίνει τα 2 πρώτα ψηφία από αριστερά (δηλ. ```12```) το οποίο στη συνέχεια πολλ/ζεται με το 10 (```scale == -1```, δηλ. ```τιμή x 10```<sup>-scale</sup> ή ```12x10```<sup>-(-1)</sup>), επομένως το αποτέλεσμα. \n",
    "\n",
    "Για το επιθυμητό αποτέλεσμα:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "872ac759-f7bd-4f89-a97e-ab6d5d9af941",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "123.46"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BigDecimal x = new BigDecimal(\"123.456\");\n",
    "x = x.setScale(2, RoundingMode.HALF_UP);\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dac284f7-568a-4b57-9aa2-9b83dcf00dd9",
   "metadata": {},
   "source": [
    "Μπορείτε να πειραματιστείτε περαιτέρω εδώ <a href=\"sandbox/bigdecimal.html\" target=\"_blank\"><img src=\"../../../assets/javaalmanac.svg\" alt=\"javaalmanac.io\" style=\"width:5%; height:5%;\"></a>."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1eab896c-ad68-4669-b56c-3e77a74600fc",
   "metadata": {},
   "source": [
    "### Μαθηματικοί τελεστές\n",
    "* ```add()```\n",
    "* ```subtract()```\n",
    "* ```multiply()```\n",
    "\n",
    "Η ```multiply(BigDecimal multiplicand, MathContext mc)``` παρέχει δυνατότητες στρογγυλοποίησης και ακρίβειας του αποτελέσματος. Η ```MathContext(int setPrecision, RoundingMode setRoundingMode)``` δίνει τη δυνατότητα να ορίσουμε τον αριθμό των δεκαδικών ψηφίων και τον τρόπο στρογγυλοποίησης (```RoundingMode.CEILING, RoundingMode.DOWN, RoundingMode.UP, RoundingMode.HALF__DOWN, RoundingMode.HALF__UP, RoundingMode.HALF__EVEN, RoundingMode.UNECESSARY```).\n",
    "\n",
    "* ```divide()```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "000af943-36b7-4328-ae61-66b60731db15",
   "metadata": {},
   "outputs": [
    {
     "ename": "EvalException",
     "evalue": "Non-terminating decimal expansion; no exact representable decimal result.",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1m\u001b[31mjava.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.\u001b[0m",
      "\u001b[1m\u001b[31m\tat java.base/java.math.BigDecimal.divide(BigDecimal.java:1766)\u001b[0m",
      "\u001b[1m\u001b[31m\tat .(#132:1)\u001b[0m"
     ]
    }
   ],
   "source": [
    "BigDecimal a = new BigDecimal(\"5\");\n",
    "BigDecimal b = new BigDecimal(\"7\");\n",
    "BigDecimal result = a.divide(b);\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da3155da-3fc4-4f7b-9e21-7d2702241acd",
   "metadata": {},
   "source": [
    "Η διαίρεση αποτυγχάνει αν το αποτέλεσμα δεν είναι ντετερμενιστικός αριθμός. Η ```BigDecimal``` εμφανίζει πάντα αυτήν την εξαίρεση όταν πρέπει να \"αποκόψει\" δεκαδικά ψηφία για οποιονδήποτε λόγο. Γι' αυτό καλύτερα να χρησιμοποιείτε κάποιες από τις άλλες μεθόδους ```divide()``` όπου μπορείτε να παρέχετε την ακρίβεια και τον τρόπο στρογγυλοποίησης, π.χ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "602dfbb1-e3ca-4c04-a25e-482280ed6d51",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7142857143"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BigDecimal result = a.divide(b, 10, RoundingMode.HALF_UP);  // χρησιμοποιείται στις περισσότερες περιπτώσεις\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f1516f1-e228-455d-a658-77cb8cc6a58d",
   "metadata": {},
   "source": [
    "* ```divideAndRemainder()```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "1997ab15-7990-4568-af77-9e2ae9beec86",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 5]"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BigDecimal[] result = a.divideAndRemainder(b);\n",
    "Arrays.toString(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd813912-a8ce-4ce9-87bb-8aa373d7197b",
   "metadata": {},
   "source": [
    "* ```divideToIntegralValue()```\t// ακέραιο μέρος της διαίρεσης\n",
    "* ```remainder()```\n",
    "* ```pow()```\n",
    "* ```max()```\n",
    "* ```min()```\n",
    "* ```movePointLeft()```   \t// μετακίνηση υποδιαστολής αριστερά\n",
    "* ```movePointRight()```\t// μετακίνηση υποδιαστολής αριστερά\n",
    "\n",
    "## ```Math```\n",
    "Στα προηγούμενα μαθήματα είδαμε κάποιες χρήσεις της κλάσης ```Math``` (π.χ. ```Math.PI, Math.E, Math.sin(), Math.random(), Math.abs()```) κλπ. \n",
    "\n",
    "```java\n",
    "jshell> Math.\n",
    "E                 IEEEremainder(    PI                abs(              acos(             addExact(         asin(           atan(             atan2(            cbrt(             ceil(             class             copySign(         cos(            cosh(             decrementExact(   exp(              expm1(            floor(            floorDiv(         floorMod(       \n",
    "fma(              getExponent(      hypot(            incrementExact(   log(              log10(            log1p(          \n",
    "max(              min(              multiplyExact(    multiplyFull(     multiplyHigh(     negateExact(      nextAfter(      \n",
    "nextDown(         nextUp(           pow(              random()          rint(             round(            scalb(         \n",
    "signum(           sin(              sinh(             sqrt(             subtractExact(    tan(              tanh(           \n",
    "toDegrees(        toIntExact(       toRadians(        ulp(      \n",
    "```\n",
    "\n",
    "Η κλάση αυτή παρέχει μερικές μεθόδους ως λύση για το πρόβλημα της υπερχείλισης που είδαμε στα μαθήματα της 1ης εβδομάδας:\n",
    "```java\n",
    "Math.addExact()\n",
    "Math.subtractExact()\n",
    "Math.multiplyExact()\n",
    "Math.negateExact()\n",
    "Math.incrementExact()\n",
    "Math.decrementExact()\n",
    "Math.toIntExact()\n",
    "```\n",
    "Οι μέθοδοι αυτές εμφανίζουν ```ArithmeticException``` αν υπάρξει λάθος εκτέλεσης, π.χ. υπερχείλιση.\n",
    "Π.χ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "231fc80b-5ebf-4b22-911f-6bfc5b36fba9",
   "metadata": {},
   "outputs": [
    {
     "ename": "EvalException",
     "evalue": "integer overflow",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1m\u001b[31mjava.lang.ArithmeticException: integer overflow\u001b[0m",
      "\u001b[1m\u001b[31m\tat java.base/java.lang.Math.addExact(Math.java:883)\u001b[0m",
      "\u001b[1m\u001b[31m\tat .(#135:1)\u001b[0m"
     ]
    }
   ],
   "source": [
    "Math.addExact((int)1E30, 1000);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bb9a091-e4a8-4d78-bc6f-9a514957ec7a",
   "metadata": {},
   "source": [
    "## Είσοδος\n",
    "\n",
    "Υπάρχουν διάφοροι τρόποι να διαβάσουμε από τη μονάδα εισόδου (συνήθως το πληκτρολόγιο):\n",
    "\n",
    "### ```System.console```\n",
    "Δε δουλεύει με το jshell (ούτε με το NetBeans) αλλά διαθέτει τη δυνατότητα να αποκρύπτει την είσοδο (π.χ. για να εισάγετε έναν κωδικό)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cc524e2-c0af-4bc5-8403-7f25da768656",
   "metadata": {},
   "source": [
    "```java\n",
    "import java.io.Console;\n",
    "import java.util.Arrays;\n",
    "\n",
    "public class Test {\n",
    "    public static void main(String[] args) {\n",
    "\t\tConsole console = System.console();\n",
    "\t\tif (console != null) { // Console returns null on jshell or inside an IDE\n",
    "\t\t\tString name = console.readLine(\"> Εισάγετε όνομα χρήστη και πατήστε Enter%n\");\n",
    "\t\t\tconsole.printf(\"Γειά σου %s!%n\", name);\n",
    "\t\t\tconsole.printf(\"> Εισάγετε κωδικό και πατήστε Enter: \");\n",
    "\t\t\tchar[] password = console.readPassword();\n",
    "\t\t\tconsole.printf(\"Δώσατε τον κωδικό: %s%n\", String.valueOf(password));\n",
    "\t\t\tArrays.fill(password, ' '); // καλή τεχνική να σβήνετε τον κωδικό αν δε χρησιμοποιείται άλλο\n",
    "\t\t}\n",
    "    }\n",
    "}\n",
    "```\n",
    "Από ένα κέλυφος Unix/Linux ή τερματικό DOS:\n",
    "```java\n",
    "$ javac Test.java\n",
    "$ java Test\n",
    "> Εισάγετε όνομα χρήστη και πατήστε Enter\n",
    "Γιάννης\n",
    "Γειά σου Γιάννης!\n",
    "> Εισάγετε κωδικό και πατήστε Enter: \n",
    "Δώσατε τον κωδικό: pass01\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ba8bc45-2f68-45a6-93e4-c09120bb3adc",
   "metadata": {},
   "source": [
    "Γιατί η ```Console.readPassword()``` επιστρέφει ένα ```char[]``` κι όχι ```String```; Για ασφάλεια είναι η απάντηση. Με αυτόν τον τρόπο μπορεί να καθαριστεί αμέσως μετά τη χρήση, όπως και γίνεται στο πιο πάνω παράδειγμα. Αν επέστρεφε ```String```, τότε θα προστίθετο στην δεξαμενή μνήμης των αλφαριθμητικών και με ένα memory dump θα μπορούσε κάποιος να δει τον κωδικό. \n",
    "\n",
    "### ```java.util.Scanner```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d75ff55e-d7cf-4722-8f05-955ec57146a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Όνομα χρήστη: "
     ]
    }
   ],
   "source": [
    "import java.util.Scanner;\n",
    "Scanner scanner = new Scanner(System.in);\n",
    "System.out.print(\"Όνομα χρήστη: \");\n",
    "String username = scanner.next();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3d1a327-0f12-4243-b361-94aa4121368c",
   "metadata": {},
   "outputs": [],
   "source": [
    "username"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73709bc3-de7d-4ab0-af4a-239f020084a0",
   "metadata": {},
   "source": [
    "Δεν υποστηρίζει απόκρυψη εισόδου (π.χ. για ανάγνωση κωδικού όπως η ```System.console```).\n",
    "\n",
    "* ```next()``` ανάγνωση κειμένου μέχρι το επόμενο κενό (ανάγνωση ενός token)\n",
    "* ```nextLine()``` ανάγνωση κειμένου μέχρι την αλλαγή γραμμής\n",
    "* ```nextByte()```\n",
    "* ```nextShort()```\n",
    "* ```nextInt()```\n",
    "* ```nextLong()```\n",
    "* ```nextFloat()```\n",
    "* ```nextDouble()```\n",
    "* ```nextBigInteger()```\n",
    "* ```nextBigDecimal()```\n",
    "* ```hasNextByte()```\n",
    "* ```hasNextShort()```\n",
    "* ```hasNextInt()```\n",
    "* ```hasNextLong()```\n",
    "* ```hasNextFloat()```\n",
    "* ```hasNextDouble()```\n",
    "* ```hasNextBigInteger()```\n",
    "* ```hasNextBigDecimal()```\n",
    "\n",
    "```java\n",
    "if (scanner.hasNextFloat()){ \n",
    "\tfloat fValue = scanner.nextFloat(); \n",
    "} else {\n",
    "\tString sValue = scanner.next(); \n",
    "}\n",
    "```\n",
    "\n",
    "Αν θέλετε να δέχεστε το ENTER ως έγκυρη είσοδο:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21bebfac-bf9f-4dce-88db-46f6497ebf27",
   "metadata": {},
   "outputs": [],
   "source": [
    "Scanner IN = new Scanner(System.in).useDelimiter(\"(\\\\b|\\\\B)\");\n",
    "String s = null;\n",
    "do { \n",
    "    s = IN.nextLine();\n",
    "} while (s.isEmpty());"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33b111de-f808-4a15-be3f-5bf557db8a47",
   "metadata": {},
   "source": [
    "### ```BufferedReader```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "149bd9cb-a162-4d65-8eeb-692776ea52d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "System.out.print(\"Όνομα χρήστη: \");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f3909a51-9f8c-450a-9b1d-7997bfed7760",
   "metadata": {},
   "outputs": [],
   "source": [
    "BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "92eb13d9-2f47-4964-a557-bb1060441b66",
   "metadata": {},
   "outputs": [],
   "source": [
    "String username = \"\";\n",
    "try {\n",
    "    username = reader.readLine();\n",
    "} catch(IOException e) {\n",
    "    e.printStackTrace();\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a0cd980-7423-4d43-8d8d-5462ac8e2f83",
   "metadata": {},
   "outputs": [],
   "source": [
    "username"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efbc565f-ec47-4380-8686-2c83833572a2",
   "metadata": {},
   "source": [
    "### Text-IO\n",
    "Η εξωτερική βιβλιοθήκη [Text-IO](https://github.com/beryx/text-io) προσπαθεί να συνδυάσει τα πλεονεκτήματα των ανωτέρω τριών τρόπων χωρίς τα προβλήματά τους. Για να τη χρησιμοποιήσετε με το jshell, ακολουθήστε τα εξής βήματα:\n",
    "\n",
    "1. Κατεβάστε τις βιβλιοθήκες [text-io-x.x.x.jar](https://search.maven.org/search?q=a:text-io) και [slf4j-api-x.x.x.jar](https://search.maven.org/search?q=a:slf4j-parent)\n",
    "2. Εκκινήστε το jshell ως ```jshell --class-path /<path-to>/text-io-x.x.x.jar:/<path-to>/slf4j-api-x.x.x.jar``` ή εκκινήστε το κανονικά και δώστε την εντολή ```jshell> /env -class-path /<path-to>/text-io-x.x.x.jar:/<path-to>/slf4j-api-x.x.x.jar``` (για τα Windows χρησιμοποιήστε ```\\```)\n",
    "\n",
    "```java\n",
    "jshell> import org.beryx.textio.*\n",
    "\n",
    "jshell> TextIO textIO = TextIoFactory.getTextIO();\n",
    "SLF4J: No SLF4J providers were found.\n",
    "SLF4J: Defaulting to no-operation (NOP) logger implementation\n",
    "SLF4J: See http://www.slf4j.org/codes.html#noProviders for further details.\n",
    "textIO ==> org.beryx.textio.TextIO@31304f14\n",
    "\n",
    "jshell> String username = textIO.newStringInputReader().withDefaultValue(\"admin\").read(\"Username: \");\n",
    "username ==> \"admin\"\n",
    "```\n",
    "Εμφανίζεται το ξεχωριστό παράθυρο ```TextTerminal``` το οποίο δέχεται την είσοδο του χρήστη. Μπορείτε να πατήσετε απλά ```ENTER``` ώστε η μεταβλητή ```username``` να λάβει την εξ' ορισμού τιμή ```\"admin\"```.\n",
    "\n",
    "![](assets/Fig1.png)\n",
    "\n",
    "**Εικόνα 6.2.1** _Παράθυρο ```TextTerminal```_ \n",
    "\n",
    "```java\n",
    "jshell> String password = textIO.newStringInputReader().withMinLength(6).withInputMasking(true).read(\"Password: \");\n",
    "password ==> \"123456\"\n",
    "```\n",
    "με το αποτέλεσμα:\n",
    "\n",
    "```\n",
    "Username:  [admin]: ​\n",
    "Password:  ​\n",
    "Invalid value.\n",
    "Expected a string with at least 6 characters.\n",
    "\n",
    "Password:  ​******\n",
    "```\n",
    "Επίσης μπορείτε να χρησιμοποιήσετε το παράθυρο ```TextTerminal``` όχι μόνο για είσοδο αλλά και για έξοδο, π.χ.\n",
    "\n",
    "```java\n",
    "jshell> textIO.getTextTerminal().printf(\"Username: %s, password %s.\\n\", username, password);\n",
    "```\n",
    "\n",
    "Για περισσότερα, αναφερθείτε στις πηγές.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b6c8565-8c5c-4681-8f83-be39fb9ffd33",
   "metadata": {},
   "source": [
    "## Ασκήσεις\n",
    "1. [Να γράψετε ένα πρόγραμμα που να δημιουργεί μια κλάση ```Supplier``` με τα εξής γνωρίσματα: ```long id, String productName, int quantity, String city```. Στη μέθοδο ```main()``` της κλάσης αποθηκεύστε 4 αντικείμενα της κλάσης αυτής σε έναν πίνακα και εμφανίστε την ακόλουθη έξοδο στην οθόνη (ID: 2 χαρακτήρες αριστερής στοίχισης, Name: 6 χαρακτήρες αριστερής στοίχισης, qt: 2 χαρακτήρες, City: 10 χαρακτήρες αριστερής στοίχισης):](https://codecheck.io/files/231204215383bkeidswnl6ks4ro89ygqamq)\n",
    "\n",
    "```\n",
    "ID Name  qt City\n",
    "---------------------- \n",
    "1  Sony  20 Hania\n",
    "2  Apple 10 Heraklion\n",
    "3  Apple 30 Hania\n",
    "4  Dell  40 Rethymnon\n",
    "```\n",
    "\n",
    "2. [Υλοποιήστε τον αλγόριθμο εύρεσης του ν-στού αριθμού Fibonacci της άσκησης 3 του 5ου μαθήματος της 2ης εβδομάδας χρησιμοποιώντας ```BigInteger``` και υπολογίστε έναν πολύ μεγάλο αρ. Fibonacci, π.χ. τον 5000-ό](https://codecheck.io/files/23121616327iqx7uu8x5s2cfd247d8zmp6g). Επαληθεύστε την υλοποίησή σας [εδώ](http://www.javascripter.net/math/calculators/fibonaccinumberscalculator.htm). \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b619e4d-4c89-4329-b8f1-8997bd51686d",
   "metadata": {},
   "source": [
    "## Πηγές\n",
    "1. Iordache S. (2016), [\"Interactive Console Applications in Java\"](https://dzone.com/articles/interactive-console-applications-in-java).\n",
    "1. Horstmann C., [Big Java 5 - Chapter 4 - Fundamental Data Types](https://www.cs.ryerson.ca/~aferworn/courses/CPS109/CLASSES/week04/ch04/index.html)\n",
    "1. Kiwy F. (2020), [\"Four common pitfalls of the BigDecimal class and how to avoid them\"](https://blogs.oracle.com/javamagazine/four-common-pitfalls-of-the-bigdecimal-class-and-how-to-avoid-them?source=:em:nw:mt:::RC_WWMK200429P00043:NSL400084275), Java Magazine.\n",
    "1. [Generate Random Numbers](http://www.javapractices.com/topic/TopicAction.do?Id=62)\n",
    "1. [Formatting with printf() in Java (2019)](https://www.baeldung.com/java-printstream-printf)\n",
    "1. [Java printf( ) Method Quick Reference](https://www.cs.colostate.edu/~cs160/.Spring16/resources/Java_printf_method_quick_reference.pdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db113700-9416-4bc2-8916-7a3b39488acb",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "[<](../6.1-Exceptions/6.1-Exceptions.ipynb) | [Δ](../../TOC.ipynb) | [>](../6.3-BuildTools/6.3-BuildTools.ipynb)   \n",
    "\n",
    "---"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "codemirror_mode": "java",
   "file_extension": ".jshell",
   "mimetype": "text/x-java-source",
   "name": "Java",
   "pygments_lexer": "java",
   "version": "17+35-LTS-2724"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}