Daten aus .txt Datei einlesen und weiterverarbeiten

[maxmuster987]

Ich weiß, wie man Daten aus .txt Dateien einliest und ausgibt, aber ich weiß noch nicht, wie man diese Daten weiterverarbeitet.
Der Benutzer soll den Dateinamen eingeben ohne die Endung .txt .
Danach soll geprüft werden, ob die jeweilige Datei mit der Zeichenfolge DATA: startet.
Wenn dem so ist, dann sollen weitere Schritte fortgesetzt werden (aber dazu später, erst einmal will ich einlesen und verarbeiten).
Wenn der Benutzer einen Dateinamen eingibt, den es nicht gibt, dann soll eine Fehlermeldung ausgegeben werden.

Das Programm unten ist nur zum Einlesen und Ausgeben gedacht.

Wenn jetzt die Datei bspw. test.txt mit DATA: startet, dann kann weitergearbeitet werden.

Hinter DATA: 10 steht eine Zahl, die die Länge des arrays am Ende wiedergibt.

Da drunter stehen dann Zeilen in Form von:
DATA: 10
19:00, 12.23
20:20, 10.00
...
...

Und diese Daten will ich einlesen UND verarbeiten.
Die erste Zahl steht für die Uhrzeit und die zweite Zahl für eine Geschwindigkeit (Format bleibt in jeder Zeile identisch).
Diese will ich in einem array speichern, um darauf zurückzugreifen, um die nötigen Berechnungen machen zu können.

import java.io.*;
import javax.swing.*;
import java.util.*;

public class Uebung {
    public static void main (String[] args) throws Exception {
        String eingabe = "";
        eingabe = JOptionPane.showInputDialog("Dateiname: ");
       
        try {
            File doc = new File(eingabe+".txt");
            BufferedReader obj = new BufferedReader(new FileReader(doc));
           
            String strng;
            while((strng=obj.readLine()) != null)
                System.out.println(strng);
        }
        catch(FileNotFoundException e) {
            System.out.println("Dateiname nicht existent.");
        }
    }

   
   
   
}

 

[KonradN]

Also erst einmal solltest Du try with resources verwenden, damit so ein Reader auch wieder geschlossen wird. Das sieht dann so aus:

        try (BufferedReader obj = new BufferedReader(new FileReader(eingabe+".txt"))) {
            String strng;
            while((strng=obj.readLine()) != null)
                System.out.println(strng);
        }
        catch(FileNotFoundException e) {
            System.out.println("Dateiname nicht existent.");
        }
    }

Da aber dann:
- Sinnvolle Namen! obj und strng sagen ja absolut nichts aus! Von mir aus reader oder so für den Reader auf der Datei und das andere ist eine Zeile der Datei so dass man das line nennen könnte. Und eingabe - was wurde da eingegeben? Das ist dann filename oder so.

Und die gelesene Zeile willst Du dann verarbeiten -> dann mach das in einer Methode und schon hast Du:

        try (BufferedReader reader = new BufferedReader(new FileReader(filename+".txt"))) {
            String line;
            while((line=obj.readLine()) != null)
                verarbeite(line);
        }
        catch(FileNotFoundException e) {
            System.out.println("Dateiname nicht existent.");
            e.printStackTrace();
        }

Und in der Methode verarbeite kannst Du dann schauen: Fängt die Zeile mit DATA an? Oder hat sie das andere Format? Das kann man dann schauen, wie Du das auswertest. Das kann man zur Not von Hand machen oder man nutzt reguläre Ausdrücke. Man könnte auf der Zeile auch einen Scanner erzeugen und da dann jeweils die Separatoren setzen um die Zahlen einzulesen: Dann sind es 2 int und ein double Wert oder so.
==> Das ist aber ein eigenständiges Problem. Das ist ja der Sinn mit den Methoden. Teile und Herrsche! Du liest die Zeilen und verarbeitest diese. Das macht der Code. Die eigentliche Verarbeitung fehlt aber noch.

 

[Neumi5694]

Noch wichtig: Trennen, trennen, trennen.
In der Main-Methode einlesen ... technisch ok, von der Übersicht her Unsinn.
Besser: Eine Methode schreiben, die nichts anderes macht, als die Datei einzulesen. Rückgabewert ist eine Liste von Strings.
Dann kannst du diese Liste weiterverarbeiten.

 

[Oneixee5]

Oder mit der NIO-API:

try (Stream<String> lines =  Files.lines(Path.of(eingabe + ".txt"), StandardCharsets.UTF_8)) {
    lines.forEach(MeineKlasse::verarbeite);
} catch(FileNotFoundException e) {
    System.out.println("Dateiname nicht existent.");
}

private void verarbeite(final String line) {
    // ...
}

try {
    List<String> lines =  Files.readAllLines(Path.of(eingabe + ".txt"), StandardCharsets.UTF_8);
    verarbeite(lines);
} catch(final FileNotFoundException e) {
    System.out.println("Dateiname nicht existent.");
}

try {
    String content =  Files.readString(Path.of(eingabe + ".txt"), StandardCharsets.UTF_8);
    verarbeite(content);
} catch(final FileNotFoundException e) {
    System.out.println("Dateiname nicht existent.");
}

Das ist viel übersichtlicher.

 

[maxmuster987]

Sinnvolle Namen! obj und strng sagen ja absolut nichts aus!

Ich habe das aus einer anderen Website gezogen und wusste nicht genau, was die einzelnen Sachen bedeuten sollen, deswegen habe ich die auch nicht umbenannt, weil sie das getan hatten, was ich wollte, ohne es zu hinterfragen. 🙄

Jetzt bin ich überfordert, womit ich das eher lösen soll. Mit der angesprochenen NIO API oder weiterhin mit dem BufferedReader?

Oder mit der NIO-API:

Sind die 3 Abschnitte Teil des Programms oder ist jeder einzelne Abschnitt einfach eine andere Darstellungsweise, um das Problem zu lösen?

 

[KonradN]

Jetzt bin ich überfordert, womit ich das eher lösen soll. Mit der angesprochenen NIO API oder weiterhin mit dem BufferedReader?

Das ist aus meiner Sicht von Deiner Situation abhängig. Darauf gehe ich am Ende etwas ein.

Sind die 3 Abschnitte Teil des Programms oder ist jeder einzelne Abschnitt einfach eine andere Darstellungsweise, um das Problem zu lösen?

Das sind einfach mehrere Möglichkeiten, wie es gehen könnte. Was man da genau nehmen will, muss man für sich entscheiden. Beim lernen von Java wird oft lange auf java.nio verzichtet was relativ schade ist. Ich erachte es als durchaus wichtig. Wenn Du aber gerade einen Java Kurs machst und dieser Kurs auch auf java.nio verzichtet, dann würde ich das erst einmal weglassen und mir rein die Dinge ansehen, die den Kurs betreffen. Wenn Du in den Dingen sicher bist, dann sollte der Blick über den Tellerrand kommen.

