'会飞的猪
'会飞的猪

excelUtils 导入导出 utils

excel 导入导出 utils

poi的pom导入


    
      org.apache.poi
      poi
      3.12
    
    
      org.apache.poi
      poi-ooxml
      3.12
    
    
    
      com.alibaba
      fastjson
      1.2.6

utils编写

package com.example.utils;

import org.apache.poi.EncryptedDocumentException;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFDateUtil;
import org.apache.poi.hssf.usermodel.HSSFFont;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
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.ss.usermodel.WorkbookFactory;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@SuppressWarnings("deprecation")
public class ExcelUtils {

	/** Excel 最大行数 */
	public static final Integer EXCEL_MAX_ROW = 60000;
	

	private static final Logger logger = LoggerFactory.getLogger(ExcelUtils.class);

	/**
	 * 导出excel
	 *
	 * @param response
	 * @param excelHead
	 *            顶部标题
	 * @param excelBody
	 *            数据源字段
	 * @param dataList
	 *            数据源
	 * @param FileName
	 *            文明名称
	 * @param SheetName
	 *            sheet页名称
	 * @return
	 */
	@SuppressWarnings("resource")
	public static void exportExcelByMap(HttpServletResponse response, List excelHead, List excelBody,
                                        List> dataList, String FileName, String SheetName) {
		try {
			// 文件名称
			String folder = "tempexportexcel" + File.separator + new SimpleDateFormat("yyyyMMdd").format(new Date());
			String location = Thread.currentThread().getContextClassLoader().getResource("").getPath();// 获取路径
			// 创建文件
			File f = new File(location.substring(0, location.indexOf("classes")) + folder);
			if (!f.exists()) {
			    Boolean b=f.mkdirs();
				if(!b){
				    throw new RuntimeException("创建目录失败");
				}
			}
			ServletOutputStream out = response.getOutputStream();
			response.setHeader("Content-disposition",
					"attachment; filename=" + new String(FileName.getBytes("GB2312"), "8859_1") + ".xls");// 设定输出文件头
			response.setContentType("application/msexcel");// 定义输出类型
			// 建立excel文件
			HSSFWorkbook workBook = new HSSFWorkbook();

			int totalCount = 0;
			if (!CollectionUtils.isEmpty(dataList)) {
				totalCount = dataList.size();
			}
			for (int n = 0; n < (totalCount / EXCEL_MAX_ROW) + 1; n++) {
				HSSFSheet sheet;
				if (n == 0) {
					// 创建一个工作表
					sheet = workBook.createSheet(SheetName);
				} else {
					sheet = workBook.createSheet(SheetName + "(" + n + ")");
				}
				// 插入文件头
				if (excelHead != null && excelHead.size() > 0) {
					HSSFRow row = sheet.createRow(0);
					for (int i = 0; i < excelHead.size(); i++) {
						// 在Label对象的子对象中指明单元格的位置和内容
						HSSFCell cell = row.createCell(i);
						cell.setCellValue(excelHead.get(i) + "");
					}
				}

				// 插入数据
				if (dataList != null && dataList.size() > 0) {
					Integer dataLen = dataList.size() - EXCEL_MAX_ROW * n;
					if (dataLen > EXCEL_MAX_ROW) {
						dataLen = EXCEL_MAX_ROW;
					}
					for (int i = 0; i < dataLen; i++) {
						Map lineData = dataList.get(i + EXCEL_MAX_ROW * n);
						Row row = sheet.createRow(i + 1);
						for (int j = 0; j < excelBody.size(); j++) {
							Cell cell = row.createCell(j);
							Object valObj = lineData.get(excelBody.get(j));
							if (valObj != null) {
							    if (valObj instanceof Date) {
                                    DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
                                    cell.setCellValue(format.format(valObj));
                                }else{
                                    cell.setCellValue(valObj + "");
                                }
							} else {
								cell.setCellValue("");
							}
						}
					}
				}
			}
			workBook.write(out);
			out.close();
		} catch (IOException e) {
			logger.error("导出数据异常", e);
			throw new RuntimeException(e.getMessage());
		}
	}
	/**
	 * 导出excel 只生成文件流，不导出
	 *
	 * @param excelHead
	 *            顶部标题
	 * @param excelBody
	 *            数据源字段
	 * @param dataList
	 *            数据源
	 * @param FileName
	 *            文明名称
	 * @param SheetName
	 *            sheet页名称
	 * @return
	 */
	@SuppressWarnings("resource")
	public static InputStream exportExcelByMap(List excelHead, List excelBody,
                                               List> dataList, String FileName, String SheetName) {
		try {
			// 建立excel文件
			HSSFWorkbook workBook = new HSSFWorkbook();

			int totalCount = 0;
			if (!CollectionUtils.isEmpty(dataList)) {
				totalCount = dataList.size();
			}
			for (int n = 0; n < (totalCount / EXCEL_MAX_ROW) + 1; n++) {
				HSSFSheet sheet;
				if (n == 0) {
					// 创建一个工作表
					sheet = workBook.createSheet(SheetName);
				} else {
					sheet = workBook.createSheet(SheetName + "(" + n + ")");
				}
				// 插入文件头
				if (excelHead != null && excelHead.size() > 0) {
					HSSFRow row = sheet.createRow(0);
					for (int i = 0; i < excelHead.size(); i++) {
						// 在Label对象的子对象中指明单元格的位置和内容
						HSSFCell cell = row.createCell(i);
						cell.setCellValue(excelHead.get(i) + "");
					}
				}

				// 插入数据
				if (dataList != null && dataList.size() > 0) {
					Integer dataLen = dataList.size() - EXCEL_MAX_ROW * n;
					if (dataLen > EXCEL_MAX_ROW) {
						dataLen = EXCEL_MAX_ROW;
					}
					for (int i = 0; i < dataLen; i++) {
						Map lineData = dataList.get(i + EXCEL_MAX_ROW * n);
						Row row = sheet.createRow(i + 1);
						for (int j = 0; j < excelBody.size(); j++) {
							Cell cell = row.createCell(j);
							Object valObj = lineData.get(excelBody.get(j));
							if (valObj != null) {
								cell.setCellValue(valObj + "");
							} else {
								cell.setCellValue("");
							}
						}
					}
				}
			}
			ByteArrayOutputStream os = new ByteArrayOutputStream();
	        try {
	        	workBook.write(os);
	        } catch (IOException e) {
	            e.printStackTrace();
	        }

	        byte[] content = os.toByteArray();
	        InputStream is = new ByteArrayInputStream(content);
	        return is;
		} catch (Exception e) {
			logger.error("导出数据异常", e);
			return null;
		}
	}
	//导出Excel
	@SuppressWarnings("resource")
	public static void exportExcelByObject(HttpServletResponse response, List excelHead, List excelBody,
                                           List dataList, String FileName, String SheetName) {
		try {
			// 文件名称
			String folder = "tempexportexcel" + File.separator + new SimpleDateFormat("yyyyMMdd").format(new Date());
			String location = Thread.currentThread().getContextClassLoader().getResource("").getPath();// 获取路径
			// 创建文件
			File f = new File(location.substring(0, location.indexOf("classes")) + folder);
			if (!f.exists()) {
			    Boolean b = f.mkdirs();
			    if(!b){
                    throw new RuntimeException("创建目录失败");
                }
			}
			ServletOutputStream out = response.getOutputStream();
			response.setHeader("Content-disposition",
					"attachment; filename=" + new String(FileName.getBytes("GB2312"), "iso-8859-1") + ".xls");// 设定输出文件头
			response.setContentType("application/msexcel");// 定义输出类型
			// 建立excel文件
			HSSFWorkbook workBook = new HSSFWorkbook();

			int totalCount = 0;
			if (!CollectionUtils.isEmpty(dataList)) {
				totalCount = dataList.size();
			}
			for (int n = 0; n < (totalCount / EXCEL_MAX_ROW) + 1; n++) {
				HSSFSheet sheet;
				if (n == 0) {
					// 创建一个工作表
					sheet = workBook.createSheet(SheetName);
				} else {
					sheet = workBook.createSheet(SheetName + "(" + n + ")");
				}
				// 插入文件头
				if (excelHead != null && excelHead.size() > 0) {
					HSSFRow row = sheet.createRow(0);
					for (int i = 0; i < excelHead.size(); i++) {
						// 在Label对象的子对象中指明单元格的位置和内容
						HSSFCell cell = row.createCell(i);
						cell.setCellValue(excelHead.get(i) + "");
					}
				}

				// 插入数据
				if (dataList != null && dataList.size() > 0) {
					Integer dataLen = dataList.size() - EXCEL_MAX_ROW * n;
					if (dataLen > EXCEL_MAX_ROW) {
						dataLen = EXCEL_MAX_ROW;
					}
					for (int i = 0; i < dataLen; i++) {
						Object lineData = dataList.get(i + EXCEL_MAX_ROW * n);
						Row row = sheet.createRow(i + 1);
						for (int j = 0; j < excelBody.size(); j++) {
							Cell cell = row.createCell(j);
							Object valObj = getFieldValueByName(excelBody.get(j), lineData);
							if (valObj != null) {
								String valObjString=valObj.toString();
                                if (valObj instanceof Boolean) {
                                    if (((Boolean) valObj).booleanValue()) {
                                        cell.setCellValue("是");
                                    }else{
                                        cell.setCellValue("否");
                                    }
                                } else if (valObj instanceof Date) {
                                    DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
                                    cell.setCellValue(format.format(valObj));
                                } else if(valObjString.startsWith("http")){
                                	//超链接样式
									HSSFCellStyle linkStyle = workBook.createCellStyle();
									HSSFFont cellFont= workBook.createFont();
									cellFont.setUnderline((byte) 1);
									cellFont.setColor(HSSFColor.BLUE.index);
									linkStyle.setFont(cellFont);
									//塞入超链接参数
                                	cell.setCellType(HSSFCell.CELL_TYPE_FORMULA);
									cell.setCellFormula("HYPERLINK(\"" + valObj+ "\",\"" + valObj+ "\")");
									cell.setCellStyle(linkStyle);
								}else {
                                    cell.setCellValue(valObj + "");
                                }
							} else {
								cell.setCellValue("");
							}
						}
					}
				}
			}
			workBook.write(out);
			out.close();
		} catch (IOException e) {
			logger.error("导出数据异常", e);
            throw new RuntimeException(e.getMessage());
		}
	}

