package HelloJava;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Locale;

public class splitOrMergeFile {
	protected String path;
	protected int maxLength;

	public splitOrMergeFile(String path, int maxLength) {
		this.path = path;
		this.maxLength = maxLength;
		File f = new File(path);
		if (f.exists())
			System.out.format(Locale.CHINA, "源文件存在: %s, 其大小为: %,d字节%n", f.toString(), f.length());
		else
			System.out.format("源文件不存在: %s%n", f.toString());
	}

	public void splitFile() throws IOException {
		File f = new File(this.path);
		FileInputStream fis = new FileInputStream(f);
		long fileLength = f.length();
		long totalChunks = (fileLength + this.maxLength - 1) / this.maxLength;
		byte[] buffer = new byte[this.maxLength];

		for (int i = 0; i < totalChunks; i++) {
			int readLength = (int) Math.min(this.maxLength, fileLength - i * this.maxLength);
			int bytesRead = fis.read(buffer, 0, readLength);

			if (bytesRead == -1) {
				break;
			}
			this.outputSubfile(buffer, bytesRead, i);
		}
		fis.close();
	}

	public void mergeFile() throws IOException {
		long maxIndex = this.getSplitNumber();
		long lengthByte = this.getSplitLength(maxIndex);
		long length = 0;
		byte[] buffer = new byte[(int) lengthByte];

		String[] fileName = new String[2];
		File fileNameObject = new File(this.path);
		String nameExtension = "";
		int lastPoint = this.path.lastIndexOf('.');

		if (fileNameObject.toString().contains(".")) {
			nameExtension = this.path.substring(lastPoint);
			fileName[0] = this.path.substring(0, lastPoint);
			fileName[1] = nameExtension;
		} else {
			fileName[0] = this.path;
			fileName[1] = "";
		}

		for (long i = 0; i < maxIndex; i++) {
			File f = new File(this.path + "-" + i + ".dat");
			FileInputStream fis = new FileInputStream(f);
			fis.read(buffer, (int) length, (int) f.length());
			length += f.length();
			fis.close();
		}
		if (maxIndex > 0) {
			File f = new File(fileName[0] + "-source" + fileName[1]);
			FileOutputStream fos = new FileOutputStream(f);
			fos.write(buffer, 0, (int) lengthByte);
			fos.close();
			System.out.format(Locale.CHINA, "合并子文件输出: %s, 其大小为: %,d字节%n", f.toString(), f.length());
		} else {
			System.out.format("子文件不存在: %s-0.dat%n", this.path);
		}
	}

	protected void outputSubfile(byte[] buffer, int bytesRead, int index) throws IOException {
		File f = new File(this.path + "-" + index + ".dat");
		FileOutputStream fos = new FileOutputStream(f);
		fos.write(buffer, 0, bytesRead);
		fos.close();
		System.out.format(Locale.CHINA, "输出子文件: %s, 其大小为: %,d字节%n", f.toString(), f.length());
	}

	protected long getSplitNumber() {
		for (long i = 0; i < Long.MAX_VALUE; i++) {
			File f = new File(this.path + "-" + i + ".dat");
			if (!f.exists())
				return i;
		}
		return 0;
	}

	protected long getSplitLength(long maxIndex) {
		long lengthByte = 0;
		for (long i = 0; i < maxIndex; i++) {
			File f = new File(this.path + "-" + i + ".dat");
			lengthByte += f.length();
		}
		return lengthByte;
	}

