Zweidimensionale Arrayverwaltung

J

JiXXaW

Mitglied
Hallo Zusammen,

ich versuche seit einigen Tagen ein Programm zu schreiben, welches mit erlaubt ein zwei dimensionales Array zu verwalten. Meine Grundidee ist das dieses Programm drei Dinge kann:

1) ein in einem Textfile abgelegtes Array einlesen

2) das vorhandene Array um eine Zeile mit neuen Eingaben erweitern

3) das erweiterte Array in einer .txt-Datei ablegen.

Die werte für die Dimensionen des Arrays sind auch aus txt Dateien entnommen. und soll mit einem Wert von null (also einer zeile) und einem Wert von 2(also 3 spalten) starten. beim vergrößern soll immer ein neuer datensatz angelegt werden ( also nur eine erhöhung der Zeilenanzahl stattfinden) und der neue Wert soll an das untere Ende des Arrays geschrieben werden.



Mein aktueller code sieht für die drei geschriebenen Methoden folgendermaßen aus:

1)

loadArray:
public void loadArray()
    {
        
        //Array erzeugen
        try {
            BufferedReader br = new BufferedReader(new FileReader(arraysWH.getArraySizePath()));
            BufferedReader bx = new BufferedReader(new FileReader(arraysWH.getCounterPath()));
            try {

                arraysWH.setAnzahlZeilenMasterData(Integer.parseInt(bx.readLine()));
                arraysWH.setAnzahlSpaltenMasterData(Integer.parseInt(br.readLine()));
                
                br.close();
                bx.close();
                arraysWH.masterData= new String[arraysWH.getAnzahlZeilenMasterData()][arraysWH.getAnzahlSpaltenMasterData()];
                
            }
            catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        //Daten aus txt laden
        
        System.out.println("Lade Daten aus txt-File");
        Scanner in;
        try {
            in = new Scanner(new FileReader(arraysWH.getMasterDataPath()));
        int lineCount = 0;
        
        try{
        
        while (in.hasNextLine()) {
              String[] currentLine = in.nextLine().trim().split(",");
                 for (int i = 0; i <arraysWH.masterData.length; i++) {
                     arraysWH.masterData[lineCount][i] = currentLine[i];;   
                     System.out.println(arraysWH.masterData[lineCount][i]+",");
                    
                        }
                
              lineCount++;
             }
        System.out.println(arraysWH.masterData.length+" Datensätze geladen");
        }
        catch(ArrayIndexOutOfBoundsException ex)
        {
            System.out.println(arraysWH.masterData.length+" Datensätze geladen(müssten vermutlich immer null sein)");
        }
        
        
        in.close();
        System.out.println();
          System.out.println("Laden abgeschlossen");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        this.status("Ende Laden");
        }

2)

Code:
]public void extendArray()
    {
        System.out.println("Starte Arrayerweiterung");
        
        System.out.println("Anzahl Zeilen: "+arraysWH.getAnzahlZeilenMasterData());
        System.out.println("Anzahl Spalten: "+arraysWH.getAnzahlSpaltenMasterData());
        arraysWH.setAnzahlZeilenIntermediateData(arraysWH.getAnzahlZeilenMasterData()+1);
        arraysWH.setAnzahlSpaltenIntermediateData(arraysWH.getAnzahlSpaltenMasterData());
        
        arraysWH.intermediateData = new String[arraysWH.getAnzahlZeilenIntermediateData()][arraysWH.getAnzahlSpaltenIntermediateData()];
        
        
        
        
        
        
            //Daten zwischenspeichern
        System.out.println("############################################");
        System.out.println("Starte Speichervorgang");
        System.out.println("masterDatalength/anzahl Zeilen: "+arraysWH.masterData.length);
        //System.out.println("masterDatalength/Anzahl Spalten: "+arraysWH.masterData[0].length);
        System.out.println("intermediateDatalength/anzahl Zeilen: "+arraysWH.intermediateData.length);
        System.out.println("intermediateDatalength/Anzahl Spalten: "+arraysWH.intermediateData[0].length);
        
        
            for (int i=0;i<arraysWH.masterData.length;i++)
                {
                    for (int j=0;j<arraysWH.getAnzahlSpaltenMasterData();j++)
                    {
                        arraysWH.intermediateData[i][j]=arraysWH.masterData[i][j];
                        System.out.println("Wert übertragen spalte: "+j+" Zeile: "+i+" "+arraysWH.intermediateData[i][j]);
                    }
                    System.out.println("Zeilenwechsel");
                }
            arraysWH.masterData=null;
            
            
            System.out.println("Speichervorgang abgeschlossen");
            System.out.println("############################################");
            //Arraygrößen überprüfen
            arraysWH.masterData = new String[arraysWH.getAnzahlZeilenIntermediateData()][arraysWH.getAnzahlSpaltenIntermediateData()];
            
            
            System.out.println("intermediate Zeilen: "+arraysWH.intermediateData.length);
            System.out.println("intermediate Spalten: "+arraysWH.intermediateData[0].length);
            
            //Daten zufügen
            System.out.println("Starte hinzufügen von Daten");
            
            
            arraysWH.intermediateData[arraysWH.getAnzahlZeilenMasterData()][0]=arraysWH.getString1Value();
            arraysWH.intermediateData[arraysWH.getAnzahlZeilenMasterData()][1]=arraysWH.getString2Value();
            arraysWH.intermediateData[arraysWH.getAnzahlZeilenMasterData()][2]=arraysWH.getString3Value();
            System.out.println("Zufügen von Daten abgeschlossen");
            System.out.println("############################################");
            
            System.out.println(arraysWH.intermediateData[0][0]);
             System.out.println(arraysWH.intermediateData[0][1]);
             System.out.println(arraysWH.intermediateData[0][2]);
            
             System.out.println(arraysWH.masterData[0][0]);
             System.out.println(arraysWH.masterData[0][1]);
             System.out.println(arraysWH.masterData[0][2]);

            //Daten zurückspeichern
        
             for (int i=0;i<arraysWH.getAnzahlZeilenIntermediateData();i++)
                {
                    for (int j=0;j<arraysWH.getAnzahlSpaltenIntermediateData();j++)
                    {
                        arraysWH.masterData[i][j]=arraysWH.intermediateData[i][j];
                    }
                }
             System.out.println(arraysWH.masterData[0][0]);
             System.out.println(arraysWH.masterData[0][1]);
             System.out.println(arraysWH.masterData[0][2]);
            //zwischenspeicher löschen
             arraysWH.intermediateData=null;
    }

