Add character for last value in list in JAVA

Question

Given this input

0000027788|001400000000000000000001224627|G1|||G1 0000027789|001400000000000000000001224627|D1|||G1 0000027790|001400000000000000000001224627|D1|||G1 0000027790|001400000000000000000001224627|D1|||G1 0000027791|001400000000000000000001224627|G2|||G2 0000027792|001400000000000000000001224627|D2|||G2 0000027793|001400000000000000000001224627|D2|||G2 0000027794|001400000000000000000001224627|G6|||G6 

I need the 3rd column, especially from the file, and find the last D1 for the group G1 and similarly the last D2 for a specific G2. After finding the last value, I need to add something to the corresponding line, for example, "LL":

I tried this, but the string joins in parallel to each D1, not just the last D1.

This is my code:

 package com.scb.firstreport; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Set; import java.util.StringTokenizer; public class EDWBatchProcessor { //static Logger log = Logger.getLogger(EDWBatchProcessor.class.getName()); public static void main(String[] args) throws JRException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { //log.debug("Hello this is a debug message"); File fileDir = new File("D:\\EDWFileProcessing\\simple.txt"); String line = null; String[] split = null; try { // FileReader reads text files in the default encoding. BufferedReader in = new BufferedReader( new InputStreamReader( new FileInputStream(fileDir), "UTF-8")); BufferedWriter bufferedWriter = null; while((line = in.readLine()) != null) { //System.out.println(line); split = line.split("\\|"); List<String> customerList = new ArrayList<String>(); if(!customerList.contains(split[1])){ customerList.add(split[1]); bufferedWriter = new BufferedWriter(new OutputStreamWriter( new FileOutputStream("D:\\EDWFileProcessing\\output\\"+split[1]+".txt",true), "UTF-8")); bufferedWriter.write(line); bufferedWriter.newLine(); bufferedWriter.close(); } else{ bufferedWriter.write(line); bufferedWriter.close(); } } final File folder = new File("D:\\EDWFileProcessing\\output"); listFilesForFolder(folder); // Always close files. in.close(); } catch(FileNotFoundException ex) { System.out.println( "Unable to open file '"); } catch(IOException ex) { System.out.println( "Error reading file '" ); // Or we could just do this: // ex.printStackTrace(); } } private static void listFilesForFolder(File folder) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, JRException, IOException { for (final File fileEntry : folder.listFiles()) { if (fileEntry.isDirectory()) { //listFilesForFolder(fileEntry); } else { // System.out.println(fileEntry.getName().substring(0, 30)); //System.out.println(fileEntry.getAbsolutePath()); File fileDir = new File(fileEntry.getAbsolutePath()); String line = null; String lineNew = "000000000000000000000000000000000"; String[] split = null; // FileReader reads text files in the default encoding. BufferedReader in = new BufferedReader( new InputStreamReader( new FileInputStream(fileDir), "UTF-8")); BufferedWriter bufferedWriter = null; List<String> customerList = new ArrayList<String>(); List<String> recTypeList = new ArrayList<String>(); while((line = in.readLine()) != null) { // System.out.println(line); split = line.split("\\|"); bufferedWriter = new BufferedWriter(new OutputStreamWriter( new FileOutputStream("D:\\EDWFileProcessing\\output\\simple\\"+split[1]+".txt",true), "UTF-8")); System.out.println("Split2222222222========>>"+split[2]); System.out.println("Split2222222222========>>"+recTypeList.contains(split[2])); if(!recTypeList.contains(split[2])){ recTypeList.add(split[2]); bufferedWriter.newLine(); bufferedWriter.write(line); }else{ bufferedWriter.newLine(); line = line.concat("|LL"); bufferedWriter.write(line); System.out.println("line new....................."); //bufferedWriter.newLine(); //bufferedWriter.write(lineNew); // bufferedWriter.newLine(); } //bufferedWriter.newLine(); bufferedWriter.close(); } in.close(); } } } } 

I tried using a list, but "LL" is added to the end of G2.

  for (ListIterator<String> it = recTypeList.listIterator(); it.hasNext(); i++) { String s1 = it.next(); if(s1.equals("G2")) { int ind=it.previousIndex()-1; String val=recTypeList.get(ind); String lastop=val.concat("LL"); bufferedWriter.write(lastop); System.out.println(lastop); System.out.println(val); } 

Answer 1

Here's how you can find the last D# for each G# and add an LL end at the end. If we knew more about how the format behaves, it could be simplified. I replaced the reading of the file by putting it as a line and dividing the lines so that the lines are what you have after you finish reading all the lines.

 public class Test { public static void main(String[] args) { String input = "0000027788|001400000000000000000001224627|G1| | |G1\r\n" + "0000027789|001400000000000000000001224627|D1| | |G1\r\n" + "0000027790|001400000000000000000001224627|D1| | |G1\r\n" + "0000027790|001400000000000000000001224627|D1| | |G1\r\n" + "0000027791|001400000000000000000001224627|G2| | |G2\r\n" + "0000027792|001400000000000000000001224627|D2| | |G2\r\n" + "0000027793|001400000000000000000001224627|D2| | |G2\r\n" + "0000027794|001400000000000000000001224627|G6| | |G6"; String[] lines = input.split("\r\n"); String[][] parts = new String[lines.length][]; for (int i = 0; i < lines.length; i++) parts[i] = lines[i].split("\\|"); String currG = "G1"; String lastD = ""; for (int i = 1; i < lines.length; i++) { if (parts[i][2].startsWith("G")) { System.out.println("Last D for " + currG + " is " + lastD + " at line " + (i-1)); lines[i-1] += " LL"; currG = parts[i][2]; } else lastD = parts[i][2]; } System.out.println(); for (int i = 0; i < lines.length; i++) System.out.println(lines[i]); } } 

Output:

 Last D for G1 is D1 at line 3 Last D for G2 is D2 at line 6 0000027788|001400000000000000000001224627|G1| | |G1 0000027789|001400000000000000000001224627|D1| | |G1 0000027790|001400000000000000000001224627|D1| | |G1 0000027790|001400000000000000000001224627|D1| | |G1 LL 0000027791|001400000000000000000001224627|G2| | |G2 0000027792|001400000000000000000001224627|D2| | |G2 0000027793|001400000000000000000001224627|D2| | |G2 LL 0000027794|001400000000000000000001224627|G6| | |G6 

My assumptions are that the second column has only G# or D# , and row 0 has G1 .

Edit: If I add to my above assumptions that under each G# there is D with only the same # , then this is shorter:

 public class Test { public static void main(String[] args) { String input = "0000027788|001400000000000000000001224627|G1| | |G1\r\n" + "0000027789|001400000000000000000001224627|D1| | |G1\r\n" + "0000027790|001400000000000000000001224627|D1| | |G1\r\n" + "0000027790|001400000000000000000001224627|D1| | |G1\r\n" + "0000027791|001400000000000000000001224627|G2| | |G2\r\n" + "0000027792|001400000000000000000001224627|D2| | |G2\r\n" + "0000027793|001400000000000000000001224627|D2| | |G2\r\n" + "0000027794|001400000000000000000001224627|G6| | |G6"; String[] lines = input.split("\r\n"); String[][] parts = new String[lines.length][]; for (int i = 0; i < lines.length; i++) parts[i] = lines[i].split("\\|"); String currG = "G1"; for (int i = 1; i < lines.length; i++) { if (parts[i][2].startsWith("G")) { System.out.println("Last D" + parts[i-1][2].substring(1) + " for " + currG + " is at line " + (i-1)); lines[i-1] += " LL"; currG = parts[i][2]; } } System.out.println(); for (int i = 0; i < lines.length; i++) System.out.println(lines[i]); } } 

Edit2: with read and write file

 public class Test { public static void main(String[] args) { String input = "path\\to\\input\\text.txt"; String output = "path\\to\\output\\text.txt"; BufferedReader in; BufferedWriter out; try { in = new BufferedReader(new InputStreamReader(new FileInputStream(input), "UTF-8")); out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(output, true), "UTF-8")); String line, lastLine; lastLine = in.readLine(); while ((line = in.readLine()) != null) { String[] parts = line.split("\\|"); if (parts[2].startsWith("G")) { lastLine += " LL"; } out.write(lastLine); out.write(System.lineSeparator()); lastLine = line; } out.write(lastLine); in.close(); out.close(); } catch (IOException e) { e.printStackTrace(); } } } 