	public static void main(String[] args) {
		splitOrMergeFile f = new splitOrMergeFile("D:\\software\\nonLoaded\\eclipse\\eclipse.exe", 1024 * 100);
		try {
			f.splitFile();
			f.mergeFile();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

package myFileTest;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

import j2se.HelloWorld;
public class TestFile {

	public static void main(String[]args) throws IOException
	{
		File fold = new File("D:/testFolder/");			//测试路径
		File f = new File(fold,"/testFile.txt");		//测试文件
		fold.mkdirs();									//如果测试路径不存在，则新建一个
		FileOutputStream fos = new FileOutputStream(f);
		
		byte[]bs = getRandomStr(300*1000+3).getBytes(); //生成指定长度的字符串并转为数组
		fos.write(bs);									//写入内容
		fos.close();
		File parentFile = SplitFile(f,100*1000);		//将写入内容完毕的文件，拆分成若干个子文件
		File combineFile = CombineFile(parentFile);		//将拆分完毕的子文件，合并为一个文件
		if(FileEquals(f,combineFile))					//检查拆分、合并后的结果与原始文件是否相等
		{
			System.out.println("结果检查通过！原始文件经过拆分并合并后的结果，与原始文件完全一致；成功无损地完成文件拆分、合并过程。");
		}
		else
			System.out.println("结果检查失败！原始文件进行文件拆分、合并过程失败或过程有损失。");
	}
	//指定拆分长度，将file拆分为若干子文件（file-1、file-2...）,拆分成功返回拆分文件存放的文件夹parentFile文件，失败返回null。
	public static File SplitFile(File file,int splitLength) throws IOException
	{
		if(file == null)return null;
		if(!file.exists())return null;
		int num = (int) Math.ceil((double)file.length()/splitLength);
		FileInputStream fis = new FileInputStream(file);
		File parentFile = new File(String.format("%s/newSplitFolder", file.getParent()));
		byte[]bs = new byte[(int)file.length()];
		fis.read(bs);
		for (int i = 0; i < num; i++) {
			byte[]tempArr;
			if(i<num-1)
			{
				tempArr = Arrays.copyOfRange(bs, i*splitLength, i*splitLength+splitLength);
			}
			else //拆分到最后一个文件
				tempArr = Arrays.copyOfRange(bs, i*splitLength, i*splitLength+(int)file.length()-((i-1)*splitLength+splitLength));
			parentFile.mkdirs();
			File f = new File(parentFile,String.format("/%s-%d.txt",(file.getName().split("\\."))[0],i+1));//split匹配正则表达式，'.'表示任意字符，需要转义
			FileOutputStream fos = new FileOutputStream(f);
			fos.write(tempArr);
			fos.close();
			System.out.println(String.format("拆分成功！第%d个子文件为：%s，大小为  %s %s字节", i+1,f.getAbsoluteFile(),String.valueOf(f.length()>=1000?(double)f.length()/1000:f.length()),f.length()>=1000?"千":""));
		}
		return parentFile;
	}
	//根据提供的文件夹，获取该文件夹下的所有子文件，将所有子文件合并为一个新的文件并返回，失败返回null;返回的合并结果路径位于提供的文件夹内。
	public static File CombineFile(File parentFileFolder) throws IOException
	{
		if(parentFileFolder==null)return null;
		File[]fs = parentFileFolder.listFiles();
		if(fs==null)return null;
		if(fs.length<1)return null;
		int total = 0;
		for (File f : fs) {
			total+=f.length();
		}
		byte[]bs = new byte[total];
		int index = 0;
		for (File f : fs) {
			if(f==null)continue;
			if(!f.exists())continue;
			byte[]datas = new byte[(int)f.length()];
			FileInputStream fis = new FileInputStream(f);
			fis.read(datas);
			System.arraycopy(datas, 0, bs, index, (int)f.length());
			index += f.length();
			fis.close();
		}
		File resFile = new File(String.format("%s/%s.%s",fs[0].getParent(),"combineFile",fs[0].getName().split("\\.")[1])); 
		FileOutputStream fos = new FileOutputStream(resFile);
		fos.write(bs);
		fos.close();
		
		System.out.println(String.format("%n子文件合并成功！合并结果文件：path:%s%nspace:%s %s字节", resFile.getAbsoluteFile(),
				String.valueOf(resFile.length()>=1000?(double)resFile.length()/1000:resFile.length())
				,resFile.length()>=1000?"千":""));
		return resFile;
	}
	//判断两个文件的内容、大小是否完全一致
	public static boolean FileEquals(File f1,File f2) throws IOException
	{
		if(f1==null||f2==null)return false;
		if(!f1.exists()||!f2.exists())return false;
		if(f1.length()!=f2.length())return false;
		FileInputStream fis = new FileInputStream(f1);
		byte[]bs1 = new byte[(int)f1.length()];
		byte[]bs2 = new byte[(int)f2.length()];
		fis.read(bs1);
		fis.close();
		fis = new FileInputStream(f2);
		fis.read(bs2);
		fis.close();
		return Arrays.equals(bs1, bs2);
	}
	///生成指定长度的随机字符串
	public static String getRandomStr(int length)
	{
		char[] cs = new char[length];
		for (int i = 0; i < cs.length; i++) {
			int rcase = (int)(Math.random()*10);//用于随机判断大小写
			if(rcase>=5)//各占一半的概率
			{
	
				cs[i] = (char)('A'+Math.random()*25);//Z与A相差25
			}
			else 
			{
				cs[i] = (char)('a'+Math.random()*25);//Z与a相差25
			}
				
		}
		return new String(cs);
	}
}

package project.study.file;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class heFile {

    public static void main(String[] args) throws IOException {
        File f = new File("/Users/shiyingzhi/Desktop/测试数据/JAVA_PROJECT/project/study/file/he.md");

        int i = 1;
        byte[] all = new byte[2600];
        while (i < 26) {
            File fz = new File("/Users/shiyingzhi/Desktop/测试数据/JAVA_PROJECT/" + (i++) + ".md");
            FileInputStream fi = new FileInputStream(fz);
            byte[] b = new byte[(int) fz.length()];

            fi.read(b);
//            for(byte bb : b){
//                System.out.println(bb);
//            }
            System.out.println(i);
            System.arraycopy(b, 0, all, (i - 1) * 100, b.length);
            fi.close();

        }
        FileOutputStream fos = new FileOutputStream(f.getAbsoluteFile());
        fos.write(all);
        fos.close();

    }


}

    public static void main(String[] args) {
        String path="C:\\hello\\88.jpg";
        String parentPath="C:\\hello";
        int limit=100*1024,start=0;
        ArrayList<File> saveArr=new ArrayList<>();
        File parFile=new File(parentPath);
        File file=new File(path);
        try(
                BufferedInputStream bis=new BufferedInputStream(new FileInputStream(file))
        ){
            /**
             * 拆分文件
             */
            //将主文件的字节全部读进一个数组
            byte[] saveAll=bis.readAllBytes();
            //计数 需要建立多少个子文件
            int count=saveAll.length/limit;
            //建立好子文件的对象
            while (count>0){
                saveArr.add(new File(parFile,"88.jpg"+"-"+count));
                count--;
            }
            //遍历，往里填充数据，同时创建文件
            for (File temp:saveArr){
                try (
                        BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(temp));
                        ){
                    if ((start+limit*2)<saveAll.length){
                        bos.write(saveAll,start,limit);
                    }else {
                        bos.write(saveAll,start,saveAll.length-start);
                    }
                    System.out.println("输出子文件: "+temp+"\t它的大小是"+temp.length());
                    start+=limit;
                }
            }

            /**
             * 合并文件
             */
            int start2=0,destLength=0;
            byte destArr[];
            for (File temp:saveArr){
                destLength += temp.length();
            }
            byte[] addAll=new byte[destLength];
            for (File temp:saveArr){
                try (
                        BufferedInputStream biss=new BufferedInputStream(new FileInputStream(temp))
                        ){
                        destArr=biss.readAllBytes();
                        System.arraycopy(destArr,0,addAll,start2,destArr.length);
                        start2 += destArr.length;
                }
            }
            File file1=new File(parFile,"addAll");
            try(
                    BufferedOutputStream boss=new BufferedOutputStream(new FileOutputStream(file1));
                    ){
                boss.write(addAll);
            }

        } catch (IOException e) {
            throw new RuntimeException(e);
        }


    }

/**
 *
 * @param metafile 源文件
 * @param kb 分片大小（kb）
 * @throws IOException
 */
private static void departFile(File metafile, int kb) throws IOException {
    int partSize = kb * 1024;
    FileInputStream fis = new FileInputStream(metafile);
    //文件分片数量
    long n = metafile.length()%partSize == 0 ? metafile.length() / partSize : metafile.length() / partSize + 1;
    for (int i = 0; i < n; i++) {
        //创建待写入的缓冲区，每次写入分片长度的数据
        //只有最后一个文件的大小是不一样的，这里做了判断
        byte[] part = new byte[i < n-1 ? partSize : (int) (metafile.length() % partSize)];
        //由于fis是在循环外面创建的，所以每次循环它都是继续上次读的位置继续读取，而不是每次从头读数据
        //所以不用考虑每次将fis的指针向后移动partSize个位置
        fis.read(part);
        //创建新分片文件
        File temp = new File(metafile.getAbsolutePath() + "-" + i);
        temp.createNewFile();
        FileOutputStream fos = new FileOutputStream(temp);
        //将缓冲区内的数据写入新文件内
        fos.write(part);
        fos.close();
    }
    fis.close();
}
 
/**
 *
 * @param metaFile 源文件
 */
private static void unionFile(File metaFile) throws IOException {
    File[] files = new File[0];
    byte[] all = new byte[0];
    for (int i = 0; i < Integer.MAX_VALUE; i++) {
        File file = new File(metaFile.getAbsolutePath() + "-" + i);
        //如果文件不存在说明已经找到所有的分片文件
        if (!file.exists())
            break;
        files = Arrays.copyOf(files, files.length+1);
        files[files.length-1] = file;
    }
    for (int i = 0; i < files.length; i++) {
        //每次创建子串，然后用System.arraycopy将新串连接到all串的末尾
        byte[] tmp = new byte[(int) files[i].length()];
        all = Arrays.copyOf(all, (i+1) * (int) files[i].length());
        FileInputStream fis = new FileInputStream(files[i]);
        fis.read(tmp);
        System.arraycopy(tmp, 0, all, (int) (i * files[i].length()), (int) files[i].length());
        fis.close();
    }
    File newFile = new File(metaFile.getParent(), "New " + metaFile.getName());
    if (!newFile.exists())
        newFile.createNewFile();
    FileOutputStream fos = new FileOutputStream(newFile);
    fos.write(all);
    fos.close();
}
 
public static void main(String[] args) {
 
    //练习-拆分文件
    File f1 = new File("C:\\Users\\ljbeiji\\Desktop\\Test Folder\\xyz\\split.pdf");
    System.out.println(f1.exists());
    try {
        departFile(f1, 100);
    } catch (IOException e) {
        e.printStackTrace();
    }
 
    //练习-合并文件
    try {
        unionFile(f1);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

//如图，左边是合并后的文件，右边是原文件
//合并后的文件可以访问，但缺少中文，查看官方的FileInputStream解释里有这样一段话：
//FileOutputStream is meant for writing streams of raw bytes such as image data. For writing streams of characters, consider using FileWriter.
//意思就是要想保留字符，得用FileWriter类，这个FileOutputStream类只保留原始数据（图片之类的）和ASCII表的字符
//我对照了一下，除了中文没了，其他的英文位置和页面数量都一致，所以代码应该是可信的