	/**
	 * 导入excel生成list
	 *
	 * @param is
	 *            文件流
	 * @param listMapKey
	 *            键
	 * @return
	 */
	public static List> importExcelByMap(InputStream is, List listMapKey) {
		List> list = new ArrayList<>();
		try {
			//修改成支持03格式和07格式
			//HSSFWorkbook wb = new HSSFWorkbook(new POIFSFileSystem(is));
			//XSSFWorkbook wb = new XSSFWorkbook(new POIFSFileSystem(is));
			Workbook wb = WorkbookFactory.create(is);
			Sheet sheet = wb.getSheetAt(0);
			int rowNum = sheet.getLastRowNum();
			for (int i = 1; i <= rowNum; i++) {
				Row row = sheet.getRow(i);
				Map map = new HashMap<>();
				for (int j = 0; j < listMapKey.size(); j++) {
					Cell cell = row.getCell(j);
					String cellValue = getCellValue(cell);
					map.put(listMapKey.get(j) + "", cellValue);
				}
				list.add(map);
			}
		} catch (Exception e) {
			logger.error("导入excel异常", e);
			throw new RuntimeException(e.getMessage());
		}

		return list;
	}
	
    /**
     * 导入excel生成list
     *
     * @param is
     *            文件流
     * @param
     *
     * @return
     */
    public static List importExcelByObject(InputStream is, List listKey, String entity) {
        List list = new ArrayList();
        try {
            // 修改成支持03格式和07格式
            // HSSFWorkbook wb = new HSSFWorkbook(new POIFSFileSystem(is));
            // XSSFWorkbook wb = new XSSFWorkbook(new POIFSFileSystem(is));
            Workbook wb = WorkbookFactory.create(is);
            Sheet sheet = wb.getSheetAt(0);
            int rowNum = sheet.getLastRowNum();
            for (int i = 1; i <= rowNum; i++) {
                Row row = sheet.getRow(i);
                Class clazz = Class.forName(entity);
                Object obj = clazz.newInstance();
                for (int j = 0; j < listKey.size(); j++) {
                    Cell cell = row.getCell(j);
                    String cellValue = getCellValue(cell);

                    Field f = clazz.getDeclaredField(listKey.get(j));
                    f.setAccessible(true);
                    String type = f.getType().toString();
                    if ("class java.lang.String".equals(type)) {
                        f.set(obj, cellValue);
                    } else if ("class java.lang.Integer".equals(type)) {
                        f.set(obj, "".equals(cellValue) ? null : Integer.parseInt(cellValue));
                    } else if ("class java.lang.Long".equals(type)) {
                        f.set(obj, "".equals(cellValue) ? null : Long.parseLong(cellValue));
                    } else if ("class java.math.BigDecimal".equals(type)) {
                        f.set(obj, "".equals(cellValue) ? null : new BigDecimal(cellValue));
                    } else if ("class java.util.Date".equals(type)) {
                        f.set(obj, "".equals(cellValue) ? null : formatDate(cellValue));
                    } else if ("class java.lang.Boolean".equals(type)) {
                        f.set(obj, "".equals(cellValue) ? null : Boolean.parseBoolean(cellValue));
                    } else {
                        f.set(obj, cellValue);
                    }
                }
                list.add(obj);
            }
        } catch (IOException | IllegalArgumentException | IllegalAccessException | NoSuchFieldException
                | SecurityException | EncryptedDocumentException | InvalidFormatException | ClassNotFoundException
                | InstantiationException e) {
            logger.error("导入excel异常", e);
            throw new RuntimeException(e.getMessage());
        }

        return list;
    }

	public static List> importExcelByParam(InputStream is, List> listMapKey) {
		List> list = new ArrayList<>();
		try {
			//HSSFWorkbook wb = new HSSFWorkbook(new POIFSFileSystem(is));
			Workbook wb = WorkbookFactory.create(is);
			Sheet sheet = wb.getSheetAt(0);
			int rowNum = sheet.getLastRowNum();
			for (int i = 1; i <= rowNum; i++) {
				Row row = sheet.getRow(i);
				Map map = new HashMap<>();
				for (int j = 0; j < listMapKey.size(); j++) {
					Cell cell = row.getCell(ParseUtils.objToInteger(listMapKey.get(j).get("index")));
					String cellValue = getCellValue(cell);
					map.put(listMapKey.get(j).get("key") + "", cellValue);
				}
				list.add(map);
			}
		} catch (Exception e) {
			logger.error("导入excel异常", e);
			throw new RuntimeException(e.getMessage());
		}

		return list;
	}
	
	public static List importExcelObjByParam(InputStream is, List> listMapKey, String entity) {
		 List list = new ArrayList();
		try {
			//HSSFWorkbook wb = new HSSFWorkbook(new POIFSFileSystem(is));
			Workbook wb = WorkbookFactory.create(is);
			Sheet sheet = wb.getSheetAt(0);
			int rowNum = sheet.getLastRowNum();
			for (int i = 1; i <= rowNum; i++) {
				Row row = sheet.getRow(i);
				Class clazz = Class.forName(entity);
                Object obj = clazz.newInstance();
				for (int j = 0; j < listMapKey.size(); j++) {
					Cell cell = row.getCell(ParseUtils.objToInteger(listMapKey.get(j).get("index")));
					String cellValue = getCellValue(cell);
					Field f = clazz.getDeclaredField(listMapKey.get(j).get("key").toString());
                    f.setAccessible(true);
                    String type = f.getType().toString();
                    if ("class java.lang.String".equals(type)) {
                        f.set(obj, cellValue);
                    } else if ("class java.lang.Integer".equals(type)) {
                        f.set(obj, "".equals(cellValue) ? null : Integer.parseInt(cellValue));
                    } else if ("class java.lang.Long".equals(type)) {
                        f.set(obj, "".equals(cellValue) ? null : Long.parseLong(cellValue));
                    } else if ("class java.math.BigDecimal".equals(type)) {
                        f.set(obj, "".equals(cellValue) ? null : new BigDecimal(cellValue));
                    } else if ("class java.util.Date".equals(type)) {
                        f.set(obj, "".equals(cellValue) ? null : formatDate(cellValue));
                    } else if ("class java.lang.Boolean".equals(type)) {
                        f.set(obj, "".equals(cellValue) ? null : Boolean.parseBoolean(cellValue));
                    } else {
                        f.set(obj, cellValue);
                    }
				}
				list.add(obj);
			}
		} catch (Exception e) {
			logger.error("导入excel异常", e);
			throw new RuntimeException(e.getMessage());
		}

		return list;
	}