Wenn Du Streams kennst, dann ist die erste Variante, die vorgestellt wurde, wie sinnvolle. Darüber wird sowas in der Regel gemacht (aus meiner Sicht, die ist aber sehr subjektiv!) Da kommt dann aber auch noch hinzu, dass da ein try with resources verwendet wurde. Stream<T> hat das in der Dokumentation auch direkt beschrieben:

Streams have a BaseStream.close() method and implement AutoCloseable. Operating on a stream after it has been closed will throw IllegalStateException. Most stream instances do not actually need to be closed after use, as they are backed by collections, arrays, or generating functions, which require no special resource management. Generally, only streams whose source is an IO channel, such as those returned by Files.lines(Path), will require closing. If a stream does require closing, it must be opened as a resource within a try-with-resources statement or similar control structure to ensure that it is closed promptly after its operations have completed.

Das nur als kleiner Wink mit den Zaunpfahl: Hier kommen einige Dinge zusammen, die beachtet werden müssen und die bekannt sein sollten. Einfach mal ein Gegenpol zu "ich mache einen Kurs": Wenn du keinen Kurs machst sondern irgendwo als Junior Software Engineer angefangen haben solltest: Dann sind das Dinge, die wichtig sind und da solltest Du Dich direkt hinsetzen und Dir diese im Detail erarbeiten und damit rumspielen. 8Und dafür solltest Du auch die Zeit haben / bekommen.

 

[Neumi5694]

Jetzt bin ich überfordert, womit ich das eher lösen soll. Mit der angesprochenen NIO API oder weiterhin mit dem BufferedReader?

Das ist letztendlich deine Entscheidung. Mit dem Buffered Reader liest du selbst manuell ein, nio hat vorgefertigte Methoden.

Ich vergess immer wieder, dass es nio gibt, greife stattdessen auf meine selbst geschriebenen Methoden zu, die teils noch aus der Zeit vor nio stammen.
Persönlich bin ich der Auffassung, Zugriffe sollten so kurz und kompakt wie möglich gehalten werden, weshalb ich das Einlesen der Datei als Stringliste (erst nach Schließen der Datei auswerten) gegenüber der "live" Stream Variante bevorzuge.
Nichts ist lästiger, als sich um einen IO Fehler kümmern zu müssen, wenn man schon am Berechnen und Auswerten ist.
Womöglich muss man dann die bereits berechneten/angezeigten/angewendeten Teilergebnisse wieder entfernen, was viel lustiger klingt, als es ist.

Aber hier mögen sich die Geister scheiden. Es scheint mir, du würdest einen Anfängerkurs machen, also halt es so einfach wie möglich (was auch grundsätzlich eine gute Idee für später wird).
Schreib also erst mal irgendwas, was deine Strings einliest ohne sie (nur) auf dem Bildschirm auszugeben. Sie müssen irgendwo für die Weiterverarbeitung zwischengespeichert werden.

 

[maxmuster987]

Wenn Du aber gerade einen Java Kurs machst und dieser Kurs auch auf java.nio verzichtet

Der verzichtet tatsächlich aktuell komplett auf java.nio.

Momentan bin ich bei Streams allgemein, also character-Streams und Filter-Streams (Puffer-Streams).
Filter-Streams sind Datenpuffer, in denen Daten zur Verarbeitung zwischengelagert und verändert werden können. Darunter fallen BufferedReader oder BufferedWriter. Das habe ich momentan gelernt bzw. bin dran.
Mit FileReader lese ich die Dateien ein und mit BufferedReader speicher ich sie zwischen, um sie für die Weiterverarbeitung verwenden zu können.

Aus dem Grund hab ich mich dann zu aktuellem Zeitpunkt entschieden, dann doch auf java.nio zu verzichten und erst einmal über diesen Weg das Ganze zu lösen.

Ich hab das Ganze von oben mal bisschen auseinandergezogen, damit das für mich übersichtlicher ist, anstatt alles in den Klammern verschachtelt zu haben.
In Zeile 21, was muss ich da als Rückgabewert hinschreiben? Bisher war es meistens double oder so was, aber hier benötige ich doch bestimmt was anderes.

import java.io.*;
import javax.swing.*;
import java.util.*;

public class Uebung {
    public static void main (String[] args) throws Exception {

    String filename = "";
   
    filename = JOptionPane.showInputDialog("Geben Sie den Dateinamen ohne .txt ein:");
    verarbeite(filename);




    }
   
   
   
    //Ab hier drunter Methoden:
    public static RUECKGABEWERT? verarbeite(final String filename) {
        try {
            FileReader fileR = new FileReader(filename+".txt");
            BufferedReader bufR = new BufferedReader(fileR);
            String zeile;
            if(zeile.startsWith("DATA:") {
                ...
                ...
                ...
            }
            while((zeile=bufR.readLine()) != null)
            bufR.close();      
        }
        catch (IOException e){
            System.out.println("Fehler in Dateibehandlung.");
        }
    }
}

Wenn die Zeile mit DATA: startet, dann kann ich meine weiteren Dinge erledigen.
Und wenn nicht, dann brauche ich ja noch mein else{...}, was das Programm beendet.
Kommt das else dann noch vor das while?

Es scheint mir, du würdest einen Anfängerkurs machen

Dein Schein trügt dich nicht, dem ist auch noch so.😆

 

[KonradN]

Die Methode verarbeitet die Daten ja nur und gibt nichts zurück. Daher wäre da dann void als Rückgabetyp anzugeben.

 

[Neumi5694]

Wenn die Zeile mit DATA: startet, dann kann ich meine weiteren Dinge erledigen.
Und wenn nicht, dann brauche ich ja noch mein else{...}, was das Programm beendet.
Kommt das else dann noch vor das while?

Nein, das while selbst prüft. Falls die Zeile nicht mit "DATA:" beginnt, soll das Auslesen ja laut deiner Beschreibung abgebrochen und das Programm beendet werden.
Hier würde es sich anbieten, das WHILE vor die Schleife zu steleln, in nur dann betreten wird, falls Bedingung erfüllt ist. Innen musst du dann also nicht mehr prüfen.

while (data != null && data.startsWith("DATA:") {
//...
}

Und wirklich ... verwende die try with resource, wie von Kneitzel vorgeschlagen.


ps: Ich glaube, du hast ein klein wenig missverstanden, wie das mit der "verarbeite" Methode gemeint war. Diese sollte auf jede Zeile der Datei angewendet werden, nicht auf den Dateinamen.
Zu dem Zeitpunkt war allerdings noch nicht bekannt, dass du abhängig vom Zeileninhalt das Programm beenden willst.

 

[maxmuster987]

Ich weiß nicht, ob ich heute einfach nur auf dem Schlauch stehe oder ob mir diese Aufgabe wirklich Kopfschmerzen bereitet, weil ich noch zu wenig Wissen habe, um die richtig zu bearbeiten.
Ich weiß eure Ansätze sehr zu schätzen, aber ich verstehe momentan nur die Hälfte davon... 😕

Ich fasse mal die Aufgabe zusammen, vielleicht kann man mir dann besser helfen, dass ich damit auch klar komme.

1) Eingabe des Dateinamens
2) Startet die Textdatei nicht mit DATA: , dann Programmabbruch mit Fehlermeldung
3) Startet die Textdatei mit DATA:, dann die weiteren Zeilen in ein Array einlesen. Die Zahl hinter DATA: 10 gibt die Arraygröße wieder.
4) Für die Ausgaben müssen Zeitstempel und Geschwindigkeit ermittelt werden in der Form: Zeit, Geschwindigkeit:
10:00, 18.20
12:00, 41.50
13:00, 01.50
...
5) Ausgabe: Windenergie auf eine Nachkommastelle runden
6) Bedingung: Wenn Geschwindigkeit v >= 40, dann pWind = 0 und Meldung " Wind zu stark "
Wenn Geschwindigkeit v <= 2, dann pWind = 0 und Meldung "Wind zu schwach"

