java试题，做的并不是很符合题目要求，欢迎指正！

对于以下几题所使用的语言的要求：
(1) 每题所使用的编程语言可以使用Java、Python或Scala；
(2) 除非题目中有特别说明，语言的标准库都是可以使用的，不要使用其他第三方的库。

1. 文件改名工具
   编写一个程序，将指定目录及其所有子目录下的所有包含空格的文件改名（无需将目录改
   名），改名的规则为将原文件名中的空格替换为下划线“_”。如果改名后的文件名出现冲突，
   则报告错误信息并且中止改名。指定目录可以由命令行参数指定。

2. 文本编辑器
   编写一个微型的面向行的文本编辑器。用户通过命令行的方式与文本编辑器交互。编辑器接
   收如下命令：
    a [<文本>]              追加一行文本（若无文本，则追加一个空行）
    d <行号>                删除指定行
    i <行号> <文本>           在指定行之前插入一行文本
    s                     显示所有的行，包括每行的行号
    u                     撤销上一个编辑操作（a、d、i都属于编辑操作，其他不是）
    w <文件名>               将所有内容输出到指定的文件中
    q                     退出
   例：
       输入： a Hello world!
       输入： a This is a line of text.
       输入： i 2 the second line
       输入： a the last line
       输入： s
       输出： 1: Hello world!
               2: the second line
               3: This is a line of text.
               4: the last line
       输入： d 2
       输入： u
       输入： d 3
       输入： w a.txt
       输入： q

   a.txt文件的内容应当是：
       Hello world!
       the second line
       the last line

   要求：在设计时应当考虑其可扩展性，例如，日后如果需要增加新的编辑命令，应避免对已
   实现的命令的代码进行修改。

3.归并
   编写一个方法merge，该方法的两个输入参数的类型为任意可比较大小的类型的序列，用户调
   用该方法时保证输入的两个序列都是按照升序排列好的。编写一个函数，对两个序列进行合
   并，生成一个新的序列，该序列包含两个输入序列中的所有元素，并且这些元素在合并后的
   序列中也是升序排列的。将合并后的序列返回。
    自己定义函数接口，给出函数实现，并且写出测试代码。

   例如，若选用Java语言，用户会这样使用该函数：
       List<Integer> s1 = Arrays.asList(3, 6, 7, 12);
       List<Integer> s2 = Arrays.asList(-1, 5, 14);
       List<Integer> result = merge(s1, s2);
   若使用Python语言，用户会这样使用该函数：
       s1 = [3, 6, 7, 12]
       s2 = [-1, 5, 14]
       result = merge(s1, s2)
   若使用Scala语言，用户会这样使用该函数：
       val s1 = 3 :: 6 :: 7 :: 12 :: Nil
       val s2 = -1 :: 5 :: 14 :: Nil
       val result = merge(s1, s2)

   要求：需要注意算法效率，应当保证算法的时间复杂度为O(n)，其中n是两个输入列表的长度
   和。不允许使用现成的排序方法实现。

4. 消息队列
   实现一个支持多线程的消息队列，支持两种操作：
    (1) push：向队列中放置一个新的元素；
    (2) pop：从队列中取出一个元素。
   执行pop时，若队列中的元素为空，则当前线程阻塞，直到队列中有元素位置。
    自己给出接口和实现，并且写出测试代码。

第一题：

1. 文件改名工具
   编写一个程序，将指定目录及其所有子目录下的所有包含空格的文件改名（无需将目录改
   名），改名的规则为将原文件名中的空格替换为下划线“_”。如果改名后的文件名出现冲突，
   则报告错误信息并且中止改名。指定目录可以由命令行参数指定。

import java.io.File;

public class Test{
    public static void main(String[] args){
        File file = new File("C:/01-test");
        if(!file.exists()){
            System.out.println("没有指定的目录文件。");
            return;
        }else{
            boolean flag = rename(file);
            if(!flag){
                System.out.println("没有要修改的文件");
            }
        }
    }

    public static boolean rename(File file){
        boolean state = false;
        File[] files = file.listFiles();
        if(files != null){
            for(File f:files){
                if(!f.isDirectory()){
                    String s = f.getName();
                    int i = s.indexOf(" ");
                    if(i != -1){
                        state = true;
                        s = s.replaceAll(" ", "-");
                        File f2 = new File(f.getParent() + "/" + s);
                        boolean flag = f.renameTo(f2);
                        if(flag){
                            System.out.println("成功修改一个文件名");
                        }else{
                            System.out.println("失败");
                        }
                    }
                }
                rename(f);
            }
        }
        return state;
    }
}

第二题：

