鉴于此输入

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

我需要特别是文件中的第三列,并找到哪个是组G1的最后一个D1,类似地是特定G2的最后一个D2。找到最后一个值后,我需要在相应的行中添加一些内容,例如“LL”:

java - 在JAVA列表中的最后一个值后面附加一个字符-LMLPHP

我已经尝试过了,但是该行不仅与最后一个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, 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();

        }
   }
}

}

我尝试使用列表,但是“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);
                 }

最佳答案

在这里,您可以找到每个D#的最后一个G#,并在末尾附加一个LL。如果我们知道有关格式表现方式的更多信息,则可以将其简化。我通过将文件作为字符串并拆分行来替代读取文件,以便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]);
    }
}

输出:
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#下有D且仅具有相同#的代码,则它会更短:
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, 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();
        }
    }
}

正确处理异常。

下面是它的工作原理:

在搜索lastLine以获得新的line时,G保留前一行的内容。如果找到一个,则lastLine必须包含上一个D的最后一个G。这是第一个迭代:
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
...

10-07 19:47
查看更多