3)

save Array:
public void saveArray()
    {
        try {
            PrintWriter bw = new PrintWriter(new FileWriter(arraysWH.getMasterDataPath()));
            PrintWriter bx = new PrintWriter(new FileWriter(arraysWH.getCounterPath()));
            bx.print(arraysWH.masterData.length);
            int s=arraysWH.masterData.length;
            System.out.println(s);
            
            for (int i = 0; i<arraysWH.masterData.length; i++)
            {
                for(int j = 0; j<arraysWH.masterData[0].length; j++)
                {
                    
                  bw.print(arraysWH.masterData[i][j]+ ",");
                  
                }
                bw.println();
            
            
            
        }
            bw.close();
            bx.close();
        }catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
    }

            

    }

mein Problem dabei ist, das ich vermutlich irgendwo die zuweisungen verbastel, sodass am Ende nicht mehr das herauskommt was eigentlich soll. Aus dem Grund habe ich angefangen den Code mit so vielen kommentaren zu versehen, um die aktuellen zustände der variablen zu den entsprechenden Zeitpunkten zu sehen ( das debuggen funktioniert bei diesem Projekt komischerweise nicht, zumindest sind alle bedienelemente ausgegraut)

beim ersten Durchlauf des Programms bekomme ich eine ganz normale ausgabe und auch das speichern funktioniert:

Hans,schlafen,Audi,

beim zweiten Durchlauf ist die ausgabe die folgende:

Hans,null,null,
Peter,sitzen,BMW,

beim dritten:

Hans,null,null,
Peter,sitzen,null,
Klaus,gehen,Dacia,

beim vierten:

Hans,null,null,
Peter,sitzen,null,
Klaus,gehen,Dacia,
Peter,schlafen,Dacia,

und von dem fünften an:

Hans,null,null,
null,null,null,
null,null,null,
null,null,null,
Hans,schlafen,Audi,

das Problem wird vermutlich in der Zuweisung der Array Dimensionen liegen, allerdings finde ich meinen Fehler einfach nicht und hatte gehofft das vielleicht jemand der in der richtung etwas versierter ist (vielleicht sogar mit wenig aufwand) den grund für die fehlerhafte ausgabe aufzeigen kann.

eine andere sache die mir aufgefallen ist, die ich allerdings bis jetzt nur so umgehen konnte ist die tatsache das ich als Zeilenanzahl den Wert 3 lade und nicht wie eigentlich vorgesehen den Wert 2.

falls weitere Codeschnipsel gewünscht sind kann ich diese gerne nachliefern, aber vielleicht ist das problem ja garnicht so kompliziert wie ich es gerade denke.

Vielen Dank im vorhinein schon einmal.
 
kneitzel

kneitzel

Top Contributor
Also Dein Code ist kaum lesbar. Und ich frage mich, wie das, was Du schreibst und das was ich im Code sehe, überhaupt zusammen passen soll. Die Namen der Methoden und Variablen ist dazu auch nicht wirklich hilfreich fürchte ich... Aber was mir da so etwas auffällt:

Wenn Du Daten in einer Text-Datei hast: Was liest Du dann aus zwei Dateien? Du scheinst da zwei Dateien zu haben, die jeweils nur eine Zeile mit der Größe des Arrays enthalten? Das sieht mir zu komplex aus und ergibt sich mir nicht wirklich. Die Anzahl der Datensätze ergibt sich aus der Anzahl der Zeilen (z.B.). Und es können dynamische Typen verwendet werden wie z.B. ArrayList.

Dann würde ich den Code besser strukturieren. Da scheint die Aufteilung noch nicht wirklich durchdacht zu sein. So hast Du Methoden einer Klasse, die die genauen Details der Klasse, von deren Typ arraysWH ist, kennen muss. Denn Du greifst ständig auf Implementrationsdetails zu.

Und dann bezüglich der Logik beim Erweitern des Arrays:
- intermediateData: Wenn das nur temporär benötigt wird, dann würde doch eine lokale Variable ausreichen. Da muss dann doch keine Instanzvariable herhalten, oder brauchst Du das noch einmal?
- Warum kopierst Du die Daten zwei Mal? Du hast doch ein zweidimensionales Array mit den gewünschten Daten in intermediateData. Da würde dann doch ein Kopieren der Referenz in masterData ausreichen.

Dann noch der Hinweis: Schau Dir mal try with resources an.

Was den Fehler selbst angeht - beim Laden scheint es mir nicht ganz richtig zu sein:
Java:
while (in.hasNextLine()) {
              String[] currentLine = in.nextLine().trim().split(",");
                 for (int i = 0; i <arraysWH.masterData.length; i++) {
                     arraysWH.masterData[lineCount][i] = currentLine[i];;   
                     System.out.println(arraysWH.masterData[lineCount][i]+",");
                    
                        }
                
              lineCount++;
             }
Du lädst eine Zeile und splittest die auf. Das ist noch ok.
Aber dann gehst Du durch und hast eine Schleife von 0 bis i < arraysWH.masterData.length - und das ist doch quatsch. Du willst doch die Zeile auswerten. Und masterDate.length wäre die Anzahl der Datensätze? Das dürfte doch auch eine IndexOutOfBoundsException werfen, wenn Du nur 3 Werte pro Zeile hast aber mehr wie 3 Datensätze liest, oder nicht? Aber das ist wie gesagt alles sehr schwer zu lesen und zu verstehen was Du da überhaupt versuchst....
 
J

JiXXaW

Mitglied
vielen Dank für die schnelle Antwort,