Es sollen aber alle Zeilen ausgegeben werden, also nicht weil pWind plötzlich 0 ist, auf einmal abbrechen.
Ich brauche also alle Werte ab der zweiten Zeile.

Die Ausgabe sieht dann am Bildschirm so aus bspw.:

10:00 vWind = 18.20 km/h pWind = 86.9kW
12:00 vWind = 41.50 km/h pWind = 0kW Wind zu stark
13:00 vWind = 01.50 km/h pWind = 0kW Wind zu schwach

import java.io.*;
import javax.swing.*;
import java.util.*;

public class Uebung {
    public static void main (String[] args) throws Exception {

    String filename = "";
    System.out.println("==============================");
    System.out.println("=== Auswertung Windenergie ===");
    System.out.println("==============================");
  
    filename = JOptionPane.showInputDialog("Geben Sie den Dateinamen ohne .txt ein:");
    verarbeite(filename);

    System.out.println(uhrzeit +"vWind = " +geschwindigkeit +" km/h\t pWind = "+windenergie(XXZeileXX) +" kW");
  
  
    }
  
    /*
    int limit = zeile.length;
    data.substring(6,limit)
    */
  
  
    //Ab hier drunter Methoden:
    public static void verarbeite(final String filename) {
        while(zeile != null && zeile.startsWith("DATA:"){
            try {
                FileReader fileR = new FileReader(filename+".txt");
                BufferedReader bufR = new BufferedReader(fileR);
                String zeile;
                if(zeile.startsWith("DATA:") {
                ... 
                ...
                ...
                }
                while((zeile=bufR.readLine()) != null)
                bufR.close();     
            }
            catch (IOException e){
                System.out.println("Fehler in Dateibehandlung.");
            }
        }
    }
  
    public static double windenergie(double v) {        // v soll aus der Text-Datei-Zeile ausgelesen werden ab Zeile 2, wenn Zeile 1 mit DATA: gestartet hat
        final int r = 20;
        final double rho = 1.2225;
        double flaeche = Math.PI*r^2;
      
        if(v>2 || v<40) {
            double pWind = (1/2.)*rho*flaeche*v^3;
        }
        else if (v>=40) {
            double pWind = 0;
            System.out.print("\tWind zu stark.");
        }
        else {
            double pWind = 0;
            System.out.print("\tWind zu schwach.");
        }
      
    }
}

 

[KonradN]

Was mir gerade noch aufgefallen ist: Ein Punkt war evtl. noch etwas missverstanden:

Momentan bin ich bei Streams allgemein, also character-Streams und Filter-Streams (Puffer-Streams).
Filter-Streams sind Datenpuffer, in denen Daten zur Verarbeitung zwischengelagert und verändert werden können. Darunter fallen BufferedReader oder BufferedWriter. Das habe ich momentan gelernt bzw. bin dran.

Da evtl. nur noch der kleine Hinweis: Wenn hier im Zusammenhang mit dem Vorschlag von @Oneixee5 von Streams die Rede ist, dann sind damit nicht die diversen *stream Klassen aus java.io gemeint, die auf InputStream oder OutputStream basieren sondern die mit Java 8 eingeführte Stream-API, die dann auf das Package java.util.stream bzw. auf das Interface java.util.stream.BaseStream zurück geht und die einen funktionalen Ansatz bietet (Und wo dann auch Dinge wie Lambda Expressions und Methodenreferenzen mit ins Spiel kommen).

Das solltest Du dann aber jetzt komplett ignorieren. Das kommt später - wenn nicht in deinem Kurs dann halt durch eigenes Erarbeiten nach dem Kurs. Das kannst Du Dir aber einfach einmal etwas merken für später.

Ich fasse mal die Aufgabe zusammen, vielleicht kann man mir dann besser helfen, dass ich damit auch klar komme.

1) Eingabe des Dateinamens
2) Startet die Textdatei nicht mit DATA: , dann Programmabbruch mit Fehlermeldung
3) Startet die Textdatei mit DATA:, dann die weiteren Zeilen in ein Array einlesen. Die Zahl hinter DATA: 10 gibt die Arraygröße wieder.
4) Für die Ausgaben müssen Zeitstempel und Geschwindigkeit ermittelt werden in der Form: Zeit, Geschwindigkeit:
10:00, 18.20
12:00, 41.50
13:00, 01.50
...
5) Ausgabe: Windenergie auf eine Nachkommastelle runden
6) Bedingung: Wenn Geschwindigkeit v >= 40, dann pWind = 0 und Meldung " Wind zu stark "
Wenn Geschwindigkeit v <= 2, dann pWind = 0 und Meldung "Wind zu schwach"

Da ist mein Tipp immer gleich: Bilde es so ab!
Aus 1) wird dann String filename = eingabeDateiname();

Bei 2 und 3 baust Du die Logik auch genau so auf. Um das bearbeiten zu können, musst Du die Datei Zeile für Zeile lesen. Das ist also der Rahmen drumherum: Du öffnest die Datei um da dann Zeilenweise lesen zu können.
Bei 2) ist dann doch: Du liest eine Zeile und prüfst diese. Ist sie nicht wie gewünscht kommt die Fehlermeldung und der Abbruch
Bei 3) ist dann die Schleife. Du hast eine Zahl oben eingelesen und da kannst Du das (oder die) Array(s) anlegen um diese dann in einer Schleife zu füllen.

Also wäre für Dich wichtig, dass Du den Ablauf einmal in Worten genau aufschreibst: Was ist wann zu tun und zu machen? Dabei auch ruhig mit groben Anweisungen arbeiten. Die beschreibst Du dann separat halt auch noch (und das werden dann Methoden!)

 

[Jw456]

Erste Problem was gleich auffällt ist. Du willst in der While Anweisung deine Variable Zeile benutzen aber die wird erst später erstellt. In der While.

 

[Jw456]

Zum verständnis du musst ja erstmal die Zeile aus dem Stream lesen.
Bevor du etwas prüfen testen kannst.

Das ist das was Konrad mit Grundüberlegung meint.

 

[Neumi5694]

