如何用Java来进行文件切割和简单的内容过滤的实现
一 由来
去年由于项目的需求，要将一个任意一个文件制作成一个xml文件，并且需要保持文件内容本身不产生变化，还要能够将这个xml重新还原为原文件。如果小型的文件还好处理，大型的xml,比如几个G的文件，基本上就OOM了，很难直接从节点中提取数据。所以我采用了流的方式。于是有了这个文件的裁剪工具。
二 使用场景
本工具可能的使用场景：
1.对任一文件的切割/裁剪。通过字节流的方式，开始节点和终止节点，裁剪出两个节点之间的部分。
2.往任一文件的头/尾拼接指定字符串。可以很容易将一个文件嵌入在某一个节点中。
3.简单的文本抽取。可以根据自己定义的规则，提取出来想要的文本内容，并且允许对提取出来的文本进行再处理（当然，只是进行简单地抽取文字，并不是什么智能的复杂过程的抽取T_T ）。
4.文本过滤。根据自己制定的规则，过滤掉指定的文字。
整个工具仅是对Java文件操作api的简单加工，并且也没有使用nio。在需要高效率的文件处理情景下，本工具的使用有待考量。文章目的是为了给出自己的一种解决方案，若有更好的方案，欢迎大家给出适当的建议。
三 如何使用
别的先不说，来看看如何使用吧！
1.读取文件指定片段
读取第0~1048个字节之间的内容。
public void readasbytes(){
FileExtractor cuter = new FileExtractor();
byte[] bytes = cuter.from("D:\\11.txt").start(0).end(1048).readAsBytes();
}
2.文件切割
将第0~1048个字节之间的部分切割为一个新文件。
public File splitAsFile(){
FileExtractor cuter = new FileExtractor();
return cuter.from("D:\\11.txt").to("D:\\22.txt").start(0).end(1048).extractAsFile();
}
3.将文件拼接到一个xml节点中
将整个文件的内容作为Body节点，写入到一个xml文件中。返回新生成的xml文件对象。
public File appendText(){
FileExtractor cuter = new FileExtractor();
return cuter.from("D:\\11.txt").to("D:\\44.xml").appendAsFile("<Document><Body>", "</Body></Document>");
}
4.读取并处理文件中的指定内容
假如有需求：读取11.txt的前三行文字。其中，第一行和第二行不能出现”帅”字，并且在第三行文字后加上字符串“我好帅！”。
public String extractText(){
FileExtractor cuter = new FileExtractor();
return cuter.from("D:\\11.txt").extractAsString(new EasyProcesser() {
@Override
public String finalStep(String line, int lineNumber, Status status) {
if(lineNumber==3){
status.shouldContinue = false;//表示不再继续读取文件内容
return line+"我好帅!";
}
return line.replaceAll("帅","");
}
});
}
4.简单的文本过滤
将一个文件中所有的“bug”去掉，且返回一个处理后的新文件。
public File killBugs(){
FileExtractor cuter = new FileExtractor();
return cuter.from("D:\\bugs.txt").to("D:\\nobug.txt").extractAsFile(new EasyProcesser() {
@Override
public String finalStep(String line, int lineNumber, Status status) {
return line.replaceAll("bug", "");
}
});
}
四 基本流程
通过接口回调的方式，将文件的读取过程和处理过程分离开来；定义了IteratorFile类来负责遍历一个文件，读取文件的内容；分字节、行两种的方式来进行文件内容的遍历。下面的介绍，也会分为读取和处理两个部分单独介绍。
五 文件的读取
定义回调接口
定义一个接口Process,对外暴露了两个文件内容处理方法，一个支持按字节进行读取，一个方法支持按行读取。
public interface Process{
/**
* @param b 本次读取的数据
* @param length 本次读取的有效长度
* @param currentIndex 当前读取到的位置
* @param available 读取文件的总长度
* @return true 表示继续读取文件，false表示终止读取文件
* @time 2017年1月22日 下午4:56:41
*/
public boolean doWhat(byte[] b,int length,int currentIndex,int available);
/**
*
* @param line 本次读取到的行
* @param currentIndex 行号
* @return true 表示继续读取文件，false表示终止读取文件
* @time 2017年1月22日 下午4:59:03
*/
public boolean doWhat(String line,int currentIndex);
让ItratorFile中本身实现这个接口，但是默认都是返回true,不做任何的处理。如下所示：
public class IteratorFile implements Process
{
......
/**
* 按照字节来读取遍历文件内容，根据自定义需要重写该方法
*/
@Override
public boolean doWhat(byte[] b, int length,int currentIndex,int available) {
return true;
}
/**
* 按照行来读取遍历文件内容，根据自定义需要重写该方法
*/
@Override
public boolean doWhat(String line,int currentIndex) {
return true;
}
......
}
按字节遍历文件内容
实现按照字节的方式来进行文件的遍历（读取）。在这里使用了skip（）方法来控制从第几个节点开始读取内容；然后在使用文件流读取的时候，将每次读取到得数据传递给回调接口的方法；需要注意的是，每次读取到得数据是存在一个字节数组bytes里面的，每次读取的长度也是需要传递给回调接口的。我们很容易看出，一旦dowhat()返回false,文件的读取立即就退出了。
public void iterator2Bytes(){
init();
int length = -1;
FileInputStream fis = null;
try {
file = new File(in);
fis = new FileInputStream(file);
available = fis.available();
fis.skip(getStart());
readedIndex = getStart();
if (!beforeItrator()) return;
while ((length=fis.read(bytes))!=-1) {
readedIndex+=length;
if(!doWhat(bytes, length,readedIndex,available)){
break;
}
}
if(!afterItrator()) return;
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
按行来遍历文件内容
常规的文件读取方式，在while循环中，调用了回调接口的方法，并且传递相关的数据。
public void iterator2Line(){
init();
BufferedReader reader = null;
FileReader read = null;
String line = null;
try {
file = new File(in);
read = new FileReader(file);
reader = new BufferedReader(read);
if (!beforeItrator()) return;
while ( null != (line=reader.readLine())) {
readedIndex++;
if(!doWhat(line,readedIndex)){
break;
}
}
if(!afterItrator()) return ;
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
read.close();
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
然后，还需要提供方法来设置要读取的源文件路径。
public IteratorFile from(String in){
this.in = in;
return this;
}
六 文件内容处理
FileExtractor介绍
定义了FileExtractor类，来封装对文件内容的处理操作；该类会引用到遍历文件所需要的类IteratorFile。
FileExtractor的基本方法
/**
* 往文件头或者文件结尾插入字符串
* @tips 不能对同一个文件输出路径反复执行该方法，否则会出现文本异常，因为用到了RandomAccessFile,如有需要，调用前需手动删除原有的同名文件
* @param startStr 文件开头要插入的字符串
* @param endStr 文件结尾要插入的字符串
* @return 生成的新文件
* @time 2017年1月22日 下午5:05:35
*/
public File appendAsFile(final String startStr,String endStr){}
/**
* 从指定位置截取文件
* @tips 适合所有的文件类型
* @return
* @time 2017年1月22日 下午5:06:36
*/
public File splitAsFile(){}
/**
* 文本文件的特殊处理（情景：文本抽取，文本替换等）
* @tips 只适合文本文件，对于二进制文件，因为换行符的原因导致文件出现可能无法执行等问题。
* @time 2017年1月22日 下午5:09:14
*/
public File extractAsFile(FlowLineProcesser method) {
/**
* 文本文件的特殊处理（情景：文本抽取，文本替换等）
* @tips 只适合文本文件，对于二进制文件，因为换行符的原因导致文件出现可能无法执行等问题。
* @time 2017年1月22日 下午5:09:14
*/
public String extractAsString(FlowLineProcesser method) {}
/**
* 读取指定位置的文件内容为字节数组
* @return
* @time 2017年1月23日 上午11:06:18
*/
public byte[] readAsBytes(){}
其中，返回值为File的方法在处理完成后，都出返回一个经过内容后的新文件。
其他方法
同样，设置源文件位置的方法，以及截取位置的相关方法
/**
* 设置源文件
*/
public FileExtractor from(String in){
this.in = in;
return this;
}
/**
* 设置生成临时文件的位置（返回值为File的方法均需要设置）
*/
public FileExtractor to(String out) {
this.out = out;
return this;
}
/**
* 文本开始截取的位置（包含此位置），字节相关的方法均需要设置
*/
public FileExtractor start(int start){
this.startPos = start;
return this;
}
/**
* 文本截取的终止位置（包含此位置），字节相关方法均需要设置
*/
public FileExtractor end(int end) {
this.endPos = end;
return this;
}
按字节读取文件时的文件内容处理
有几个重点：
1.因为要根据字节的位置来进行文件截取，所以需要根据字节来遍历文件，所以要重写doWhat()字节遍历的的方法。并在外部构造一个OutPutStream来进行新文件的写出工作。
2.每次遍历读取出的文件内容，都存放在一个字节数组b里面，但并不是b中的数据都是有用的，所以需要传递b有效长度length。
3.readedIndex记录了到本次为止（包括本次）为止，已经读取了多少位数据。
4.按照自己来遍历文件时，如何判断读取到了的终止位置？
当（已读的数据总长度）readedIndex>endPos（终止节点）时，说明本次读取的时候超过了应该终止的位置，此时b数组中有一部分数据就是多读的了，这部分数据是不应该被保存的。我们可以通过计算得到读超了多少位，即length-(readedIndex-endPos-1)，那么只要保存这部分数据就可以了。
读取指定片段的文件内容：
//本方法在需要读取的数据多时，不建议使用，因为byte[]是不可变的，多次读取的时候，需要进行多次的byete[] copy过程，效率“感人”。
public byte[] readAsBytes(){
try {
checkIn();
} catch (Exception e) {
e.printStackTrace();
return null;
}
//临时保存字节的容器
final BytesBuffer buffer = new BytesBuffer();
IteratorFile c = new IteratorFile(){
@Override
public boolean doWhat(byte[] b, int length, int currentIndex,
int available) {
if(readedIndex>endPos){
//说明已经读取到了endingPos位置并且读超了
buffer.addBytes(b, 0, length-(readedIndex-endPos-1)-1);
return false;
}else{
buffer.addBytes(b, 0, length-1);
}
return true;
}
};
//按照字节进行遍历
c.from(in).start(startPos).iterator2Bytes();
return buffer.toBytes();
}
当文件很大时，生成一个新的文件的比较靠谱的方法，所以，类似直接返回byte[]，在文件读取之前，设置一个outputSteam,在内容循环读取的过程中，将读取的内容写入到一个新文件中去。
public File splitAsFile(){
......
final OutputStream os = FileUtils.openOut(file);
try {
IteratorFile itFile = new IteratorFile(){
@Override
public boolean doWhat(byte[] b, int length,int readedIndex,int available) {
try {
if(readedIndex>endPos){
//说明已经读取到了endingPos位置,并且读超了readedIndex-getEnd()-1位
os.write(b, 0, length-(readedIndex-endPos-1));
return false;//终止读取
}else{
os.write(b, 0, length);
}
return true;
} catch (IOException e) {
e.printStackTrace();
return false;
}
}
}.from(in).start(startPos);
itFile.iterator2Bytes();
} catch (Exception e) {
e.printStackTrace();
this.tempFile = null;
}finally{
try {
os.flush();
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return getTempFile();
}
按行来读取时的文件内容处理
首先，再次声明，按行来遍历文件的时候，只适合文本文件。除非你对每一行的换行符用\r还是\n没有要求。像exe文件，如果用行来遍历的话，你写出为一个新的文件的时候，任意一个的换行符的不对都可能导致一个exe文件变为”unexe”文件！
过程中，我用到了：
一个辅助类Status，来辅助控制遍历的流程。
一个接口FlowLineProcesser，类似于一个处理文本的流水线。
Status和FlowLineProcesser是相互辅助的，Status也能辅助FlowLineProcesse是流水线的具体过程，Status是控制处理过程中怎么处理d的。
我也想了许多次，到底要不要把这个过程搞的这么复杂。但是还是先留着吧…
先看辅助类Status:
public class Status{
/**
* 是否找到了开头,默认false，若true则后续的遍历不会执行相应的firstStep()方法
*/
public boolean overFirstStep = false;
/**
* 是否找到了结尾，默认false,若true则后续的遍历不会执行相应的finalStep()方法
*/
public boolean overFinalStep = false;
/**
* 是否继续读取源文件，默认true表示继续读取，false则表示，执行本次操作后，遍历终止
*/
public boolean shouldContinue = true;
}
然后是FlowLineProcesser接口：
FlowLineProcesser是一个接口，类似于一个流水线。定义了两步操作，分别对应两个方法fistStep()和finalStep()。其中两个方法的返回值都是String，firstStep接受到得line是真正从文件中读取到的行，它将line经过自己的处理后，返回处理后的line给finalStep。所以，finalStep中得line其实是firstStep处理后的结果。但是最终真正返回给主处理流程的line，正是finalStep处理后的返回值。
public interface FlowLineProcesser{
/**
*
* @param line 读取到的行
* @param lineNumber 行号,从1开始
* @param status 控制器
* @return
* @time 2017年1月22日 下午5:02:02
*/
String firstStep(String line,int lineNumber,Status status);
/**
* @tips
* @param line 读取到的行（是firstStep()处理后的结果）
* @param lineNumber 行号,从1开始
* @param status 控制器
* @return
* @time 2017年1月22日 下午5:02:09
*/
String finalStep(String line,int lineNumber,Status status);
}
现在，可以来看一下如何去实现文本的抽取了：
所有读取的行，都临时存到一个stringbuilder中去。firstStep先进行一次处理，得到返回值后传递给finalStep,再次处理后，将得到的结果保存下来。如果最后的结果是null,则不会保存。
public String extractAsString(FlowLineProcesser method) {
try {
checkIn();
} catch (Exception e) {
e.printStackTrace();
return null;
}
final StringBuilder builder = new StringBuilder();
this.mMethod = method;
new IteratorFile(){
Status status = new Status();
@Override
public boolean doWhat(String line, int currentIndex) {
String lineAfterProcess = "";
if(!status.overFirstStep){
lineAfterProcess = mMethod.firstStep(line, currentIndex,status);
}
if(!status.shouldContinue){
return false;
}
if(!status.overFinalStep){
lineAfterProcess = mMethod.finalStep(lineAfterProcess,currentIndex,status);
}
if(lineAfterProcess!=null){
builder.append(lineAfterProcess);
builder.append(getLineStr());//换行符被写死在这里了
}
if(!status.shouldContinue){
return false;
}
return true;
}
}.from(in).iterator2Line();
return builder.toString();
}
当要抽取的文本太大的时候，可以采用生成新文件的方式。与返回string的流程基本一致。
public File extractAsFile(FlowLineProcesser method) {
try {
checkIn();
checkOut();
} catch (Exception e) {
e.printStackTrace();
return null;
}
this.mMethod = method;
File file = initOutFile();
if(file==null){
return null;
}
FileWriter fileWriter = null;
try {
fileWriter = new FileWriter(file);
} catch (Exception e) {
e.printStackTrace();
return null;
}
final BufferedWriter writer = new BufferedWriter(fileWriter);
IteratorFile itfile = new IteratorFile(){
Status status = new Status();
@Override
public boolean doWhat(String line, int currentIndex) {
String lineAfterProcess = "";
if(!status.overFirstStep){
lineAfterProcess = mMethod.firstStep(line, currentIndex,status);
}
if(!status.shouldContinue){
return false;
}
if(!status.overFinalStep){
lineAfterProcess = mMethod.finalStep(lineAfterProcess,currentIndex,status);
}
if(lineAfterProcess!=null){
try {
writer.write(lineAfterProcess);
writer.newLine();//TODO 换行符在此给写死了
} catch (IOException e) {
e.printStackTrace();
return false;
}
}
if(!status.shouldContinue){
return false;
}
return true;
}
};
itfile.from(in).iterator2Line();
if(writer!=null){
try {
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
try {
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
return getTempFile();
}
好啦，介绍到此就要结束啦，我们下次再聊~
代码包供您下载哦！—>代码包
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我们。
相关推荐
-
JAVA中正则表达式匹配，替换，查找，切割的方法
正则表达式的查找;主要是用到String类中的split(); String str; str.split();方法中传入按照什么规则截取,返回一个String数组 常见的截取规则: str.split("\\.")按照.来截取 str.split(" ")按照空格截取 str.split("cc+")按照c字符来截取,2个c或以上 str.split((1)\\.+)按照字符串中含有2个字符或以上的地方截取(1)表示分组为1 截取的例子; 按照
-
Java正则表达式(匹配、切割、替换、获取)等方法
正则表达式:符合一定规则的表达式 作用:用于专门操作字符串 特点:用于一些特定的符号来表示一些代码操作,这样就简化书写,主要是学习一些特殊符号的使用 好处:可以简化对字符串的复杂操作. 弊端:符号定义越多,正则越长,阅读性越差 具体操作: 1.匹配:String matches方法 用规则匹配所有的字符串,只要有一个不符合,则匹配结束. 2.切割:String sqlit(); 3.替换:replaceAll(); 4.获取:将字符串中的符合规则的子串取出. 操作步骤: 首先,将正则表大式封装成
-
java 实现切割文件和合并文件的功能
java 实现切割文件和合并文件的功能 一.切割文件代码如下: 需求:将一个媒体文件切割成多个碎片(每个碎片的大小为1M),并添加配置说明文件 1.创建(指定)一个文件夹,用于保存切割出来的碎片 2.创建源文件对象,并传入一个输入流对象 3.创建一个缓冲区为1M 4.创建一个输入流对象并将源文件对象传入,创建一个输出流对象引用 5.每个缓冲区获取到碎片时,使用输出对应流对象写入到一个新的文件 6.
-
java实现上传图片进行切割的方法
本文实例讲述了java实现上传图片进行切割的方法.分享给大家供大家参考.具体分析如下: 为什么我要进行上传的图片进行切割呢,我这个项目的图片是部门logo,每个部门都可以选择不同的logo,但是要应对浏览器的兼容以及拉伸,我选择了把一张图片切成左.中.右和剩下的部分,因为左边和中变可能会有图案或者字所以不能拉伸,拉伸的只是右边的部分,剩下的部分自适应就可以了.所以用了javax的ImageReader来操作.最后以blob类型保存数据库中. 首先要在form表单里面写上enctype="mult
-
java字符串切割实例学习(获取文件名)
上传文件路径为:C:/Documents and Settings/collin/My Documents/111-lazyloading.gif,欲取出文件名:111-lazyloading.gif.可以 复制代码 代码如下: String temp[] = name.split("////");if (temp.length > 1) {name = temp[temp.length - 1];} regex为////,因为在java中//表示一个/,而regex中//也表示
-
如何用Java来进行文件切割和简单的内容过滤的实现
一 由来 去年由于项目的需求,要将一个任意一个文件制作成一个xml文件,并且需要保持文件内容本身不产生变化,还要能够将这个xml重新还原为原文件.如果小型的文件还好处理,大型的xml,比如几个G的文件,基本上就OOM了,很难直接从节点中提取数据.所以我采用了流的方式.于是有了这个文件的裁剪工具. 二 使用场景 本工具可能的使用场景: 1.对任一文件的切割/裁剪.通过字节流的方式,开始节点和终止节点,裁剪出两个节点之间的部分. 2.往任一文件的头/尾拼接指定字符串.可以很容易将一个文件嵌入在某一个
-
Java删除指定文件夹下的所有内容的方法(包括此文件夹)
如下所示: // 删除文件夹 private static void deleteDirectory(File file) { if (file.isFile()) {// 表示该文件不是文件夹 file.delete(); } else { // 首先得到当前的路径 String[] childFilePaths = file.list(); for (String childFilePath : childFilePaths) { File childFile = new File(file
-
Java Swing组件文件选择器JFileChooser简单用法示例
本文实例讲述了Java Swing组件文件选择器JFileChooser简单用法.分享给大家供大家参考,具体如下: 先来看效果: 说明:选择文件或者文件夹.本例子就直接在控制台输出文件或者文件夹的路径.实际开发中,就可以将文件或文件夹的路径封装为File的实例来使用了. 具体代码如下: package awtDemo; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.io.F
-
Java读写ini文件代码示例
本文实例主要实现Java读写ini文件,具体如下,代码中有详细注释. 在java中,配置文件一般主要是两种形式:xml文件或者property文件.但大部分人都习惯使用ini文件,而且ini文件的分节以及注释功能,比起xml,也是易懂易用的. 实例代码: package com.epoint.tools; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.OutputStream; im
-
JAVA导出CSV文件实例教程
以前导出总是用POI导出为Excel文件,后来当我了解到CSV以后,我发现速度飞快. 如果导出的数据不要求格式.样式.公式等等,建议最好导成CSV文件,因为真的很快. 虽然我们可以用Java再带的文件相关的类去操作以生成一个CSV文件,但事实上有好多第三方类库也提供了类似的功能. 这里我们使用apache提供的commons-csv组件 Commons CSV 文档在这里 http://commons.apache.org/ http://commons.apache.org/proper/co
-
JAVA.io读写文件方式汇总
一.Java把这些不同来源和目标的数据都统一抽象为数据流. Java语言的输入输出功能是十分强大而灵活的. 在Java类库中,IO部分的内容是很庞大的,因为它涉及的领域很广泛:标准输入输出,文件的操作,网络上的数据流,字符串流,对象流,zip文件流. 这里介绍几种读写文件的方式 二.InputStream.OutputStream(字节流) //读取文件(字节流) InputStream in = new FileInputStream("d:\\1.txt"); //写入相应的文件
-
浅谈Java中File文件的创建以及读写
1.创建一个文件 @Test public void test6() throws IOException { File file1 = new File("C:\\IDEA\\h1.txt"); if(!file1.exists()){//文件不存在 file1.createNewFile(); System.out.println("创建成功"); }else{//文件存在 file1.delete(); System.out.println("删除成
-
Java实现FTP文件上传
一.配置FTP文件服务器 以Ubuntu为例 FTP两种模式简介 PORT(主动模式) 第一步FTP客户端首先随机选择一个大于1024的端口p1,并通过此端口发送请求连接到FTP服务器的21号端口建立TCP连接,在FTP中这个连接叫做控制连接,连接成功建立后,FTP客户端会发送port命令,紧接着FTP客户端会监视自己的p1+1端口,FTP服务器接收到port命令会从自己的20号端口向FTP客户端的p1+1端口发起请求建立TCP连接,这个连接叫做数据连接,用来发送数据,数据传输完毕后数据连接随即
-
Java持久化XML文件配置解析
目录 选择一个格式 XML 基础 创建一个示例配置文件 使用 Java 解析 XML 使用 Java 访问 XML 的值 使用 Java 更新 XML 如何保证配置不出问题 在你使用 Java 编写软件时实现持久化配置. 当你编写一个应用时,你通常都会希望用户能够定制化他们和应用交互的方式,以及应用与系统进行交互的方式.这种方式通常被称为 “偏好preference” 或者 “设置setting”,它们被保存在一个 “偏好文件” 或者 “配置文件” 中,有时也直接简称为 “配置config”.配
-
Java实现大文件的切割与合并操作示例
本文实例讲述了Java实现大文件的切割与合并操作.分享给大家供大家参考,具体如下: 这里实现对大文件的切割与合并. 按指定个数切(如把一个文件切成10份)或按指定大小切(如每份最大不超过10M),这两种方式都可以. 在这里我只是给大家写下我自己的一点简单的代码: package io2; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io