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 d7c8970..5181b31 100644 Binary files a/out/production/Textanalyse/com/structix/Analyse.class and b/out/production/Textanalyse/com/structix/Analyse.class differ diff --git a/out/production/Textanalyse/com/structix/Main.class b/out/production/Textanalyse/com/structix/Main.class index 29b2dd6..501f126 100644 Binary files a/out/production/Textanalyse/com/structix/Main.class and b/out/production/Textanalyse/com/structix/Main.class differ diff --git a/out/production/Textanalyse/com/structix/Menu.class b/out/production/Textanalyse/com/structix/Menu.class index 14c54e0..5d153f9 100644 Binary files a/out/production/Textanalyse/com/structix/Menu.class and b/out/production/Textanalyse/com/structix/Menu.class differ 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); }