1) Eingabe des Dateinamens
2) Startet die Textdatei nicht mit DATA: , dann Programmabbruch mit Fehlermeldung
3) Startet die Textdatei mit DATA:, dann die weiteren Zeilen in ein Array einlesen. Die Zahl hinter DATA: 10 gibt die Arraygröße wieder.
4) Für die Ausgaben müssen Zeitstempel und Geschwindigkeit ermittelt werden in der Form: Zeit, Geschwindigkeit:
}[/CODE]

Na das klingt aber schon etwas anders und macht auch was Anderes als das, was du oben implemtiert hast.

1) ignorier ich mal gekonnt, das passiert alles bevor du zur Datei kommst
4) ebenfalls, Ausgaben kommen erst später
2) 3) Die Auswertung der ersten Zeile ist also eine andere als die Auswertung der anderen Zeilen.

Sprich: Dein Prozessor muss das unterscheiden können.
Nur für die erste Zeile prüfst du auf "DATA:" und / oder Abbruch der Schleife.
Alle folgenden Zeilen werden als Daten ausgewertet.

line = ...;
  //ansonsten geht eh nichts
 boolean isValidDataFile = line != null && line.startwith("DATA:");
if (isValidDataFile) {
    do {
        line = ...;
        ausgewerteteDaten.add(auswergung(line));
    } while line != null;
} else {
  //..irgendwas ausgeben vielleicht?
}

 

[maxmuster987]

Ich hab ja oft gesagt bekommen, ich soll das Programm in viele kleine Methoden aufteilen.
Dann habe ich mir sowas in die Richtung nun überlegt.

Die Eingabe in einer Methode, wie oben gesagt.

Danach, will ich die Prüfung in einer Methode machen, die mir den Wahrheitswert zurückgibt?

Jetzt habe ich ein true oder false erhalten.

Mit diesem Warheitswert gehe ich dann in eine if-Anweisung, falls true, dann sollen die Daten ausgelesen werden in einer Methode.

Ich habe allerdings noch Probleme mit dem Daten einlesen ab Zeile 2.
Ich weiß ehrlich gesagt noch nicht, wie ich das anstellen soll. Der nachfolgende Code ist mit Sicherheits nur Murcks, aber damit ihr meinen groben Weg nachvollziehen könnt, was ich eigentlich machen möchte, um zur Lösung zu kommen.
Die Variable zeile1, zeile und zeilenAnzahl habe ich auch noch nicht näher definiert, da habe ich auch noch meine Probleme.

import java.io.*;
import javax.swing.*;
import java.util.*;

public class Uebung {
    public static void main (String[] args) throws Exception {

        System.out.println("==============================");
        System.out.println("=== Auswertung Windenergie ===");
        System.out.println("==============================");
       
        String filename = eingabeDateiname();
        boolean pruefung = dateiPruefung(filename);
       
        if(pruefung == true){
            datenAuslesen(filename);
        }
        else{
            System.out.println("Datei startet nicht mit DATA: -> Programmabbruch.");
            System.exit(0);
        }
       
        for(int i=0; i<zeilenAnzahl-1; i++){
            System.out.println(uhrzeitenFeld[i] +" vWind = " +geschwindigkeitsFeld[i] +" km/h\t pWind = " +pWind +" kW ");
        }
    }
   
   
    /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    Ab hier drunter Methoden:
    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
   
    //Eingabe des Dateinamens
    public static String eingabeDateiname(){
        String eingabe = JOptionPane.showInputDialog("Geben Sie den Dateinamen ohne .txt ein:");
        return eingabe;
    }
   
    //Pruefen, ob die Datei mit DATA: startet -> Wahrheitswert zurueckgeben
    public static boolean dateiPruefung(String filename){
        try {
            FileReader fileR = new FileReader(filename+".txt");
            BufferedReader bufR = new BufferedReader(fileR);
            String zeile;      
            boolean wahrheitswertVonZeile1 = zeile.startsWith("DATA:");
            return wahrheitswertVonZeile1;
        }
    }
   
    //Datei ab Zeile 2 auslesen, falls dateiPruefung true zurueckgibt  
    public static String datenAuslesen(String filename){
        int limit = zeile1.length;
        int arraygroesse = Integer.parseInt(zeile1.substring(6,limit));                  
        double uhrzeitenFeld [] = new double [arraygroesse];
        double geschwindigkeitsFeld [] = new double [arraygroesse];
       
        try {
        ...
        ...
        ...
        }
    }
   
   

   
   
   
/*

   
   
    //Berechnung der Windenergie
    public static double windenergie(double v) {        // v soll aus der Text-Datei-Zeile ausgelesen werden
        final int r = 20;
        final double rho = 1.2225;
        double flaeche = Math.PI*r^2;
       
        if(v>2 && v<40) {
            double pWind = (1/2.)*rho*flaeche*v^3;
        }
        else if (v>=40) {
            double pWind = 0;
            System.out.print("\tWind zu stark.");
        }
        else {
            double pWind = 0;
            System.out.print("\tWind zu schwach.");
        }
       
    }
    */
   
}

 

[Jw456]

Tipp wie wir schon sagten musst du erst mal was aus den BufferReader lesen.

Lesen tut man mit read. Ich sehe kein read von bufR

In deinem Fall wird readline wohl sinnvoller sein.

BufferedReader (Java Platform SE 8 )

 

[maxmuster987]

Ich habe mich bisschen weiter probiert und try with resource bisschen näher angeschaut.
Ich habe die Methode dateiPruefung jetzt angepasst in folgender Form:

public static boolean dateiPruefung(String filename){
    boolean wahrheitswertVonZeile1;

    try(FileReader fileR = new FileReader(filename+".txt");
        BufferedReader bufR = new BufferedReader(fileR)) {

        String zeile;  
        zeile = bufR.readLine();
        wahrheitswertVonZeile1 = zeile.startsWith("DATA:");
    }
    catch(NullPointerException e) {
    }
    return wahrheitswertVonZeile1;
}

 

[Jw456]

Soweit sollte die Methode jetzt das machen was sie aussagt.

Aber jetzt du willst nun in der zweiten Methode deine gelesen daten weiter verarbeiten.
Entweder müsste deine erste die daten zurückschicken nicht nur ein boolean.
Oder deine Variable Zeile idz ist nucht nicht lokal.
Sondern eine Instanzvariable.

Was ist da "zeile1" wo kommt die her.

Arbeitest du nicht mit einer IDE die dir das gleich sagt.

 

[Jw456]

Mal eine Frage zum Aufbau deiner Datei.

Am Anfang ist DATA: was kommt jetzt gleich die Daten ohne einen Zeilenumbruch oder mit?

Bedenke das ReadLine bei einem Aufruf den Stream immer nur bis zum Zeilenumbruch liest und als String zurück gibt.
Wenn die Datei etwa so ausschaut wirst du mit deinem Konzept nicht weit kommen.

DATA:(Zeilenumbruch)
10:00, 18.20(Zeilenumbruch)
12:00, 41.50(Zeilenumbruch)
13:00, 01.50(Zeilenumbruch)

