给定这个输入
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();
}
}
}
}
我尝试使用列表，但“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。如果我们知道有关格式行为方式的更多信息，它可能会变得更简单。我通过将文件作为字符串并拆分行来代替读取文件，以便 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 必须包含 previous 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
...
关于java - 在 JAVA 列表中为最后一个值附加一个字符，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/34368012/
总的来说，我对ruby还比较陌生，我正在为我正在创建的对象编写一些rspec测试用例。许多测试用例都非常基础，我只是想确保正确填充和返回值。我想知道是否有办法使用循环结构来执行此操作。不必为我要测试的每个方法都设置一个assertEquals。例如:describeitem,"TestingtheItem"doit"willhaveanullvaluetostart"doitem=Item.new#HereIcoulddotheitem.name.shouldbe_nil#thenIcoulddoitem.category.shouldbe_nilendend但我想要一些方法来使用
我有一个字符串input="maybe(thisis|thatwas)some((nice|ugly)(day|night)|(strange(weather|time)))"Ruby中解析该字符串的最佳方法是什么？我的意思是脚本应该能够像这样构建句子:maybethisissomeuglynightmaybethatwassomenicenightmaybethiswassomestrangetime等等，你明白了......我应该一个字符一个字符地读取字符串并构建一个带有堆栈的状态机来存储括号值以供以后计算，还是有更好的方法？也许为此目的准备了一个开箱即用的库？
我的目标是转换表单输入，例如“100兆字节”或“1GB”，并将其转换为我可以存储在数据库中的文件大小(以千字节为单位)。目前，我有这个:defquota_convert@regex=/([0-9]+)(.*)s/@sizes=%w{kilobytemegabytegigabyte}m=self.quota.match(@regex)if@sizes.include?m[2]eval("self.quota=#{m[1]}.#{m[2]}")endend这有效，但前提是输入是倍数(“gigabytes”，而不是“gigabyte”)并且由于使用了eval看起来疯狂不安全。所以，功能正常，
在我的Rails(2.3，Ruby1.8.7)应用程序中，我需要将字符串截断到一定长度。该字符串是unicode，在控制台中运行测试时，例如'א'.length，我意识到返回了双倍长度。我想要一个与编码无关的长度，以便对unicode字符串或latin1编码字符串进行相同的截断。我已经了解了Ruby的大部分unicode资料，但仍然有些一头雾水。应该如何解决这个问题？ 最佳答案 Rails有一个返回多字节字符的mb_chars方法。试试unicode_string.mb_chars.slice(0,50)
对于具有离线功能的智能手机应用程序，我正在为Xml文件创建单向文本同步。我希望我的服务器将增量/差异(例如GNU差异补丁)发送到目标设备。这是计划:Time=0Server:hasversion_1ofXmlfile(~800kiB)Client:hasversion_1ofXmlfile(~800kiB)Time=1Server:hasversion_1andversion_2ofXmlfile(each~800kiB)computesdeltaoftheseversions(=patch)(~10kiB)sendspatchtoClient(~10kiBtransferred)Cl
大约一年前，我决定确保每个包含非唯一文本的Flash通知都将从模块中的方法中获取文本。我这样做的最初原因是为了避免一遍又一遍地输入相同的字符串。如果我想更改措辞，我可以在一个地方轻松完成，而且一遍又一遍地重复同一件事而出现拼写错误的可能性也会降低。我最终得到的是这样的:moduleMessagesdefformat_error_messages(errors)errors.map{|attribute,message|"Error:#{attribute.to_s.titleize}#{message}."}enddeferror_message_could_not_find(obje
我试图获取一个长度在1到10之间的字符串，并输出将字符串分解为大小为1、2或3的连续子字符串的所有可能方式。例如:输入:123456将整数分割成单个字符，然后继续查找组合。该代码将返回以下所有数组。[1,2,3,4,5,6][12,3,4,5,6][1,23,4,5,6][1,2,34,5,6][1,2,3,45,6][1,2,3,4,56][12,34,5,6][12,3,45,6][12,3,4,56][1,23,45,6][1,2,34,56][1,23,4,56][12,34,56][123,4,5,6][1,234,5,6][1,2,345,6][1,2,3,456][123
我正在使用的第三方API的文档状态:"[O]urAPIonlyacceptspaddedBase64encodedstrings."什么是“填充的Base64编码字符串”以及如何在Ruby中生成它们。下面的代码是我第一次尝试创建转换为Base64的JSON格式数据。xa=Base64.encode64(a.to_json) 最佳答案 他们说的padding其实就是Base64本身的一部分。它是末尾的“=”和“==”。Base64将3个字节的数据包编码为4个编码字符。所以如果你的输入数据有长度n和n%3=1=>"=="末尾用于填充n%
使用带有Rails插件的vim，您可以创建一个迁移文件，然后一次性打开该文件吗？textmate也可以这样吗？ 最佳答案 你可以使用rails.vim然后做类似的事情::Rgeneratemigratonadd_foo_to_bar插件将打开迁移生成的文件，这正是您想要的。我不能代表textmate。 关于ruby-使用VimRails，您可以创建一个新的迁移文件并一次性打开它吗？，我们在StackOverflow上找到一个类似的问题： https://sta
我需要从一个View访问多个模型。以前，我的links_controller仅用于提供以不同方式排序的链接资源。现在我想包括一个部分(我假设)显示按分数排序的顶级用户(@users=User.all.sort_by(&:score))我知道我可以将此代码插入每个链接操作并从View访问它，但这似乎不是“ruby方式”，我将需要在不久的将来访问更多模型。这可能会变得很脏，是否有针对这种情况的任何技术？注意事项:我认为我的应用程序正朝着单一格式和动态页面内容的方向发展，本质上是一个典型的网络应用程序。我知道before_filter但考虑到我希望应用程序进入的方向，这似乎很麻烦。最终从任何