	/**
	 * 从excel中抽取数据，key：表头，value：数据
	 * @param is
	 * @return
	 * @throws IOException
	 */
	public static List> extractFromExcel(InputStream is) throws Exception {
		// 数据列表，key:表头，value：数据
		List> dataList = new ArrayList<>();

		//HSSFWorkbook wb = new HSSFWorkbook(new POIFSFileSystem(is));
		Workbook wb = WorkbookFactory.create(is);
		Sheet sheet = wb.getSheetAt(0);
		int lastRowNum = sheet.getLastRowNum();
		if (lastRowNum > 0) {
			Row titleRow = sheet.getRow(0);
			int lastCellNum = titleRow.getLastCellNum();
			// 构建表头列表
			List titleList = new ArrayList<>(lastCellNum + 1);
			for (int j = 0; j <= lastCellNum; j++) {
				Cell cell = titleRow.getCell(j);
				String cellValue = getCellValue(cell);
				titleList.add(cellValue);
			}

			// 构建表头：数据对应关系
			for (int i = 1; i <= lastRowNum; i++) {
				Row row = sheet.getRow(i);
				Map map = new HashMap<>();

				for (int j = 0; j <= lastCellNum; j++) {
					Cell cell = row.getCell(j);
					String cellValue = getCellValue(cell);
					map.put(titleList.get(j) + "", cellValue);
				}
				dataList.add(map);
			}
		}

		return dataList;
	}

	public static String getCellValue(Cell cell) {
		String cellvalue = "";

		if (cell != null) {
			switch (cell.getCellType()) {
			case Cell.CELL_TYPE_NUMERIC: { // 数值
				if (HSSFDateUtil.isCellDateFormatted(cell)) { // 如果是日期格式
					Date date = cell.getDateCellValue();
					SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
					cellvalue = sdf.format(date);
				} else { // 如果是数字
					cell.setCellType(Cell.CELL_TYPE_STRING);
					cellvalue = cell.getStringCellValue();
					//cellvalue = new BigDecimal(cell.getNumericCellValue()).toPlainString(); //浮点数有精度问题
				}
				break;
			}
			case Cell.CELL_TYPE_STRING: { // 字符串
				cellvalue = cell.getStringCellValue();
				break;
			}
			case Cell.CELL_TYPE_FORMULA: { // 公式
				cellvalue = cell.getCellFormula();
				break;
			}
			case Cell.CELL_TYPE_BLANK: { // 空值
				cellvalue = "";
				break;
			}
			case Cell.CELL_TYPE_BOOLEAN: {// Boolean
				cellvalue = String.valueOf(cell.getBooleanCellValue());
				break;
			}
			default: { // 默认字符串
				cellvalue = cell.getStringCellValue();
				break;
			}
			}
		}

		return cellvalue.trim();
	}

