在JAVA中为列表中的最后一个值追加一个字符
鉴于这一输入在JAVA中为列表中的最后一个值追加一个字符,java,filereader,filewriter,Java,Filereader,Filewriter,鉴于这一输入 0000027788|001400000000000000000001224627|G1|||G1 0000027789|001400000000000000000001224627|D1|||G1 0000027790|001400000000000000000001224627|D1|||G1 0000027790|001400000000000000000001224627|D1|||G1 0000027791|001400000000000000000001224627|G
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
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();
}
}
}
}
package com.scb.firstreport；
导入java.io.BufferedReader；
导入java.io.BufferedWriter；
导入java.io.File；
导入java.io.FileInputStream；
导入java.io.FileNotFoundException；
导入java.io.FileOutputStream；
导入java.io.FileReader；
导入java.io.FileWriter；
导入java.io.IOException；
导入java.io.InputStreamReader；
导入java.io.OutputStreamWriter；
导入java.util.ArrayList；
导入java.util.HashSet；
导入java.util.List；
导入java.util.Set；
导入java.util.StringTokenizer；
公共类EDWBatch处理器{
//静态记录器log=Logger.getLogger（EDWBatchProcessor.class.getName（））；
publicstaticvoidmain（String[]args）抛出JRException、NoSuchFieldException、SecurityException、IllegalArgumentException、IllegalAccessException{
//debug（“您好，这是一条调试消息”）；
File fileDir=新文件（“D:\\EDWFileProcessing\\simple.txt”）；
字符串行=null；
String[]split=null；
试一试{
//FileReader以默认编码读取文本文件。
BufferedReader in=新的BufferedReader(
新的InputStreamReader(
新的FileInputStream（fileDir），“UTF-8”）；
BufferedWriter BufferedWriter=null；
而（（line=in.readLine（））！=null）{
//系统输出打印项次（行）；
split=line.split（“\\\\”）；
List customerList=new ArrayList（）；
如果（！customerList.contains（拆分[1]））{
customerList.add（拆分[1]）；
缓冲写入程序=
新建BufferedWriter（新建OutputStreamWriter(
新的FileOutputStream（“D:\\EDWFileProcessing\\output\\”+split[1]+“.txt”，true），“UTF-8”）；
bufferedWriter.write（行）；
bufferedWriter.newLine（）；
bufferedWriter.close（）；
}
否则{
bufferedWriter.write（行）；
bufferedWriter.close（）；
}
}
最终文件文件夹=新文件（“D:\\EDWFileProcessing\\output”）；
listFilesForFolder（文件夹）；
//始终关闭文件。
in.close（）；
}
捕获（FileNotFoundException ex）{
System.out.println(
“无法打开文件“”）；
}
捕获（IOEX异常）{
System.out.println(
“读取文件“”时出错”
);
//或者我们可以这样做：
//例如printStackTrace（）；
}
}
private static void listFilesForFolder（文件文件夹）抛出NoSuchFieldException、SecurityException、IllegalArgumentException、IllegalAccessException、JRException、IOException{
对于（最终文件条目：folder.listFiles（））{
if（fileEntry.isDirectory（））{
//listFilesForFolder（文件条目）；
}否则{
//System.out.println（fileEntry.getName（）.substring（0,30））；
//System.out.println（fileEntry.getAbsolutePath（））；
File fileDir=新文件（fileEntry.getAbsolutePath（））；
字符串行=null；
字符串lineNew=“000000000000000000000000000”；
String[]split=null；
//FileReader以默认编码读取文本文件。
BufferedReader in=新的BufferedReader(
新的InputStreamReader(
新的FileInputStream（fileDir），“UTF-8”）；
BufferedWriter BufferedWriter=null；
List customerList=new ArrayList（）；
List recTypeList=新建ArrayList（）；
而（（line=in.readLine（））！=null）{
//系统输出打印项次（行）；
split=line.split（“\\\\”）；
缓冲写入程序=
新建BufferedWriter（新建OutputStreamWriter(
新的FileOutputStream（“D:\\EDWFileProcessing\\output\\simple\\”+split[1]+“.txt”，true），“UTF-8”）；
System.out.println（“split2222=====>>”+split[2]）；
System.out.println（“split2222=====>>”+recTypeList.contains（split[2]）；
如果（！recTypeList.contains（拆分[2]））{
添加（拆分[2]）；
bufferedWriter.newLine（）；
bufferedWriter.write（行）；
}否则{
bufferedWriter.newLine（）；
line=line.concat（“|LL”）；
bufferedWriter.write（行）；
System.out.println（“行新“……”）；
//bufferedWriter.newLine（）；
//bufferedWriter.write（lineNew）；
//bufferedWriter.newLine（）；
}
//bufferedWriter.newLine（）；
bufferedWriter.close（）；
}
in.close（）；
}
}
}
}
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);
}
for（ListIterator it=recTypeList.ListIterator（）；it.hasNext（）；i++）{
字符串s1=it.next（）；
如果（s1等于（“G2”））
{
int ind=it.previousIndex（）-1；
String val=recTypeList.get（ind）；
字符串lastop=val.concat（“LL”）；
bufferedWriter.write（lastop）；
System.out.println（lastop）；
系统输出打印项次（val）；
}
GDLL
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
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]);
}
}
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: 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
...
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();
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();
}
}
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();
}