package com.dwx.passage2;

public class RandomizedSelect {

    //正常来说 我们操作的都是整数数组
    private int list[];
    //我们使用的是private私有对象 因此需要编写get/set方法来设置和获取值

    public int[] getList() {
        return list;
    }

    public void setList(int[] list) {
        this.list = list;
    }

    //快速排序的思路是将第一个作为端点 但是我们这里使用一个随机数来获得端点
    /*
    参数表：
    start：列表要查询的开始
    end：列表查询的结束
    find：我们要查询的第几小
     */

    public int RandomizedSelect(int start,int end,int find){
        //编写程序结束程序
        //如果开始等于结束 我们没有什么课选的了 就选择到了合适的数据
        if (start==end){
            //这个就是我们找到的第几小的结果
            return list[start];
        }
        int i = RandomQuickSort(start,end);
        //比较我们得到的这个第几小和我们的目标小又什么区别
        //如果i大 则说明我们要找的find在划分后的后边
        //则将我们的起始地址设置为i+1,结束还是end，此时我们要找find-i小
        //注意 我们这里的j 因为 我们的start 不一定就是从零开始的 因此 我们选择后的第几小 就需要用find-j
        int j = i-start+1;
        if (find<=j){
            return RandomizedSelect(start,i,find);
        }else {
            return RandomizedSelect(i+1,end,find-j);
        }
    }


    //这个程序是对我们需要的list的一段进行一次快排 二我们快排的结果是随机的 通过random来获得我们的基准元素
    public int RandomQuickSort(int start,int end){
        //我们这里只需要一个开始和一个结束
        //获得一个随机数 在start和end之间
        //我们这里的随机数要设置好
        int n = (int)(Math.random()*100)%(end-start)+start;
        System.out.println("这里我们将第"+n+"个元素作为基准元素");
        //将我们的基准元素存储起来

        int t = list[n];
        list[n] = list[start];
        list[start] = t;
        int i,j;
        //我们准备进行快排
        i = start;
        j = end;
        //快速排序的思想就是把比基准元素小的都放在左边
        //把比基准元素大的都放在右边 然后把基准元素归位
        while (i != j){
            //先让右哨兵动 找到合适数据后才停止
            while (list[j]>=t && j>i){
                j--;
            }
            //说明右哨兵已经选择好了 使左哨兵开始动
            while (list[i]<=t && i<j){
                i++;
            }
            //两个哨兵都找到了 交换数据
            if (i<j) {
                int temp = list[i];
                list[i] = list[j];
                list[j] = temp;
            }

        }
        //将我们的基准元素放到合适的地方
        list[start] = list[i];
        list[i] = t;
        //我们找到的i就是我们这一次找到的目的元素所在的位置(即第几小)
        return i;
    }
}

import com.dwx.passage2.RandomizedSelect;

import java.util.Scanner;

public class RandomSelectTest {
    public static void main(String[] args) {
        RandomizedSelect select = new RandomizedSelect();
        //选择我们的一个list
        int[] list = new int[]{13,45,85,63,21,54,96,35,74,84,9,6,3,8,5};

        System.out.println("我们的无序数组的长度"+list.length);
        select.setList(list);
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入我们要选择第几小:");
        int find = scanner.nextInt();
        int i = select.RandomizedSelect(0, list.length - 1, find);
        System.out.println("我们找到的数据"+i);

        System.out.println("====================================");
        for (int i1 : list) {
            System.out.print(i1+"\t");
        }
        System.out.println();
        System.out.println("====================================");
        //这里设置一个简单排序来检测结果的正确性
        int[] query = query(list);

        for (int i1 : query) {
            System.out.print(i1+"\t");
        }
        System.out.println();
        System.out.println("理论上我们的目标值"+list[find-1]);

    }

    //下边我们写一个冒泡排序 把我们的list进行一个排序 看看是否我们的答案和我们的找到的数据相同
    public static int[] query(int[] list){
        //冒泡排序
        int i;
        int j;
        int temp;
        //冒泡排序的思想是 每次找到一个最小的放在应该最小的位置
        int min;
        for (i=0;i<list.length;i++){
            min = i;
            for (j=i;j<list.length;j++){
                if (list[j] < list[min]){
                    //记录找到的最小的数的下标
                    min = j;
                }
            }
//            if (i!=min) {
                temp = list[min];
                list[min] = list[i];
                list[i] = temp;
//            }

        }
        return list;
    }
}

package com.dwx.passage2;

public class ChessBoard {

    //这里我们写一个二维整数数组
    private int Board[][];
    //全局变量 表示
    int title = 0;

    public void setBoard(int[][] board) {
        Board = board;
    }

    public int[][] getBoard() {
        return Board;
    }

    //我们使用的还是使用递归算法
    public void ChessBoard(int tr, int tc, int dr, int dc, int size){
        //这里 tr ,tc表示棋盘左上角的编号（行和列
        //dr dcr表示特殊方块所在的地方
        //size表示棋盘的大小

        //程序结束的条件 已经不能在分了
        if (size == 1){
            return ;
        }
        //增加一个骨牌编号
        int t = title++;
        int s = size/2;
        if (dr<tr+s && dc < tc+s){
            //说明特殊方块在七班左上角
            ChessBoard(tr,tc,dr,dc,s);
        }else {
            //如果没在 则把左上角棋盘的左上角变成特殊棋盘
            Board[tr+s-1][tc+s-1] = t;
            ChessBoard(tr,tc,tr+s-1,tc+s-1,s);
        }
        //同理 操作其他的三个子棋盘
        //这个是第
        if (dr<tr+s && dc >= tc+s){
            ChessBoard(tr,tc+s,dr,dc,s);
        }else {
            Board[tr+s-1][tc+s] = t;
            ChessBoard(tr,tc+s,tr+s-1,tc+s,s);
        }
        if (dr>=tr+s && dc < tc+s){

            ChessBoard(tr+s,tc,dr,dc,s);
        }else {
            Board[tr+s][tc+s-1] = t;
            ChessBoard(tr+s,tc,tr+s,tc+s-1,s);
        }
        if (dr>=tr+s && dc >= tc+s){

            ChessBoard(tr+s,tc+s,dr,dc,s);
        }else {
            Board[tr+s][tc+s] = t;
            ChessBoard(tr+s,tc+s,tr+s,tc+s,s);
        }

    }
}