2. 文本编辑器
   编写一个微型的面向行的文本编辑器。用户通过命令行的方式与文本编辑器交互。编辑器接
   收如下命令：
    a [<文本>]              追加一行文本（若无文本，则追加一个空行）
    d <行号>                删除指定行
    i <行号> <文本>           在指定行之前插入一行文本
    s                     显示所有的行，包括每行的行号
    u                     撤销上一个编辑操作（a、d、i都属于编辑操作，其他不是）
    w <文件名>               将所有内容输出到指定的文件中
    q                     退出
   例：
       输入： a Hello world!
       输入： a This is a line of text.
       输入： i 2 the second line
       输入： a the last line
       输入： s
       输出： 1: Hello world!
               2: the second line
               3: This is a line of text.
               4: the last line
       输入： d 2
       输入： u
       输入： d 3
       输入： w a.txt
       输入： q

   a.txt文件的内容应当是：
       Hello world!
       the second line
       the last line

   要求：在设计时应当考虑其可扩展性，例如，日后如果需要增加新的编辑命令，应避免对已
   实现的命令的代码进行修改。

import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Scanner;

public class Test02 {
    public static void main(String[] args) {
        ArrayList<String> strList = new ArrayList<String>();
        Scanner sc = new Scanner(System.in);
        String commonBak = "";
        String deleteBak = "";
        boolean state = false;
exit:
        while (true) {
            String str = sc.nextLine();
            if (str.length() == 1 || str.substring(1, 2).equals(" ")) {
                String temp = str.substring(0, 1);
                switch (temp) {
                case "a":
                    if (str.length() == 1 || str.substring(2).equals(null)) {
                        strList.add("");
                    } else {
                        strList.add(str.substring(2));
                        state = true;
                        commonBak = str;
                    }
                    break;
                case "d":
                    if (str.length() == 1 || str.substring(2).equals(null)) {
                        System.out.println("请添加行号");
                    } else {
                        String s = str.substring(2).replaceAll(" ", "");
                        boolean flag = false;
                        for (int i = 0; i < s.length(); i++) {
                            if (java.lang.Character.isDigit((char) s.charAt(i))) {
                                flag = true;
                            } else {
                                flag = false;
                            }
                        }
                        if (flag) {
                            int line = Integer.parseInt(s);
                            if (line > strList.size()) {
                                System.out.println("行号太大，找不到指定的行");
                            } else {
                                deleteBak = strList.get(line - 1);
                                strList.remove(line - 1);
                                state = true;
                                commonBak = str;
                            }
                        } else {
                            System.out.println("指定的行号不正确");
                        }
                    }
                    break;
                case "i":
                    if (str.length() == 1 || str.substring(2).equals(null)) {
                        System.out.println("请添加行号");
                    } else {
                        String arr[] = str.split(" ");
                        boolean flag = false;
                        for (int i = 0; i < arr[1].length(); i++) {
                            if (java.lang.Character.isDigit((char) arr[1]
                                    .charAt(i))) {
                                flag = true;
                            } else {
                                flag = false;
                            }
                        }
                        if (flag) {
                            int line = Integer.parseInt(arr[1]);
                            if (line > strList.size()) {
                                System.out.println("行号太大，找不到指定的行");
                            } else {
                                String s = "";
                                for (int i = 2; i < arr.length; i++) {
                                    s = s + arr[i] + " ";
                                }
                                strList.add(line - 1, s);
                                state = true;
                                commonBak = str;
                            }
                        } else {
                            System.out.println("指定的行号不正确");
                        }
                    }
                    break;
                case "s":
                    for (int i = 0; i < strList.size(); i++) {
                        int num = i + 1;
                        System.out.println(num + "：" + strList.get(i));
                    }
                    break;
                case "u":
                    if(!state || commonBak.equals("")){
                        System.out.println("没有上一步操作，无法撤销！");
                    }else{
                        String common = commonBak.substring(0, 1);
                        switch (common){
                        case "a":
                            strList.remove(strList.size() - 1);
                            break;
                        case "d":
                            String arrD[] = commonBak.split(" ");
                            int line = Integer.parseInt(arrD[1]);
                            strList.add(line - 1, deleteBak);
                            break;
                        case "i":
                            String arrI[] = commonBak.split(" ");
                            int lineI = Integer.parseInt(arrI[1]);
                            strList.remove(lineI - 1);
                            break;
                        default:
                            break;
                        }
                    }
                    break;
                case "w":
                    String arr[] = str.split(" ");
                    File file = new File("D:/" + arr[1]);
                    PrintWriter pfp = null;
                    try {
                        pfp = new PrintWriter(file);
                        for(int i = 0; i < strList.size(); i++){
                            pfp.print(strList.get(i) + "
");
                        }
                        System.out.println("已保存在D:/" + arr[1]);
                    } catch (FileNotFoundException e) {
                        e.printStackTrace();
                    } finally {
                        pfp.close();
                    }
                    break;
                case "q":
                    System.out.println("已退出");
                    break exit;
                case "p":
                    for (int i = 0; i < strList.size(); i++) {
                        System.out.println(strList.get(i));
                    }
                    break;
                default:
                    break;
                }
            } else {
                System.out.println("请在命令后加空格");
            }
        }
    }
}

第三题：

3.归并
   编写一个方法merge，该方法的两个输入参数的类型为任意可比较大小的类型的序列，用户调
   用该方法时保证输入的两个序列都是按照升序排列好的。编写一个函数，对两个序列进行合
   并，生成一个新的序列，该序列包含两个输入序列中的所有元素，并且这些元素在合并后的
   序列中也是升序排列的。将合并后的序列返回。
    自己定义函数接口，给出函数实现，并且写出测试代码。