    public static Object getFieldValueByName(String fieldName, Object o) {
        try {
            String firstLetter = fieldName.substring(0, 1).toUpperCase();
            String getter = "get" + firstLetter + fieldName.substring(1);
            Method method = o.getClass().getMethod(getter, new Class[] {});
            Object value = method.invoke(o, new Object[] {});
            return value;
        } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException
                | InvocationTargetException e) {
            try {
                // todo fixme 这里发现了导出的bug ,目前简单优化了代码
                String firstLetter = fieldName.substring(0, 1);
                String getter = "get" + firstLetter + fieldName.substring(1);
                Method method = o.getClass().getMethod(getter, new Class[] {});
                Object value = method.invoke(o, new Object[] {});
                return value;
            } catch (Exception ec) {
                logger.error(ec.getMessage(), ec);
                return null;
            }
        }
    }

	/**
	 * 客户收款分析导出，包含合并单元格，动态列
	 * @param response
	 * @param FileName
	 * @param SheetName
	 * @param excelHead
	 * @param exceltitle2
	 * @param excelBody
	 * @param dataList
	 */
	@SuppressWarnings("resource")
	public static void exportExcelByMerge(HttpServletResponse response, String FileName, String SheetName,
                                          List> excelHead, List exceltitle2, List excelBody, List> dataList) {
		try {
			// 文件名称
			String folder = "tempexportexcel" + File.separator + new SimpleDateFormat("yyyyMMdd").format(new Date());
			String location = Thread.currentThread().getContextClassLoader().getResource("").getPath();// 获取路径
			// 创建文件
			File f = new File(location.substring(0, location.indexOf("classes")) + folder);
			if (!f.exists()) {
			    Boolean b = f.mkdirs();
			    if(!b){
                    throw new RuntimeException("创建目录失败");
                }
			}
			ServletOutputStream out = response.getOutputStream();
			response.setHeader("Content-disposition",
					"attachment; filename=" + new String(FileName.getBytes("GB2312"), "8859_1") + ".xls");// 设定输出文件头
			response.setContentType("application/msexcel");// 定义输出类型
			// 建立excel文件
			HSSFWorkbook workBook = new HSSFWorkbook();
			HSSFCellStyle cellStyle = workBook.createCellStyle();
			cellStyle.setAlignment(HSSFCellStyle.ALIGN_CENTER);//水平居中
			cellStyle.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);//垂直居中
			int totalCount = 0;
			if (!CollectionUtils.isEmpty(dataList)) {
				totalCount = dataList.size();
			}
			for (int n = 0; n < (totalCount / EXCEL_MAX_ROW) + 1; n++) {
				HSSFSheet sheet;
				if (n == 0) {
					// 创建一个工作表
					sheet = workBook.createSheet(SheetName);
				} else {
					sheet = workBook.createSheet(SheetName + "(" + n + ")");
				}
				// 插入文件头
				if (excelHead != null && excelHead.size() > 0) {
					HSSFRow row00 = sheet.createRow(0);
					HSSFRow row01 = sheet.createRow(1);
					int cell_i=0;
					for (int i = 0; i < excelHead.size(); i++) {
						Map title1=excelHead.get(i);
						if("2".equals(ParseUtils.objToString(title1.get("row"))) && "1".equals(ParseUtils.objToString(title1.get("cell")))){
							sheet.addMergedRegion(new CellRangeAddress(0,  1, (short) cell_i,(short) cell_i));
							HSSFCell cell00 = row00.createCell(cell_i);
							cell00.setCellStyle(cellStyle);
							cell00.setCellValue(ParseUtils.objToString(title1.get("title")));
							cell_i++;
						}
						if("1".equals(ParseUtils.objToString(title1.get("row")))){
						    Integer result = ParseUtils.objToInteger(title1.get("cell"));
							if(result > 0){
								int cell_i_2=cell_i+ParseUtils.objToInteger(title1.get("cell"))-1;
								HSSFCell cell00 = row00.createCell(cell_i);
								cell00.setCellStyle(cellStyle);
								sheet.addMergedRegion(new CellRangeAddress(0,0,(short)cell_i,(short)cell_i_2));
								cell00.setCellValue(ParseUtils.objToString(title1.get("title")));
								cell_i=cell_i_2;
								cell_i++;
							}
						}
					}
					for (int i = 0; i < exceltitle2.size(); i++) {
						HSSFCell cell = row01.createCell(i+8);
						cell.setCellStyle(cellStyle);
						cell.setCellValue(ParseUtils.objToString(exceltitle2.get(i)));
					}
				}

				// 插入数据
				if (dataList != null && dataList.size() > 0) {
					Integer dataLen = dataList.size() - EXCEL_MAX_ROW * n;
					if (dataLen > EXCEL_MAX_ROW) {
						dataLen = EXCEL_MAX_ROW;
					}
					for (int i = 0; i < dataLen; i++) {
						Map lineData = dataList.get(i + EXCEL_MAX_ROW * n);
						Row row = sheet.createRow(i + 2);
						for (int j = 0; j < excelBody.size(); j++) {
							Cell cell = row.createCell(j);
							Object valObj = lineData.get(excelBody.get(j));
							if (valObj != null) {
								cell.setCellValue(valObj + "");
							} else {
								cell.setCellValue("");
							}
						}
					}
				}
			}
			workBook.write(out);
			out.close();
		} catch (IOException e) {
            logger.error("导出数据异常", e);
            throw new RuntimeException(e.getMessage());
        }
	}


	/**
	 * 导出excel并合并列
	 *
	 * @param response
	 * @param excelHead
	 * @param excelBody
	 * @param dataList
	 * @param FileName
	 * @param
	 * @param startRow
	 * @param endRow
	 */
	@SuppressWarnings({ "resource"})
	public static void exportMergeExcelByObject(HttpServletResponse response, List excelHead, List excelBody,
                                                List dataList, String FileName, String sheetName, int startRow, int endRow) {
		try {
			// 文件名称
			String folder = "tempexportexcel" + File.separator + new SimpleDateFormat("yyyyMMdd").format(new Date());
			String location = Thread.currentThread().getContextClassLoader().getResource("").getPath();// 获取路径
			// 创建文件
			File f = new File(location.substring(0, location.indexOf("classes")) + folder);
			if (!f.exists()) {
			    Boolean b = f.mkdirs();
			    if(!b){
                    throw new RuntimeException("创建目录失败");
                }
			}
			ServletOutputStream out = response.getOutputStream();
			response.setHeader("Content-disposition",
					"attachment; filename=" + new String(FileName.getBytes("GB2312"), "8859_1") + ".xlsx");// 设定输出文件头
			response.setContentType("application/msexcel");// 定义输出类型
			// 建立excel文件
			XSSFWorkbook workBook = new XSSFWorkbook();
			XSSFCellStyle cellStyle = workBook.createCellStyle();
			cellStyle.setWrapText(true);    
			cellStyle.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);//垂直居中
			XSSFCellStyle cellSt = workBook.createCellStyle();
			cellSt.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);//垂直居中
			cellSt.setAlignment(HSSFCellStyle.ALIGN_CENTER);
			cellSt.setWrapText(true); 
			int totalCount = 0;
			if (!CollectionUtils.isEmpty(dataList)) {
				totalCount = dataList.size();
			}
			for (int n = 0; n < (totalCount / EXCEL_MAX_ROW) + 1; n++) {
				XSSFSheet sheet;
				if (n == 0) {
					// 创建一个工作表
					sheet = workBook.createSheet(sheetName);
				} else {
					sheet = workBook.createSheet(sheetName + "(" + n + ")");
				}
				sheet.getPrintSetup().setLandscape(true);
				sheet.setColumnWidth(0, 1000);
				sheet.setColumnWidth(1, 3000);
				sheet.setColumnWidth(2, 3000);
				sheet.setColumnWidth(3, 3000);
				sheet.setColumnWidth(4, 3000);
				sheet.setColumnWidth(5, 1700);
				sheet.setColumnWidth(6, 800);
				sheet.setColumnWidth(7, 2500);
				sheet.setColumnWidth(8, 2000);
				sheet.setColumnWidth(9, 3000);
				sheet.setColumnWidth(10, 13000);

				// 插入文件头
				if (excelHead != null && excelHead.size() > 0) {
					XSSFRow row = sheet.createRow(0);
					for (int i = 0; i < excelHead.size(); i++) {
						// 在Label对象的子对象中指明单元格的位置和内容
						XSSFCell cell = row.createCell(i);
						cell.setCellValue(excelHead.get(i) + "");
					}
				}

				// 插入数据
				if (dataList != null && dataList.size() > 0) {
					Integer dataLen = dataList.size() - EXCEL_MAX_ROW * n;
					if (dataLen > EXCEL_MAX_ROW) {
						dataLen = EXCEL_MAX_ROW;
					}
					for (int i = 0; i < dataLen; i++) {
						Object lineData = dataList.get(i + EXCEL_MAX_ROW * n);
						Row row = sheet.createRow(i + 1);
						String thisAddress = "";
						for (int j = 0; j < excelBody.size(); j++) {
							Object valObj = getFieldValueByName(excelBody.get(j), lineData);
							if (j >= startRow && j <= endRow) {
								if(valObj instanceof Date){
									DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
									thisAddress += format.format(valObj);
								}else{
									thisAddress += valObj + "";
								}
							}
							if (j < startRow) {
								Cell cell = row.createCell(j);
								if (j > 0) {
									cell.setCellStyle(cellSt);	
								}
								if (valObj != null) {
									if(valObj instanceof Date){
										DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
										cell.setCellValue(format.format(valObj));
									}else{
										cell.setCellValue(valObj.toString());										
									}
								} else {
									cell.setCellValue("");
								}
							}

							if (j > endRow) {
								Cell cell = row.createCell(j - (endRow - startRow));
								cell.setCellStyle(cellStyle);												
								if (valObj != null) {
									if(valObj instanceof Date){
										DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
										cell.setCellValue(format.format(valObj));
									}else{
										cell.setCellValue(valObj + "");
									}
								} else {
									cell.setCellValue("");
								}
							}

							if (j == endRow) {
								Cell cell = row.createCell(j - (endRow - startRow));
								cell.setCellStyle(cellStyle); 
								cell.setCellValue(thisAddress);
							}
						}
					}
				}
			}
			workBook.write(out);
			out.close();
		} catch (IOException e) {
			logger.error("导出数据异常", e);
            throw new RuntimeException(e.getMessage());
		}
	}
	
	/**
	 * 根据XSSFCell类型设置数据
	 * 
	 * @param cell
	 * @return
	 */
	@Transactional(readOnly = false)
	public static String getCellFormatValue(Cell cell) {
		String cellvalue = "";
		if (cell != null) {
			// 判断当前Cell的Type
			switch (cell.getCellType()) {
			// 如果当前Cell的Type为NUMERIC
			case XSSFCell.CELL_TYPE_NUMERIC:
				cellvalue = String.valueOf(cell.getNumericCellValue());
				break;
			// 如果当前Cell的Type为STRIN
			case XSSFCell.CELL_TYPE_STRING:
				// 取得当前的Cell字符串
				cellvalue = cell.getRichStringCellValue().getString();
				break;
			// 默认的Cell值
			default:
				cellvalue = "";
			}
		} else {
			cellvalue = "";
		}
		if (cellvalue.endsWith(".0")) {
			cellvalue = cellvalue.substring(0, cellvalue.length() - 2);
		}
		return cellvalue;
	}
	
	/**
	 * 读取Excel表格表头的内容
	 * 
	 * @param
	 * @return String 表头内容的数组
	 */
	@Transactional(readOnly = false)
	public static Map> readExcelTitle(XSSFWorkbook wb, InputStream is) {
		Map> map = new HashMap>();
		Sheet sheet = wb.getSheetAt(0);
		Row row0 = sheet.getRow(0);
		Row row1 = sheet.getRow(1);
		// 标题总列数
		int colNum = row0.getPhysicalNumberOfCells();
		Map enTitleMap = new HashMap();
		Map cnTitleMap = new HashMap();

		for (int i = 0; i < colNum; i++) {
			enTitleMap.put(i + "", getCellFormatValue(row0.getCell((short) i)));
			cnTitleMap.put(i + "", getCellFormatValue(row1.getCell((short) i)));
		}
		map.put("enTitleMap", enTitleMap);
		map.put("cnTitleMap", cnTitleMap);
		return map;
	}


	public static Date formatDate(String d) {
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
		Date date = null;
		try {
			date = formatter.parse(d);
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return date;
	}
}

 
  
ParseUtils
 
  
package com.example.utils;


import com.alibaba.fastjson.JSON;