import com.dwx.passage2.ChessBoard;

public class BoardTest {
    public static void main(String[] args) {
        //现在开一个4*4的二维整数数组
        int[][] board = new int[4][4];
        //期初都是0
        for (int[] ints : board) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        //添加一个特殊方块 这里我们选择使用随机函数 我们把特殊方块设为9
        //产生o-3的随机数
         int x =  (int)(Math.random()*10)%4;
         int y =  (int)(Math.random()*10)%4;
        System.out.println("特殊块的所在:"+"("+x+","+y+")");
        board[x][y] = 9;
        //修改过的棋盘
        for (int[] ints : board) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        //调用算法 填充棋盘

        ChessBoard board1 = new ChessBoard();
        //先把我们的目的board设置进去
        board1.setBoard(board);
        //调用方法处理
        board1.ChessBoard(0,0,x,y,4);
        //获得调整过的board
        int[][] board2 = board1.getBoard();
        System.out.println("==========结果=========");
        //输出调整过的棋盘
        for (int[] ints : board2) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

    }
}

0	0	0	0	
0	0	0	0	
0	0	0	0	
0	0	0	0	
特殊块的所在:(1,1)
0	0	0	0	
0	9	0	0	
0	0	0	0	
0	0	0	0	
==========结果=========
1	1	2	2	
1	9	0	2	
3	0	0	4	
3	3	4	4	

package com.dwx.passage2;

public class Dijkstar {
    public static void main(String[] args) {

        int[] dis = new int[10];
        int[] book = new int[10];
        int i,j,n,u = 0,v,min;
        int inf = 99999999;

        int e[][] = new int[][]{
                {0,2,1,8,inf,inf,inf,inf},
                {2,0,inf,6,1,inf,inf,inf},
                {1,inf,0,7,inf,inf,9,inf},
                {8,6,7,0,5,1,2,inf},
                {inf,1,inf,5,0,3,inf,9},
                {inf,inf,inf,1,3,0,4,6},
                {inf,inf,9,2,inf,4,0,3},
                {inf,inf,inf,inf,9,6,3,0}
        };
        n = e[0].length-1;



        //初始化dis数组  这里是记录源点到其他各点的最短距离的
        for (i=0;i<=n;i++){
            dis[i] = e[0][i];
        }

        //初始化book数组 book数组是记录已经被放入最短路径集合的点
        for (i=0;i<=n;i++){
            book[i] = 0;
        }
        //将第一个点（源点）放入book数组中
        book[0] = 1;
        //Dijkstra算法的核心
        for (i=0;i<=n-1;i++){
            min = inf;
            //找到距离源点最短的点
            for (j=0;j<=n;j++){
                if (book[j] == 0 && dis[j]<min){
                    min = dis[j];
                    u = j;
                }
            }
            //将这个点读到book数组中
            book[u] = 1;
            for (v=0;v<=n;v++){
                //收缩调整最短路径
                if (e[u][v] < inf){
                    if (dis[v]>dis[u]+e[u][v]){
                        dis[v] = dis[u]+e[u][v];
                    }
                }
            }

        }
        for (int di : dis) {
            System.out.print(di+"\t");
        }



    }


}

package com.dwx.passage2;

import java.util.Scanner;

public class Dijkstra {
    public static void main(String[] args) {
        int[][] e = new int[10][10];
        int[] dis = new int[10];
        int[] book = new int[10];
        int i,j,n,m,t1,t2,t3,u = 0,v,min;
        int inf = 99999999;


        //这个操作是在实现存储图
        //读入顶点个数 和 边的条数
        Scanner scanner = new Scanner(System.in);
        //n表示顶点个数 m表示边数
        n = scanner.nextInt();
        m = scanner.nextInt();

        //初始化 将自己到自己的顶点为0 其他的全改为inf
        for(i = 1;i <= n;i++){
            for (j = 1;j<=n;j++){
                if (i == j){
                    e[i][j] = 0;
                }else {
                    e[i][j] = inf;
                }

            }
        }


        //读入边和权值
        //这里我们使用的是有向边
        for (i = 1; i <= m;i++){
            //这里 t1表示起始的顶点 t2表示目标定点 t3表示权值
            t1 = scanner.nextInt();
            t2 = scanner.nextInt();
            t3 = scanner.nextInt();
            e[t1][t2] = t3;
            // e[t2][t1] = t3; //如果加上这一句话 就是在储存无向图
        }
        //初始化dis数组  这里是记录源点到其他各点的最短距离的
        for (i=1;i<=n;i++){
            dis[i] = e[1][i];
        }

        //初始化book数组 book数组是记录已经被放入最短路径集合的点
        for (i=1;i<=n;i++){
            book[i] = 0;
        }
        //将第一个点（源点）放入book数组中
        book[1] = 1;
        //Dijkstra算法的核心
        for (i=1;i<=n-1;i++){
            min = inf;
            //找到距离源点最短的点
            for (j=1;j<=n;j++){
                if (book[j] == 0 && dis[j]<min){
                    min = dis[j];
                    u = j;
                }
            }
            //将这个点读到book数组中
            book[u] = 1;
            for (v=1;v<=n;v++){
                //收缩调整最短路径
                if (e[u][v] < inf){
                    if (dis[v]>dis[u]+e[u][v]){
                        dis[v] = dis[u]+e[u][v];
                    }
                }
            }

        }
        for (int di : dis) {
            System.out.print(di+"\t");
        }



    }
}