   例如，若选用Java语言，用户会这样使用该函数：
       List<Integer> s1 = Arrays.asList(3, 6, 7, 12);
       List<Integer> s2 = Arrays.asList(-1, 5, 14);
       List<Integer> result = merge(s1, s2);
   若使用Python语言，用户会这样使用该函数：
       s1 = [3, 6, 7, 12]
       s2 = [-1, 5, 14]
       result = merge(s1, s2)
   若使用Scala语言，用户会这样使用该函数：
       val s1 = 3 :: 6 :: 7 :: 12 :: Nil
       val s2 = -1 :: 5 :: 14 :: Nil
       val result = merge(s1, s2)

   要求：需要注意算法效率，应当保证算法的时间复杂度为O(n)，其中n是两个输入列表的长度
   和。不允许使用现成的排序方法实现。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Test03 {
    public static void main(String[] args) {
        List<Integer> s1 = Arrays.asList(3, 6, 7, 12);
        List<Integer> s2 = Arrays.asList(-1, 5, 14);
        List<Integer> result = merge(s1, s2);
        for(int i = 0; i < result.size(); i++){
            System.out.println(result.get(i));
        }
    }

    public static List merge(List s1, List s2) {
        Object obj = s1.get(0);
        if (obj instanceof Integer) {
            int[] arr = new int[s1.size() + s2.size()];
            // 合并
            for (int i = 0; i < s1.size() + s2.size(); i++) {
                if (i < s1.size()) {
                    arr[i] = (int) s1.get(i);
                } else {
                    arr[i] = (int) s2.get(i - s1.size());
                }
            }
            // 排序
            for (int i = 0; i < arr.length; i++) {
                for (int j = 0; j < arr.length; j++) {
                    // 小于号：从小到大排序；大于号：从大到小排序；
                    if (arr[i] < arr[j]) {
                        int bak = arr[j];
                        arr[j] = arr[i];
                        arr[i] = bak;
                    }
                }
            }
            // 添加到list
            List<Integer> result = new ArrayList<Integer>();
            for (int i = 0; i < arr.length; i++) {
                result.add(arr[i]);
            }
            return result;
        } else if (obj instanceof Double) {
            // 待添加
            return null;
        } else if (obj instanceof Float) {
            // 待添加
            return null;
        } else {
            return null;
        }
    }
}

第四题：

4. 消息队列
   实现一个支持多线程的消息队列，支持两种操作：
    (1) push：向队列中放置一个新的元素；
    (2) pop：从队列中取出一个元素。
   执行pop时，若队列中的元素为空，则当前线程阻塞，直到队列中有元素位置。
    自己给出接口和实现，并且写出测试代码。

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

class Test04 {
    public static void main(String[] args) {
        Server s = new Server();
        MyPush myPush = new MyPush(s);
        MyPop myPop = new MyPop(s);
        Thread t1 = new Thread(myPush);
        Thread t2 = new Thread(myPop);
        t1.start();
        t2.start();
    }
}

class Server {
    List<String> list = new ArrayList();
    int index = 0;

    public synchronized void push(String s) {
        while (index == 20) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();
        index++;
        list.add(s);
        System.out.println("添加了一行内容，现在共有" + index + "行。");
    }

    public synchronized void pop() {
        while (index == 0) {
            try {
                System.out.println("没有内容，无法获取。");
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();
        list.remove(list.size() - 1);
        index--;
        int num = index + 1;
        System.out.println("删除了第" + num + "行内容。" + "还剩" + list.size() + "行内容。");
    }
}

class MyPush implements Runnable {
    Server s = new Server();

    public MyPush(Server s) {
        this.s = s;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            s.push("test");
            try {
                Thread.sleep((int) (Math.random() * 1000));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

class MyPop implements Runnable {
    Server s = new Server();

    public MyPop(Server s) {
        this.s = s;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            s.pop();
            try {
                Thread.sleep((int) (Math.random() * 1000));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}