鉴于此输入
- 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
我需要特别是从文件中的第3列,并找到哪个是G1组的最后一个D1,同样也是特定G2的D2.找到最后一个值后,我需要在相应的行中添加一些内容,如“LL”:
我已经尝试过,但是这条线并没有平行地附加到每个D1上,而不仅仅是最后一个D1.
这是我的代码:
- 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,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","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();
- }
- }
- }
- }
我尝试使用列表,但“LL”被附加到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);
- }
解决方法
以下是为每个G#找到最后一个D#的方法,并在最后添加一个LL.如果我们知道有关格式行为的更多信息,那么它可以变得更简单.我把它作为一个字符串替换读取文件并拆分行,这样你读完所有行后就会得到行.
- 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]);
- }
- }
输出:
- 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
我的假设是第二列只有G#或D#,而第0列则是G1.
编辑:如果我添加到我的上述假设,在每个G#下有Ds只有相同的#,那么这更短:
- 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:带文件读写
- 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,"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();
- }
- }
- }
正确处理异常.
下面是它的工作原理:
lastLine保持前一行读取而行搜索新G.如果找到一个,则lastLine必须包含前一个G的最后一个D.这是第一次迭代:
- 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's the last D for G1.
- ---
- lastLine: G2 4
- line: D2 5
- ...