工具类

常用工具类：

    1.POI工具类：
        import org.apache.poi.hssf.usermodel.HSSFWorkbook;
        import org.apache.poi.ss.usermodel.Cell;
        import org.apache.poi.ss.usermodel.Row;
        import org.apache.poi.ss.usermodel.Sheet;
        import org.apache.poi.ss.usermodel.Workbook;
        import org.apache.poi.xssf.usermodel.XSSFWorkbook;
        import org.springframework.web.multipart.MultipartFile;

        import java.io.FileNotFoundException;
        import java.io.IOException;
        import java.io.InputStream;
        import java.text.SimpleDateFormat;
        import java.util.ArrayList;
        import java.util.List;

        public class POIUtils {
            private final static String xls = "xls";
            private final static String xlsx = "xlsx";
            private final static String DATE_FORMAT = "yyyy/MM/dd";
            /**
             * 读入excel文件，解析后返回
             * @param file
             * @throws IOException
             */
            public static List<String[]> readExcel(MultipartFile file) throws IOException {
                //检查文件
                checkFile(file);
                //获得Workbook工作薄对象
                Workbook workbook = getWorkBook(file);
                //创建返回对象，把每行中的值作为一个数组，所有行作为一个集合返回
                List<String[]> list = new ArrayList<String[]>();
                if(workbook != null){
                    for(int sheetNum = 0;sheetNum < workbook.getNumberOfSheets();sheetNum++){
                        //获得当前sheet工作表
                        Sheet sheet = workbook.getSheetAt(sheetNum);
                        if(sheet == null){
                            continue;
                        }
                        //获得当前sheet的开始行
                        int firstRowNum  = sheet.getFirstRowNum();
                        //获得当前sheet的结束行
                        int lastRowNum = sheet.getLastRowNum();
                        //循环除了第一行的所有行
                        for(int rowNum = firstRowNum+1;rowNum <= lastRowNum;rowNum++){
                            //获得当前行
                            Row row = sheet.getRow(rowNum);
                            if(row == null){
                                continue;
                            }
                            //获得当前行的开始列
                            int firstCellNum = row.getFirstCellNum();
                            //获得当前行的列数
                            int lastCellNum = row.getPhysicalNumberOfCells();
                            String[] cells = new String[row.getPhysicalNumberOfCells()];
                            //循环当前行
                            for(int cellNum = firstCellNum; cellNum < lastCellNum;cellNum++){
                                Cell cell = row.getCell(cellNum);
                                cells[cellNum] = getCellValue(cell);
                            }
                            list.add(cells);
                        }
                    }
                    workbook.close();
                }
                return list;
            }

            //校验文件是否合法
            public static void checkFile(MultipartFile file) throws IOException{
                //判断文件是否存在
                if(null == file){
                    throw new FileNotFoundException("文件不存在！");
                }
                //获得文件名
                String fileName = file.getOriginalFilename();
                //判断文件是否是excel文件
                if(!fileName.endsWith(xls) && !fileName.endsWith(xlsx)){
                    throw new IOException(fileName + "不是excel文件");
                }
            }
            public static Workbook getWorkBook(MultipartFile file) {
                //获得文件名
                String fileName = file.getOriginalFilename();
                //创建Workbook工作薄对象，表示整个excel
                Workbook workbook = null;
                try {
                    //获取excel文件的io流
                    InputStream is = file.getInputStream();
                    //根据文件后缀名不同(xls和xlsx)获得不同的Workbook实现类对象
                    if(fileName.endsWith(xls)){
                        //2003
                        workbook = new HSSFWorkbook(is);
                    }else if(fileName.endsWith(xlsx)){
                        //2007
                        workbook = new XSSFWorkbook(is);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return workbook;
            }
            public static String getCellValue(Cell cell){
                String cellValue = "";
                if(cell == null){
                    return cellValue;
                }
                //如果当前单元格内容为日期类型，需要特殊处理
                String dataFormatString = cell.getCellStyle().getDataFormatString();
                if(dataFormatString.equals("m/d/yy")){
                    cellValue = new SimpleDateFormat(DATE_FORMAT).format(cell.getDateCellValue());
                    return cellValue;
                }
                //把数字当成String来读，避免出现1读成1.0的情况
                if(cell.getCellType() == Cell.CELL_TYPE_NUMERIC){
                    cell.setCellType(Cell.CELL_TYPE_STRING);
                }
                //判断数据的类型
                switch (cell.getCellType()){
                    case Cell.CELL_TYPE_NUMERIC: //数字
                        cellValue = String.valueOf(cell.getNumericCellValue());
                        break;
                    case Cell.CELL_TYPE_STRING: //字符串
                        cellValue = String.valueOf(cell.getStringCellValue());
                        break;
                    case Cell.CELL_TYPE_BOOLEAN: //Boolean
                        cellValue = String.valueOf(cell.getBooleanCellValue());
                        break;
                    case Cell.CELL_TYPE_FORMULA: //公式
                        cellValue = String.valueOf(cell.getCellFormula());
                        break;
                    case Cell.CELL_TYPE_BLANK: //空值
                        cellValue = "";
                        break;
                    case Cell.CELL_TYPE_ERROR: //故障
                        cellValue = "非法字符";
                        break;
                    default:
                        cellValue = "未知类型";
                        break;
                }
                return cellValue;
            }
        }
    
    2.日期工具类：
        import java.text.SimpleDateFormat;
        import java.util.*;

        /**
         * 日期操作工具类
         */
        public class DateUtils {
            /**
             * 日期转换-  String -> Date
             *
             * @param dateString 字符串时间
             * @return Date类型信息
             * @throws Exception 抛出异常
             */
            public static Date parseString2Date(String dateString) throws Exception {
                if (dateString == null) {
                    return null;
                }
                return parseString2Date(dateString, "yyyy-MM-dd");
            }

            /**
             * 日期转换-  String -> Date
             *
             * @param dateString 字符串时间
             * @param pattern    格式模板
             * @return Date类型信息
             * @throws Exception 抛出异常
             */
            public static Date parseString2Date(String dateString, String pattern) throws Exception {
                if (dateString == null) {
                    return null;
                }
                SimpleDateFormat sdf = new SimpleDateFormat(pattern);
                Date date = sdf.parse(dateString);
                return date;
            }

            /**
             * 日期转换 Date -> String
             *
             * @param date Date类型信息
             * @return 字符串时间
             * @throws Exception 抛出异常
             */
            public static String parseDate2String(Date date) throws Exception {
                if (date == null) {
                    return null;
                }
                return parseDate2String(date, "yyyy-MM-dd");
            }

            /**
             * 日期转换 Date -> String
             *
             * @param date    Date类型信息
             * @param pattern 格式模板
             * @return 字符串时间
             * @throws Exception 抛出异常
             */
            public static String parseDate2String(Date date, String pattern) throws Exception {
                if (date == null) {
                    return null;
                }
                SimpleDateFormat sdf = new SimpleDateFormat(pattern);
                String strDate = sdf.format(date);
                return strDate;
            }

            /**
             * 获取当前日期的本周一是几号
             *
             * @return 本周一的日期
             */
            public static Date getThisWeekMonday() {
                Calendar cal = Calendar.getInstance();
                cal.setTime(new Date());
                // 获得当前日期是一个星期的第几天
                int dayWeek = cal.get(Calendar.DAY_OF_WEEK);
                if (1 == dayWeek) {
                    cal.add(Calendar.DAY_OF_MONTH, -1);
                }
                // 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
                cal.setFirstDayOfWeek(Calendar.MONDAY);
                // 获得当前日期是一个星期的第几天
                int day = cal.get(Calendar.DAY_OF_WEEK);
                // 根据日历的规则，给当前日期减去星期几与一个星期第一天的差值
                cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - day);
                return cal.getTime();
            }

            /**
             * 获取当前日期周的最后一天
             *
             * @return 当前日期周的最后一天
             */
            public static Date getSundayOfThisWeek() {
                Calendar c = Calendar.getInstance();
                int dayOfWeek = c.get(Calendar.DAY_OF_WEEK) - 1;
                if (dayOfWeek == 0) {
                    dayOfWeek = 7;
                }
                c.add(Calendar.DATE, -dayOfWeek + 7);
                return c.getTime();
            }

            /**
             * 根据日期区间获取月份列表
             *
             * @param minDate 开始时间
             * @param maxDate 结束时间
             * @return 月份列表
             * @throws Exception
             */
            public static List<String> getMonthBetween(String minDate, String maxDate, String format) throws Exception {
                ArrayList<String> result = new ArrayList<>();
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");

                Calendar min = Calendar.getInstance();
                Calendar max = Calendar.getInstance();

                min.setTime(sdf.parse(minDate));
                min.set(min.get(Calendar.YEAR), min.get(Calendar.MONTH), 1);

                max.setTime(sdf.parse(maxDate));
                max.set(max.get(Calendar.YEAR), max.get(Calendar.MONTH), 2);
                SimpleDateFormat sdf2 = new SimpleDateFormat(format);

                Calendar curr = min;
                while (curr.before(max)) {
                    result.add(sdf2.format(curr.getTime()));
                    curr.add(Calendar.MONTH, 1);
                }

                return result;
            }

            /**
             * 根据日期获取年度中的周索引
             *
             * @param date 日期
             * @return 周索引
             * @throws Exception
             */
            public static Integer getWeekOfYear(String date) throws Exception {
                Date useDate = parseString2Date(date);
                Calendar cal = Calendar.getInstance();
                cal.setTime(useDate);
                return cal.get(Calendar.WEEK_OF_YEAR);
            }

            /**
             * 根据年份获取年中周列表
             *
             * @param year 年分
             * @return 周列表
             * @throws Exception
             */
            public static Map<Integer, String> getWeeksOfYear(String year) throws Exception {
                Date useDate = parseString2Date(year, "yyyy");
                Calendar cal = Calendar.getInstance();
                cal.setTime(useDate);
                //获取年中周数量
                int weeksCount = cal.getWeeksInWeekYear();
                Map<Integer, String> mapWeeks = new HashMap<>(55);
                for (int i = 0; i < weeksCount; i++) {
                    cal.get(Calendar.DAY_OF_YEAR);
                    mapWeeks.put(i + 1, parseDate2String(getFirstDayOfWeek(cal.get(Calendar.YEAR), i)));
                }
                return mapWeeks;
            }

            /**
             * 获取某年的第几周的开始日期
             *
             * @param year 年分
             * @param week 周索引
             * @return 开始日期
             * @throws Exception
             */
            public static Date getFirstDayOfWeek(int year, int week) throws Exception {
                Calendar c = new GregorianCalendar();
                c.set(Calendar.YEAR, year);
                c.set(Calendar.MONTH, Calendar.JANUARY);
                c.set(Calendar.DATE, 1);

                Calendar cal = (GregorianCalendar) c.clone();
                cal.add(Calendar.DATE, week * 7);

                return getFirstDayOfWeek(cal.getTime());
            }

            /**
             * 获取某年的第几周的结束日期
             *
             * @param year 年份
             * @param week 周索引
             * @return 结束日期
             * @throws Exception
             */
            public static Date getLastDayOfWeek(int year, int week) throws Exception {
                Calendar c = new GregorianCalendar();
                c.set(Calendar.YEAR, year);
                c.set(Calendar.MONTH, Calendar.JANUARY);
                c.set(Calendar.DATE, 1);

                Calendar cal = (GregorianCalendar) c.clone();
                cal.add(Calendar.DATE, week * 7);

                return getLastDayOfWeek(cal.getTime());
            }

            /**
             * 获取当前时间所在周的开始日期
             *
             * @param date 当前时间
             * @return 开始时间
             */
            public static Date getFirstDayOfWeek(Date date) {
                Calendar c = new GregorianCalendar();
                c.setFirstDayOfWeek(Calendar.SUNDAY);
                c.setTime(date);
                c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek());
                return c.getTime();
            }

            /**
             * 获取当前时间所在周的结束日期
             *
             * @param date 当前时间
             * @return 结束日期
             */
            public static Date getLastDayOfWeek(Date date) {
                Calendar c = new GregorianCalendar();
                c.setFirstDayOfWeek(Calendar.SUNDAY);
                c.setTime(date);
                c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek() + 6);
                return c.getTime();
            }
            //获得上周一的日期
            public static Date geLastWeekMonday(Date date) {
                Calendar cal = Calendar.getInstance();
                cal.setTime(getThisWeekMonday(date));
                cal.add(Calendar.DATE, -7);
                return cal.getTime();
            }

            //获得本周一的日期
            public static Date getThisWeekMonday(Date date) {
                Calendar cal = Calendar.getInstance();
                cal.setTime(date);
                // 获得当前日期是一个星期的第几天
                int dayWeek = cal.get(Calendar.DAY_OF_WEEK);
                if (1 == dayWeek) {
                    cal.add(Calendar.DAY_OF_MONTH, -1);
                }
                // 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
                cal.setFirstDayOfWeek(Calendar.MONDAY);
                // 获得当前日期是一个星期的第几天
                int day = cal.get(Calendar.DAY_OF_WEEK);
                // 根据日历的规则，给当前日期减去星期几与一个星期第一天的差值
                cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - day);
                return cal.getTime();
            }

            //获得下周一的日期
            public static Date getNextWeekMonday(Date date) {
                Calendar cal = Calendar.getInstance();
                cal.setTime(getThisWeekMonday(date));
                cal.add(Calendar.DATE, 7);
                return cal.getTime();
            }

            //获得今天日期
            public static Date getToday(){
                return new Date();
            }

            //获得本月一日的日期
            public static Date getFirstDay4ThisMonth(){
                Calendar calendar = Calendar.getInstance();
                calendar.set(Calendar.DAY_OF_MONTH,1);
                return calendar.getTime();
            }

            //获得本月最后一日的日期
            public static Date getLastDay4ThisMonth(){
                Calendar calendar = Calendar.getInstance();
                calendar.add(Calendar.MONTH, 1);
                calendar.set(Calendar.DAY_OF_MONTH, 0);
                return calendar.getTime();
            }

            public static void main(String[] args) {
                try {
                    System.out.println("本周一" + parseDate2String(getThisWeekMonday()));
                    System.out.println("本月一日" + parseDate2String(getFirstDay4ThisMonth()));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        
    3.Jedis工具类：
        import redis.clients.jedis.Jedis;
        import redis.clients.jedis.JedisPool;
        import redis.clients.jedis.JedisPoolConfig;

        /**
         * ToDo
         *
         * @author Lyle
         * @date 2019/12/25
         */
        public class JedisUtils {
            //创建全局变量以便静态代码块中可以使用
            private static JedisPoolConfig jedisPoolConfig;
            private static JedisPool jedisPool;

            static {

                //因为JedisPool只需要创建和配置一次,所以放入静态代码块比较好
                jedisPoolConfig = new JedisPoolConfig();
                jedisPoolConfig.setMaxTotal(10);    //最多连接数量
                jedisPoolConfig.setMaxWaitMillis(1000); //等待时间
                // 2. 创建JedisPool对象
                String host = "127.0.0.1";
                int port = 6379;
                jedisPool = new JedisPool(jedisPoolConfig, host, port);
            }
            //对外提供get方法获得jedis,静态方法,类名调用比较好
            public static Jedis getJedis(){
                // 3. 从JedisPool获得jedis
                Jedis jedis = jedisPool.getResource();
                return jedis;

            }
            //释放资源
            public static void close(Jedis jedis){
                if(jedis != null){
                    jedis.close();
                }
            }


        }

4.响应结果工具类：
        package entity;

        import java.io.Serializable;

        /**
         * 描述
         *
         * @author 三国的包子
         * @version 1.0
         * @package entity *
         * @since 1.0
         */
        public class Result<T> implements Serializable {
            private boolean flag;//是否成功
            private Integer code;//返回码
            private String message;//返回消息
            private T data;//返回数据

            public Result(boolean flag, Integer code, String message, Object data) {
                this.flag = flag;
                this.code = code;
                this.message = message;
                this.data = (T) data;
            }

            public Result(boolean flag, Integer code, String message) {
                this.flag = flag;
                this.code = code;
                this.message = message;
            }

            public Result() {
                this.flag = true;
                this.code = StatusCode.OK;
                this.message = "操作成功!";
            }

            public boolean isFlag() {
                return flag;
            }

            public void setFlag(boolean flag) {
                this.flag = flag;
            }

            public Integer getCode() {
                return code;
            }

            public void setCode(Integer code) {
                this.code = code;
            }

            public String getMessage() {
                return message;
            }

            public void setMessage(String message) {
                this.message = message;
            }

            public T getData() {
                return data;
            }

            public void setData(T data) {
                this.data = data;
            }
        }

5.分页返回结果工具类：
        package entity;

        import java.util.List;

        /**
         * 分页结果类
         */
        public class PageResult<T> {

            private Long total;//总记录数
            private List<T> rows;//记录

            public PageResult(Long total, List<T> rows) {
                this.total = total;
                this.rows = rows;
            }

            public PageResult() {
            }

            public Long getTotal() {
                return total;
            }

            public void setTotal(Long total) {
                this.total = total;
            }

            public List<T> getRows() {
                return rows;
            }

            public void setRows(List<T> rows) {
                this.rows = rows;
            }
        }

6.分页中接收前端参数的工具类：
        package entity;

        import java.io.Serializable;
        import java.util.List;

        public class Page <T> implements Serializable{

            // 页数（第几页）
            private long currentpage;

            // 查询数据库里面对应的数据有多少条
            private long total;// 从数据库查处的总记录数

            // 每页查5条
            private int size;

            // 下页
            private int next;
            
            private List<T> list;

            // 最后一页
            private int last;
            
            private int lpage;
            
            private int rpage;
            
            //从哪条开始查
            private long start;
            
            //全局偏移量
            public int offsize = 2;
            
            public Page() {
                super();
            }

            /****
             *
             * @param currentpage
             * @param total
             * @param pagesize
             */
            public void setCurrentpage(long currentpage,long total,long pagesize) {
                //可以整除的情况下
                long pagecount =  total/pagesize;

                //如果整除表示正好分N页，如果不能整除在N页的基础上+1页
                int totalPages = (int) (total%pagesize==0? total/pagesize : (total/pagesize)+1);

                //总页数
                this.last = totalPages;

                //判断当前页是否越界,如果越界，我们就查最后一页
                if(currentpage>totalPages){
                    this.currentpage = totalPages;
                }else{
                    this.currentpage=currentpage;
                }

                //计算start
                this.start = (this.currentpage-1)*pagesize;
            }

            //上一页
            public long getUpper() {
                return currentpage>1? currentpage-1: currentpage;
            }

            //总共有多少页，即末页
            public void setLast(int last) {
                this.last = (int) (total%size==0? total/size : (total/size)+1);
            }

            /****
             * 带有偏移量设置的分页
             * @param total
             * @param currentpage
             * @param pagesize
             * @param offsize
             */
            public Page(long total,int currentpage,int pagesize,int offsize) {
                this.offsize = offsize;
                initPage(total, currentpage, pagesize);
            }

            /****
             *
             * @param total   总记录数
             * @param currentpage    当前页
             * @param pagesize    每页显示多少条
             */
            public Page(long total,int currentpage,int pagesize) {
                initPage(total,currentpage,pagesize);
            }

            /****
             * 初始化分页
             * @param total
             * @param currentpage
             * @param pagesize
             */
            public void initPage(long total,int currentpage,int pagesize){
                //总记录数
                this.total = total;
                //每页显示多少条
                this.size=pagesize;

                //计算当前页和数据库查询起始值以及总页数
                setCurrentpage(currentpage, total, pagesize);

                //分页计算
                int leftcount =this.offsize,    //需要向上一页执行多少次
                        rightcount =this.offsize;

                //起点页
                this.lpage =currentpage;
                //结束页
                this.rpage =currentpage;

                //2点判断
                this.lpage = currentpage-leftcount;            //正常情况下的起点
                this.rpage = currentpage+rightcount;        //正常情况下的终点

                //页差=总页数和结束页的差
                int topdiv = this.last-rpage;                //判断是否大于最大页数

                /***
                 * 起点页
                 * 1、页差<0  起点页=起点页+页差值
                 * 2、页差>=0 起点和终点判断
                 */
                this.lpage=topdiv<0? this.lpage+topdiv:this.lpage;

                /***
                 * 结束页
                 * 1、起点页<=0   结束页=|起点页|+1
                 * 2、起点页>0    结束页
                 */
                this.rpage=this.lpage<=0? this.rpage+(this.lpage*-1)+1: this.rpage;

                /***
                 * 当起点页<=0  让起点页为第一页
                 * 否则不管
                 */
                this.lpage=this.lpage<=0? 1:this.lpage;

                /***
                 * 如果结束页>总页数   结束页=总页数
                 * 否则不管
                 */
                this.rpage=this.rpage>last? this.last:this.rpage;
            }

            public long getNext() {
                return  currentpage<last? currentpage+1: last;
            }

            public void setNext(int next) {
                this.next = next;
            }

            public long getCurrentpage() {
                return currentpage;
            }

            public long getTotal() {
                return total;
            }

            public void setTotal(long total) {
                this.total = total;
            }

            public long getSize() {
                return size;
            }

            public void setSize(int size) {
                this.size = size;
            }

            public long getLast() {
                return last;
            }

            public long getLpage() {
                return lpage;
            }

            public void setLpage(int lpage) {
                this.lpage = lpage;
            }

            public long getRpage() {
                return rpage;
            }

            public void setRpage(int rpage) {
                this.rpage = rpage;
            }

            public long getStart() {
                return start;
            }

            public void setStart(long start) {
                this.start = start;
            }

            public void setCurrentpage(long currentpage) {
                this.currentpage = currentpage;
            }

            /**
             * @return the list
             */
            public List<T> getList() {
                return list;
            }

            /**
             * @param list the list to set
             */
            public void setList(List<T> list) {
                this.list = list;
            }

            public static void main(String[] args) {
                    //总记录数
                    //当前页
                    //每页显示多少条
                    int cpage =17;
                    Page page = new Page(1001,cpage,50,7);
                    System.out.println("开始页:"+page.getLpage()+"__当前页："+page.getCurrentpage()+"__结束页"+page.getRpage()+"____总页数："+page.getLast());
            }
        }

手动分页接收数据模型


package com.itheima.mm.entity;

import lombok.Data;

import java.io.Serializable;
import java.util.Map;

/**
 * @author ：yp
 * @description : 封装查询条件
 * @version: 1.0 a=(当前页码-1)
 */
@Data
public class QueryPageBean implements Serializable{
    private Integer currentPage; // 页码
    private Integer pageSize;   //每页记录数
    private Map queryParams;    //查询条件


    private Integer offset; // 分页查询，开始记录下标

    /**
     * 获取分页起始记录位置
     * 根据分页页数，计算limit其实记录
     * @return
     */
    public Integer getOffset(){
        return (currentPage-1)*pageSize;
    }
}

基于pageHelper分页插件的手动分页工具类

import java.util.List;
 
import com.github.pagehelper.PageInfo;
 
/**
 * 
 * @ClassName: 
 * @Description: 基于com.github.pagehelper分页插件的手动分页
 * @author 
 * @date 2020年3月15日
 *
 */
public class PageHelperUtils {
 
    /**
     * 
     * @Title: initPageInfo
     * @Description: 将整理后需要分页的数据list进行分页显示
     * @param pageNum
     *            当前页
     * @param pageSize
     *            每页显示的数目
     * @param list
     *            逻辑处理之后所需要统计的总数据
     * @return PageInfo<T> 返回PageInfo，这是统计数据中当前页需要显示的数据集合（分页数据）
     */
    public static <T> PageInfo<T> initPageInfo(int pageNum, int pageSize, List<T> list) {
        int total = list.size();
        // 默认如果当前页小于0则为第一页
        pageNum = pageNum <= 0 ? 1 : pageNum;
        // 默认如果当前页大于最大的页数为当前页
        pageNum = pageNum > (total + pageSize - 1) / pageSize ? (total + pageSize - 1) / pageSize : pageNum;
        // 将需要分页的数组进行截取处理
        int fromIndex = 0;
        int toIndex = 0;
        if (total / pageSize == 0 && total % pageSize > 0) {
            // 表示当前数据只有一页
            fromIndex = 0;
            toIndex = total;
        } else if (total / pageSize >= 1 && total % pageSize >= 0) {
            // 超过一页
            fromIndex = (pageNum - 1) * pageSize;
            toIndex = pageNum * pageSize >= total ? total : pageSize * pageNum;
        }
        // 真正需要分页显示的数据
        List<T> tempList = list.subList(fromIndex, toIndex);
        // 结果集(每页显示的数据)
        PageInfo<T> pageInfo = new PageInfo<>(tempList);
        // 当前页
        pageInfo.setPageNum(pageNum);
        // 每页的数量
        pageInfo.setPageSize(pageSize);
        // 当前页的数量
        pageInfo.setSize(tempList.size());
        // 当前页面第一个元素在数据库中的行号
        pageInfo.setStartRow(0);
        // 当前页面最后一个元素在数据库中的行号
        pageInfo.setEndRow(tempList.size() > 0 ? tempList.size() - 1 : 0);
        // 总记录数
        pageInfo.setTotal(total);
        // 总页数
        pageInfo.setPages((total + pageSize - 1) / pageSize);
        // 计算导航页
        calcNavigatepageNums(pageInfo);
        // 计算前后页，第一页，最后一页
        calcPage(pageInfo);
        // 判断页面边界
        judgePageBoudary(pageInfo);
        return pageInfo;
    }
 
    /**
     * 计算导航页
     */
    private static <T> void calcNavigatepageNums(PageInfo<T> pageInfo) {
        int pages = pageInfo.getPages();
        int navigatePages = pageInfo.getNavigatePages();
        int pageNum = pageInfo.getPageNum();
        // 当总页数小于或等于导航页码数时
        if (pages <= navigatePages) {
            pageInfo.setNavigatepageNums(new int[pages]);
            for (int i = 0; i < pages; i++) {
                pageInfo.getNavigatepageNums()[i] = i + 1;
            }
        } else { // 当总页数大于导航页码数时
            pageInfo.setNavigatepageNums(new int[navigatePages]);
            int startNum = pageNum - navigatePages / 2;
            int endNum = pageNum + navigatePages / 2;
 
            if (startNum < 1) {
                startNum = 1;
                // (最前navigatePages页
                for (int i = 0; i < navigatePages; i++) {
                    pageInfo.getNavigatepageNums()[i] = startNum++;
                }
            } else if (endNum > pages) {
                endNum = pages;
                // 最后navigatePages页
                for (int i = navigatePages - 1; i >= 0; i--) {
                    pageInfo.getNavigatepageNums()[i] = endNum--;
                }
            } else {
                // 所有中间页
                for (int i = 0; i < navigatePages; i++) {
                    pageInfo.getNavigatepageNums()[i] = startNum++;
                }
            }
        }
    }
 
    /**
     * 计算前后页，第一页，最后一页
     */
    private static <T> void calcPage(PageInfo<T> pageInfo) {
        int[] navigatepageNums = pageInfo.getNavigatepageNums();
        int pageNum = pageInfo.getPageNum();
        int pages = pageInfo.getPages();
        if (navigatepageNums != null && navigatepageNums.length > 0) {
            pageInfo.setFirstPage(navigatepageNums[0]);
            pageInfo.setLastPage(navigatepageNums[navigatepageNums.length - 1]);
            if (pageNum > 1) {
                pageInfo.setPrePage(pageNum - 1);
            }
            if (pageNum < pages) {
                pageInfo.setNextPage(pageNum + 1);
            }
        }
    }
 
    /**
     * 判定页面边界
     */
    private static <T> void judgePageBoudary(PageInfo<T> pageInfo) {
        int pageNum = pageInfo.getPageNum();
        int pages = pageInfo.getPages();
        pageInfo.setIsFirstPage(pageNum == 1);
        pageInfo.setIsLastPage(pageNum == pages);
        pageInfo.setHasPreviousPage(pageNum > 1);
        pageInfo.setHasNextPage(pageNum < pages);
    }
 
}

使用递归调用查询子类

public List<Depart> getChildren(Long id,List<Depart> list){
        List<Depart> children=new ArrayList<>();
        List<Depart> departs=new ArrayList<>();
        if (list!=null&&list.size()>0){
            for (Depart depart : list) {
                if (depart.getPid()==id.longValue()){
                    children.add(depart);
                }
            }
        }
        if (children!=null&&children.size()>0){
            for (Depart child : children) {
                List<Depart> departList = getChildren(child.getId(), list);
                departs.addAll(departList);
            }
        }
        if (children.size()==0){
            return new ArrayList<>();
        }
        return children;
    }

使用递归方法将List集合转换成树形结构的方法

/**
     * 方法二、
     * @param list
     * @return
     */
    public static List<TreeNode> listToTree(List<TreeNode> list) {
        //用递归找子。
        List<TreeNode> treeList = new ArrayList<TreeNode>();
        for (TreeNode tree : list) {
            if (tree.getPid() == 0) {
                treeList.add(findChildren(tree, list));
            }
        }
        return treeList;
    }
 
    private static TreeNode findChildren(TreeNode tree, List<TreeNode> list) {
        for (TreeNode node : list) {
            if (node.getPid() == tree.getId()) {
                if (tree.getChildren() == null) {
                    tree.setChildren(new ArrayList<TreeNode>());
                }
                tree.getChildren().add(findChildren(node, list));
            }
        }
        return tree;
    }

树形结构扁平化的方法

/**
     * 树形结构扁平化，页面展示形成树形结构{@link SomeModel#getDisplayName()}
     * 先展示自己，再展示自己的下级
     * @param tree 具备children的一个列表
     */
    public List<SomeModel> flatten(List<SomeModel> tree){
        List<SomeModel> list = new LinkedList<>();
        for (SomeModel someModel : tree) {
            list.add(someModel);
            //孩子扁平化
            List<SomeModel> children = someModel.getChildren();
            if(CollectionUtil.isEmpty(children)){
                continue;
            }
            List<SomeModel> flatten = flatten(children);
            list.addAll(flatten);
            someModel.setChildren(null);
        }
        return list;
    }

json解析工具类

<!-- Jackson Json处理工具包 -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.4.2</version>
</dependency>

<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.7.3</version>
</dependency>

<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.7.3</version>
</dependency>

<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.7.3</version>
</dependency>

package com.taotao.model.utils;
 
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
 
import java.util.List;
 
/**
 * json工具类
 */
public class JsonUtils {
 
    // 定义jackson对象
    private static final ObjectMapper MAPPER = new ObjectMapper();
 
    /**
     * 将对象转换成json字符串。
     * <p>Title: pojoToJson</p>
     * <p>Description: </p>
     * @param data
     * @return
     */
    public static String objectToJson(Object data) {
        try {
            String string = MAPPER.writeValueAsString(data);
            return string;
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }
    
    /**
     * 将json结果集转化为对象
     * 
     * @param jsonData json数据
     * @param clazz 对象中的object类型
     * @return
     */
    public static <T> T jsonToPojo(String jsonData, Class<T> beanType) {
        try {
            T t = MAPPER.readValue(jsonData, beanType);
            return t;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    
    /**
     * 将json数据转换成pojo对象list
     * <p>Title: jsonToList</p>
     * <p>Description: </p>
     * @param jsonData
     * @param beanType
     * @return
     */
    public static <T>List<T> jsonToList(String jsonData, Class<T> beanType) {
        JavaType javaType = MAPPER.getTypeFactory().constructParametricType(List.class, beanType);
        try {
            List<T> list = MAPPER.readValue(jsonData, javaType);
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        return null;
    }
    
}

根据文件url下载文件

public class FileDownload {

    public static void main(String[] args) {
        try{
            downLoadFromUrl("https://ss3.bdstatic.com/70cFv8Sh_Q1YnxGkpoWK1HF6hhy/it/u=2534506313,1688529724&fm=26&gp=0.jpg",
                    "百度.jpg","d:/");
        }catch (Exception e) {
            // TODO: handle exception
        }


    }

    public static void  downLoadFromUrl(String urlStr,String fileName,String savePath) throws IOException {
        URL url = new URL(urlStr);
        HttpURLConnection conn = (HttpURLConnection)url.openConnection();
        //设置超时间为3秒
        conn.setConnectTimeout(3*1000);
        //防止屏蔽程序抓取而返回403错误
        conn.setRequestProperty("User-Agent", "Mozilla/4.0 (compatible; MSIE 5.0; Windows NT; DigExt)");

        //得到输入流
        InputStream inputStream = conn.getInputStream();
        //获取自己数组
        byte[] getData = readInputStream(inputStream);

        //文件保存位置
        File saveDir = new File(savePath);
        if(!saveDir.exists()){
            saveDir.mkdir();
        }
        File file = new File(saveDir+File.separator+fileName);
        FileOutputStream fos = new FileOutputStream(file);
        fos.write(getData);
        if(fos!=null){
            fos.close();
        }
        if(inputStream!=null){
            inputStream.close();
        }


        System.out.println("info:"+url+" download success");

    }

    /**
     * 从输入流中获取字节数组
     * @param inputStream
     * @return
     * @throws IOException
     */
    public static  byte[] readInputStream(InputStream inputStream) throws IOException {
        byte[] buffer = new byte[1024];
        int len = 0;
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        while((len = inputStream.read(buffer)) != -1) {
            bos.write(buffer, 0, len);
        }
        bos.close();
        return bos.toByteArray();
    }


}