**输入**
    6 9
1 2 1
1 3 12
2 3 9
2 4 3
3 5 5
4 3 4
4 5 13
4 6 16
5 6 4

package com.dwx.file;


import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

import java.io.File;
import java.io.FileInputStream;

public class ReadExlse {
    public static void main(String[] args) throws Exception {

        //正常的文件类File无法读取Excel文件，需要使用Apache的包
        //Excel的全路径
        String path = "E:\\java\\filetest\\src\\main\\java\\com\\dwx\\file\\test.xlsx";
        File file = new File(path);
        System.out.println(file.isFile());
        //对文件进行操作 将文件转化成流
        FileInputStream stream = new FileInputStream(file);
        //对这个文件流进行操作
        //创建这个Excel的对象
        XSSFWorkbook sheets = new XSSFWorkbook(stream);

        //获取全部的sheets数
        int numberOfSheets = sheets.getNumberOfSheets();
        System.out.println("================================================");
        System.out.println("此文件的所有表格数为："+numberOfSheets);
        System.out.println("================================================");
        for (int k=0;k<numberOfSheets;k++) {
            System.out.println("这是第"+(k+1)+"个表格");
            XSSFSheet sheetAt = sheets.getSheetAt(k);

            int firstRowNum = sheetAt.getFirstRowNum();
            int lastRowNum = sheetAt.getLastRowNum();
            System.out.println(firstRowNum);
            System.out.println(lastRowNum);

            for (int i = firstRowNum; i <= lastRowNum; i++) {
                XSSFRow row = sheetAt.getRow(i);
             if (row==null){
                 System.out.println("         ");
                 continue;
             }

                short lastCellNum = row.getLastCellNum();
                short firstCellNum = row.getFirstCellNum();
               if (lastCellNum < 0 || firstCellNum < 0){
                   continue;
               }

                for (int j = firstCellNum; j <= lastCellNum; j++) {
                    XSSFCell cell = row.getCell(j);
                    System.out.print(cell + "\t");
                }
                System.out.println();
            }
        }
        //关闭流
        sheets.close();
        stream.close();

    }
}

package com.dwx.file;

import org.apache.poi.xssf.usermodel.*;


import java.io.FileOutputStream;
import java.io.IOException;

public class WriteExlse {
    //这个程序是一个写Excel的程序 面向的尾缀也是xlsx
    public static void main(String[] args) throws IOException {
        String fileName = "C:\\Users\\Lenovo\\Desktop\\监审软件编译"+"\\MyExlse"+".xlsx";
        String sheetName = "sheet01";

        //设置一个sheets
        XSSFWorkbook sheets = new XSSFWorkbook();
        //设置第一个表的表格
        //设置第一个表的row数目
        int firstRowNumber = 0;
        int lastRowNumber = 10;
        int firstCellNumber = 0;
        int lastCellNumber = 5;
        //一个整个Excel文件创建一个表
        XSSFSheet sheet = sheets.createSheet(sheetName);
        XSSFRow xssfRow;
        XSSFCell xssfCell;

        for (int i=firstRowNumber;i<lastRowNumber;i++){

            //表给某一行设置一个行
            XSSFRow row = sheet.createRow(i);

            for (int j=firstCellNumber;j<lastCellNumber;j++){
                //对这个行设置更多的cell（小室）
                XSSFCell cell = row.createCell(j);
                //给这个cell（小室）设置值
                cell.setCellValue("test");
            }


        }
        //编写一个输出流
        FileOutputStream stream = new FileOutputStream(fileName);
        //把流写出去 一个sheets Excel表写出去
        sheets.write(stream);


    }
}

package com.dwx.file;

import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class minban_fengmian {
    public XSSFSheet setminban_fengmain(XSSFWorkbook sheets){


        //设置民办封面
        //创建一个sheet
        XSSFSheet sheet = sheets.createSheet("封面");
        //封面的第一行是空着的
        int i;
        XSSFRow xssfRow;
        XSSFCell xssfCell;
        // 申请第一行 行和列都是从零开始的
        XSSFRow row = sheet.createRow(0);
        CellRangeAddress cellAddresses1 = new CellRangeAddress(0, 0, 0, 1);
        sheet.addMergedRegion(cellAddresses1);
        //第一行是四个cell
        for ( i = 0;i<4;i++){
            XSSFCell cell = row.createCell(i);
            //第一行都是空着的 因此我们也把这个值设成空值
            cell.setCellValue("");
        }

        //下边编写第二行
        //第二行只用一列
        //设置单元格的合并
        CellRangeAddress cellAddresses = new CellRangeAddress(1, 1, 0, 5);
        sheet.addMergedRegion(cellAddresses);
        XSSFRow row1 = sheet.createRow(1);
        XSSFCell cell = row1.createCell(0);
        cell.setCellValue("新乡市民办学校教育定价成本监审表");

        //第三行是一个空格行
        CellRangeAddress cellAddresses2 = new CellRangeAddress(2, 2, 0, 5);
        sheet.addMergedRegion(cellAddresses2);
        XSSFRow row2 = sheet.createRow(2);
        XSSFCell cell1 = row2.createCell(0);
        cell1.setCellValue("");
        //为第五后的合并单元格
        for (i=3;i<=11;i++){
            CellRangeAddress cellAddresses4 = new CellRangeAddress(i, i, 2, 4);
            sheet.addMergedRegion(cellAddresses4);
        }
        //第五航到第12行
        String[] name = new String[]{"学 校 名 称","法 定人 代 表","学 校 地 址","邮 政 编 码","财务负责人","填  表  人","电     话  ","邮     箱","传     真 "};
        for (i = 3;i<=11; i++){
            XSSFRow row4 = sheet.createRow(i);
            XSSFCell cell4 = row4.createCell(1);
            cell4.setCellValue(name[i-3]);

        }
        //第十三行是空格行
        sheet.createRow(12);
        //第十四行
        XSSFRow row3 = sheet.createRow(13);
        XSSFCell cell2 = row3.createCell(3);
        cell2.setCellValue("学校盖章");
        CellRangeAddress cellAddresses3 = new CellRangeAddress(13, 13, 3, 4);
        sheet.addMergedRegion(cellAddresses3);
        //第十五行

        XSSFRow row4 = sheet.createRow(14);
        XSSFCell cell3 = row4.createCell(3);
        cell3.setCellValue("          年");

        XSSFCell cell4 = row4.createCell(4);
        cell4.setCellValue("     月           日");

        //一下是对表格的宽度等的优化

        //设置列宽

        sheet.setColumnWidth(0, 258*23+184);
        sheet.setColumnWidth(1, 258*23+184);
        sheet.setColumnWidth(3, 258*13+184);
        sheet.setColumnWidth(4, 258*13+184);
        sheet.setColumnWidth(5, 258*28+184);

        //设置行高
        sheet.setDefaultRowHeight((short) 456);




        return sheet;
    }
}

