Java将文件按照指定格式切分成多个文件

	public static void main(string[] args) {
        try {
            file file = new file("d://test.txt");
            inputstreamreader r = new inputstreamreader(new fileinputstream(file));
            bufferedreader reader = new bufferedreader(r);

            string content;
            string lasta = "1";
            stringbuffer sb = new stringbuffer("");
            do{
                content = reader.readline();
                if(content == null){
                    //最后一次输出
                    file outfile = new file("d://" + lasta + ".txt");
                    outputstreamwriter writer = new outputstreamwriter(new fileoutputstream(outfile));
                    writer.write(sb.tostring());
                    writer.close();

                    break;
                }
                //注：你的截取规则
                string a = content.substring(0,1);

                if(a.equals(lasta)){
                    sb.append(content).append("\n");
                }else{
                    //标识改变，输出文件
                    file outfile = new file("d://" + lasta + ".txt");
                    outputstreamwriter writer = new outputstreamwriter(new fileoutputstream(outfile));
                    writer.write(sb.tostring());
                    //清空输出内容
                    sb = new stringbuffer("");
                    sb.append(content).append("\n");
                    writer.close();
                }
                lasta = a;

                system.out.println("=======");
            }while (true);

            r.close();
            reader.close();

        } catch (exception e) {
            e.printstacktrace();
        }


    }

//java实现把一个大文件切割成n个固定大小的文件 
package com.johnny.test; 
import java.io.bufferedreader; 
import java.io.file; 
import java.io.fileinputstream; 
import java.io.fileoutputstream; 
import java.io.filereader; 
import java.io.ioexception; 
public class fengefile { 
        public static final string suffix = “.txt”; // 分割后的文件名后缀 
        // 将指定的文件按着给定的文件的字节数进行分割文件，其中name指的是需要进行分割的文件名，size指的是指定的小文件的大小 
        public static string[] divide(string name, long size) throws exception { 
                file file = new file(name); 
                if (!file.exists() || (!file.isfile())) { 
                        throw new exception(“指定文件不存在！”); 
                } 
                // 获得被分割文件父文件，将来被分割成的小文件便存在这个目录下 
                file parentfile = file.getparentfile(); 
                // 取得文件的大小 
                long filelength = file.length(); 
                system.out.println(“文件大小：”+filelength+” 字节”); 
                if (size <= 0) { 
                        size = filelength / 2; 
                } 
                // 取得被分割后的小文件的数目 
                int num = (filelength % size != 0) ? (int) (filelength / size + 1) 
                                : (int) (filelength / size); 
                // 存放被分割后的小文件名 
                string[] filenames = new string[num]; 
                // 输入文件流，即被分割的文件 
                fileinputstream in = new fileinputstream(file); 
                // 读输入文件流的开始和结束下标 
                long end = 0; 
                int begin = 0; 
                // 根据要分割的数目输出文件 
                for (int i = 0; i < num; i++) { 
                        // 对于前num – 1个小文件，大小都为指定的size 
                        file outfile = new file(parentfile, file.getname() + i + suffix); 
                        // 构建小文件的输出流 
                        fileoutputstream out = new fileoutputstream(outfile); 
                        // 将结束下标后移size 
                        end += size; 
                        end = (end > filelength) ? filelength : end; 
                        // 从输入流中读取字节存储到输出流中 
                        for (; begin < end; begin++) { 
                                out.write(in.read()); 
                        } 
                        out.close(); 
                        filenames[i] = outfile.getabsolutepath(); 
                } 
                in.close(); 
                return filenames; 
        } 
        public static void readfilemessage(string filename) {// 将分割成的小文件中的内容读出 
                file file = new file(filename); 
                bufferedreader reader = null; 
                try { 
                        reader = new bufferedreader(new filereader(file)); 
                        string string = null; 
                        // 按行读取内容，直到读入null则表示读取文件结束 
                        while ((string = reader.readline()) != null) { 
                                system.out.println(string); 
                        } 
                        reader.close(); 
                } catch (ioexception e) { 
                        e.printstacktrace(); 
                } finally { 
                        if (reader != null) { 
                                try { 
                                        reader.close(); 
                                } catch (ioexception e1) { 
                                } 
                        } 
                } 
        } 
        public static void main(final string[] args) throws exception { 
                string name = “d:/boss/123.txt”; 
                long size = 1024*1024*4;//1k=1024b(字节) 
                string[] filenames = fengefile.divide(name, size); 
                system.out.println(“文件” + name + “分割的结果如下：”); 
                for (int i = 0; i < filenames.length; i++) { 
                        system.out.println(filenames[i] + “的内容如下：”); 
                        //fengefile.readfilemessage(filenames[i]); 
                        system.out.println(); 
                } 
        } 
} 

public class filetest {
 