Ich bin noch ein Anfänger was Java im allgemeinen angeht, deshalb ist meine Codestruktur nicht gerade das gelbe vom Ei, genauso wie Variablen oä teilweise nicht da sind wo sie hingehören. Ich habe diesbezüglich leider noch keine Anleitung gefunden (auch was das allgemeine Strukturieren von projekten angeht, also welche klassen zusammen gepackt werden und wie diese dann in welchen packages angeordnet werden.)

Die beiden Textdateien habe ich nur eingefügt weil es einfacher war als die sachen in eine datei zu schreiben, zugegebenermaßen hätte ich diese auch im code ändern können.

Das mit der lokalen variable stimmt.

zwei mal kopiere ich weil ich es bis jetzt nicht besser weiß.



ich habe den Code jetzt einmal in eine Klasse geschrieben und versucht etwas übersichtlicher zu gestalten:

main:
package arrayFundamentalsPkg;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;

public class main {

    public static void main(String[] args)

    {
        
        int lineCtr = 1;
        int noOfValues = 3;
        
        

        try {
            BufferedReader br = new BufferedReader(new FileReader("Pfad zur counter.txt-Datei "));

            lineCtr = Integer.parseInt(br.readLine());

            br.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        
        System.out.println("erzeuge ein Array mit: ");

        String[][] masterData = new String[lineCtr][noOfValues];

        try {
            Scanner in = new Scanner(new FileReader("Pfad zur array.txt-Datei"));
            int lineCount = 0;
            while (in.hasNextLine()) {
                String[] currentLine = in.nextLine().trim().split(",");
                for (int i = 0;i<3;i++)
                {
                masterData[lineCount][i] = currentLine[i];
                
                System.out.print(masterData[lineCount][i] + ",");
                }System.out.println();
            }
            in.close();
        } catch (FileNotFoundException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }

        
        
        for (int i = 0; i < masterData.length; i++) {
            for (int j = 0; j < masterData[0].length; j++) {
                System.out.print(masterData[i][j]+" ,");
            }System.out.println();
        }

// zufügen von Daten

        // uebertrag in temporaeres array

        String[][] intermediateData = new String[lineCtr + 1][noOfValues];

        for (int i = 0; i < masterData.length; i++) {
            for (int j = 0; j < masterData[0].length; j++) {
                intermediateData[i][j] = masterData[i][j];
            }
        }

        
        // zufügen von neuen Werten

            System.out.println("ersten wert eingeben");
            intermediateData[lineCtr][0] = String.valueOf(lineCtr);
            System.out.println("zweiten wert eingeben");
            intermediateData[lineCtr][1] = String.valueOf(lineCtr+1);
            System.out.println("dritten wert eingeben");
            intermediateData[lineCtr][2] = String.valueOf(lineCtr+2);

        System.out.println("Ausgabe der in intermediateData vorhandenen Daten: ");
        for (int i = 0; i < intermediateData.length; i++) {
            for (int j = 0; j < intermediateData[0].length; j++) {
                System.out.print(intermediateData[i][j]+" ,");
            }System.out.println();
        }

        // masterData loeschen
        masterData = null;
        // neu erstellen
        lineCtr++;

        masterData = new String[lineCtr][noOfValues];

        // zurückspeichern

        for (int i = 0; i < intermediateData.length; i++) {
            for (int j = 0; j < intermediateData[0].length; j++) {
                masterData[i][j] = intermediateData[i][j];
            }
        }

        System.out.println("Ausgabe der in masterdata zurückgespeicherten Daten: ");
        for (int i = 0; i < masterData.length; i++) {
            for (int j = 0; j < masterData[0].length; j++) {
                System.out.print(masterData[i][j]+" ,");
            }System.out.println();
        }
        
        
        PrintWriter bw;
        try {
            bw = new PrintWriter(new FileWriter("Pfad zur array.txt-Datei"));
        
        for (int i = 0; i < masterData.length; i++) {
            for (int j = 0; j < masterData[0].length; j++) {

                bw.print(masterData[i][j] + ",");

            }bw.println();
            }
            

            
            
            bw.close();
        } catch (IOException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
            
            try {
                PrintWriter bx = new PrintWriter(new FileWriter("D:\\Development\\Arrays\\data\\counter.txt"));
                bx.print(String.valueOf(lineCtr));
                bx.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }


Auf diese Art und weise schaffe ich es jetzt das die Werte im Array ordnungsgemäß angelegt werden, allerdings nur in den ersten Iterationen, danach beginnt das array sich mit nullen zu füllen. Aber die anzahl an angelegten Datensätzen scheint nun zumindest zu stimmen.

was ich gerne schaffen würde wäre beliebig viele aus drei Einträgen bestehende Datensätze speichern zu können.
 
kneitzel

kneitzel

Top Contributor
Erst einmal ist vielleicht wichtig: Das sollen nur Hinweise sein - es ist normal, dass es am Anfang nicht alles super ist und es da so Kritik gibt.

Fangen wir es einmal etwas anders an:
a) Ich kann mit der Beschreibung der Problematik nicht viel anfangen. "beginnt das Array sich mit nullen zu füllen" besagt erst einmal nicht viel. Evtl. etwas mehr Beschreibung, was schief läuft und was die genaue Eingabe und die Ausgabe des Programmes ist.
Was mir auffällt: Du schreibst immer nur in den ersten Datensatz, d.h. die Variable linecount ist beim Lesen immer 0. nach dem System.out.println müsstest Du linecount erhöhen.

b) Das erwähnte try with resources ist ein Konstrukt, das dir das Schließen von Dateien und so abnimmt.

Aus dem folgenden Code:
Java:
        try {
            BufferedReader br = new BufferedReader(new FileReader("Pfad zur counter.txt-Datei "));

            lineCtr = Integer.parseInt(br.readLine());

            br.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
könnte man folgendes machen:
Java:
        try (BufferedReader br = new BufferedReader(new FileReader("Pfad zur counter.txt-Datei "))) {
            lineCtr = Integer.parseInt(br.readLine());
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
Das einfach nur einmal in Kürze, weil ich Dir das ja als eine Verbesserung vorgeschlagen hatte. Das sollte ebenso mit dem Scanner funktionieren und auch beim schreiben von Dateien.

c) Du musst die Daten nur einmal kopieren. Du erstellst ein neues Array und füllst dieses. Am ende kopierst Du die Daten zurück mit dem Code:
Java:
        masterData = new String[lineCtr][noOfValues];

        // zurückspeichern

        for (int i = 0; i < intermediateData.length; i++) {
            for (int j = 0; j < intermediateData[0].length; j++) {
                masterData[i][j] = intermediateData[i][j];
            }
        }

Da würde ein einfaches
Java:
masterData = intermediateData;
ausreichen.
 
J

JiXXaW

Mitglied
Kein Problem, Hinweise sind super.

Dann werde ich versuchen mal etwas mehr Licht in die Fehlerbeschreibung zu bringen. Aktuell ist es so ,dass das Programm drei Zahlen einließt und am Ende des Arrays Speichert. Die erste Zahl ist immer die Zahl des Durchlaufs(also beim ersten durchlauf 1) und für die beiden anderen wird hochgezählt.

für die folgenden Schleifendurchläufe bekomme ich nun die folgenden Ausgaben:

0:

0,1,2,

1:

0,1,2,
1,2,3,

bis hier hin ist alles so wie ich mir das vorgestellt habe. Die neuen Zahlen werden eingelesen und an der letzten Stelle im Array zugefügt.Was jetzt aber als nächstes kommt ist:

2:

1,2,3,
1,2,3,
2,3,4,

3:

2,3,4,
2,3,4,
2,3,4,
3,4,5,

und 4:

3,4,5,
3,4,5,
3,4,5,
3,4,5,
4,5,6,

kann es sein das da irgendwas mit dem laden immer noch nicht stimmt? auch weil das Problem erst in der dritten Iteration auftritt?

den Linecount habe ich nun angepasst und dieser sieht jetzt folgendermaßen aus:

neuer lineCount:
String[][] masterData = new String[lineCtr][noOfValues];

        try {
            Scanner in = new Scanner(new FileReader("D:\\Development\\Arrays\\data\\masterData.txt"));
            
            while (in.hasNextLine()) {
                String[] currentLine = in.nextLine().trim().split(",");
                for (int lineCount = 0;lineCount<lineCtr;lineCount++)
                {
                for (int i = 0;i<3;i++)
                {
                masterData[lineCount][i] = currentLine[i];
                
                System.out.print(masterData[lineCount][i] + ",");
                }System.out.println();
                }
            }
            in.close();
        } catch (FileNotFoundException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }

zu b) das werde ich so einbauen, danke.

zu c) da hätte ich ja auch selbst nochmal drauf kommen können :D.
 
J

JiXXaW

Mitglied
Okay, meinen Fehlern habe ich eben auch gefunden. und zwar muss das currentLine-Array in die darunterliegende For-Schleife. Habe das ganze abgeändert und jetzt Funktioniert es wunderbar, auch wenn ich noch nicht ganz verstehe wieso. Da ich bis jetzt noch nirgends fündig geworden bis was das laden, verlängern und abspeichern eines zwei dimensionalen Arrays angeht hier noch einmal der funktionierende Code:
funktionierende Version:
package arrayFundamentalsPkg;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;

public class main {