Da wird es besser sein die Daten in einer Schleife in eine Liste oder Array zu lesen und dann weiter zu verarbeiten. Selbst wenn du deine Stringvariable „zeile“ als Instanzvariable (global) machst. Wird sie nach dem ersten lesen nur das „DATA:“ als Inhalt haben, und keine Daten.

Edit:
In deinen ersten Post #1 Zeile 15-16 war das lesen ja schon vorhanden.

            while((strng=obj.readLine()) != null)
                System.out.println(strng);

Nur muss in der Schleife schon etwas mehr passieren als nur eine Ausgabe.

Erst mal am besten immer Klammern benutzen. Hier könntest du es in eine Liste oder Array speichern. Die dann entweder zurückgeben oder die Liste /Array als Instanzvariable erstellen.
Um es weiter zu verarbeiten.

 

[Jw456]

Da drunter stehen dann Zeilen in Form von:
DATA: 10
19:00, 12.23
20:20, 10.00

Was bedeutet die "10" ?
Zehn folgende Zeilen ?

 

[maxmuster987]

Was bedeutet die "10" ?
Zehn folgende Zeilen ?

Jawohl, das bedeutet das.
Im Beispiel:
DATA: 3
10:00, 20.50
11:00, 30.00
13:45, 41.50



Ich hatte mich gestern Nacht auch noch um das Daten auslesen ab Zeile 2 "gekümmert" bzw. versucht.
Ich weiß, dass das noch nicht korrekt ist, weil ich jetzt doppelt auslese.
Das erste try soll mir die erste Zeile auswerten, denn ich brauche ja den Zahlenwert hinter dem Data. Dieser Wert ist ja x beliebig, deswegen die Variable "zeile1Laenge", damit ich weiß, bis wohin ausgelesen werden soll im substring.
Der Startwert ist ja 6, weil DATA: insgesamt 6 Zeichen hat mit Leerzeichen.

Und das zweite try soll alle Daten ab Zeile 2 in ein Array speichern.
Aber so wie ich das gemacht habe (so vermute ich mal), wird beim zweiten Array ebenfalls die erste Zeile nochmal ausgelesen. Das heißt, ich muss irgendwie beide trys zusammenpacken, oder?

public static String datenAuslesen(String filename){
 
    int zeile1Laenge = 0, arraygroesse = 0, zahlenwertHinterData = 0;
 
    try(FileReader fileR = new FileReader(filename+".txt");
        BufferedReader bufR = new BufferedReader(fileR)) {
     
        String zeile1;
        zeile1 = bufR.readLine();
        zeile1Laenge = zeile1.length;
        zahlenwertHinterData = zeile1.substring(6, zeile1Laenge+1);
        arraygroesse = Integer.parseInt(zahlenwertHinterData);
     
    }
    catch(NullPointerException e){
    }
 
    double uhrzeitenFeld [] = new double [arraygroesse];
    double geschwindigkeitsFeld [] = new double [arraygroesse];
 
    try(FileReader fileR = new FileReader(filename+".txt");
        BufferedReader bufR = new BufferedReader(fileR)) {

        for(int i=0; i<arraygroesse; i++) {
            String zeile;
            zeile = bufR.read(line);
            uhrzeitenFeld[i] = zeile.substring(0,5);
            geschwindigkeitsFeld[i] = zeile.substring(7,12);
        }
        while((zeile = bufR.readLine()) != null)
    }
    catch(NullPointerException e) {
    }
}

 

[Jw456]

Beachte da du einen neuen File / BufferReader benutzt du auch die Datei wider von Anfang an liest. Also nach den ersten Durchgang der for ist das „DATA“ wider in der String Variablen.

 

[Jw456]

Zweitens deine Beiden Arrays sind wieder nur lokal wie willst du später darauf zugreifen.

Ich denke du wiederholst nochmal Grundlagen Java Sichtbarkeit und Gültigkeit von Variablen.
Unterschied Lokale Variablen, Instanzvariablen, und Klassenvariablen.

 

[Jw456]

Drittens die Methode wird auch nicht Kompilieren da sie keine Rückgabe macht return.

Welche IDE benutzt du?

 

[Jw456]

  static String[] uhrzeitenFeld;
    static double[] geschwindigkeitsFeld;

    public static boolean datenAuslesen(String filename) {

        int zeile1Laenge = 0, arraygroesse = 0 ;

        try (FileReader fileR = new FileReader(filename + ".txt");
             BufferedReader bufR = new BufferedReader(fileR)) {

            String zeile;
            while ((zeile = bufR.readLine()) != null) { // so nicht notwendig

                zeile1Laenge = zeile.length();
                arraygroesse = Integer.parseInt(zeile.substring(6, zeile1Laenge + 1));

                uhrzeitenFeld = new String[arraygroesse];
                geschwindigkeitsFeld = new double[arraygroesse];

                for (int i = 0; i < arraygroesse; i++) {
                    String zeileDaten;
                    zeileDaten = bufR.readLine();
                    uhrzeitenFeld[i] = zeileDaten.substring(0, 5);
                    geschwindigkeitsFeld[i] = Double.parseDouble(zeileDaten.substring(7, 12));
                }

            }
        } catch (FileNotFoundException e) {
            return false;
     
        } catch (IOException e) {
            return false;
        }

        return true;
    }

so in etwa könnte es gehen.

Welche IDE benutzt du?

"10:00" ist kein Double, sondern ein String Parsen nach double wird immer Fehler geben.

Edit :
sorry das while brauchst du so eigentlich nicht. versuche selber warum.

 

[maxmuster987]

Zweitens deine Beiden Arrays sind wieder nur lokal wie willst du später darauf zugreifen.

Was ist, wenn ich die "einfach" direkt unterhalb der Klasse class definiere?
Ist sie dann nicht überall aufgreifbar?

Welche IDE benutzt du?

Notepad++

"10:00" ist kein Double, sondern ein String Parsen nach double wird immer Fehler geben.

Aber 10:00 will ich doch auch gar nicht nach double parsen? Das double parsen gilt nur für die Geschwindigkeit. Die Uhrzeit benötige ich nur als String.

 

[Jw456]

Aber 10:00 will ich doch auch gar nicht nach double parsen? Das double parsen gilt nur für die Geschwindigkeit. Die Uhrzeit benötige ich nur als String.

ja tust du auch nicht.
Aber der Code wird nicht Kompiliren.
Du bekommst mit readLine immer einen String zurück den kannst du nicht einem duoble zuweisen. Compiler Fehler
Deine Arrays sind beide vom Datentyp double.

 

[Jw456]

Notepad++

Wieso das?
Das ist keine IDE. Nur ein einfacher Editor. Kein Wunder das du so grundlegende Fehler machst.

 

[maxmuster987]

Du bekommst mit readLine immer einen String zurück den kannst du nicht einem duoble zuweisen. Compiler Fehl
Deine Arrays sind beide vom Datentyp double.

