Creating Log files.

Question

Hello friends,
I am developing a program which works with 4 different text files.
3 of them for reading and 1 for writing and reading.
Here's a skeleton:
open file1 for reading.
for each element in file1 do
      record the element in the log file
      open file2 for reading
      open file3 for writing
      for every element in file2 do
            process all elements in file2 for one element of file1
            generating an element for file3
            write out the processed elements to file3.
       end for // here we have file3 ready for the next step
end for
open file3 for reading
open file4 for reading
for each element in file3 do
      process result1 and store it in log file
      process result2 and store it in log file
      for each element in file4 do
             process result3 and store it in log file
      end for
end forCan anyone suggest me how to use the Logger to log all the results?
Also, How should I open the files to read and write?
I am new to working with files in java and reading about the different I/O streams is driving me nuts at the moment.
Thank you in advance.

Answer 1

Thanks Keith for the useful links.
I had to do a bit of reading regarding working with files in java
here is what I have gotten to so far:
try {
                     // OPEN PERMUTATION FILE FOR READING
                     FileInputStream pstream = new FileInputStream("permutations.txt");  // THIS FILE IS GENERATED IN PREVIOUS STEP
                     DataInputStream pin = new DataInputStream(pstream);
                     BufferedReader pbr = new BufferedReader(new InputStreamReader(pin));
               //FileReader permfr = new FileReader("permutations.txt");
               //BufferedReader permbr = new BufferedReader(permfr);           // WILL THIS WORK INSTEAD OF ABOVE 3 LINES?
               //StreamTokenizer permst = new StreamTokenizer(permbr);
               // OPEN INPUT FILE FOR READING
               FileInputStream istream = new FileInputStream("sample.txt");  // THIS IS THE INPUT FILE OF WORDS
               DataInputStream in = new DataInputStream(istream);
               BufferedReader ibr = new BufferedReader(new InputStreamReader(in));
               //FileReader ifr = new FileReader("sample.txt");
               //BufferedReader ibr = new BufferedReader(ifr);           // WILL THIS WORK INSTEAD OF ABOVE 3 LINES?
               //StreamTokenizer ist = new StreamTokenizer(ibr);
               // CREATE A TEMP FILE FOR OUTPUT
                        // Creating a temp file because I will be using it for one permutation only
                        // instead of writing to a file and clearing it again for the next permutation.
               File tempoutput = File.createTempFile("output",".txt");
               String permstr;    // PERMUTATION string
               String ipstr;      // INPUT string
               String opstr;      // OUTPUT string
               // create input char array, perm array and output char array
               char[] permArray;
               char[] opArray = null;
               char[] ipArray;
               while ((permstr = pbr.readLine()) != null)   { // for all strings in permutation file do
                    // read one permutation string
                    StringTokenizer permst = new StringTokenizer(permstr);
                    while(permst.hasMoreTokens()){  // TILL the end of permutation file
                         // convert the permutation string to char array and store it
                         String perm = permst.nextToken();
                         permArray = perm.toCharArray();
                         // open the output file for writing
                         BufferedWriter out = new BufferedWriter(new FileWriter(tempoutput, true));
                         // open the input file (original dictionary) for reading
                         while ((ipstr = ibr.readLine()) != null) {   // for all the words in the input file (dictionary)
                              // read one input string
                              StringTokenizer ipst = new StringTokenizer(ipstr);
                              while (ipst.hasMoreTokens()){
                                   // convert it into a char array and store it in 'input' char array
                                   String ip = ipst.nextToken();
                                   ipArray = ip.toCharArray();
                                   // for each element in the permute array
                                   for(int i=0; i<=perm.length()-1; i++) {
                                        // read the permute array elements, index i
                                        // store it in input index j
                                        int j = permArray;
                                        // generate output as you go as output[i] = input[j]
                                        opArray[i] = ipArray[j];
                                   // convert output char array to string
                                   opstr = String.valueOf(opArray);
                              // write the permuted output string to the output file
                                   out.write("\n"+opstr);
                                   out.flush();
                                   out.close();
                         // OPEN OUTPUT FILE FOR READING
// RUN SOME PROGRAMS AND GENERATE SOME NUMBERS
                         newop.close();
                         STORE THE RESULTS (PREFERABLY IN A LOG FILE)
I AM STILL WORKING ON HOW TO DO THIS
                         tempoutput.delete(); // delete the temp input file
               } // end reading permutation file
               // CLOSE ALL STREAMS Below
               pstream.close();
               pin.close();
               pbr.close();
               istream.close();
               in.close();
               ibr.close();
          catch (IOException e){
               System.err.println("Error: " + e.getMessage());
I am currently debugging this piece of code.
Can anyone point out any flaws/design errors here?
Any suggestions to make it better/efficient?
Greatly appreciated as always.