import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class ParseUtils {


	/**
	 * json转list
	 * 
	 * @param
	 * @return list
	 */
	public static List> jsonToList2(String arr) {
		List> returnList = new ArrayList>();
		com.alibaba.fastjson.JSONArray mainArray = JSON.parseArray(arr);
		for (int i = 0; i < mainArray.size(); i++) {
			com.alibaba.fastjson.JSONArray paramObject = (com.alibaba.fastjson.JSONArray) mainArray.get(i);
			Map map = new HashMap();
			for (int j = 0; j < paramObject.size(); j++) {
				map.put(""+j, paramObject.get(j));
			}
			returnList.add(map);
		}
		return returnList;
	}

	/**
	 * Object转Long
	 * 
	 * @param Object
	 * @return Long
	 */
	public static Long objToLong(Object obj) {
		if (obj != null && !"".equals(obj))
			return Long.parseLong(obj.toString());
		else
			return null;
	}
	
	public static Integer objToInteger(Object obj) {
		if (obj != null && !"".equals(obj))
			return Integer.parseInt(obj.toString());
		else
			return null;
	}

	public static BigDecimal objToBigDecimal(Object obj) {
		if (obj != null && !"".equals(obj))
			return new BigDecimal(obj.toString());
		else
			return null;
	}

	/**
	 * Object转String
	 * 
	 * @param Object
	 * @return String
	 */
	public static String objToString(Object obj) {
		if (obj != null)
			return obj.toString();
		else
			return null;
	}
	
	
	public static Date strToDate(String dateString){
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
	    Date date = null;
		try {
			date = sdf.parse(dateString);
		    return date;
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		    return null;
		}  
	}
	
	public static Date strToDateTime(String dateString){
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	    Date date = null;
		try {
			date = sdf.parse(dateString);
		    return date;
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		    return null;
		}  
	}
	
	public static Boolean objToBoolean(Object obj){
		return (Boolean)obj;
	}

	
}


 
  
导入模板，示例：
 
  
   /**
     * 导入数据联系人，进行效验.
     *
     * @param files
     * @return
     * @throws IOException
     */
    @SuppressWarnings("resource")
    @ApiOperation(value = "POST导入数据联系人，进行效验按钮-website:customerMessage:edit", notes = "需要携带Token")
    @RequiresPermissions("website:customerMessage:edit")
    @RequestMapping(value = "fileUpload", method = RequestMethod.POST)
    @ResponseBody
    public ResultBo fileUpload(@RequestParam(value = "files") MultipartFile[] files) throws IOException {
        //对文件大小进行判断是否是空文件
        //对文件后缀进行判断
        if (files.length == 0) {
            return ResultBoFactory.createResultBo(ResultEnum.E1302_FILE_UPLOAD_FAIL);
        }
        //获取文件名字
        String filename = files[0].getOriginalFilename();
        //获取文件后缀
        String filenames = StringUtils.substringAfterLast(filename, ".");
        if (!Filelist.contains(filenames)) {
            return ResultBoFactory.createResultBo(ResultEnum.E1303_FILE_UPLOAD_TYPE_FAIL);
        }
        //读取文件
        InputStream inputStream = files[0].getInputStream();
        //将用户id存入集合中
        List customerInfoList = new ArrayList();

        // 编写解析代码逻辑
        // 基于.xls 格式解析 HSSF
        // 1、 加载Excel文件对象
        HSSFWorkbook hssfWorkbook = new HSSFWorkbook(inputStream);
        // 2、 读取一个sheet
        HSSFSheet sheet = hssfWorkbook.getSheetAt(0);//获取第一个sheet对象
        //获取总行数
        int rowNums = sheet.getLastRowNum();
        if (rowNums > 200) {
            return ResultBoFactory.createResultBo(ResultEnum.E1304_FILE_SIZE);
        }

        // 3、 读取sheet中每一行，一行数据 对应 一个区域对象
        for (Row row : sheet) {
            //设置一列的取值类型
            row.getCell(0).setCellType(HSSFCell.CELL_TYPE_STRING);
            // 第一行表头跳过
            if (row.getRowNum() == 0) {
                // 第一行 跳过
                continue;
            }
            // 跳过id为空值的行，要求此行作废
            if (row.getCell(0) == null
                    || StringUtils.isBlank(row.getCell(0).getStringCellValue())) {
                return ResultBoFactory.createResultBo(ResultEnum.E1305_FILE_ERROR);
                //continue;
            }
            //获取当前行
            int rowNum = row.getRowNum() + 1;
            String stringCellValue = row.getCell(0).getStringCellValue();
            if (stringCellValue.indexOf(" ") != -1) {
                return ResultBoFactory.createResultBo(ResultEnum.E4_OPERATION_FAIL.getCode(), "第" + rowNum + "行" + "存在非法字符!");
            }

            if (!stringCellValue.startsWith("C")) {
                return ResultBoFactory.createResultBo(ResultEnum.E4_OPERATION_FAIL.getCode(), "第" + rowNum + "行" + "所输入用户编号格式不正确！");
            }

            CustomerInfo customerInfo = customerMessageService.queryCustomerInfoByCustomerSeq(stringCellValue);
            if (customerInfo == null) {
                return ResultBoFactory.createResultBo(ResultEnum.E4_OPERATION_FAIL.getCode(), "第" + rowNum + "行用户" + stringCellValue + "不存在!");
            }
            customerInfoList.add(stringCellValue);
        }
        int oldCustomerInfo = customerInfoList.size();//总数量
        List customerList = removeDuplicate(customerInfoList);
        int distinctNum = oldCustomerInfo - customerList.size();

        Map hashMap = new HashMap<>();
        hashMap.put("countExcleSuccess", customerList.size());//上传成功的数量
        hashMap.put("distinctNum", distinctNum);//去重数量
        //将联系人转成字符串
        ObjectMapper mapper = new ObjectMapper();
        String string = mapper.writeValueAsString(customerList);
        hashMap.put("customerInfoId", string);
        return ResultBoFactory.createResultBo(ResultEnum.E0_SUCCESS, hashMap);
    }

    //数据去重
    private static List removeDuplicate(List list) {
        LinkedHashSet set = new LinkedHashSet(list.size());
        set.addAll(list);
        list.clear();
        list.addAll(set);
        return list;
    }

 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(常用Utils)

        

            

                
    
                    
  • OC语言多界面传值五大方式
                        Magnetic_h
iosui学习objective-c开发语言
                        
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
    
                    
    • 
                    
  • 理解Gunicorn：Python WSGI服务器的基石
                        范范0825
ipythonlinux运维
                        
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
    
                    
    • 
                    
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值）
                        研学随笔
arcgis经验分享
                        
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
    
                    
    • 
                    
  • Python数据分析与可视化实战指南
                        William数据分析
pythonpython数据
                        
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
    
                    
    • 
                    
  • git常用命令笔记
                        咩酱-小羊
git笔记
                        
    ###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
    
                    
    • 
                    
  • 509. 斐波那契数(每日一题)
                        lzyprime

                        
    lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
    
                    
    • 
                    
  • Git常用命令－修改远程仓库地址
                        猿大师
LinuxJavagitjava
                        
    查看远程仓库地址gitremote-v返回结果originhttps://git.coding.net/＊＊＊＊＊.git(fetch)originhttps://git.coding.net/＊＊＊＊＊.git(push)修改远程仓库地址gitremoteset-urloriginhttps://git.coding.net/＊＊＊＊＊.git先删除后增加远程仓库地址gitremotermori
    
                    
    • 
                    
  • Day17笔记-高阶函数
                        ~在杰难逃~
Python笔记python开发语言pycharm数据分析
                        
    高阶函数【重点掌握】函数的本质：函数是一个变量，函数名是一个变量名，一个函数可以作为另一个函数的参数或返回值使用如果A函数作为B函数的参数，B函数调用完成之后，会得到一个结果，则B函数被称为高阶函数常用的高阶函数：map(),reduce(),filter(),sorted()1.map()map(func,iterable)，返回值是一个iterator【容器，迭代器】func:函数iterab
    
                    
    • 
                    
  • Python爬虫解析工具之xpath使用详解
                        eqa11
python爬虫开发语言
                        
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
    
                    
    • 
                    
  • mac电脑命令行获取电量
                        小米人er
我的博客macos命令行
                        
    在macOS上，有几个命令行工具可以用来获取电量信息，最常用的是pmset命令。你可以通过以下方式来查看电池状态和电量信息：查看电池状态：pmset-gbatt这个命令会返回类似下面的输出：Nowdrawingfrom'BatteryPower'-InternalBattery-0(id=1234567)95%;discharging;4:02remainingpresent:true输出中包括电
    
                    
    • 
                    
  • Python开发常用的三方模块如下：
                        换个网名有点难