Ah okay, das meinst du, dann habe ichs falsch aufgenommen.

Wieso das?

Weil das nur auf den Arbeitsrechnern zur Verfügung steht, ich hab da kein IntelliJ oder andere Programme, die dafür geeignet wären.
Das Einzige, was möglich wäre. Wenn ich mir IntelliJ zuhause auf einen Stick runterlade und ich das Programm immer über den Stick öffnen könnte. Aber ich weiß nicht, ob das funktioniert, weil auf den Rechnern selbst kann ich das nicht installieren aus Firmenensicherheitsgründen frag den Geier...

Welche Umgebung würdest du denn empfehlen?

 

[Jw456]

Ich nutze IntelliJ.

Glaube Eclipse ist oder gibt es auch als Portabel Version. Was somit auf einen Firmen Rechner laufen könnte.

 

[maxmuster987]

Habe mich jetzt über eine Stunde mit der Installation von Eclipse auf einen Stick auseinandergesetzt und bin anscheinend zu dumm, um das da drauf zu bekommen auch nach sämtlichen Videotutorials und sonstigem.
Daher bleibe ich dann wohl doch Notepad++ treu und arbeite dort weiter, auch wenn's fehleranfälliger ist.

 

[Jw456]

Die Fehler machst ja du, und du sollst lernnen das auch zu erkennen.
Der Compiler gibt dir ja auch entsprechende Fehler Meldungen.

Du musst es halt öfters versuchen zu compilieren um die Fehler zu sehen.

In einer IDE siehst du es halt einfacher.

 

[Oneixee5]

Eclipse muss man nicht über den Installer installieren. Einfach eins der Pakete als zip runterladen, entpacken und fertig. Du benötigst natürlich ein Java. Ich empfehle OpenJDK 17 aber ein JRE tut es auch.
Eine weitere Alternative wäre Visual Studio Code, der Installer entpackt einfach nur und das funktioniert auch auf abgesicherten Firmen PC. Visual Studio Code muss man sich aber selbst aufrüsten, um damit Java zu programmieren. Auch hier ist ein JDK notwendig.
Eine IDE auf einem USB-Stick wird bestimmt viel zu langsam.

 

[Jw456]

Eclipse muss man nicht über den Installer installieren. Einfach eins der Pakete als zip runterladen, entpacken und fertig. Du benötigst natürlich ein Java. Ich empfehle OpenJDK 17 aber ein JRE tut es auch.
Eine weitere Alternative wäre Visual Studio Code, der Installer entpackt einfach nur und das funktioniert auch auf abgesicherten Firmen PC. Visual Studio Code muss man sich aber selbst aufrüsten, um damit Java zu programmieren. Auch hier ist ein JDK notwendig.
Eine IDE auf einem USB-Stick wird bestimmt viel zu langsam.

Auf dem Stick ja. Aber er könnte es auf dem Firmen Rechner in seinem Home Verzeichnis laufen lassen. Ohne Admin Rechte und Einträge in die Windows-Registrierungsdatenbank.

 

[maxmuster987]

Die Fehler machst ja du, und du sollst lernnen das auch zu erkennen.
Der Compiler gibt dir ja auch entsprechende Fehler Meldungen.

Ja, dem bin ich mir bewusst. Ich meine nur damit, dass ich dann die Fehler nicht so schnell sehen kann. :-D

Einfach eins der Pakete als zip runterladen, entpacken und fertig. Du benötigst natürlich ein Java. Ich empfehle OpenJDK 17 aber ein JRE tut es auch.

Hehehe, das hat mir geholfen. Jetzt habe ich es hinbekommen! Danke.

import java.io.*;
import javax.swing.*;
import java.util.*;

public class Uebung {

    public static void main(String[] args) {
        System.out.println("==============================");
        System.out.println("=== Auswertung Windenergie ===");
        System.out.println("==============================");
        
        String filename = eingabeDateiname();
        boolean pruefung = dateiPruefung(filename);
        
        if(pruefung == true){
            datenAuslesen(filename);
        }
        else{
            System.out.println("Datei startet nicht mit DATA: -> Programmabbruch.");
            System.exit(0);
        }
        
        for(int i=0; i<zeilenAnzahl-1; i++){
            System.out.println(uhrzeitenFeld[i] +" vWind = " +geschwindigkeitsFeld[i] +" km/h\t pWind = " +pWind[i] +" kW ");
        }
    }
    
    //Ab hier drunter Methoden:
    //Eingabe des Dateinamens
    public static String eingabeDateiname(){
        String eingabe = JOptionPane.showInputDialog("Geben Sie den Dateinamen ohne .txt ein:");
        return eingabe;
    }
    
    //Pruefen, ob die Datei mit DATA: startet -> Wahrheitswert zurueckgeben
    public static boolean dateiPruefung(String filename){
        boolean wahrheitswertVonZeile1;
        
        try(FileReader fileR = new FileReader(filename+".txt");
            BufferedReader bufR = new BufferedReader(fileR)) {
                
            String zeile;   
            zeile = bufR.readLine();
            wahrheitswertVonZeile1 = zeile.startsWith("DATA:");
        }
        catch(NullPointerException e) {
        }
        return wahrheitswertVonZeile1;
    }
    
    //Datei ab Zeile 2 auslesen, falls dateiPruefung true zurueckgibt   
public static String datenAuslesen(String filename){
    
    int zeile1Laenge = 0, arraygroesse = 0, zahlenwertHinterData = 0;
    
    try(FileReader fileR = new FileReader(filename+".txt");
        BufferedReader bufR = new BufferedReader(fileR)) {   
        
        String zeile1;
        zeile1 = bufR.readLine();
        zeile1Laenge = zeile1.length;
        zahlenwertHinterData = zeile1.substring(6, zeile1Laenge+1);
        arraygroesse = Integer.parseInt(zahlenwertHinterData);
        
        double uhrzeitenFeld [] = new double [arraygroesse];
        double geschwindigkeitsFeld [] = new double [arraygroesse];
    


        for(int i=0; i<arraygroesse; i++) {
            String zeile;
            zeile = bufR.read(line);
            uhrzeitenFeld[i] = zeile.substring(0,5);
            geschwindigkeitsFeld[i] = zeile.substring(7,12);
        }
        while((zeile = bufR.readLine()) != null)   
    }
    catch(NullPointerException e) {
    }
}   
    

}

Wenn ich das jetzt in Eclipse ausführen lasse, dann bekomme ich folgende Fehler:

Exception in thread "main" java.lang.Error: Unresolved compilation problems:
    zeilenAnzahl cannot be resolved to a variable
    uhrzeitenFeld cannot be resolved to a variable
    geschwindigkeitsFeld cannot be resolved to a variable
    pWind cannot be resolved to a variable

    at Uebung.main(Uebung.java:23)

 

[Jw456]

Genau das was ich dir schon gesagt habe. Du kannst einem double keinen String zuweisen.

zeilenAnzahl benutzt du ohne es erstellt zu haben.

 

[maxmuster987]