package com.dwx.file;

import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class minban_biaoyi {
    public XSSFSheet setSheet(XSSFWorkbook sheets){

        String sheetName = "基本情况表1";
        XSSFSheet sheet = sheets.createSheet(sheetName);


        //编写第一行的内容
        XSSFRow row = sheet.createRow(0);
        XSSFCell cell = row.createCell(0);
        cell.setCellValue("表：一");

        //编写第二行的内容
        //第二行是从A到L有一个合并单元格
        CellRangeAddress cellAddresses = new CellRangeAddress(1, 1, 0, 11);
        sheet.addMergedRegion(cellAddresses);
        XSSFRow row1 = sheet.createRow(1);
        XSSFCell cell1 = row1.createCell(0);

        cell1.setCellValue("XXX学校教育定价成本监审学生人数调查表");
        //第三行也是一个大的合并单元格
        CellRangeAddress cellAddresses2 = new CellRangeAddress(2, 2, 0, 11);
        sheet.addMergedRegion(cellAddresses2);
        XSSFRow row2 = sheet.createRow(2);
        XSSFCell cell2 = row2.createCell(0);

        cell2.setCellValue("学校名称：（盖章）");
        //第四五行有一个不规律的合并单元格
        CellRangeAddress cellAddresses1 = new CellRangeAddress(3, 4, 0, 0);
        CellRangeAddress cellAddresses6 = new CellRangeAddress(3, 4, 1, 1);
        CellRangeAddress cellAddresses3 = new CellRangeAddress(3, 4, 8, 8);
        CellRangeAddress cellAddresses4 = new CellRangeAddress(3, 4, 9, 9);
        CellRangeAddress cellAddresses5 = new CellRangeAddress(3, 4, 10, 10);
        CellRangeAddress cellAddresses7 = new CellRangeAddress(3, 4, 11, 11);
        sheet.addMergedRegion(cellAddresses1);
        sheet.addMergedRegion(cellAddresses6);
        sheet.addMergedRegion(cellAddresses3);
        sheet.addMergedRegion(cellAddresses4);
        sheet.addMergedRegion(cellAddresses5);
        sheet.addMergedRegion(cellAddresses7);
        //又有一系列小的横向合并
        for (int i=2;i<8;i=i+2){
            CellRangeAddress cellAddresses8 = new CellRangeAddress(3, 3, i, i + 1);
            sheet.addMergedRegion(cellAddresses8);
        }
        //给第4、5行填值

        XSSFRow row3 = sheet.createRow(3);
        row3.createCell(0).setCellValue("项          目");
        row3.createCell(1).setCellValue("栏次及关系");
        row3.createCell(8).setCellValue("总监审数");
        row3.createCell(9).setCellValue("教育生均监审数");
        row3.createCell(10).setCellValue("住宿生均监审数");
        row3.createCell(11).setCellValue("备注");
        row3.createCell(2).setCellValue("2019年");
        row3.createCell(4).setCellValue("2020年");
        row3.createCell(6).setCellValue("2021年");

        XSSFRow row4 = sheet.createRow(4);
        for (int j = 2;j<=7;j++){
            if (j%2 == 0){
                row4.createCell(j).setCellValue("申报数");
            }else {
                row4.createCell(j).setCellValue("核定数");
            }
        }

        //对于表二 固定的值为两个列
        //使用数组的思路进行存值
        String[] list1 = new String[]{
                     "一、规模班数" ,
                        "小学" ,
                        "初中" ,
                        "高中" ,
                        "二、班人数" ,
                        "小学（人/班" ,
                        "初中（人/班" ,
                        "高中（人/班" ,
                        "三、规模人数" ,
                        "小学" ,
                        "初中" ,
                        "高中" ,
                        "四、实际班级数（个）" ,
                        "小学" ,
                        "初中" ,
                        "高中" ,
                        "五、实际在校平均标准学生数" ,
                        "（一）小学标准学生数" ,
                        "其中：年初学生数" ,
                        "         年末学生数" ,
                        "（二）初中标准学生数" ,
                        "其中：年初学生数" ,
                        "         年末学生数" ,
                        "（三）高中标准学生数" ,
                        "其中：年初学生数" ,
                        "         年末学生数" ,
                        "六、实际在校平均住宿标准学生数" ,
                        "（一）小学标准住宿学生数" ,
                        "其中：年初学生数" ,
                        "         年末学生数" ,
                        "（二）初中标准住宿学生数" ,
                        "其中：年初学生数" ,
                        "         年末学生数" ,
                        "（三）高中标准住宿学生数" ,
                        "其中：年初学生数" ,
                        "         年末学生数"
        };
        int listLength,b;
        //
        listLength = list1.length;
        for (b=0;b<listLength;b++){
            XSSFRow row5 = sheet.createRow(b+5);
            row5.createCell(0).setCellValue(list1[b]);
            row5.createCell(1).setCellValue(b+1);

        }

        //填充L列备注的填充
        //L列有几个单元格的合并
        sheet.addMergedRegion(new CellRangeAddress(6,8,11,11));
        sheet.addMergedRegion(new CellRangeAddress(10,12,11,11));
        sheet.addMergedRegion(new CellRangeAddress(14,16,11,11));
        sheet.addMergedRegion(new CellRangeAddress(18,20,11,11));
        sheet.addMergedRegion(new CellRangeAddress(22,30,11,11));
        sheet.addMergedRegion(new CellRangeAddress(32,40,11,11));

        //给备注填值

        int [] rowNumber = new int[]{5,6,9,10,14,18,22,32};

        String[] rowValue = new String[]{
                "建校时可容纳班级数" ,
                        "2019-2020年填写“双减”前规模数；2021年按“双减”后规模数填写。" ,
                        "建校时每班人数" ,
                        "2019-2020年填写“双减”前规模数；2021年按“双减”后规模数填写。" ,
                        "规模人数=规模班数X班级人数" ,
                        "纸质说明每个年级多少个班？" ,
                        "按实际在校学生人数填写，或按三年学籍人数纸质上报。",
                        "按实际在校住宿学生人数填写。"
        };
        for (int o=0;o<=7;o++){
            sheet.getRow(rowNumber[o]).createCell(11).setCellValue(rowValue[o]);
        }

        //内容填充部分已经全部填写完毕 开始设置表格的列宽
        sheet.setColumnWidth(0,258*36+184);
        sheet.setColumnWidth(1,258*22+184);
        sheet.setColumnWidth(11,258*66+184);



        return sheet;
    }
}

