将文件剪切为多个文件（Java）

我需要你的帮助。 我使用Talend ESB，我想制作Javabean

例如，我有一个平面文件：

11886 1855 0000004309000
11886 1855 0000057370000
11886 1856 0000057374001    
11886 1856 0000057375000     

在我的示例中，我需要两个文件（消息），一个过滤器“1855”和“1856”（是订单数量）

第一个文件：

11886 1855 0000004309000
11886 1855 0000057370000

第二个文件：

11886 1856 0000057374001     
11886 1856 0000057375000

编辑： 但我不知道每个文件的订单数量

如果我的原始文件中有三个订单（每个订单三行）=>我想要三个文件，每个订单有三行

如果我的原始文件中有四个订单==>我想要四个文件

如果我的原始文件中有五个订单==>我想要五个文件

等等

---

这是我的开始代码。 我想分割成多个文件。 我真的很想知道怎么做

package beans;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import org.apache.camel.*;


public class bean_test implements Processor{

    private static final String ENDPOINT_NAME = "Endpoint";
    private static final String END_TAG_ENDPOINT_NAME = "endEndpoint";
    private static final int NUMERO_SITE_START_POSITION = 6;
    private static final int NUMERO_SITE_END_POSITION = 11;


    @Override
    public void process(Exchange exchange) throws Exception {

        ProducerTemplate producerTemplate = exchange.getContext().createProducerTemplate();
        String ropEndpoint = exchange.getIn().getHeader(ENDPOINT_NAME, String.class);
        String endRopEndpoint = exchange.getIn().getHeader(END_TAG_ENDPOINT_NAME, String.class);
        InputStream is = new ByteArrayInputStream(exchange.getIn().getBody(String.class).getBytes());
        aggregateBody(producerTemplate, is, ropEndpoint, endRopEndpoint, new HashMap<String, Object>(exchange.getIn().getHeaders()));

    }