    public static void main(String[] args)

    {
        
        int lineCtr = 1;
        int noOfValues = 3;
        
        

        try (BufferedReader br = new BufferedReader(new FileReader("Pfad zur größe des Datensatzes"))){
            lineCtr = Integer.parseInt(br.readLine());
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        
        System.out.println("erzeuge ein Array mit: ");

        String[][] masterData = new String[lineCtr][noOfValues];

        try (Scanner in = new Scanner(new FileReader("Pfad zum array"))){
            
            while (in.hasNextLine()) {
                
                for (int lineCount = 0;lineCount<lineCtr;lineCount++)
                {
                String[] currentLine = in.nextLine().trim().split(",");
                for (int i = 0;i<3;i++)
                {
                masterData[lineCount][i] = currentLine[i];
                
                System.out.print(masterData[lineCount][i] + ",");
                }System.out.println();
                }
            }
            
        } catch (FileNotFoundException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }

        
        
        for (int i = 0; i < masterData.length; i++) {
            for (int j = 0; j < masterData[0].length; j++) {
                System.out.print(masterData[i][j]+" ,");
            }System.out.println();
        }

// zufügen von Daten

        // uebertrag in temporaeres array

        String[][] intermediateData = new String[lineCtr + 1][noOfValues];

        for (int i = 0; i < masterData.length; i++) {
            for (int j = 0; j < masterData[0].length; j++) {
                intermediateData[i][j] = masterData[i][j];
            }
        }

        
        // zufügen von neuen Werten

            System.out.println("ersten wert eingeben");
            intermediateData[lineCtr][0] = String.valueOf(lineCtr);
            System.out.println("zweiten wert eingeben");
            intermediateData[lineCtr][1] = String.valueOf(lineCtr+1);
            System.out.println("dritten wert eingeben");
            intermediateData[lineCtr][2] = String.valueOf(lineCtr+2);

        System.out.println("Ausgabe der in intermediateData vorhandenen Daten: ");
        for (int i = 0; i < intermediateData.length; i++) {
            for (int j = 0; j < intermediateData[0].length; j++) {
                System.out.print(intermediateData[i][j]+" ,");
            }System.out.println();
        }

        // masterData loeschen
        masterData = null;
        // neu erstellen
        lineCtr++;

        masterData = new String[lineCtr][noOfValues];

        // zurückspeichern

        masterData = intermediateData;
        
        
    
        try (PrintWriter bw = new PrintWriter(new FileWriter("Pfad zum array"))){
        
        for (int i = 0; i < masterData.length; i++) {
            for (int j = 0; j < masterData[0].length; j++) {

                bw.print(masterData[i][j] + ",");

            }bw.println();
            }
            
            
            
            
        
        } catch (IOException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
            
            try (PrintWriter bx = new PrintWriter(new FileWriter("Pfad zum zähler"))){
                bx.print(String.valueOf(lineCtr));
                bx.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

Vielen Dank für deine Hilfe und einen schönen Abend
 

Ähnliche Java Themen

Anzeige

Neue Themen


Oben