Handle exceptions correctly.

Here's how it works:

lastLine saves the previous line while line searches for a new G If it is found, then lastLine must contain the last D previous G Here are the first iterations:

 lastLine: G1 0 line: D1 1 --- lastLine: D1 1 line: D1 2 --- lastLine: D1 2 line: D1 3 --- lastLine: D1 3 line: G2 4 // line starts with G, so append LL to lastLine because it the last D for G1. --- lastLine: G2 4 line: D2 5 ... 

Answer 2

If your input file is sorted by columns G and D, you can do this in one go:

 public void processSorted() throws Exception { reset(); previousG = null; while (next()) { finishLastLine(); out.print(line); previousDep = values[2]; previousG = group(); } finishLastLine(); } private void finishLastLine() { if (previousG != null && previousDep != null) { if (!group().equals(previousG) || !dep().equals(previousDep)) { if (previousG.equals("G1") && previousDep.equals("D1")) { out.print("|LL"); } else if (previousG.equals("G2") && previousDep.equals("D2")) { out.print("|LL"); } } out.println(); } } 

If it is not sorted, you first need to find the last entries for D1 and D2 (you need to get to the end to talk about it), and then read the input again to write the output file (if you were not told that the processing time is important and always there will be enough memory to process the input):

 public void scanUnsorted() throws Exception { reset(); while (next()) { switch (group()) { case "G1": if (dep().equals("D1")) lastD1 = index; break; case "G2": if (dep().equals("D2")) lastD2 = index; break; } } } public void write() throws Exception { reset(); while (next()) { out.print(line); if (lastD1 >= 0 && index == lastD1 || lastD2 >= 0 && index == lastD2 ) { out.print("|LL"); } out.println(); } out.flush(); } 

Here is the full runnable gist with test cases.

Answer 3

First of all, you need to make two passes over the file; one to determine where each last row for each GX is, and then add LL there. However, I think if we knew what your process was and why you needed to do this, we could help more.

Answer 4

There is no need to store a list of lines - this can be significant if you are processing very large files. You need to save the previous line when reading the file and write it "one line".

You can remove clientList (which you are not using anyway) and recTypeList from findFilesForFolder and just add one line.

I took part of your code and added some of my lines to show what I mean:

  String previousLine = null; String[] previousSplit = null; while((line = in.readLine()) != null) { split = line.split("\\|"); // ... if (previousLine != null) { bufferedWriter.write(previousLine); if (!previousSplit[2].equals(split[2])) { bufferedWriter.write("LL"); } bufferedWriter.newLine(); // ... } previousLine = line; previousSplit = split; } bufferedWriter.write(previousLine); bufferedWriter.write("LL"); bufferedWriter.newLine(); 

(The above code just illustrates the technique, you will need to add some extra processing to your own code to check the last column - the group - and do it yourself for each group.)