package com.dwx.file;

import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class minban_biaoer {

    public XSSFSheet setSheet(XSSFWorkbook sheets){

        //创建子表格 并且给其附上名字
        String sheetName = "基本情况表2";
        XSSFSheet sheet = sheets.createSheet(sheetName);


        //编写第一行的内容
        XSSFRow row = sheet.createRow(0);
        XSSFCell cell = row.createCell(0);
        cell.setCellValue("表：二");

        //编写第二行的内容
        //第二行是从A到L有一个合并单元格
        CellRangeAddress cellAddresses = new CellRangeAddress(1, 1, 0, 11);
        sheet.addMergedRegion(cellAddresses);
        XSSFRow row1 = sheet.createRow(1);
        XSSFCell cell1 = row1.createCell(0);

        cell1.setCellValue("新乡市民办学校教育定价成本监审其它情况调查表");
        //第三行也是一个大的合并单元格
        CellRangeAddress cellAddresses2 = new CellRangeAddress(2, 2, 0, 11);
        sheet.addMergedRegion(cellAddresses2);
        XSSFRow row2 = sheet.createRow(2);
        XSSFCell cell2 = row2.createCell(0);

        cell2.setCellValue("学校名称：（盖章）                                                                                                  单位：人");

        //第四五行有一个不规律的合并单元格
        CellRangeAddress cellAddresses1 = new CellRangeAddress(3, 4, 0, 0);
        CellRangeAddress cellAddresses6 = new CellRangeAddress(3, 4, 1, 1);
        CellRangeAddress cellAddresses3 = new CellRangeAddress(3, 4, 8, 8);
        CellRangeAddress cellAddresses4 = new CellRangeAddress(3, 4, 9, 9);
        CellRangeAddress cellAddresses5 = new CellRangeAddress(3, 4, 10, 10);
        CellRangeAddress cellAddresses7 = new CellRangeAddress(3, 4, 11, 11);
        sheet.addMergedRegion(cellAddresses1);
        sheet.addMergedRegion(cellAddresses6);
        sheet.addMergedRegion(cellAddresses3);
        sheet.addMergedRegion(cellAddresses4);
        sheet.addMergedRegion(cellAddresses5);
        sheet.addMergedRegion(cellAddresses7);
        //又有一系列小的横向合并
        for (int i=2;i<8;i=i+2){
            CellRangeAddress cellAddresses8 = new CellRangeAddress(3, 3, i, i + 1);
            sheet.addMergedRegion(cellAddresses8);
        }
        //给第4、5行填值

        XSSFRow row3 = sheet.createRow(3);
        row3.createCell(0).setCellValue("项          目");
        row3.createCell(1).setCellValue("栏次及关系");
        row3.createCell(8).setCellValue("总监审数");
        row3.createCell(9).setCellValue("教育生均监审数");
        row3.createCell(10).setCellValue("住宿生均监审数");
        row3.createCell(11).setCellValue("备注");
        row3.createCell(2).setCellValue("2019年");
        row3.createCell(4).setCellValue("2020年");
        row3.createCell(6).setCellValue("2021年");

        XSSFRow row4 = sheet.createRow(4);
        for (int j = 2;j<=7;j++){
            if (j%2 == 0){
                row4.createCell(j).setCellValue("申报数");
            }else {
                row4.createCell(j).setCellValue("核定数");
            }
        }

        String[] listC1 = new String[]{
                "一、教职工总数" ,
                        "（一）行政管理人数 " ,
                        "（二）小学教师人员数" ,
                        "（三）初中教师人员数" ,
                        "（四）高中教师人员数" ,
                        "（五）宿管人员数" ,
                        "（六）餐厅人员数" ,
                        "（七）其他辅助人员数" ,
                        "（八）临时人员 " ,
                        "二、总建筑面积" ,
                        "（一）教学建筑面积" ,
                        "小学" ,
                        "初中" ,
                        "高中" ,
                        "共用建筑面积" ,
                        "（二）住宿面积" ,
                        "小学" ,
                        "初中" ,
                        "高中" ,
                        "（三）餐厅面积" ,
                        "三、年收入" ,
                        "学费收入" ,
                        "餐厅收入" ,
                        "其它收入",
                        "四、现执行收费标准"
        };
        String[] listC10 = new String[]{
                "" ,
                        "指校长、学生科、教导处、会计室、维修人员等",
                        "" ,
                        "" ,
                        "" ,
                        "" ,
                        "" ,
                        "保洁、保安和其它人员" ,
                        "低质说明从事什么岗位，工资如何发放。" ,
                        "" ,
                        "" ,
                        "" ,
                        "" ,
                        "" ,
                        "指大门、厕所等共用设施" ,
                        "" ,
                        "" ,
                        "" ,
                        "" ,
                        "" ,
                        "" ,
                        "" ,
                        "" ,
                        "" ,
                        "单位：元/生.年"
        };
        int listC1Length = listC1.length;
        int i;
        for (i=0;i<listC1Length;i++){
            XSSFRow row5 = sheet.createRow(i + 5);
            row5.createCell(0).setCellValue(listC1[i]);
            row5.createCell(1).setCellValue(i+1);
            row5.createCell(11).setCellValue(listC10[i]);
        }

        //内容填充部分已经全部填写完毕 开始设置表格的列宽
        sheet.setColumnWidth(0,258*36+184);
        sheet.setColumnWidth(1,258*22+184);
        sheet.setColumnWidth(11,258*66+184);


        return sheet;
    }
}