    private void aggregateBody(ProducerTemplate producerTemplate, InputStream content, String ropEndPoint, String endRopEndpoint, Map<String, Object> headers){
        BufferedReader br = new BufferedReader(new InputStreamReader(content));
        String line;
        Map<String, StringBuilder> articles = new LinkedHashMap<String, StringBuilder>();
        StringBuilder aggregateFile = new StringBuilder();
        try {
            String lineId = null;
            while((line = br.readLine()) != null){
            lineId = line.substring(NUMERO_SITE_START_POSITION, NUMERO_SITE_END_POSITION);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally{
            try {
                if(br != null)br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

packagebean；
导入java.io.BufferedReader；
导入java.io.ByteArrayInputStream；
导入java.io.IOException；
导入java.io.InputStream；
导入java.io.InputStreamReader；
导入java.util.HashMap；
导入java.util.LinkedHashMap；
导入java.util.Map；
导入org.apache.camel.*；
公共类bean\u测试实现处理器{
私有静态最终字符串ENDPOINT_NAME=“ENDPOINT”；
私有静态最终字符串END\u TAG\u ENDPOINT\u NAME=“endEndpoint”；
专用静态最终整数站点起始位置=6；
专用静态最终整数位置=11；
@凌驾
公共作废进程（Exchange）引发异常{
ProducerTemplate ProducerTemplate=exchange.getContext（）.createProducerTemplate（）；
String ropEndpoint=exchange.getIn（）.getHeader（端点名称，String.class）；
String endRopEndpoint=exchange.getIn（）.getHeader（END\u TAG\u ENDPOINT\u NAME，String.class）；
InputStream is=newbytearrayinputstream（exchange.getIn（）.getBody（String.class.getBytes（））；
aggregateBody（producerTemplate、is、ropEndpoint、endRopEndpoint、新HashMap（exchange.getIn（）.getHeaders（））；
}
专用void聚合体（ProducerTemplate ProducerTemplate、InputStream内容、字符串ropEndPoint、字符串endRopEndpoint、地图标题）{
BufferedReader br=新的BufferedReader（新的InputStreamReader（内容））；
弦线；
Map articles=newlinkedhashmap（）；
StringBuilder aggregateFile=新建StringBuilder（）；
试一试{
字符串lineId=null；
而（（line=br.readLine（））！=null）{
lineId=行。子字符串（数字站点开始位置、数字站点结束位置）；
}
}捕获（IOE异常）{
e、 printStackTrace（）；
}
最后{
试一试{
如果（br！=null）br.close（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
}
}

先谢谢你

路易莎

编辑：我的新代码，但我不知道如何返回文件

package beans;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

import org.apache.camel.*;


public class bean_test implements Processor{

    private static final String ENDPOINT = "aggregateEndpoint";
    private static final int NUMERO_SITE_START_POSITION = 46;
    private static final int NUMERO_SITE_END_POSITION = 55;


    @Override
    public void process(Exchange exchange) throws Exception {

        ProducerTemplate producerTemplate = exchange.getContext().createProducerTemplate();
        String endpoint = exchange.getIn().getHeader(ENDPOINT, String.class);
        InputStream is = new ByteArrayInputStream(exchange.getIn().getBody(String.class).getBytes());
        aggregateBody(producerTemplate, is, endpoint, new HashMap<String, Object>(exchange.getIn().getHeaders()));

    }

    private void aggregateBody(ProducerTemplate producerTemplate, InputStream content, String endpoint, Map<String, Object> headers){
        BufferedReader br = new BufferedReader(new InputStreamReader(content));
        String line;
        Set<String> order=new TreeSet<String>();

        try {
            String lineId = null;   
            while((line = br.readLine()) != null){
                lineId = line.substring(NUMERO_SITE_START_POSITION, NUMERO_SITE_END_POSITION);
                order.add(lineId);
            }

            for(int i=0;i<order.size();i++){
                String key = "file" + i;
                File F = new File(key);
                Iterator it = order.iterator();
                FileWriter fw = new FileWriter(F.getAbsoluteFile());
                BufferedWriter bw = new BufferedWriter(fw);

                while((line = br.readLine()) != null){
                    while(it.hasNext()){
                        lineId = line.substring(NUMERO_SITE_START_POSITION, NUMERO_SITE_END_POSITION);
                        if (lineId.equals(it.next())) {
                            bw.write(line);
                        }
                    }

                }
            }


        } catch (IOException e) {
            e.printStackTrace();
        }
        finally{
            try {
                if(br != null)br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

packagebean；
导入java.io.BufferedReader；
导入java.io.BufferedWriter；
导入java.io.ByteArrayInputStream；
导入java.io.File；
导入java.io.FileWriter；
导入java.io.IOException；
导入java.io.InputStream；
导入java.io.InputStreamReader；
导入java.util.HashMap；
导入java.util.Iterator；
导入java.util.Map；
导入java.util.Set；
导入java.util.TreeSet；
导入org.apache.camel.*；
公共类bean\u测试实现处理器{
私有静态最终字符串ENDPOINT=“aggregateEndpoint”；
专用静态最终整数站点起始位置=46；
专用静态最终整数位置=55；
@凌驾
公共作废进程（Exchange）引发异常{
ProducerTemplate ProducerTemplate=exchange.getContext（）.createProducerTemplate（）；
String endpoint=exchange.getIn（）.getHeader（endpoint，String.class）；
InputStream is=newbytearrayinputstream（exchange.getIn（）.getBody（String.class.getBytes（））；
aggregateBody（producerTemplate、is、endpoint、新HashMap（exchange.getIn（）.getHeaders（））；
}
私有void aggregateBody（ProducerTemplate ProducerTemplate、InputStream内容、字符串端点、映射头）{
BufferedReader br=新的BufferedReader（新的InputStreamReader（内容））；
弦线；
设置顺序=新树集（）；
试一试{
字符串lineId=null；
而（（line=br.readLine（））！=null）{
lineId=行。子字符串（数字站点开始位置、数字站点结束位置）；
order.add（lineId）；
}
对于（int i=0；i许多人似乎认为不应该拆分文件。但如果必须这样做，一个简单的解决方案是读入文件，我在下面称之为
flatfile.txt
，然后检查每行的第二个条目，看看它是
1855
还是
1856
。在每种情况下，然后将输出写入相应的文件

try {
    File f1 = new File("f1855.txt");
    File f2 = new File("f1856.txt");

    if (!f1.exists()) {
        f1.createNewFile();
    }
    FileWriter fw1 = new FileWriter(f1.getAbsoluteFile());
    BufferedWriter bw1 = new BufferedWriter(fw1);

    if (!f2.exists()) {
        f2.createNewFile();
    }
    FileWriter fw2 = new FileWriter(f2.getAbsoluteFile());
    BufferedWriter bw2 = new BufferedWriter(fw2);

    String currLine;
    BufferedReader br = new BufferedReader(new FileReader("flatfile.txt"));

    while ((currLine = br.readLine()) != null) {
        String[] parts = currLine.split(" ");
        if (parts[1].equals("1855")) {
            bw1.write(currLine);
        }
        else if (parts[1].equals("1856")) {
            bw2.write(currLine);
        }
        else {
            System.out.println("Found a line which did not match 1855 or 1856.");
        }
    }
} catch (IOException e) {
    e.printStackTrace();
} finally {
    try {
        if (br != null) br.close();
        if (bw1 != null) bw1.close();
        if (bw2 != null) bw2.close();
    } catch (IOException ex) {
        ex.printStackTrace();
    }
}

这个答案确实是由用户Ranx给出的，不是我自己的；但是，我认为它值得复制，因为它很优雅，并且保持了骆驼的习惯用法

从概念上讲，您希望分割文件中的记录。然后，对于每个记录，您希望使用一些值来选择目标输出文件。

Camel列表上用户Ranx提供的Camel特定解决方案使用了Camel特性：目标文件名可以从消息中的值派生（这是您的规范的一部分）


将字符串拆分为记录，然后将其解压为某种格式，提取所需字段并将其设置为标头，将其封送回字符串，最后使用文件名中的标头值写入文件（追加）

这在代码段中表达：

from("file:/inbox")
 .split(body())
 .unmarshal(dataFormat)
 .setHeader("fileName",simple("${body.identifier}"))
 .marshal(dataFormat)
 .to("file:/outbox/?fileName=${header.fileName}.txt&fileExist=Append") 

或者，您也可以避免编组和解编组，使用一个简单的处理器按原样读取字符串正文，并如上所述设置标头。这将是：
拆分文件的逻辑是什么？你好，Boris，逻辑基于字段1855和1856（我的文件中的位置7到11）。它是