python开发语言
                        
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
    
                    
    • 
                    
  • Shell、Bash、Zsh这都是啥啊
                        小白码上飞
bashlinux开发语言
                        
    Zsh和Bash都是我们常用的Shell，那先搞明白啥是shell吧。Shell作为一个单词，他是“壳”的意思，蛋壳坚果壳。之所以叫壳，是为了和计算机的“核”来区分，用它表示“为使用者提供的操作界面”。所以这个命名其实很形象，翻译成中文，直译过来叫“壳层”。个人认为这个叫法很奇怪，意译貌似也没有什么好的词汇来匹配。就还是叫shell吧。维基百科给的定义是：Incomputing,ashellisa
    
                    
    • 
                    
  • 一文掌握python常用的list（列表）操作
                        程序员neil
pythonpython开发语言
                        
    目录一、创建列表1.直接创建列表：2.使用list()构造器3.使用列表推导式4.创建空列表二、访问列表元素1.列表支持通过索引访问元素，索引从0开始：2.还可以使用切片操作访问列表的一部分：三、修改列表元素四、添加元素1.append()：在末尾添加元素2.insert()：在指定位置插入元素五、删除元素1.del：删除指定位置的元素2.remove()：删除指定值的第一个匹配项3.pop()：
    
                    
    • 
                    
  • 发现荞麦过敏这件事
                        怪小泊

                        
    荞麦在我这里不是常用的谷物。所以前二十年，我以为自己是很正常的，从街头小吃到包装零食到每日三餐，从来没有不能吃的。可是有天我突然病倒了，喉咙火辣辣的肿痛，口水都咽不下去，舌头发麻。当时我以为吃太多零食所致，因为那天我吃了很辣的泡椒凤爪。其实我是不怎么吃辣的。而那个泡椒凤爪真的超辣。当时我以为自己吃多了，并不知道自己对哪个食物过敏。因为不舒服我早早睡了，结果并没有睡着。肚子一阵一阵疼，非常痛苦，终于
    
                    
    • 
                    
  • Linux vi常用命令
                        fengyehongWorld
Linuxlinux
                        
    参考资料viコマンド（vimコマンド）リファレンス目录一.保存系命令二.删除系命令三.移动系命令四.复制粘贴系命令一.保存系命令⏹保存并退出:wq⏹强制保存并退出:wq!⏹退出(文件未编辑):q⏹强制退出(忽略已编辑内容):q!⏹另存为:w新文件名二.删除系命令⏹删除当前行dd⏹清空整个文档gg：移动到文档顶部dG：删除到最后一行ggdG三.移动系命令⏹移动到文档顶部gg⏹移动到文档底部#方式1G
    
                    
    • 
                    
  • CentOS 7官方源停服，配置本机光盘yum源
                        码哝小鱼
linux运维centoslinux运维
                        
    1、挂载系统光盘mkdir/mnt/isomount-oloop/tools/CentOS-7-x86_64-DVD-1810.iso/mnt/isocd/mnt/iso/Packages/rpm-ivh/mnt/iso/Packages/yum-utils-1.1.31-50.el7.noarch.rpm(图形界面安装，默契已安装）如安装yum-utils依赖错误，按提示安装依赖包rpm-ivh
    
                    
    • 
                    
  • 语文主题教学学习笔记之87
                        东哥杂谈

                        
    “语文主题教学”学习笔记之八十七（0125）今天继续学习小学语文主题教学的实践样态。板块三：教学中体现“书艺”味道。作为四大名著之一的《水浒传》，堪称我国文学宝库之经典。对从《水浒传》中摘选的单元，教师就要了解其原生态，即评书体特点。这也要求教师要了解一些常用的评书行话术语，然后在教学时适时地加入一些，让学生体味其文本中原有的特色。学生也要尽可能地通过朗读的方式，而不单是分析讲解的方式进行学习。细
    
                    
    • 
                    
  • Linux查看服务器日志
                        TPBoreas
运维linux运维
                        
    一、tail这个是我最常用的一种查看方式用法如下：tail-n10test.log查询日志尾部最后10行的日志;tail-n+10test.log查询10行之后的所有日志;tail-fn10test.log循环实时查看最后1000行记录(最常用的)一般还会配合着grep用，(实时抓包)例如:tail-fn1000test.log|grep'关键字'（动态抓包）tail-fn1000test.log
    
                    
    • 
                    
  • MongoDB知识概括
                        GeorgeLin98
持久层mongodb
                        
    MongoDB知识概括MongoDB相关概念单机部署基本常用命令索引-IndexSpirngDataMongoDB集成副本集分片集群安全认证MongoDB相关概念业务应用场景：传统的关系型数据库（如MySQL），在数据操作的“三高”需求以及应对Web2.0的网站需求面前，显得力不从心。解释：“三高”需求：①Highperformance-对数据库高并发读写的需求。②HugeStorage-对海量数
    
                    
    • 
                    
  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）...
                        weixin_39762838
mac备份android手机通讯录导入iphone
                        
    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
    
                    
    • 
                    
  • 利用python实现图片格式之间的相互转换
                        难得北窗高卧
python开发语言
                        
    一、概要图片一般有多种格式，常见的图片格式包括：JPEG（.jpg或.jpeg）：一种广泛使用的有损压缩格式，适用于摄影图像和网页上的图片。PNG（.png）：一种无损压缩格式，支持透明度和更好的图像质量，常用于图标、图形和需要透明背景的图片。该图片是4通道的，外加一个透明通道。如截屏GIF（.gif）：一种支持动画和透明度的格式，常用于简单的动画和图标。BMP（.bmp）：一种无损格式，存储图像
    
                    
    • 
                    
  • 入门MySQL——查询语法练习
                        K_un

                        
    前言：前面几篇文章为大家介绍了DML以及DDL语句的使用方法，本篇文章将主要讲述常用的查询语法。其实MySQL官网给出了多个示例数据库供大家实用查询，下面我们以最常用的员工示例数据库为准，详细介绍各自常用的查询语法。1.员工示例数据库导入官方文档员工示例数据库介绍及下载链接：https://dev.mysql.com/doc/employee/en/employees-installation.h
    
                    
    • 
                    
  • 更改npm镜像源为淘宝镜像
                        骆小骆
基于node.js
                        
    npm常用指令后缀*最近复习了一下node.js整理了一下跟node.js相关的指令后缀*--save、-S参数意思是把模块的版本信息保存到dependencies（生产环境依赖）中，即你的package.json文件的dependencies字段中；–--save-dev、-D参数意思是把模块版本信息保存到devDependencies（开发环境依赖）中，即你的package.json文件的de
    
                    
    • 
                    
  • 常见的 JVM 调优方法有哪些？
                        爪哇天下
jvm
                        
    常见的JVM调优方法有哪些？可以具体到调整哪个参数，调成什么值？对年轻代的EdenSurvivor的比例进行配置-XX:SurvivorRatio=8：表示设置2个Survivor区：1个Eden区的大小比值为2:8，这意味着Survivor区占整个年轻代的1/5，这个参数默认为8如果经常性的SurvivorTo放不下YGC的剩余的对象时候，可以适当的调整比例常用的CMS收集器：设置回收阈值，需要
    
                    
    • 
                    
  • 补充元象二面
                        Redstone Monstrosity
前端面试
                        
    1.请尽可能详细地说明，防抖和节流的区别，应用场景？你的回答中不要写出示例代码。防抖（Debounce）和节流（Throttle）是两种常用的前端性能优化技术，它们的主要区别在于如何处理高频事件的触发。以下是防抖和节流的区别和应用场景的详细说明：防抖和节流的定义防抖：在一段时间内，多次执行变为只执行最后一次。防抖的原理是，当事件被触发后，设置一个延迟定时器。如果在这个延迟时间内事件再次被触发，则重
    
                    
    • 
                    
  • pyhon+ffmpeg 常用音视频处理命令
                        不再游移
ffmpeg音视频python
                        
    FFmpeg是多媒体领域的万能工具。只要涉及音视频领域的处理，基本上没有它做不了的事情！通俗点讲，从视频录制、视频编辑再到播放，它都能做！前段时间做了个短视频自动化脚本项目，需要自动处理音视频（包括一些合成、拼接、转场、调色等等），当时做的时候找各种命令还是很痛苦的，因此对用到的所有处理命令做了个汇总，方便以后使用。目录一、获取音频时长二、获取视频信息三、获取视频时长四、多个视频合并五、视频提取视
    
                    
    • 
                    
  • Python数据分析与可视化
                        jun778895
python数据分析开发语言
                        
    Python数据分析与可视化是一个涉及数据处理、分析和以图形化方式展示数据的过程，它对于数据科学家、分析师以及任何需要从数据中提取洞察力的专业人员来说至关重要。以下将详细探讨Python在数据分析与可视化方面的应用，包括常用的库、数据处理流程、可视化技巧以及实际应用案例。一、Python数据分析与可视化的重要性数据可视化是将数据以图形或图像的形式表示出来，以便人们能够更直观地理解数据背后的信息和规
    
                    
    • 
                    
  • [实践应用] 深度学习之模型性能评估指标
                        YuanDaima2048
深度学习工具使用深度学习人工智能损失函数性能评估pytorchpython机器学习
                        
    文章总览：YuanDaiMa2048博客文章总览深度学习之模型性能评估指标分类任务回归任务排序任务聚类任务生成任务其他介绍在机器学习和深度学习领域，评估模型性能是一项至关重要的任务。不同的学习任务需要不同的性能指标来衡量模型的有效性。以下是对一些常见任务及其相应的性能评估指标的详细解释和总结。分类任务分类任务是指模型需要将输入数据分配到预定义的类别或标签中。以下是分类任务中常用的性能指标：准确率(
    
                    
    • 
                    
  • 外卖优惠券公众号哪个好?外卖领券公众号
                        高省爱氧惠

                        
    随着外卖行业的不断发展壮大，越来越多的外卖平台开始推出各种优惠券活动，吸引用户下单。而在这些外卖优惠券公众号中，我最常用的就是【氧惠】了？不知道大家都在用什么。氧惠APP（带货领导者）——是与以往完全不同的抖客+淘客app！2023全新模式，我的直推也会放到你下面。主打：带货高补贴，深受各位带货团队长喜爱（每天出单带货几十万单）。注册即可享受高补贴+0撸+捡漏等带货新体验。送万元推广大礼包，教你如
    
                    
    • 
                    
  • Shell脚本中sed使用
                        jcrhl321
linux
                        
    目录一、sed编辑器1、sed概述2、sed的工作流程3、sed命令的常见格式4、sed命令常用操作二、sed常用命令使用1、sed打印2、sed删除3、sed替换4、sed插入与增加4、sed剪切粘贴与复制粘贴一、sed编辑器sed（StreamEDitor）是一个强大而简单的文本解析转换工具，可以读取文本，并根据指定的条件对文本内容进行编辑（删除、替换、添加、移动等），最后输出所有行或者仅输出
    
                    
    • 
                                
  • ViewController添加button按钮解析。（翻译）
                                    张亚雄
c
                                    
    <div class="it610-blog-content-contain" style="font-size: 14px"></div>//  ViewController.m 
//  Reservation software 
// 
//  Created by 张亚雄 on 15/6/2. 

    
                                
    • 
                                
  • mongoDB 简单的增删改查
                                    开窍的石头
mongodb
                                    
       在上一篇文章中我们已经讲了mongodb怎么安装和数据库/表的创建。在这里我们讲mongoDB的数据库操作 
      在mongo中对于不存在的表当你用db.表名 他会自动统计 
下边用到的user是表明，db代表的是数据库 
 
      添加(insert): 

    
                                
    • 
                                
  • log4j配置
                                    0624chenhong
log4j
                                    
    1) 新建java项目 
2) 导入jar包，项目右击，properties—java build path—libraries—Add External jar，加入log4j.jar包。 
3) 新建一个类com.hand.Log4jTest 
 