zeilenAnzahl benutzt du ohne es erstellt zu haben.

Das ist nur ein Lückenfüller gewesen, damit ich weiß, welchen Wert ich da benötige. Das wird geändert zu arraygroesse.

Genau das was ich dir schon gesagt habe. Du kannst einem double keinen String zuweisen.

        String uhrzeitenFeld [] = new String [arraygroesse];

Und wenn ich es dann so mache?

 

[Jw456]

Hast du dir mal mein Beispiel angesehen. Ich glaube nein.

 

[maxmuster987]

Das Beispiel ist anscheinend untergegangen und habe ich nicht wahrgenommen.

Ich hab mir das jetzt angeschaut und hab mir die Frage gestellt, warum gebe ich hier ebenfalls einen Wahrheitswert zurück?
Welchen Nutzen bringt mir jetzt ein true oder false?

 

[KonradN]

Zum Thema Entwicklungsumgebung evtl. noch der Hinweis von mir:
IntelliJ ist auch als ZIP ladbar. Gerade für Anfänger hat Intellij deutlich mehr Hilfen als Eclipse. Daher wäre das meine Empfehlung. Und das kannst Du damit auch von einem USB Stick laufen lassen. Das dürfte aber deutlich zu langsam sein, zumindest die meisten USB Sticks, die ich so kenne, sind da sehr schlecht. Aber eine einfache kleine SSD mit USB 3 wäre hier garantiert eine super Lösung - so Du die Software nicht einfach auf dem Rechner irgendwo liegen haben kannst (z.B. dein User Verzeichnis).

Was Deinen Code angeht, so sieht der doch schon sehr gut aus. Bei lokalen Variablen ist es aber immer gut, Deklaration und Zuweisung auch zusammen zu fassen. Aus

        String zeile1;
        zeile1 = bufR.readLine();

wird dann einfach

        String zeile1 = bufR.readLine();

Und dann musst Du bei neuen lokalen Variablen nur überlegen: Was für ein Datentyp wird denn hier benötigt?

Also z.B. bei `zeile1Laenge = zeile1.length;`ist die Frage immer:
Was für ein Typ wird hier gebraucht? Dazu schaust Du Dir dann an, was denn length ist - length ist eine Methode von String, die ein int zurück gibt.
Also kommt da einfach ein int davor und schon wird die Variable auch deklariert. Und da length eine Methode ist kommen da natürlich auch () drumherum.: int zeile1Laenge = zeile1.length();

Tipp: Eine Entwicklungsumgebung unterstützt Dich direkt beim tippen! Wenn Du also zeile1.len getippt hast, dann sollte dir die Methode length schon angeboten werden. Mit der Tab Taste würde Dir IntelliJ direkt alles ergänzen so dass da dann zeile1.length(); stehen dürfte. Und wenn Du da so einen Fehler hast mit Variable nicht deklariert, dann bietet IntelliJ da auch einiges an Hilfe an! (Andere IDEs haben das auch, aber Anfängerfreundlich ist zumindest bei Eclipse nichts!)

So kannst Du den ganzen Code relativ schnell und gut überarbeiten.

Das nächste Problem kommt aber dann bei:

        double uhrzeitenFeld [] = new double [arraygroesse];
        double geschwindigkeitsFeld [] = new double [arraygroesse];

Das sind wieder lokale Variablen - aber Du willst diese Werte ja auch außerhalb des aktuellen Blocks noch haben. Hier solltest Du Dir einmal anschauen, was Instanz- oder Klassenvariablen sind.

 

[maxmuster987]

Anfängerfreundlich ist zumindest bei Eclipse nichts!

Ich dachte schon, dass es mir nur so vorkommt, weil ich noch nicht viel Erfahrung habe. Aber wenn du das sogar bestätigst, dann hat mich mein Anschein wohl doch nicht getrügt.

Das dürfte aber deutlich zu langsam sein, zumindest die meisten USB Sticks, die ich so kenne, sind da sehr schlecht. Aber eine einfache kleine SSD mit USB 3 wäre hier garantiert eine super Lösung - so Du die Software nicht einfach auf dem Rechner irgendwo liegen haben kannst (z.B. dein User Verzeichnis).

Den Hinweis nehme ich mir mal zu Herzen, dann werde ich schauen, dass ich intelliJ irgendwie da drauf bekomme.

Was Deinen Code angeht, so sieht der doch schon sehr gut aus.

Echt jetzt? Bei den vorherigen Kommentaren war ich schon am verzweifeln, dass ich komplett auf dem falschen Weg bin und habe mir neue, anderweitige Lösungsmöglichkeiten gesucht mit Hilfe von Videotutorials und Java Skripten.

length eine Methode ist kommen da natürlich auch ()

Das ist auch gut zu wissen.

Das sind wieder lokale Variablen - aber Du willst diese Werte ja auch außerhalb des aktuellen Blocks noch haben. Hier solltest Du Dir einmal anschauen, was Instanz- oder Klassenvariablen sind.

Das hatte ich auch mal am Anfang gelernt.
Instanzvariablen stehen einem Objekt zur Verfügung, während Klassenvariablen allen Objekten zur Verfügung stehen, d.h. sie sind globale Variablen.

 

[maxmuster987]

Eine Frage nebenbei zu intelliJ. Ich hab mir jetzt eine SSD bestellt, die sollte morgen da sein, solange kann ich von meinem Heim-PC intelliJ nutzen und das Ganze abarbeiten.

Ich habe ja jetzt meine Programme alle in notepad++ geschrieben und dementsprechend auch die Java Datei.
Wie öffne ich diese Java Datei in intelliJ und lasse "RUN" ausführen?
Irgendwie muss ich immer vorher ein Projekt neu öffnen und speichern. Funktioniert das nicht einfach so, dass die Java Datei eingelesen wird und der automatisch das Projekt erstellt anhand des Java-Datei-Namens?

 

[KonradN]

Generell empfehle ich, wirklich erst ein Projekt anzulegen um da dann die Dateien hinein zu kopieren. Wenn Du ein Java File direkt öffnest, dann kannst Du es nicht ausführen und viele Dinge stehen nicht zur Verfügung.