package com.dwx.file;

import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class minban_biaosan {

    public XSSFSheet setSheet(XSSFWorkbook sheets){

        //创建的子表格的名字
        String sheetName = "三年审计报告表3";
        XSSFSheet sheet = sheets.createSheet(sheetName);

        //编写第一行的内容
        XSSFRow row = sheet.createRow(0);
        XSSFCell cell = row.createCell(0);
        cell.setCellValue("表三");
        //编写第二行的内容
        //第二行是从A到L有一个合并单元格
        CellRangeAddress cellAddresses = new CellRangeAddress(1, 1, 0, 10);
        sheet.addMergedRegion(cellAddresses);
        XSSFRow row1 = sheet.createRow(1);
        XSSFCell cell1 = row1.createCell(0);

        cell1.setCellValue("新乡市xxx学校审计数基本情况表");

        //第四五行有一个不规律的合并单元格
        CellRangeAddress cellAddresses1 = new CellRangeAddress(2, 3, 0, 0);
        CellRangeAddress cellAddresses2 = new CellRangeAddress(2, 3, 10, 10);
        sheet.addMergedRegion(cellAddresses1);
        sheet.addMergedRegion(cellAddresses2);

        //又有一系列小的横向合并
        for (int i=1;i<=9;i=i+3){
            CellRangeAddress cellAddresses8 = new CellRangeAddress(2, 2, i, i + 2);
            sheet.addMergedRegion(cellAddresses8);
        }
        //给第4、5行填值

        XSSFRow row3 = sheet.createRow(2);
        row3.createCell(0).setCellValue("");
        row3.createCell(1).setCellValue(2019);
        row3.createCell(4).setCellValue(2020);
        row3.createCell(7).setCellValue(2021);



        XSSFRow row2 = sheet.createRow(3);
        for (int j = 1;j<=9;j++){
            if (j%3 == 0){
                row2.createCell(j).setCellValue("申报数");
            }else if (j%3 == 2){
                row2.createCell(j).setCellValue("核增核减数");
            }else {
                row2.createCell(j).setCellValue("审计数");
            }
        }
        row3.createCell(10).setCellValue("备注");


        //第一列的所有数据
        String[] listC1  = new String[]{
            "一、人员支出" ,
                    "1、行政和其它人员" ,
                    "2、教师" ,
                    "3、宿管人员" ,
                    "4、社会保障费" ,
                    "5、福利费" ,
                    "（一）小学人员支出",
                    "1、行政和其它人员" ,
                    "2、教师",
                    "3、宿管人员" ,
                    "4、社会保障费" ,
                    "5、福利费" ,
                    "（二）初中人员支出" ,
                    "1、行政和其它人员" ,
                    "2、教师" ,
                    "3、宿管人员" ,
                    "4、社会保障费" ,
                    "5、福利费" ,
                    "（三）高中人员支出" ,
                    "1、行政和其它人员" ,
                    "2、教师" ,
                    "3、宿管人员" ,
                    "4、社会保障费" ,
                    "5、福利费" ,
                    "二、租赁费" ,
                    "（一）小学租赁费" ,
                    "小学教学" ,
                    "小学住宿" ,
                    "（二）初中租赁费" ,
                    "初中教学" ,
                    "初中住宿" ,
                    "（三）高中租赁费" ,
                    "高中教学" ,
                    "高中住宿" ,
                    "三、财务费用" ,
                    "（一）小学财务费用" ,
                    "小学教学" ,
                    "小学住宿" ,
                    "（二）初中财务费用" ,
                    "初中教学" ,
                    "初中住宿" ,
                    "（三）高中财务费用" ,                    "高中教学\n" ,
                    "高中住宿" ,
                    "四、公用支出" ,
                    "1、办公费" ,
                    "2、水电费" ,
                    "3、维修费" ,
                    "4、职工教育经费" ,
                    "5、工会经费" ,
                    "6、招待费" ,
                    "7、交通费" ,
                    "8、" ,
                    "9、" ,
                    "10、" ,
                    "11、" ,
                    "12、" ,
                    "13、" ,
                    "14、" ,
                    "15、其它费用" ,
                    "五、合计" ,
                    "六、固定资产原值"
        };
        int listNumber = listC1.length;
        int i ;
        for (i=0;i<listNumber;i++){
            XSSFRow row5 = sheet.createRow(i + 4);
            row5.createCell(0).setCellValue(listC1[i]);
        }

        //设置第K列的数据 K列有很多的合并单元格先合并单元格
        int[] list1 = new int[]{10,29,39,48};
        int[] list2 = new int[]{17,8,8,15};
        for (int j = 0;j<4;j++){
            CellRangeAddress cellAddresses3 = new CellRangeAddress(list1[j],list1[j]+list2[j], 10, 10);
            sheet.addMergedRegion(cellAddresses3);
        }
        //为底k列设值
        int[] list3 = new int[]{10,28,29,38,39,48,64,65};
        //设置值
        String[] listK = new String[]{
                "提供2021全体人员工资发放表" ,
                        "提供三年租赁合同" ,
                        "按建筑面积比或学生比分摊" ,
                        "提供金融机构贷款合同" ,
                        "按建筑面积比或学生比分摊" ,
                        "根据审计报告科目，可增加科目或另行加行。" ,
                        "和审计报告数是否一致？" ,
                        "和审计报告数一致"
        };
        for (i = 0;i<=7;i++){
            sheet.getRow(list3[i]).createCell(10).setCellValue(listK[i]);

        }
        //设置表格宽
        sheet.setColumnWidth(0,256*32+184);
        sheet.setColumnWidth(10,256*30+184);



        return sheet;
    }
}