package com.hand;

import org.apache.log4j.Logger;


public class 
    
                                
    • 
                                
  • 多点触摸(图片缩放为例)
                                    不懂事的小屁孩
多点触摸
                                    
    多点触摸的事件跟单点是大同小异的，上个图片缩放的代码，供大家参考一下 
 


import android.app.Activity;
import android.os.Bundle;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnTouchListener
    
                                
    • 
                                
  • 有关浏览器窗口宽度高度几个值的解析
                                    换个号韩国红果果
JavaScripthtml
                                    
    1 元素的 offsetWidth 包括border padding  content  整体的宽度。 
clientWidth  只包括内容区 padding 不包括border。 
clientLeft =  offsetWidth -clientWidth  即这个元素border的值 
offsetLeft  若无已定位的包裹元素
    
                                
    • 
                                
  • 数据库产品巡礼：IBM DB2概览
                                    蓝儿唯美
db2
                                    
    IBM DB2是一个支持了NoSQL功能的关系数据库管理系统，其包含了对XML，图像存储和Java脚本对象表示（JSON）的支持。DB2可被各种类型的企 业使用，它提供了一个数据平台，同时支持事务和分析操作，通过提供持续的数据流来保持事务工作流和分析操作的高效性。 DB2支持的操作系统 
DB2可应用于以下三个主要的平台: 
  
 
 工作站，DB2可在Linus、Unix、Windo
    
                                
    • 
                                
  • java笔记5
                                    a-john
java
                                    
    控制执行流程： 
1，true和false 
   利用条件表达式的真或假来决定执行路径。例：（a==b）。它利用条件操作符“==”来判断a值是否等于b值，返回true或false。java不允许我们将一个数字作为布尔值使用，虽然这在C和C++里是允许的。如果想在布尔测试中使用一个非布尔值，那么首先必须用一个条件表达式将其转化成布尔值，例如if(a!=0)。 
2，if-els
    
                                
    • 
                                
  • Web开发常用手册汇总
                                    aijuans
PHP
                                    
    一门技术，如果没有好的参考手册指导,很难普及大众。这其实就是为什么很多技术，非常好，却得不到普遍运用的原因。
 正如我们学习一门技术，过程大概是这个样子：
 ①我们日常工作中，遇到了问题，困难。寻找解决方案，即寻找新的技术；
 ②为什么要学习这门技术？这门技术是不是很好的解决了我们遇到的难题，困惑。这个问题，非常重要，我们不是为了学习技术而学习技术，而是为了更好的处理我们遇到的问题，才需要学习新的
    
                                
    • 
                                
  • 今天帮助人解决的一个sql问题
                                    asialee
sql
                                    
                今天有个人问了一个问题，如下： 
type     AD      value           
A  
    
                                
    • 
                                
  • 意图对象传递数据
                                    百合不是茶
android意图IntentBundle对象数据的传递
                                    
    学习意图将数据传递给目标活动; 初学者需要好好研究的 
   
   1,将下面的代码添加到main.xml中 
   
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http:/
    
                                
    • 
                                
  • oracle查询锁表解锁语句
                                    bijian1013
oracleobjectsessionkill
                                    
    一.查询锁定的表 
如下语句，都可以查询锁定的表 
语句一： 
select a.sid,
       a.serial#,
       p.spid,
       c.object_name,
       b.session_id,
       b.oracle_username,
       b.os_user_name
  from v$process p, v$s
    
                                
    • 
                                
  • mac osx 10.10 下安装 mysql 5.6 二进制文件［tar.gz］
                                    征客丶
mysqlosx
                                    
    场景：在 mac osx 10.10 下安装 mysql 5.6 的二进制文件。 
 
环境：mac osx 10.10、mysql 5.6 的二进制文件 
 
步骤：[所有目录请从根“/”目录开始取，以免层级弄错导致找不到目录] 
1、下载 mysql 5.6 的二进制文件，下载目录下面称之为 mysql5.6SourceDir； 
下载地址：http://dev.mysql.com/downl
    
                                
    • 
                                
  • 分布式系统与框架
                                    bit1129
分布式
                                    
    RPC框架 Dubbo 
什么是Dubbo 
  