Bei den Projekten wäre auch meine Empfehlung, ruhig frühzeitig auf Maven zu setzen. Hier ist aber wichtig: Es wird ein Zugriff auf das Internet benötigt. Falls Du auf dem Rechner kein Internet Zugang haben solltest, so ist es vermutlich keine Idee, auf Maven zu setzen. Und wenn Dein Home Verzeichnis komplett frei bleiben soll, müsstest Du da in IntelliJ noch ein paar Konfigurationen vornehmen:
In den IntelliJ Einstellungen unter Build, Execution, Deployment > Build Tools > Maven kannst Du das user settings file und Local Repository an eine andere Stelle (Seine SSD) verschieben, damit nicht alles in deinem Home Verzeichnis unter .m2 landet. (Aber evtl. ist das ja noch in Ordnung. Zumindest das .m2/settings.xml File sollte ok sein, damit Du Maven auch auf der Kommandozeile nutzen kannst.

 

[Jw456]

Das Beispiel ist anscheinend untergegangen und habe ich nicht wahrgenommen.

Ich hab mir das jetzt angeschaut und hab mir die Frage gestellt, warum gebe ich hier ebenfalls einen Wahrheitswert zurück?
Welchen Nutzen bringt mir jetzt ein true oder false?

Du könntest zum Beispiel in der Aufruf Methode (main) prüfen ob beim lesen ein Fehler aufgtreten ist..
Brauchst dann zb deine Ausgabe nicht mehr nachen.
Es war doch glaube auch gefordert zu prüfen ob das lesen ok war.

 

[maxmuster987]

Es wird ein Zugriff auf das Internet benötigt.

Das ist leider nicht immer gegeben, deswegen würde ich darauf fürs Erste einmal verzichten.
Sobald die SSD angekommen ist im Laufe des Tages, dann werde ich es darauf einmal entpacken und paar nötige Einstellungen vornehmen.

Du könntest zum Beispiel in der Aufruf Methode (main) prüfen ob beim lesen ein Fehler aufgtreten ist..
Brauchst dann zb deine Ausgabe nicht mehr nachen.
Es war doch glaube auch gefordert zu prüfen ob das lesen ok war.

Ja genau, das war es. Aber ich dachte, das habe ich schon mit der Methode dateiPruefung abgearbeitet. Und die Methode datenAuslesen soll mir jetzt die Zeilen auslesen, wenn dateiPruefung ein true zurückgegeben hat.

public static boolean dateiPruefung(String filename){
    boolean wahrheitswertVonZeile1;

    try(FileReader fileR = new FileReader(filename+".txt");
        BufferedReader bufR = new BufferedReader(fileR)) {

        String zeile;   
        zeile = bufR.readLine();
        wahrheitswertVonZeile1 = zeile.startsWith("DATA:");
    }
    catch(NullPointerException e) {
    }
    return wahrheitswertVonZeile1;
}

 

[Jw456]

Musst du ja nicht benutzen. Dann halt einfach nur void.

 

[Jw456]

Bei der Methode dateiPruefung() würde ich auch in dem catch Zweig ein false zurückgeben. Also wenn zb beim öffnen lesen der Datei ein Fehler passiert. Sollte auch false zurück geben werden.

Ja deine Variable sollte default auf false sein ich würde es ihr aber doch am anfang zuweisen.

 

[Jw456]

Und die Methode datenAuslesen soll mir jetzt die Zeilen auslesen, wenn dateiPruefung ein true zurückgegeben hat.

Ja aber es könnte ja noch ein Fehler beim lesen und schrieben in den Arrays auftreten.
Die IDE fordert ja auch ein tray catch.
Lesen, Parsen...

 

[maxmuster987]

Ich komme einfach nicht weiter, ich verstehe es einfach nicht... Ich habe das jetzt auch in intelliJ drin und bekomme insgesamt 14 Fehlermeldungen...

Ich will es jetzt so machen, dass mein main relativ kompakt bleibt.

Dateneingabe über Methode.
Rückgabe boolean true/false.
Bei false wird in der main das Programm bereits beendet.
Bei true, dann werden Daten in der Methode datenAuslesen ausgelesen und anschließend berechnet + ausgegeben.
Ist das legitim, das so zu handhaben?

import javax.swing.*;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class TextDateienEinlesenVerarbeiten {
    public static void main (String[] args) throws Exception {

        System.out.println("==============================");
        System.out.println("=== Auswertung Windenergie ===");
        System.out.println("==============================");

        String filename = eingabeDateiname();
        boolean pruefung = dateiPruefung(filename);

        if(pruefung == true){
            datenAuslesen(filename);
        }
        else{
            System.out.println("Datei startet nicht mit DATA: -> Programmabbruch.");
            System.exit(0);
        }

    }



    /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    Ab hier drunter Methoden:
    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

    //Eingabe des Dateinamens
    public static String eingabeDateiname(){
        String eingabe = JOptionPane.showInputDialog("Geben Sie den Dateinamen ohne .txt ein:");
        return eingabe;
    }

    //Pruefen, ob die Datei mit DATA: startet -> Wahrheitswert zurueckgeben
    public static boolean dateiPruefung(String filename){
        boolean wahrheitswertVonZeile1 = false;

        try(FileReader fileR = new FileReader(filename+".txt");
            BufferedReader bufR = new BufferedReader(fileR)) {

            String zeile;
            zeile = bufR.readLine();
            wahrheitswertVonZeile1 = zeile.startsWith("DATA:");
        }
        catch(NullPointerException e) {
            return false;
        }
        return wahrheitswertVonZeile1;
    }

    //Datei ab Zeile 2 auslesen, falls dateiPruefung true zurueckgibt
    static String[] uhrzeitenFeld;
    static double[] geschwindigkeitsFeld;

    public static boolean datenAuslesen(String filename){

        int zeile1Laenge = 0, arraygroesse = 0 ;

        try (FileReader fileR = new FileReader(filename + ".txt");
             BufferedReader bufR = new BufferedReader(fileR)) {

            String zeile;
            while ((zeile = bufR.readLine()) != null) { // so nicht notwendig

                zeile1Laenge = zeile.length();
                arraygroesse = Integer.parseInt(zeile.substring(6, zeile1Laenge + 1));

                uhrzeitenFeld = new String[arraygroesse];
                geschwindigkeitsFeld = new double[arraygroesse];

                for (int i = 0; i < arraygroesse; i++) {
                    String zeileDaten;
                    zeileDaten = bufR.readLine();
                    uhrzeitenFeld[i] = zeileDaten.substring(0, 5);
                    geschwindigkeitsFeld[i] = Double.parseDouble(zeileDaten.substring(7, 12));
                }

            }
        } catch (FileNotFoundException e) {
            return false;

        } catch (IOException e) {
            return false;
        }
        return true;
    }





    //Berechnung der Windenergie
    public static double windenergie(double v) {        // v soll aus der Text-Datei-Zeile ausgelesen werden
        final int r = 20;
        final double rho = 1.2225;
        double flaeche = Math.PI*r^2;
        static double windenergieFeld[] = new double [arraygroesse];
        windenergieFeld[i] = (1/2.)*rho*flaeche*Math.pow(geschwindigkeitsFeld[i]/3.6.,3);

        if(v<=2 ) {
            System.out.println(uhrzeitenFeld[i]+ "vWind = "+geschwindigkeitsFeld[i] +" km/h \t pWind = 0kW \t Wind zu schwach ");
        }
        else if (v>=40) {
            System.out.println(uhrzeitenFeld[i]+ "vWind = "+geschwindigkeitsFeld[i] +" km/h \t pWind = 0kW \t Wind zu stark ");
        }
        else {
            System.out.println(uhrzeitenFeld[i]+ "vWind = "+geschwindigkeitsFeld[i] +" km/h \t pWind = "+windenergieFeld[i] +" kW");
        }

    }

}