集合+IO相关习题、IO+多线程相关习题

1、提供一个文件操作的方法，其需要实现功能：对一个文件的任意位置可以插入任何内容

public class TestDemo8 {
	
	/**
	 * 提供一个文件操作的方法，其需要实现功能：对一个文件的任意位置可以插入任何内容
	 * @param filePath 文件路径
	 * @param postion  追加内容添加位置
	 * @param contens  追加内容
	 */
	public static void addContainsToFile(String filePath,int position,String contents){
        try {
            File file = new File(filePath);
            System.out.println(file);
            if (!(file.exists() && file.isFile())) {
                System.out.println("文件不存在  ~ ");
                return;
            }
            if ((position < 0) || (position > file.length())) {
                System.out.println("position不合法 ~ ");
                return;
            }

            //创建临时文件
            File tempFile = File.createTempFile("temp", ".temp", new File("F:/"));
            FileOutputStream out = new FileOutputStream(tempFile);
            FileInputStream in = new FileInputStream(tempFile);
            //在退出JVM退出时自动删除
            tempFile.deleteOnExit();
            
            RandomAccessFile rw = new RandomAccessFile(file, "rw");
            
            rw.seek(position);

            int tmp;
            //将position位置后的内容写入临时文件
            while ((tmp = rw.read()) != -1) {
                out.write(tmp);
            }
            rw.seek(position);
            rw.write(contents.getBytes());
            
            while ((tmp = in.read()) != -1) {
                rw.write(tmp);
            }
            rw.close();
            out.close();
            in.close();
        }catch (IOException e) {
            e.printStackTrace();
        }
    }
		


	
	public static void main(String[] args) {
		String filePath = "D:\\lzq/int.txt";
		int postion = 9;
		String contens = "hhh";
		addContentsToFile(filePath,postion,contens);
	}

}

2、有两个有序的集合，集合的每个元素都是一段范围，求其交集，例如交集{[4,8],[9,13]}和{[6,12]}的交集是{[6,8],[9,12]}

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * @ClassName TestDemo9
 * @Description
 * @Author lzq
 * @Date 2018/12/18 12:01
 * @Version 1.0
 **/
public class TestDemo9 {
    public static void main(String[] args) {
        List<List<Integer>> lists1 = new ArrayList<>();

        List<Integer> list1 = new ArrayList<>();
        list1.add(4);
        list1.add(8);

        List<Integer> list2 = new ArrayList<>();
        list2.add(9);
        list2.add(13);

        lists1.add(list1);
        lists1.add(list2);

        List<List<Integer>> lists2 = new ArrayList<>();

        List<Integer> list = new ArrayList<>();
        list.add(6);
        list.add(12);

        lists2.add(list);

        /**
         * 例如交集{[4,8],[9,13]}和{[6,12]}的交集是{[6,8],[9,12]}
         */
        manage(lists1,lists2);
    }

    /**
     * 参数校验
     * @param lists
     * @return
     */
    private static boolean islegal(List<List<Integer>> lists) {
        if(lists.size() < 1) {
            return false;
        }
        Iterator<List<Integer>> iterator = lists.iterator();
        while(iterator.hasNext()) {
            List<Integer> list1 = iterator.next();
            if(list1.size() != 2) {
                return false;
            }
            if(list1.get(0) >= list1.get(1)) {
                return false;
            }
        }
        return true;
    }

    /**
     * 两个有序的集合，集合的每个元素都是一段范围，求其交集
     * 所求交集结果直接打印到输出终端
     * @param lists1
     * @param lists2
     */
    private  static void manage(List<List<Integer>> lists1,List<List<Integer>> lists2) {
        if(!islegal(lists1) || !islegal(lists2)) {
            return;
        }
        Iterator<List<Integer>> iterator = lists1.iterator();
        while(iterator.hasNext()) {
            List<Integer> list1 = iterator.next();;
            Iterator<List<Integer>> iterator1 = lists2.iterator();
            while (iterator1.hasNext()) {
                List<Integer> list2 = iterator1.next();
                intersection(list1,list2);
            }
        }
    }

    /**
     * 求区间交集
     * @param list1
     * @param list2
     */
    public static void intersection(List<Integer> list1,List<Integer> list2) {
       int start1 = list1.get(0);
        int end1 = list1.get(1);
        int start2 = list2.get(0);
        int end2 = list2.get(1);
        //除去没有交集的情况
        if(start2 > end1 || start1 > end2) {
            return;
        }
        //然后给这四个点排序，去掉最大的和最小的点，剩下中间的那两个点就是他们的交集
        int[] array = {start1,end1,start2,end2};
        Arrays.sort(array);
        int left = array[1];
        int right =  array[2];
        System.out.println("["+left+","+right+"]");
    }
}

运行结果：

[6,8]
[9,12]

3、一个文本文件记录了1000条数据数据内容需自己初始化产生。数据内容为部分用户的银行卡消费记录，消费记录信息包含姓名 消费金额，找出消费次数最多的用户，并且该用户单笔消费最高的金额是多少？

例：文件内容格式
张三,666
李四,7893
张三,9999
获取结果则为：张三消费次数最多，最高消费金额为：9999

import java.io.*;
import java.util.*;

/**
 * @ClassName TestDemo10
 * @Description
 * @Author lzq
 * @Date 2018/12/18 13:37
 * @Version 1.0
 **/
public class TestDemo10 {
    public static void main(String[] args) {
        String fileName = "F:/FHB/io/money.txt";
        ArrayList <String> userlist = new ArrayList <>();
        userlist.add("张三");
        userlist.add("李四");
        userlist.add("王五");
        initFile(fileName, userlist);
        searchUser(fileName);
    }