package com.dwx.file;

import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class minban_biaosi {
    public XSSFSheet setSheet(XSSFWorkbook sheets){
        String sheetName = "固定资产表4";
        XSSFSheet sheet = sheets.createSheet(sheetName);
        //编写第一行
        //编写第一行的内容
        XSSFRow row = sheet.createRow(0);
        XSSFCell cell = row.createCell(0);
        cell.setCellValue("表四");
        //编写第二行的内容
        //第二行是从A到L有一个合并单元格
        CellRangeAddress cellAddresses = new CellRangeAddress(1, 1, 0, 10);
        sheet.addMergedRegion(cellAddresses);
        XSSFRow row1 = sheet.createRow(1);
        XSSFCell cell1 = row1.createCell(0);

        cell1.setCellValue("XXX学校2021年度固定资产折旧核定表");
        //第三行是从A到L有一个合并单元格
        CellRangeAddress cellAddresses1 = new CellRangeAddress(2, 2, 0, 10);
        sheet.addMergedRegion(cellAddresses1);
        XSSFRow row2 = sheet.createRow(2);
        XSSFCell cell2 = row2.createCell(0);

        cell2.setCellValue("单位名称：（盖章）                                                                                                残值率：3%                     单位：元");

        //编写第四行的内容
        String[] list4 = new String[]{"项 目","栏次及关系","原值","教学原值","公用支出核转","宿舍原值","餐厅原值","折旧年限","教学年折旧","宿舍年折旧","备注"};
        //给第四行填值
        XSSFRow row3 = sheet.createRow(3);
        for (int i = 0 ; i < 11;i++) {
            row3.createCell(i).setCellValue(list4[i]);
        }

        //第一列是一个有规律的列 给其添值
        String[] list5 = new String[]{"一、房屋建筑物",
                "1、钢结构混凝土结构" ,
                "2、砖混结构" ,
                "3、房屋附属物和构筑物" ,
                "二、通用设备" ,
                "三、专用设备" ,
                "四、家具" ,
                "五、土地" ,
                "六、合计" ,
                "七、预增固定资产",
                "八、合计"};
        for (int j = 0;j <=10;j++){
            sheet.createRow(j+4).createCell(0).setCellValue(list5[j]);
            sheet.getRow(j+4).createCell(1).setCellValue(j+1);
        }
        sheet.getRow(11).createCell(10).setCellValue("购地合同");
        sheet.getRow(12).createCell(10).setCellValue("C13和审计报告数是否一致？");

        //创建倒数第二行 一个大的合并
        CellRangeAddress cellAddresses2 = new CellRangeAddress(15, 15, 0, 10);
        CellRangeAddress cellAddresses3 = new CellRangeAddress(16, 16, 2, 6);
        sheet.addMergedRegion(cellAddresses2);
        sheet.addMergedRegion(cellAddresses3);
        //设值
        sheet.createRow(15).createCell(0).setCellValue("1、通用设备包括计算机、网络设备、安全设备、终端设备、存储设备、电话机、传真机、复印机、投影仪、多功能一体机、车辆、音像设备、电子白板、LED显示屏、触控一体机、图书等；2、专用设备包括电梯、制冷空调、锅炉、空气能、后续安装的电机、变压器、电源设备、直饮供水设备、乐器、舞台设备、多功能厅设备、田径设备、球类设备、体育运动辅助设备等。");
        sheet.createRow(16).createCell(2).setCellValue("填表说明：加黄线的不要填写，更不要更改公式");

        //设置表格宽度
        sheet.setColumnWidth(0,256*32+184);
        sheet.setColumnWidth(10,256*35+184);



        return sheet;
    }
}

package com.dwx.file;

