涉及知识点：java动态编译，java反射，io流，java文件操作，输入输出重定向，多线程与线程安全，mysql数据库设计 等，理解起来难度较高。

下面是我自己设计的几个问题，和一些测试数据。

排序问题 的 测试 数据 和 答案

测试a

输入：

5

1 5 4 3 2

输出：

1 2 3 4 5

测试b

输入

100

6 50 90 98 96 65 85 31 90 52 25 44 78 97 84 50 5 85 7 83 27 2 48 45 79 69 72 15 87 24 34 95 99 22 95 78 19 9 17 45 62 75 80 88 87 7 73 94 55 9 21 37 82 49 37 40 66 3 59 15 79 6 22 85 57 76 49 70 93 18 77 2 58 43 26 20 73 42 24 4 47 35 20 69 50 60 12 80 33 43 66 6 32 35 62 82 61 91 11 93

输出：

2 2 3 4 5 6 6 6 7 7 9 9 11 12 15 15 17 18 19 20 20 21 22 22 24 24 25 26 27 31 32 33 34 35 35 37 37 40 42 43 43 44 45 45 47 48 49 49 50 50 50 52 55 57 58 59 60 61 62 62 65 66 66 69 69 70 72 73 73 75 76 77 78 78 79 79 80 80 82 82 83 84 85 85 85 87 87 88 90 90 91 93 93 94 95 95 96 97 98 99

测试c:

数据量太大了不在展示了

数据库测试数据

案例测试代码

排序问题：

import java.util.Scanner;

public class Test {
	public static int a[],step=0,s=0;
    /**
     * 递归函数
     * @param left 数组左区间开始
     * @param right 数组右区间结束
     */
    public static void quicksort(int left, int right) {
        int i, j,temp;
        if(left > right)
            return;
        temp = a[left]; //temp中存的就是基准数
        i = left;
        j = right;
        while(i != j){ //两探针没有碰头
            while(a[j] >= temp && i < j)//顺序很重要，要先从右边开始找
                j--;
            while(a[i] <= temp && i < j)//再找右边的
                i++;       
            if(i < j){ //交换两个数在数组中的位置
                a[i] = a[i]+a[j];
                a[j] = a[i]-a[j];
                a[i] = a[i]-a[j];
            }
        }
        //最终将基准数归位
        a[left] = a[i];
        a[i] = temp;
        s++;
        if(s>step) {//计算递归深度
            step=s;
        }
        quicksort(left, i-1);//继续递归处理左区间数据
        quicksort(i+1, right);//继续递归处理右区间数据
        s--;
    }
    public static void main(String[] args) {
    	Scanner s=new Scanner(System.in);
    	int n=s.nextInt();
    	a= new int[n];
    	for(int i=0;i<n;i++) {
    		a[i]=s.nextInt();
    	}
        quicksort(0,a.length-1);
        for(int i=0;i<a.length;i++)
            System.out.print(a[i] + " ");
    }
}

渗透问题：

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Test5Controller {
    //上下左右四个方向的增量
    static int move[][]=new int[][] {{0,0},{0,1},{1,0},{0,-1},{-1,0}};
    static int t[][]=null;
    public static void main(String[] args) {
    	Scanner s=new Scanner(System.in);
    	int n=s.nextInt();
    	int m=s.nextInt();
    	t=new int[n][m];
    	for(int i=0;i<t.length;i++) {
    		for(int j=0;j<t.length;j++) {
        		t[i][j]=s.nextInt();
        	}
    	}
        List<Node> li=new ArrayList<>();
        //先将开始时所有的墨水放入集合
        for(int i=0;i<t.length;i++) {
            for(int j=0;j<t[i].length;j++) {
                if(t[i][j]==2) {
                    li.add(new Node(i,j,2));
                }
            }
        }
        //总时间c
        int c=0;
        do {
            li=search(li);
            if(li.size()>0) {
                //如果集合里面有数据，那就向外扩散一次
                c++;
            }else {
                break;
            }
        }while(true);
         
        /**
         * 看是否所有的纸都被染色
         */
        for(int i=0;i<t.length;i++) {
            for(int j=0;j<t[i].length;j++) {
                if(t[i][j]==1) {
                    System.out.println("false");
                    return;
                }
            }
        }
        System.out.println(c);
    }
     
    public static List<Node> search(List<Node> list){
        List<Node> li=new ArrayList<>();
        /**
         * 遍历每个周围节点
         */
        for(Node n:list) {
            /**
             * 遍历每个节点的四个方向
             */
            for(int i=1;i<=4;i++) {
                int x=n.x+move[i][0];
                int y=n.y+move[i][1];
                //控制边界
                if(x<t.length&&y<t[0].length&&t[x][y]==1) {
                    t[x][y]=2;
                    li.add(new Node(x,y,t[x][y]));
                }
            }
        }
        return li;
    }
    /**
     *    模拟节点类
     */
    static class Node{
        public int x;//数组横坐标
        public int y;//数组纵坐标
        public int d;//数据
        public Node(int x, int y, int d) {
            super();
            this.x = x;
            this.y = y;
            this.d = d;
        }
        @Override
        public String toString() {
            return "Node [x=" + x + ", y=" + y + ", d=" + d + "]";
        }
    }
}

项目导入运行

项目的结构比较简单，采用springboot框架

压缩包中附项目sql脚本，导入数据库即可

本地访问地址：http://localhost:8086/page