    /**
     * 初始化文件内容：数据内容为用户的银行卡消费记录，消费记录信息包含([姓名] [消费金额])
     * 要求：用户列表中的用户出现次数随机，消费金额信息随机，总数据条数1000条
     * @param filePath  文件名路径
     * @param userLists 用户列表
     */
    private static void initFile(String filePath,List<String> userLists) {
        File file = new File(filePath);
        if(userLists.size() < 1) {
            System.err.println("用户列表不能为空");
            return;
        }
        try {
            Writer fileWriter = new FileWriter(file);
            int size = userLists.size();
            Random random = new Random();

            for(int i = 0;i < 1000;i++) {
                StringBuilder stringBuilder = new StringBuilder();
                stringBuilder.append(userLists.get(random.nextInt(size)));
                stringBuilder.append(",");
                stringBuilder.append(random.nextInt(1000));
                stringBuilder.append("\r\n");
                fileWriter.write(stringBuilder.toString());
            }
            fileWriter.write("null");
            fileWriter.close();
        }catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 在文本中寻找符合条件用户：找出消费次数最多的用户，并且该用户单笔消费最高的金额是多少？
     * 符合条件用户直接打印到输出在终端
     * @param filePath 文件路径名
     */
    private static void searchUser(String filePath) {
        try {
            Reader reader = new FileReader(filePath);
            BufferedReader bufferedReader = new BufferedReader(reader);
            String max_name = "";
            String str = null;
            //list.size该用户出现的次数  key是名字 list里面放该用户每次消费的金额
            HashMap<String,List<Integer>> hashMap = new HashMap<>();
            Integer max_money = 0;
            while(!(str = bufferedReader.readLine()).equals("null")) {
                //split()按照指定的字符拆分字符串，拆分后放到String数组里面
                String[] split = str.split(",");
                String name = split[0];
                Integer money = Integer.valueOf(split[1]);
                if(!hashMap.containsKey(name)) {   //第一次的时候
                    ArrayList<Integer> arrayList = new ArrayList<>();
                    arrayList.add(money);
                    hashMap.put(name,arrayList);
                }else {
                    List<Integer> list = hashMap.get(name);
                    list.add(money);
                    hashMap.put(name,list);
                }
            }

            //找消费次数最多的客户
            Integer num = 0;
            Iterator<Map.Entry<String,List<Integer>>> iterator = hashMap.entrySet().iterator();
            while(iterator.hasNext()) {
                Map.Entry<String,List<Integer>> next = iterator.next();
                String name1 = next.getKey();
                List<Integer> money1 = next.getValue();
                if(money1.size() > num) {
                    num = money1.size();
                    max_name = name1;
                }
            }
            System.out.println("消费次数最多的客户"+max_name);

            //找消费次数最多的客户的单笔最高消费
            List<Integer> list = hashMap.get(max_name);
            Iterator<Integer> iterator1 = list.iterator();
            while(iterator1.hasNext()) {
                Integer next = iterator1.next();
                if(next > max_money) {
                    max_money = next;
                }
            }
            System.out.println("单笔消费最高金额是"+max_money);
            bufferedReader.close();
            reader.close();
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果：

消费次数最多的客户李四
单笔消费最高金额是999

4、假设有一个很大的文件，现在要拷贝它到指定文件中，如何实现高效率的拷贝？

public class TestDemo7 {
    public static void main(String[] args) {
        String src = "F:\\FHB\\io\\money.txt";
        String dest = "F:\\FHB\\io\\dest.txt";
        MutilThreadCopyFile(src,dest,4);
    }
    /**
     * 多线程文件拷贝
     * @param srcPath：源路径
     * @param DestPath：目标地址
     * @param ThreadNum：线程数量
     */
    public static void MutilThreadCopyFile(String srcPath, String DestPath, Integer ThreadNum) {
        if(srcPath.equals(DestPath)) {  //防止源路径和目标路径是一样的的情况
            return;
        }
        File srcFile = new File(srcPath);
        File destFile = new File(DestPath);
        if(!srcFile.exists() || !destFile.exists()) { //参数校验
            return;
        }
        int length = (int)srcFile.length(); //得到源文件的字节总长度
        int each = length/ThreadNum;  //分割文件，每个文件的长度就是单个线程要拷贝的长度
        /**
         * 创建线程，配置给每个线程分割的文件，注意，可能出现5/2 = 2的情况，有余数出现
         * 这个时候应该让ThreadNum-1个线程按照正常分配去拷贝，最后所有的剩下的都交给最
         * 后一个线程去执行
         */
        for (int i = 0; i < ThreadNum-1; i++) {
            int start = i*each; //起始复制位置
            int end = start+each; //终止复制的位置
            MyThread thread = new MyThread(srcFile, destFile, start, end);
            thread.start();
        }
        if(length%ThreadNum != 0) {
            int start = each*(ThreadNum-1);
            int end = length;
            MyThread thread = new MyThread(srcFile,destFile,start,end);
            thread.start();
        }
    }
}

public class MyThread extends Thread {
    private long start = 0;
    private long end = 0;
    private File srcFile = null;
    private File destFile = null;

    public MyThread(File srcFile,File destFile,long start,long end) {
        this.srcFile = srcFile;
        this.destFile = destFile;
        this.start = start;
        this.end = end;
    }

    @Override
    public void run() {
        try {
            RandomAccessFile read = new RandomAccessFile(srcFile,"r"); //读
            RandomAccessFile writer = new RandomAccessFile(destFile,"rw"); //写
            read.seek(this.start);
            writer.seek(this.start);
            long index = this.start;
            byte[] bytes = new byte[1024];
            int n;
            while ((n = read.read(bytes)) != -1) {
                index += n;
                writer.write(bytes,0,n);
                if (index >= this.end) {
                    break;
                }
            }
            read.close();
            writer.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}