在JAVA的列表中追加最后一个值的字符
鉴于此输入
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, 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();
}
}
}
}
我尝试使用list，但是“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);
}
4 个答案:
答案 0 :(得分：0)
以下是为每个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只有#，那么这就更短了：< / p>
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]);
}
}
编辑2：文件读写
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
...
答案 1 :(得分：0)
如果输入文件按G和D列排序，则可以一次完成：
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();
}
}
如果它没有排序，你首先需要找到D1和D2的最后记录（你需要到达结尾告诉它），然后再次读取输入以写入输出文件（除非你被告知处理时间很重要，并且总是有足够的内存来处理输入）：
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();
}
以下是the full runnable gist测试用例。
答案 2 :(得分：-1)
首先，你需要对文件进行两次传递;一个确定每个GX的每个最后一行的位置，然后在那里添加LL。但是，我认为如果我们知道您的流程是什么以及为什么需要将其放在那里，我们可以提供更多帮助。
答案 3 :(得分：-1)
无需保留行列表 - 如果处理非常大的文件，这可能很重要。您需要的是在读取文件时存储上一行，并将其写为“后面一行”。
你可以从findFilesForFolder中删除customerList（你还没有使用）和recTypeList，只需添加一个字符串。
我已经接受了部分代码并添加了一些我自己的行来表明我的意思：
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();
（上面的代码只是说明了这项技术;您必须在自己的代码中添加一些处理来检查最后一列 - 组 - 并为每个组单独执行上述操作。）
相关问题
最新问题
- 我写了这段代码，但我无法理解我的错误
- 我无法从一个代码实例的列表中删除 None 值，但我可以在另一个实例中。为什么它适用于一个细分市场而不适用于另一个细分市场？
- 是否有可能使 loadstring 不可能等于打印？卢阿
- java中的random.expovariate()
- Appscript 通过会议在 Google 日历中发送电子邮件和创建活动
- 为什么我的 Onclick 箭头功能在 React 中不起作用？
- 在此代码中是否有使用“this”的替代方法？
- 在 SQL Server 和 PostgreSQL 上查询，我如何从第一个表获得第二个表的可视化
- 每千个数字得到
- 更新了城市边界 KML 文件的来源？