Merging rows with same ID together with dynamic headers with CSV

[Jas Get]

Please Help, I just can't figure it out. A friend helped with this but could not figure it our either.

I am trying to merge CSV rows together that have the same ID number, but have different values in the fields. I receive csv files weekly that can have different header names and sizes.

For example,

Read in this CSV file:

ID NAME PHONE EMAIL
22 John 555-1111
22 John 555-2222 [e-mail]
44 Bill 555-9999 [e-mail]

Should return:

ID NAME PHONE EMAIL PHONE0
22 John 555-1111 [e-mail] 555-2222
44 Bill 555-9999 [e-mail]

But it returns:

ID NAME PHONE EMAIL PHONE0 EMAIL0
22 John 555-1111 [e-mail] 555-2222 [e-mail]
44 Bill 555-9999

It does work correctly when I have this file:
ID NAME PHONE EMAIL
22 John 555-1111 [e-mail]
22 John 555-2222 [e-mail]
44 Bill 555-9999 [e-mail]




Here is my Code:

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Vector;

public class MergeRecords {
  
    private static NDVector noDups = null;
    static Vector dupHolder = null;
    private static Vector header = null;
    
    private static LinkedHashMap headerMap  = new LinkedHashMap();
    private static LinkedHashMap dupMap     = new LinkedHashMap();
    
    private static Vector  dataVect   = new Vector();
    
    private static boolean inDupMode_f = false;
    private static String  keyHeader = "";
    
    //Main 
    public static void main(String args[]) {
        String source = "C:\\tmp\\testData1.csv";
   // String source = "C:\\tmp\\testData1.csv";
      try {
         readData(source);
        } catch(Exception e){
         e.printStackTrace();
        }
        
        String dest = "C:\\tmp\\testingResults.csv";
        writeToFile(dest);
    }

    //readData Source
    private static void readData(String path) throws Exception {
     
     MergeRecords.dupHolder = new Vector();
     MergeRecords.header = new Vector();
     
     MergeRecords.noDups = new NDVector();
      
     File file = new File(path);
        BufferedReader br = new BufferedReader(
                            new InputStreamReader(
                            new FileInputStream(file)));
        String line;    
        int x = -1;
        
        String [] s = null;
        while((line = br.readLine()) != null) {
         x = x+1;
         
         s = line.split(",");
         if (x == 0) {
          for (int zx = 0; zx < s.length; zx++) {
           String header = s[zx];
                      
           Vector v = new Vector();
           
           if (zx == 0) {
              MergeRecords.headerMap.put(header, new NDVector());
           }
           else {
            MergeRecords.headerMap.put(header, new Vector());
           }
           MergeRecords.dupMap.put(header, new Vector());
          }
         }
         else {
          Collection c = MergeRecords.headerMap.keySet();
          Iterator i = c.iterator();
          for (int ix = 0; ix < s.length; ix++) {
           MergeRecords.inDupMode_f = false;
           
           int j = 0;
           while (i.hasNext()) {
               String header = (String) i.next();
               
               if (j == 0) {
                MergeRecords.keyHeader = header;
               }
               
              Vector tmpV = (Vector)MergeRecords.headerMap.get(header);
               if (j < s.length) {
                if (!MergeRecords.inDupMode_f) {
                 if (!tmpV.add(s[j])) {
                  MergeRecords.inDupMode_f = true;
                 }
                }
                else {
                 Vector dupV = (Vector)MergeRecords.dupMap.get(header);
                 dupV.add(s[j]);
                 
                }
               }
               j = j +1;
           }
          }
         }
        }
           
        Vector dupV = (Vector)MergeRecords.dupMap.get(keyHeader);
        dupV.addAll(MergeRecords.dupHolder);
       
        MergeRecords.mergeData();
    }

    //mergeData 
    private static void mergeData() {
     Vector dupV = (Vector)MergeRecords.dupMap.get(keyHeader);
     
      for (int x = 0; x < dupV.size(); x++) {
       Vector testV = (Vector)MergeRecords.headerMap.get(keyHeader);
       int index = testV.indexOf(dupV.get(x));
       int size = testV.size();
      
      Collection c = MergeRecords.dupMap.keySet();
         Iterator i = c.iterator();
         if (i.hasNext()) i.next();
         
         while (i.hasNext()) {
          String head = (String) i.next();
          Vector dupData = (Vector) MergeRecords.dupMap.get(head);
          Vector realData= (Vector) MergeRecords.headerMap.get(head);
      
          for (int y  =0; y < dupData.size(); y++) {

           if (!realData.contains((String)dupData.get(y))) {
            String newHeader = head+y;
            String data = (String)dupData.get(y);
            Vector newVector = new Vector();

            for (int ix = 0; ix <= size; ix++) {
             newVector.add(",");
            }
            newVector.setElementAt(data, index);
            
            MergeRecords.headerMap.put(newHeader, newVector);
           }
          }
         }  
     }
    }
    
    
    //writeToFile
    private static void writeToFile(String path) {
        try {
            File file = new File(path);
            BufferedWriter bw = new BufferedWriter(
                                new OutputStreamWriter(
                                new FileOutputStream(file)));
            Collection c = MergeRecords.headerMap.keySet();
            Iterator i = c.iterator();
          
            Object[] theHeads = c.toArray();
            
            for (int x = 0; x < theHeads.length; x++) {
             String header = (String)theHeads[x]+",";
             
             bw.write(header,0, header.length());
            }
            bw.newLine();
          
           int maxNum = ((Vector)MergeRecords.headerMap.get(keyHeader)).size();
          
            for (int j = 0; j <= maxNum; j++) {
             i = c.iterator();
             
             while (i.hasNext()) {
              String header = (String)i.next();
              Vector v = (Vector)MergeRecords.headerMap.get(header);
              
              String s = null;
                            
              if (v.size() > j) 
               s = (String)v.get(j)+",";
               else 
                s = ",";
              
              bw.write(s, 0, s.length());
             }
             bw.newLine();
            }
            bw.close();
        } catch(IOException e) {
            System.out.println("write error: " + e.getMessage());
        }
    }
}


//New Vector class test/hold dups 
class NDVector extends Vector {
 public NDVector() {
  super();
 }
 public boolean add(Object o) {
  if (!super.contains(o))
   return super.add(o);
  else {
   MergeRecords.dupHolder.add(o);
   return false;
  }
 }
}

    

[Jas Get]

This is just some simple test data. Sometimes there are 20 headers with 80,000 records so I was wondering if this is the most efficient way to process the records.

Thank you