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表的字符
//我对照了一下，除了中文没了，其他的英文位置和页面数量都一致，所以代码应该是可信的

package stream;

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

public class exercise2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int size = 100 * 1024;  /* 100kB */
		File file = new File("C:\\学习\\eclipse workspace\\eclipse.exe");
		if(file.length() == 0) {
			System.out.println("该文件不存在，程序退出！");
			System.exit(0);
		}
		//大致思路是先把eclipse.exe的数据读出来存入data，然后通过将data分割成eachdata，再把eachdata通过输出流写进eclipse.exe-i
		byte data[] = new byte[(int)file.length()];
		byte eachdata[] = new byte[size];
		try {
			FileInputStream fis = new FileInputStream(file);
			fis.read(data);
			fis.close();
		}catch(IOException e) {
			e.printStackTrace();
		}
		int num = (int)file.length()/size + 1;
		for(int i = 0; i < num; i++) {
			if(i + 1 != num) 
				eachdata = Arrays.copyOfRange(data, i * size, (i + 1) * size);
			else
				eachdata = Arrays.copyOfRange(data, i * size, (int)file.length());
			String filename = file.getName() + "-" + i;
			File ifile = new File(file.getParent(), filename);
			if(!ifile.exists())
				try {
					ifile.createNewFile();
				}catch(IOException e) {
					e.printStackTrace();
				}
			try {
				FileOutputStream fos = new FileOutputStream(ifile);
				fos.write(eachdata);
				fos.close();
				System.out.println(ifile.getAbsolutePath() + " " + ifile.length() + " " + "bytes.");
			}catch(IOException e){
				e.printStackTrace();
			}
		}
		
	}

}

———————————————————————拆分————————————————————————————
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestStream3 {

    public static void main(String[] args) {

            try {
                File f = new File("LOLFolder/1.txt");

                FileInputStream fis =new FileInputStream(f);

                int ohk = 100 * 1024;

                byte[] all =new byte[(int) f.length()];

                fis.read(all);

                int file_num = 1;
                for (int start = 0;start < (int) f.length();start += ohk){
                    byte[] temp;
                    try{
                        temp =new byte[ohk];
                        System.arraycopy(all, start, temp, 0, ohk);
                    }catch (ArrayIndexOutOfBoundsException a){
                        int tail = (int) f.length() % ohk;
                        temp =new byte[tail];
                        System.arraycopy(all, start, temp, 0, tail);
                    }

                    File n = new File("LOLFolder/temp"+file_num+".txt");
                    FileOutputStream fos = new FileOutputStream(n);
                    fos.write(temp);
                    fos.close();
                    file_num+=1;
                }
                fis.close();
            }catch (IOException e){
                e.printStackTrace();
            }

    }

}
———————————————————————————————合并————————————————————————————————
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class TestStream4 {

    public static void main(String[] args) {
            try {
                List<Byte> all_data = new ArrayList<>();
                for (int i = 1;i<6;i++){
                    File f = new File("LOLFolder/temp"+i+".txt");
                    byte[] all =new byte[(int) f.length()];
                    FileInputStream fis =new FileInputStream(f);
                    fis.read(all);
                    fis.close();
                    for (byte a:all){
                        all_data.add(a);
                    }
                }
                File aa = new File("LOLFolder/addall.txt");
                FileOutputStream fos = new FileOutputStream(aa);
                for (byte b:all_data){
                    fos.write(b);
                }
                System.out.println(all_data.size());
                fos.close();

            }catch (IOException e){
                e.printStackTrace();
            }

    }

}