import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class minban_biaowu {
    public XSSFSheet setSheet(XSSFWorkbook sheets){
        String sheetName = "三年账册相关科目表5";
        XSSFSheet sheet = sheets.createSheet(sheetName);
        //编写第一行
        //编写第一行的内容
        XSSFRow row = sheet.createRow(0);
        XSSFCell cell = row.createCell(0);
        cell.setCellValue("表五");
        //第二行是从A到L有一个合并单元格
        CellRangeAddress cellAddresses = new CellRangeAddress(1, 1, 0, 10);
        sheet.addMergedRegion(cellAddresses);
        XSSFRow row1 = sheet.createRow(1);
        XSSFCell cell1 = row1.createCell(0);

        cell1.setCellValue("新乡市xxx学校账册基本情况调查表");
        //第三行是从A到L有一个合并单元格

        //第思维航的第一个合并列
        sheet.addMergedRegion(new CellRangeAddress(2,3,0,0));
        //又有一系列小的横向合并
        for (int i=0;i<=6;i=i+3){
            CellRangeAddress cellAddresses1 = new CellRangeAddress(2, 2, i+1, i+3);
            sheet.addMergedRegion(cellAddresses1);
        }
        //添值
        sheet.createRow(2).createCell(0).setCellValue("科目");
        sheet.getRow(2).createCell(1).setCellValue("2019年");
        sheet.getRow(2).createCell(4).setCellValue("2020年");
        sheet.getRow(2).createCell(7).setCellValue("2021年");
        XSSFRow row4 = sheet.createRow(3);
        for (int j = 1;j<=9;j++){
            if (j%3 == 0){
                row4.createCell(j).setCellValue("凭证类型");
            }else if (j%3 == 2){
                row4.createCell(j).setCellValue("账册号");
            }else {
                row4.createCell(j).setCellValue("金额");
            }
        }

        row4.createCell(10).setCellValue("备注");

        //对第一列进行添值
        String[] listC1 = new String[]{
                "一、维修费" ,
                        "1、" ,
                        "2、" ,
                        "3、" ,
                        "4、" ,
                        "5、" ,
                        "二、低值易耗品" ,
                        "1、" ,
                        "2、" ,
                        "3、" ,
                        "4、" ,
                        "5、" ,
                        "三、其它支出" ,
                        "1、" ,
                        "2、" ,
                        "3、" ,
                        "4、" ,
                        "5、" ,
                        "四、财务费用" ,
                        "1、" ,
                        "2、" ,
                        "3、" ,
                        "4、" ,
                        "5、"
        };
        int i = 0;
        for (i = 0;i<=23;i++){
            sheet.createRow(i+4).createCell(0).setCellValue(listC1[i]);
        }
        //备注行有很多的合并单元格 这些单元格的合并都是五行
        int[] list1 = new int[]{4,10,16,22};
        String[] list2 = new String[]{
                "1、统计大于该科目金额20%的明细。2、凭证类型填写发票、合同（协议）、白条（收据）" ,

                        "1、统计大于该科目金额20%的明细。2、凭证类型填写发票、合同（协议）、白条（收据）" ,

                        "1、如果金额大于公用支出20%，请按内容分类。 如果金额小于公用支出20%，不填写。2、凭证类型填写发票、合同（协议）、白条（收据）" ,

                        "1、统计还款利息。2、凭证类型填写发票、合同（协议）、白条（收据）."


        };
        for (i = 0;i<=3;i++){
            sheet.addMergedRegion(new CellRangeAddress(list1[i],list1[i]+5,10,10));
            sheet.getRow(list1[i]).createCell(10).setCellValue(list2[i]);
        }

        //设置列表的行宽

        sheet.setColumnWidth(0,256*17+184);
        sheet.setColumnWidth(10,256*66+184);



        return sheet;
    }
}

package com.dwx.file;

import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class minban_jiaoyuhesuanbiao {

    public XSSFSheet setSheet(XSSFWorkbook sheets){
        String sheetName = "教育核定表";
        int i,j;

        XSSFSheet sheet = sheets.createSheet(sheetName);

        //对第一行进行合并单元格
        sheet.addMergedRegion(new CellRangeAddress(0,0,0,4));
        sheet.addMergedRegion(new CellRangeAddress(1,1,0,4));
        //给第一、二行添值
        sheet.createRow(0).createCell(0).setCellValue("表一");
        sheet.createRow(1).createCell(0).setCellValue("XXX学校2021年度教育培养、住宿成本生均核定表");
        //给第一列添值
        String[] list1 = new String[]{
              "项目" ,
                      "一、基本情况" ,
                      "（一）标准学生数" ,
                      "1、小学" ,
                      "2、初中" ,
                      "3、高中" ,
                      "（二）教职工" ,
                      "1、小学" ,
                      "2、初中" ,
                      "3、高中" ,
                      "（三）占地面积" ,
                      "（四）建筑面积" ,
                      "二、成本构成" ,
                      "（一）人员支出" ,
                      "1、小学" ,
                      "2、初中" ,
                      "3、高中" ,
                      "（二）租赁费" ,
                      "1、小学" ,
                      "2、初中" ,
                      "3、高中" ,
                      "（三）财务费用" ,
                      "1、小学" ,
                      "2、初中" ,
                      "3、高中" ,
                      "（四）商品和服务支出" ,
                      "（五）固定资产折旧" ,
                      "三、生均成本"
        };
        int listLength = list1.length;
        for (i = 0;i<listLength;i++){
            sheet.createRow(i+2).createCell(0).setCellValue(list1[i]);
        }
        sheet.getRow(2).createCell(1).setCellValue("申报数");
        sheet.getRow(2).createCell(2).setCellValue("核定数");
        sheet.getRow(2).createCell(3).setCellValue("教育成本核定数");
        sheet.getRow(2).createCell(4).setCellValue("住宿成本核定数");

        //调整列表的宽
        sheet.setColumnWidth(0,256*33+184);


        return sheet;
    }
}