From fc6cd439e2a29b9fde15874df0f3dc2277bfb818 Mon Sep 17 00:00:00 2001 From: structix Date: Fri, 20 May 2016 12:34:27 +0200 Subject: [PATCH] Main, Menu, Analyse Klassen kommentiert --- .idea/workspace.xml | 242 +++++++++++++----- .../Textanalyse/com/structix/Analyse.class | Bin 3751 -> 3751 bytes .../Textanalyse/com/structix/Main.class | Bin 724 -> 724 bytes .../Textanalyse/com/structix/Menu.class | Bin 2751 -> 2751 bytes src/com/structix/Analyse.java | 91 ++++++- src/com/structix/Main.java | 21 ++ src/com/structix/Menu.java | 30 ++- 7 files changed, 310 insertions(+), 74 deletions(-) diff --git a/.idea/workspace.xml b/.idea/workspace.xml index 105f010..1428c26 100644 --- a/.idea/workspace.xml +++ b/.idea/workspace.xml @@ -2,15 +2,11 @@ - - - - @@ -36,8 +32,8 @@ - - + + @@ -56,12 +52,9 @@ - - - - - - + + + @@ -89,8 +82,8 @@ - - + + @@ -116,10 +109,10 @@ @@ -161,6 +154,7 @@ + @@ -199,7 +193,6 @@ - @@ -635,11 +628,14 @@ + + + - @@ -653,7 +649,7 @@ - + @@ -694,6 +690,150 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -714,10 +854,7 @@ - - - - + @@ -757,10 +894,7 @@ - - - - + @@ -792,10 +926,7 @@ - - - - + @@ -827,10 +958,7 @@ - - - - + @@ -870,10 +998,7 @@ - - - - + @@ -893,25 +1018,6 @@ - - - - - - - - - - - - - - - - - - - @@ -920,10 +1026,26 @@ + + + + + + + + + + + + + + + + - - + + diff --git a/out/production/Textanalyse/com/structix/Analyse.class b/out/production/Textanalyse/com/structix/Analyse.class index d7c8970d6a99e7acfc1bd68a3ac26338598228fb..5181b31e4bad4bceaf195fd57a871ac7798a2fb1 100644 GIT binary patch delta 312 zcmWNM-7AA(7{-5ZqrJ0_l&@KPWBCdzAJI;Xwi24CVOeRSh$2eafl`zlaQ2+8R#Iz{ ztrW_U9B?A#FL2<*xj(>la$omz-}m)g*Hv;#PBr6h4N^k`b%a#Iw9uy7PK1crbLX8N zT=Z)*fWwfcqjWM%HzP!e8JAt~kK<#4CK6&M&89 z5>p>1C&nr%)^wF-kxf?EVuNk=g@^3k|9G0M-UDns>dDh63~@vk#|&~pl2c~X&ug~C zx#{qpS(m2l{f!qCr>H1blDwvmlI-3v#+@W9lB`OwC^H3_cwn7Jc6g#Jtnh3;eXrJw ZG5+b=H${6l-~N>KVWNSY^<^#s;eSuNK^*`9 delta 312 zcmWNM%SwV#6otPZ3xD%MWH-aVC`&4&3m6e)Wf!ufA}cK@p&-z1Iw)(>q=*I%&$PJ+ zfkBVZ1M~_Fnl$eLTI|7I9M)OiUNxuYyl35^Hkt^~LQvCAmnKX%{e(=(edqMzk`6L} zLqsadpeD)?F@}xHe)W&xW1J2q=ws5n*=ttZ{Mn7<3?63jGN-fzJp|0KF-hBB!tp{WLspdyj TdothtwDn?QfxJ~U)j;?kPi;4d diff --git a/out/production/Textanalyse/com/structix/Main.class b/out/production/Textanalyse/com/structix/Main.class index 29b2dd688e815826ce0c3744c80b6c179ee58e35..501f1261bcbdadb72aa73301d5915934156fb87b 100644 GIT binary patch delta 35 qcmcb@dWCg^ITNG8WDBM+K@|oL1~mpA23-a*27LxO27}4-nM?tQ#|C%+ delta 35 pcmcb@dWCg^ITNGMWDBM+K~V+{1~CR61_>Z3$sordHF-XhDFA}K1_}TG diff --git a/out/production/Textanalyse/com/structix/Menu.class b/out/production/Textanalyse/com/structix/Menu.class index 14c54e09bcbc3b4ab4c08ee675221c7fa4741b7e..5d153f9777f2d5093025a4f6953f2b4af002757c 100644 GIT binary patch delta 234 zcmWlQ%}N4M07lOpwQ&Ta5`#i0iUxyXa%?n;Aff+1iWY(BVweP_W&~#hTLwKqaBI=B zXPCXxx_X;7(WcvXRv(-*%8&9--$f&g+$i*0L0_P`fnfU7>-tt0_4;1a8CbQzy}J)v zTX8`Qgec1w%}lK0#6!(a8aDq^SN@D08sj9HR7}ZZeJ?dbmRb3%*Ryk^nJ34BVln>J zCxlZ(V_E4dn5?pkh07W@*gR0?5r;P_45{+YCLe6`MNRG)pG*6yJW%Bk1y0!Dj5_Bu XxuDG@w_M?KElU|M)j+2yUo++(V#qN; delta 207 zcmWm5%}N4M0EXfBjM_MZk`ZHpCjK==5R}c7MWTqMcnN|FQ9%gXXy8`p0>YyUmtDi` z71!$BxRExVzU9mJEUl&Wvzv&7X$*#~;h^9B{PN;rB!nwxn(ceQ@fKRnZ#ewVB`5bs zH6w^0lM_O+uD=D22@{c1y%Dwu66KUL(wuvLdPKM}G~()hflY!6Nm``nkYP-gZ&iP} yV!<^lZdh~6mOEK8HkXc)u9A<+KauB|1}`*urAL7eiu5VVd$S#QN2e<1rhNb`7bal< diff --git a/src/com/structix/Analyse.java b/src/com/structix/Analyse.java index 625fd4b..b6e67f7 100644 --- a/src/com/structix/Analyse.java +++ b/src/com/structix/Analyse.java @@ -8,15 +8,23 @@ import java.util.Scanner; * Created by structix on 14.05.16. */ +/* Analyse Klasse: + * Hier wird sowohl die Datei eingelesen, als auch verarbeitet. + * Die Ergebnisse werden dann von den Methoden zurückgeliefert + * + */ public class Analyse { - + //Definition der globalen Variablen private String inhalt = ""; private String woerterGesamt[]; private String einzelneWoerter[]; + //Konstruktor des Objekts mit dem Dateipfad als Übergabewert public Analyse(String dateipfad) { + //Inhalt der Datei wird an den globalen String inhalt übergeben inhalt = dateilesen(dateipfad); + //Text wird direkt für die Verarbeitung angepasst textAnpassen(); //Initialisierung der globalen Variablen @@ -24,117 +32,180 @@ public class Analyse { haeufigkeit(); } - + //Hier wird die Datei aus einem bestimmten Dateipfad ausgelesen private String dateilesen(String dateipfad) { + //Variablen werden definiert Scanner datei; String text = ""; - + //Der try-catch Block wird benötigt, falls die Datei nicht vorhanden ist try { + //Scanner bekommt den Dateipfad als File übergeben datei = new Scanner(new File(dateipfad)); + //Der Inhalt wird nach dem Regulären Ausdruck + // \Z also bis zum Ende des Inputs bzw. bis zum letzten Terminator (falls vorhanden) + //eingelesen. Ein weiterer \ kommt hinzu, um die Escapesequenz für einen \ einzuleiten. text = datei.useDelimiter("\\Z").next(); + //Scanner wird geschlossen datei.close(); } catch (FileNotFoundException ex) { + //Falls es zu einem Fehler kam, soll auf System.err eine kurze Fehlermeldung erscheinen. ex.getLocalizedMessage(); } - + //Text wird als String zurückgegeben return text; } - + //Hier wird der Text angepasst public void textAnpassen() { String verarbeitung; + //Leere Zeilen werden entfernt und Zeilenumbrüche mit Leerzeichen ersetzt verarbeitung = inhalt.replace("\n\n", ""); verarbeitung = verarbeitung.replace("\n", " "); + //Array des Textes wird mit dem Leerzeichen Delimiter erstellt woerterGesamt = verarbeitung.split(" "); } - + //Anzahl der Wörter werden zurückgegeben, da die Länge des Arrays aller Wörter abgefragt wird public int laenge() { return woerterGesamt.length; } + //Hier werden die verschiedenen Wörter im Text bestimmt public int verschiedenWoerter() { + //Initialisierung eines leeren temporären Arrays mit der länge von allen Wörtern wird erstellt String tempArray[] = new String[woerterGesamt.length]; boolean vorhanden; - int tempbelegt = 0; + int tempbelegt = 0; //Zähler für ein noch nicht vorhandenes Wort + + + //Gesamte Wörter Liste wird durchgegangen for (int i = 0; i < woerterGesamt.length; i++) { - vorhanden = false; + vorhanden = false; //Wird vor jedem Durchlauf auf false gesetzt + + //Schleife um jeden Eintrag im temporären Array mit dem woerterGesamt Array zu vergleichen for (int z = 0; z < tempArray.length; z++) { + //Wenn der Eintrag einmal oder mehrmals vorhanden ist wird vorhanden auf true gesetzt if (woerterGesamt[i].equals(tempArray[z])) { vorhanden = true; } } + //Wenn vorhanden auf false ist, also der Eintrag im temporären Array + //noch nicht vorhanden ist, soll ein neuer Eintrag erstellt werden if (!vorhanden) { tempArray[tempbelegt] = woerterGesamt[i]; + //Zähler wird für die richtige Position um 1 inkrementiert tempbelegt++; } } + + //Das Array einzelneWoerter wird mit der Länge vondem temporär Zähler initialisiert einzelneWoerter = new String[tempbelegt]; + //Hier werden alle Werte von tempArray in das einzelneWoerter Array geschrieben for (int i = 0; i < tempbelegt; i++) { einzelneWoerter[i] = tempArray[i]; } + //Der Rückgabewert wieviele verschiedene Wörter es gibt return tempbelegt; } + //Hier wird die Häufigkeit der einzelnen Wörter im Text bestimmt public String haeufigkeit() { + //Ein leeres Integer Array für die Anzahl der einzelnenWoerter wird erstellt int anzahl[] = new int[einzelneWoerter.length]; + + //Alle Einträge werden auf 0 gesetzt, damit danach hochgezählt werden kann for (int i = 0; i < anzahl.length; i++) { anzahl[i] = 0; } + //Die gesamte Wörter Liste wird durchgegangen for (int i = 0; i < woerterGesamt.length; i++) { + //Darin wird wiederum die einzelneWoerter Liste durchgegangen, + //um die Anzahl an der richtigen Stelle zu inkrementieren for (int z = 0; z < einzelneWoerter.length; z++) { + //Vergleich von einem Eintrag in der gesamten Wörterliste mit allen Einträgen + //aus dem einzelneWoerter Array if (woerterGesamt[i].equals(einzelneWoerter[z])) { anzahl[z] += 1; } } } + //Hier wird die Methode sortieren aufgerufen und dort das sortierte Ergebnis ausgegeben return sortieren(einzelneWoerter, anzahl); } + //Kompletter Text wird ausgegeben public String textausgabe() { return inhalt; } - + //Sortier Methode private String sortieren(String woerter[], int anz[]) { + /** + * Diese Methode basiert auf dem Bubblesort Sortieralgorithmus. + * Dieser wurde jedoch um ein Array erweitert. Es wird nach absteigendenden Zahlen sortiert + * und in diesem Verhältnis das woerter Array mit sortiert. + * Das heißt die Anordnung der beiden Arrays ist nach dem sortieren immernoch korrekt. + */ + + //Temporäre Variablen für Integer und String String tempstring; int tempint; + //Das komplette Array wird durchgegangen for (int i = 1; i < woerter.length; i++) { + //Darin wird das selbe Array (selbe Länge) nochmals durchgegangen + //Allerdings bei jedem Durchgang um i weniger, da diese Einträge schon sortiert wurden for (int z = 0; z < anz.length - i; z++) { + //Wenn Eintrag an der aktuellen Stelle kleiner wie an der nächsten Stelle ist, + //soll umsortiert (Plätze getauscht) werden if (anz[z] < anz[z + 1]) { + //Aktueller Eintrag wird ausgelagert tempint = anz[z]; + + //Aktueller Eintrag wird mit dem nächsten Eintrag ersetzt anz[z] = anz[z + 1]; + + //Nächster Wert wird mit dem ausgelagerten Wert überschrieben anz[z + 1] = tempint; + + //Das selbe Verfahren wird nun mit dem String gemacht, + //da die Positionen gleich bleiben sollen tempstring = woerter[z]; woerter[z] = woerter[z + 1]; woerter[z + 1] = tempstring; } } } + + //Hier werden die sortierten Einträge nacheinander ausgegeben bzw. in den String ausgabe geschrieben String ausgabe = ""; for (int i = 0; i < anz.length; i++) { ausgabe += woerter[i] + ": " + anz[i] + " (" + prozentsatz(anz[i], laenge()) + "%)" + "\n"; } + //Ausgabe wird zurückgeliefert return ausgabe; } + //Hier wird die Anzahl der Buchstaben inklusive Leerzeichen zurückgegeben public int anzBuchstabenMLeerzeichen() { //Mit Leerzeichen return inhalt.length(); } + //Hier wird die Anzahl der Buchstaben ohne Leerzeichen ausgegeben public int anzBuchstabenOLeerzeichen() { //Ohne Leerzeichen - String temp = inhalt.replace(" ", ""); + String temp = inhalt.replace(" ", ""); // Leerzeichen wird gegen "nichts" ersetzt return temp.length(); } + //Methode zum errechnen des Prozentsatzes private double prozentsatz(int prozentwert, int grundwert) { return (double) prozentwert / grundwert * 100; } + //Prozentualer Anteil der Leerzeichen public int stats_leerzeichen() { return (int) prozentsatz(anzBuchstabenMLeerzeichen() - anzBuchstabenOLeerzeichen(), anzBuchstabenMLeerzeichen()); } diff --git a/src/com/structix/Main.java b/src/com/structix/Main.java index f3da9e0..df33d8e 100644 --- a/src/com/structix/Main.java +++ b/src/com/structix/Main.java @@ -1,6 +1,18 @@ package com.structix; +/* Main: + * Diese Klasse ist für die Ausführung des gesamten Programms verantwortlich. + * Hier werden die nötigen Objekte erzeugt, um das Menü auszuführen. + * + */ + + + + + + + /* Funktionen: * Einen Text aus einer Datei lesen und nach folgenden Kriterien analysieren: * - Wörter zählen @@ -14,15 +26,24 @@ package com.structix; * 15.05.16: 20:41 - 21:38 Uhr * 16.05.16: 20:47 - 21:44 Uhr * 17.05.16: 11:59 - 12:37 Uhr + * 20.05.16: 11:18 - 12:32 Uhr */ public class Main { public static void main(String[] args) { + //Menü Objekt wird erzeugt Menu m = new Menu(); + //Auskommentieren, um einen Dateipfad einzugeben m.debug(); //m.dateipfad(); + + //Solange kein exit Befehl kommt, wird das Menü angezeigt. + //Es ist kein Schleifenkörper notwendig, da die Methode Hauptmenu + //schon einen Boolean Wert zurückgibt und damit bestimmt, ob die Bedingung wahr + //bleibt oder nicht while (!m.hauptmenu()); + //Nachricht vor dem Beenden des Programms System.out.println("Auf Wiedersehen!"); } } diff --git a/src/com/structix/Menu.java b/src/com/structix/Menu.java index 9772a96..20654bd 100644 --- a/src/com/structix/Menu.java +++ b/src/com/structix/Menu.java @@ -5,27 +5,42 @@ import java.util.Scanner; /** * Created by structix on 15.05.16. */ + +/* Menu Klasse: + * Diese Klasse bestimmt das Verhalten des Menüs. + * Hier werden die Funktionen hinter den Menüeinträgen bestimmt. + */ + public class Menu { + //Objekte vom Menubuilder werden erzeugt und mit den Überschriften initialisiert. Menubuilder mbuilder = new Menubuilder("Textanalyse"); - Analyse an; Menubuilder statsmenu = new Menubuilder("Statistiken"); + //Objekt der Analyse Klasse wird definiert. + //Es findet keine Deklaration statt, da dieses Objekt einen Dateipfad benötigt. + Analyse an; + //Zum testen kann dem Analyse Objekt ein fester Dateipfad mitgeliefert werden public void debug() { an = new Analyse("Test.txt"); } - + //Hier wird ein Dateipfad abgefragt public void dateipfad() { System.out.println("Geben Sie einen Dateipfad an (relativ sowie absolut erlaubt): "); Scanner eingabe = new Scanner(System.in); + //Instanz wird mit dem eingegebenen Dateipfad erstellt an = new Analyse(eingabe.nextLine()); } + //Hier wird das Verhalten des Hauptmenüs beschrieben public boolean hauptmenu() { + //Das Hauptmenü wird ausgeführt, solange exit nicht wahr ist boolean exit = false; int auswahl = 0; + //Menü wird mit Einträgen befüllt und auf das Ergebnis "gewartet" + //Die Zeichen für den Rahmen müssen auch angegeben werden auswahl = mbuilder.menuAnzeigen(new String[]{"Anzahl der Wörter", "Anzahl der verschiedenen Wörter", "Anzahl der Buchstaben", "Statistik Menü"}, "||"); switch (auswahl) { case 1: @@ -39,19 +54,24 @@ public class Menu { ausgabe("Buchstaben (ohne Leerzeichen): " + an.anzBuchstabenOLeerzeichen()); break; case 4: + //Aufruf eines weiteren Menüs while (!statistikmenu()); break; default: exit = true; - break; + break; //Nicht zwingend notwendig } + //Boolean wird zurückgegeben return exit; } + //Statistikmenü public boolean statistikmenu() { boolean exit = false; int auswahl = 0; + //Menü wird wieder mit Strings befüllt und der Rückgabe Wert der Variable auswahl zugeordnet auswahl = statsmenu.menuAnzeigen(new String[]{"Enthaltene Leerzeichen", "Häufigkeit der verschiedenen Wörter"}, "||"); + //Fallunterscheidung der Variable auswahl switch (auswahl) { case 1: ausgabe("Prozentsatz der enthaltenen Leerzeichen: " + an.stats_leerzeichen() + "%"); @@ -61,11 +81,13 @@ public class Menu { break; default: exit = true; - break; + break; //Nicht zwingend notwendig } + //Boolean wird zurückgegeben return exit; } + //Methode zur einfacheren Ausgabe private void ausgabe(String eing) { System.out.println(eing); }