    /**
      * 文件分隔器:给定文件的路径和每一块要拆分的大小，就可以按要求拆分文件
      * 如果指定的块给原文件都还要大，为了不动原文件，就生成另一个文件，以.bak为后缀，这样可以保证原文件
      * 如果是程序自动拆分为多个文件，那么后缀分别为".part序号"，这样就可以方便文件的合并了
      * 原理：很简单，就是利用是输入输出流，加上随机文件读取。
      */
    string filename=null;//原文件名
    long filesize=0;//原文件的大小
    long blocknum=0;//可分的块数
 
    /**
     * @param fileandpath 原文件名及路径
    */
    private void getfileattribute(string fileandpath)//取得原文件的属性
    {
        file file=new file(fileandpath);
        filename=file.getname();
        filesize=file.length();
    }
    /**
    *
    * @param blocksize 每一块的大小
    * @return 能够分得的块数
    */
    private long getblocknum(long blocksize)//取得分块数
    {
        long filesize=filesize;
        if(filesize<=blocksize)//如果分块的小小只够分一个块
        return 1;
        else {
            if(filesize%blocksize>0) {
                return filesize/blocksize+1;
            } else
                return filesize/blocksize;
        }
    }
    /**
    *
    * @param fileandpath 原文件及完整路径
    * @param currentblock 当前块的序号
    * @return 现在拆分后块的文件名
    */
    private string generateseparatorfilename(string fileandpath,int currentblock)//生成折分后的文件名，以便于将来合将
    {
        return fileandpath+".part"+currentblock;
    }
    /**
    *
    * @param fileandpath 原文件及完整路径
    * @param fileseparatename 文件分隔后要生成的文件名，与原文件在同一个目录下
    * @param blocksize 当前块要写的字节数
    * @param beginpos 从原文件的什么地方开始读取
    * @return true为写入成功，false为写入失败
    */
    private boolean writefile(string fileandpath,string fileseparatename,long blocksize,long beginpos)//往硬盘写文件
    {
        randomaccessfile raf=null;
        fileoutputstream fos=null;
        byte[] bt=new byte[1024];
        long writebyte=0;
        int len=0;
        try {
            raf = new randomaccessfile(fileandpath,"r");
            raf.seek(beginpos);
            fos = new fileoutputstream(fileseparatename);
            while((len=raf.read(bt))>0) {
                if(writebyte<blocksize)//如果当前块还没有写满
                {
                    writebyte=writebyte+len;
                    if(writebyte<=blocksize)
                        fos.write(bt,0,len);
                    else {
                        len=len-(int)(writebyte-blocksize);
                        fos.write(bt,0,len);
                    }
                }
            }
            fos.close();
            raf.close();
        } catch (exception e) {
            e.printstacktrace();
            try {
                if(fos!=null)
                    fos.close();
                if(raf!=null)
                raf.close();
            } catch(exception f)
            {
                f.printstacktrace();
            }
            return false;
        }
        return true;
    }
    /**
    * @param fileandpath 原文路径及文件名
    * @param blocksize 要拆分的每一块的大小
    * @return true为拆分成功，false为拆分失败
    */
    private boolean separatorfile(string fileandpath,long blocksize)//折分文件主函数
    {
        getfileattribute(fileandpath);//将文件的名及大小属性取出来
        //system.out.println("filesize:"+filesize);
        //system.out.println("blocksize:"+blocksize);
        blocknum=getblocknum(blocksize);//取得分块总数
        //system.out.println("blocknum:"+blocknum);
        //system.exit(0);
        if(blocknum==1)//如果只能够分一块，就一次性写入
            blocksize=filesize;
        long writesize=0;//每次写入的字节
        long writetotal=0;//已经写了的字节
        string filecurrentnameandpath=null;
        for(int i=1;i<=blocknum;i++)
        {
            if(i<blocknum)
                writesize=blocksize;//取得每一次要写入的文件大小
            else
                writesize=filesize-writetotal;
            if(blocknum==1)
                filecurrentnameandpath=fileandpath+".bak";
            else
                filecurrentnameandpath=generateseparatorfilename(fileandpath,i);
            //system.out.print("本次写入:"+writesize);     
            if(!writefile(fileandpath,filecurrentnameandpath,writesize,writetotal))//循环往硬盘写文件
                return false;
            writetotal=writetotal+writesize;
            //system.out.println("  总共写入:"+writetotal);
        }
        return true;
    }
 
    public static void main(string[] args)
    {
        filetest separator = new filetest();
        string fileandpath="f://abc.txt";//文件名及路径
        long blocksize=200*1024;//每一个文件块的大小，大小是按字节计算
        if(separator.separatorfile(fileandpath,blocksize)) {
            system.out.println("文件折分成功！");
        }
        else {
            system.out.println("文件折分失败！");
        }
    }
 
 
}