Dubbo是一个分布式服务框架，致力于提供高性能和透明化的RPC远程服务调用方案，以及SOA服务治理方案。其核心部分包含:    远程通讯: 提供对多种基于长连接的NIO框架抽象封装，包括多种线程模型，序列化，以及“请求-响应”模式的信息交换方式。    集群容错: 提供基于接
    
                                
    • 
                                
  • 那些令人蛋痛的专业术语
                                    白糖_
springWebSSOIOC
                                    
     
 spring 
 
【控制反转(IOC)/依赖注入(DI)】： 
由容器控制程序之间的关系，而非传统实现中，由程序代码直接操控。这也就是所谓“控制反转”的概念所在：控制权由应用代码中转到了外部容器，控制权的转移，是所谓反转。 
简单的说：对象的创建又容器(比如spring容器)来执行，程序里不直接new对象。 
 
 Web 
 
【单点登录(SSO)】：SSO的定义是在多个应用系统中，用户
    
                                
    • 
                                
  • 《给大忙人看的java8》摘抄
                                    braveCS
java8
                                    
    函数式接口：只包含一个抽象方法的接口 
lambda表达式：是一段可以传递的代码 
  
  
  
你最好将一个lambda表达式想象成一个函数，而不是一个对象，并记住它可以被转换为一个函数式接口。 
事实上，函数式接口的转换是你在Java中使用lambda表达式能做的唯一一件事。 
  
方法引用：又是要传递给其他代码的操作已经有实现的方法了，这时可以使
    
                                
    • 
                                
  • 编程之美-计算字符串的相似度
                                    bylijinnan
java算法编程之美
                                    
    

public class StringDistance {

	/**
	 * 编程之美 计算字符串的相似度
	 * 我们定义一套操作方法来把两个不相同的字符串变得相同，具体的操作方法为：
	 * 1.修改一个字符（如把“a”替换为“b”）;
	 * 2.增加一个字符（如把“abdd”变为“aebdd”）;
	 * 3.删除一个字符（如把“travelling”变为“trav
    
                                
    • 
                                
  • 上传、下载压缩图片
                                    chengxuyuancsdn
下载
                                    
    /**
	 * 
	 * @param uploadImage --本地路径(tomacat路径)
	 * @param serverDir   --服务器路径
	 * @param imageType   --文件或图片类型
	 * 此方法可以上传文件或图片.txt,.jpg,.gif等
	 */
	public void upload(String uploadImage,Str
    
                                
    • 
                                
  • bellman-ford(贝尔曼-福特)算法
                                    comsci
算法F#
                                    
    Bellman-Ford算法(根据发明者 Richard Bellman 和 Lester Ford 命名)是求解单源最短路径问题的一种算法。单源点的最短路径问题是指：给定一个加权有向图G和源点s，对于图G中的任意一点v，求从s到v的最短路径。有时候这种算法也被称为 Moore-Bellman-Ford 算法，因为 Edward F. Moore zu 也为这个算法的发展做出了贡献。 
 
与迪科
    
                                
    • 
                                
  • oracle ASM中ASM_POWER_LIMIT参数
                                    daizj
ASMoracleASM_POWER_LIMIT磁盘平衡
                                    
    ASM_POWER_LIMIT 
该初始化参数用于指定ASM例程平衡磁盘所用的最大权值，其数值范围为0~11，默认值为1。该初始化参数是动态参数，可以使用ALTER  SESSION或ALTER  SYSTEM命令进行修改。示例如下： 
 
SQL>ALTER  SESSION  SET   Asm_power_limit=2; 

    
                                
    • 
                                
  • 高级排序:快速排序
                                    dieslrae
快速排序
                                    
    
    public void quickSort(int[] array){
        this.quickSort(array, 0, array.length - 1);
    }
    
    public void quickSort(int[] array,int left,int right){
        if(right - left <= 0
    
                                
    • 
                                
  • C语言学习六指针_何谓变量的地址 一个指针变量到底占几个字节
                                    dcj3sjt126com
C语言
                                    
    # include <stdio.h>

int main(void)
{
	/*
	1、一个变量的地址只用第一个字节表示
	2、虽然他只使用了第一个字节表示，但是他本身指针变量类型就可以确定出他指向的指针变量占几个字节了
	3、他都只存了第一个字节地址，为什么只需要存一个字节的地址，却占了4个字节，虽然只有一个字节，
		但是这些字节比较多，所以编号就比较大，
		
    
                                
    • 
                                
  • phpize使用方法
                                    dcj3sjt126com
PHP
                                    
    phpize是用来扩展php扩展模块的，通过phpize可以建立php的外挂模块,下面介绍一个它的使用方法,需要的朋友可以参考下 
安装（fastcgi模式）的时候，常常有这样一句命令： 
代码如下: 
/usr/local/webserver/php/bin/phpize 
  
一、phpize是干嘛的？ 
phpize是什么？ 
phpize是用来扩展php扩展模块的，通过phpi
    
                                
    • 
                                
  • Java虚拟机学习 - 对象引用强度
                                    shuizhaosi888
JAVA虚拟机
                                    
     
 本文原文链接：http://blog.csdn.net/java2000_wl/article/details/8090276 转载请注明出处！ 
 无论是通过计数算法判断对象的引用数量，还是通过根搜索算法判断对象引用链是否可达，判定对象是否存活都与“引用”相关。 
 引用主要分为 ：强引用(Strong Reference)、软引用(Soft Reference)、弱引用(Wea
    
                                
    • 
                                
  • .NET Framework 3.5 Service Pack 1（完整软件包）下载地址
                                    happyqing
.net下载framework
                                    
      
Microsoft .NET Framework 3.5 Service Pack 1（完整软件包）  
http://www.microsoft.com/zh-cn/download/details.aspx?id=25150 
Microsoft .NET Framework 3.5 Service Pack 1 是一个累积更新，包含很多基于 .NET Framewo
    
                                
    • 
                                
  • JAVA定时器的使用
                                    jingjing0907
javatimer线程定时器
                                    
    1、在应用开发中，经常需要一些周期性的操作，比如每5分钟执行某一操作等。 
对于这样的操作最方便、高效的实现方式就是使用java.util.Timer工具类。 
privatejava.util.Timer timer; 
timer = newTimer(true); 
timer.schedule( 
newjava.util.TimerTask() { public void run() 

    
                                
    • 
                                
  • Webbench
                                    流浪鱼
webbench
                                    
    首页下载地址 http://home.tiscali.cz/~cz210552/webbench.html 
Webbench是知名的网站压力测试工具，它是由Lionbridge公司（http://www.lionbridge.com）开发。 
Webbench能测试处在相同硬件上，不同服务的性能以及不同硬件上同一个服务的运行状况。webbench的标准测试可以向我们展示服务器的两项内容：每秒钟相
    
                                
    • 
                                
  • 第11章 动画效果（中）
                                    onestopweb
动画
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • windows下制作bat启动脚本.
                                    sanyecao2314
javacmd脚本bat
                                    
    java -classpath C:\dwjj\commons-dbcp.jar;C:\dwjj\commons-pool.jar;C:\dwjj\log4j-1.2.16.jar;C:\dwjj\poi-3.9-20121203.jar;C:\dwjj\sqljdbc4.jar;C:\dwjj\voucherimp.jar com.citsamex.core.startup.MainStart 
    
                                
    • 
                                
  • Java进行RSA加解密的例子
                                    tomcat_oracle
java
                                    
    加密是保证数据安全的手段之一。加密是将纯文本数据转换为难以理解的密文；解密是将密文转换回纯文本。   　　数据的加解密属于密码学的范畴。通常，加密和解密都需要使用一些秘密信息，这些秘密信息叫做密钥，将纯文本转为密文或者转回的时候都要用到这些密钥。   　　对称加密指的是发送者和接收者共用同一个密钥的加解密方法。   　　非对称加密(又称公钥加密)指的是需要一个私有密钥一个公开密钥，两个不同的密钥的
    
                                
    • 
                                
  • Android_ViewStub
                                    阿尔萨斯
ViewStub
                                    
    public final class ViewStub extends View 
 
 
 java.lang.Object 
   
   android.view.View 
     
     android.view.ViewStub 
      
    
 
 类摘要： ViewStub 是一个隐藏的，不占用内存空间的视图对象，它可以在运行时延迟加载布局资源文件。当 ViewSt
    
                                
    •