Excel作为数据存储的小型载体，在日常工作中应用十分广泛，从表格打开、查看数据、处理数据，到最后的关闭表格，往往需要操作很多步骤，今天我们就盘点下那些实用且高频的快捷键组合。
浏览数据概况——Ctrl+↑ ↓ ← → 方向键
表格打开之后，第一时间先了解下数据情况，通过快捷键Ctrl+↑ ↓ ← →方向键快速移动到表格连续区域的最端部，对数据有个大概认知，可以了解数据一共有多少行、多少列。
需要注意的是，按一次快捷键只会移动到当前连续区域的最端部，如果表格存在不连续区域，需要按多次快捷键。
与之类似的快捷键Ctrl+shift+↑ ↓ ← →方向键，框选连续区域，小伙伴们自行尝试。
全选复制粘贴——Ctrl+A/C/V
复制数据三部曲，Ctrl+A全选内容，Ctrl+C复制内容，Ctrl+V粘贴内容，一个都不能少。
取消编辑与删除内容——Esc/Delete
单个单元格正在进行编辑的时候，如果想要退出编辑并还原之前的数据，按下“Esc”键即可；如果要删除表格中的数据，只需要鼠标框选需要删除的数据，按“Delete”键即可。
快速填充——Ctrl+D/R
快速填充功能等价于复制粘贴，只不过要更加迅速，同样适用于公式。
Ctrl+D竖向填充，Ctrl+R横向填充。
设置单元格格式——Ctrl+1
设置单元格格式必不可少，如果快速调出设置单元格格式界面？Ctrl+1搞定~
调整行列位置——Ctrl+X
剪切快捷键，Ctrl+X，不同于复制，Ctrl+X为剪切键，剪切粘贴之后，原位置的内容将不复存在。
下例中展示调换两列的位置，Ctrl+X快速搞定。
筛选快捷键——Ctrl+shift+L
筛选数据你还在【数据】—【筛选】吗？是时候掌握快捷筛选了！
Ctrl+shift+L，快速筛选，按一次出现筛选，再按一次，取消筛选~
窗口切换——Alt+Tab
有些时候需要在两个表格之间来回切换查看数据，Alt+Tab快捷键，快速切换没烦恼~
当然，Alt+Tab适用于任何窗口之间的切换，网页、应用程序等等，它只会在最近打开的两个界面之间进行切换。
撤销与前进——Ctrl+Z/Y
单元格误操作，输入错了内容，想还原表格？Ctrl+Z一下~撤销上步操作，可以多次按，撤销多步，如果撤销过了的话，按下Ctrl+Y前进一步即可。搭配使用，再也不用担心操作失误啦~
需要注意的是，Excel某些步骤是撤销不了的，如删除了某个工作表插页，插页删除之后，按 Ctrl+Z是没有效果的，如果想要复原，立马关闭表格，不要保存！再次打开表格就好了~
保存并关闭——Ctrl+S/W
一张表如果有修改的话，在关闭的时候Excel会人性化的提醒你是否需要保存？
有弹窗的话，需要多操作几步，本着能省则省的原则，当我们意识到需要把表格关闭的时候，先按下Ctrl+S键，将工作簿保存下来，再按下Ctrl+W键，关闭工作簿，一气呵成，全程快捷键，跟鼠标说拜拜~
小结
以上十组快捷键你是不是也经常用到呢？喜欢的小伙伴欢迎点赞关注转发，每天分享实用的小技巧。

一、需求



我们从数据库中获取到上面的内容

1.现在想做的就是把字段名也就是每一行放在excel表格里面的每一列。

2.把最后一行字段也就是字段的注释放到excel表格里面的第二列

通过Notepad++来实现

1.1,首先我们来获取字段名也就是每一行放在excel表格里面的第一列这个要求



这是复制到Notepad++里面原来的模样

1.1.1,去除相同的东西，肉眼看上去像是一行的









经过上面的替换之后就会出现下面的情况 +[^\n]*

注意这个 +[^\n]*这个表单式前面有个空格的,否则就会出问题。







 

1.1.1，上面的方法也可以不用这么麻烦，只不过是为了便于理解，看下面的方法



经过上面的替换之后就会出现下面的情况 +[^\n]*

注意这个 +[^\n]*这个表单式前面有个空格的，否则就会出现问题的。





1.1.2，获取把最后一行字段也就是字段的注释放到excel表格里面的第二列

先按照上面的方式把这段改成这样的



[^\)\n]+\)

把)前面的内容全部删除





^\s+

去除行首空行







 

 

 

 

 

参考：

http://phpmianshi.com/?id=56

有时我们copy的代码中前面有行号，一个一个删除太麻烦

可以用下面三种方式删除行号：

1.awk操作

 awk '{for(i=2;i<=NF;i++)printf("%s ",$i);print ""}' test.c  > test2.c


详解：

for (i=2;i<=NF;i++) printf("%s ",$i)  从第二列开始到最后，注意%s 后面有空格。

然后copy到编辑器格式化一下就好了

 

缺点是需要去编辑器再格式化一下

 

2.vim操作

 

在命令模式下按gg进入首行首字符

ctrl + v进入块显示模式

选中每一行的前两个字符，直到末行 delete删除

 

3.sed操作

cat test.php | sed -e 's/^[^0-9a-zA-Z]*[0-9]\{1,\}//g'


^0-9a-zA-Z  非数字或者字母开头
[0-9]\{1,\}   多位的数字

调用方法：

1、合并单元格(要合并单元格的excel 的sheet,要合并的列,要合并列的开始行,要合并列的结束行,HSSFWorkbook 对象) 

//合并某一列值相同的单元格的 （第2列，从第5行开始，到最后一行）



PoiUtil.addMergedRegion(sheet, 1, 4, sheet.getLastRowNum(),wb);

2、拷贝sheet 实际调用( @目标sheet, @源sheet,@目标 HSSFWorkbook,@源 HSSFWorkbook,@复制前几行)



package com.bf.cityBuild.util;
import java.text.DecimalFormat;
import java.util.HashMap;
import java.util.Map;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFClientAnchor;
import org.apache.poi.hssf.usermodel.HSSFComment;
import org.apache.poi.hssf.usermodel.HSSFPalette;
import org.apache.poi.hssf.usermodel.HSSFPatriarch;
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.ss.util.CellRangeAddress;
import org.apache.poi.hssf.util.HSSFColor;

/**
 * POI工具类 功能点： 1、实现excel的sheet复制，复制的内容包括单元的内容、样式、注释
setMForeColor修改HSSFColor.YELLOW的色值，setMBorderColor修改PINK的色值
 * @author Administrator
 */
public final class PoiUtil {

    /**
     * 功能：拷贝sheet 实际调用 copySheet(targetSheet, sourceSheet, targetWork,
     * sourceWork, true)
     * 
     * @param targetSheet
     * @param sourceSheet
     * @param targetWork
     * @param sourceWork
     */
    public static void copySheet(HSSFSheet targetSheet, HSSFSheet sourceSheet, HSSFWorkbook targetWork,
            HSSFWorkbook sourceWork, int index) throws Exception {
        if (targetSheet == null || sourceSheet == null || targetWork == null || sourceWork == null) {
            throw new IllegalArgumentException(
                    "调用PoiUtil.copySheet()方法时，targetSheet、sourceSheet、targetWork、sourceWork都不能为空，故抛出该异常！");
        }
        copySheet(targetSheet, sourceSheet, targetWork, sourceWork, true, index);
    }

    /**
     * 功能：拷贝sheet
     * 
     * @param targetSheet
     * @param sourceSheet
     * @param targetWork
     * @param sourceWork
     * @param copyStyle
     *            boolean 是否拷贝样式
     */
    public static void copySheet(HSSFSheet targetSheet, HSSFSheet sourceSheet, HSSFWorkbook targetWork,
            HSSFWorkbook sourceWork, boolean copyStyle, int index) throws Exception {

        if (targetSheet == null || sourceSheet == null || targetWork == null || sourceWork == null) {
            throw new IllegalArgumentException(
                    "调用PoiUtil.copySheet()方法时，targetSheet、sourceSheet、targetWork、sourceWork都不能为空，故抛出该异常！");
        }

        // 复制源表中的行
        int maxColumnNum = 0;

        Map styleMap = (copyStyle) ? new HashMap() : null;

        HSSFPatriarch patriarch = targetSheet.createDrawingPatriarch(); // 用于复制注释
        for (int i = sourceSheet.getFirstRowNum(); i <= index; i++) {
            HSSFRow sourceRow = sourceSheet.getRow(i);
            HSSFRow targetRow = targetSheet.createRow(i);

            if (sourceRow != null) {
                copyRow(targetRow, sourceRow, targetWork, sourceWork, patriarch, styleMap);
                if (sourceRow.getLastCellNum() > maxColumnNum) {
                    maxColumnNum = sourceRow.getLastCellNum();
                }
            }
        }

        // 复制源表中的合并单元格
        mergerRegion(targetSheet, sourceSheet);

        // 设置目标sheet的列宽
        for (int i = 0; i <= maxColumnNum; i++) {
            targetSheet.setColumnWidth(i, sourceSheet.getColumnWidth(i) + 250);
        }

    }

    /**
     * 功能：拷贝row
     * 
     * @param targetRow
     * @param sourceRow
     * @param styleMap
     * @param targetWork
     * @param sourceWork
     * @param targetPatriarch
     */
    public static void copyRow(HSSFRow targetRow, HSSFRow sourceRow, HSSFWorkbook targetWork, HSSFWorkbook sourceWork,
            HSSFPatriarch targetPatriarch, Map styleMap) throws Exception {
        if (targetRow == null || sourceRow == null || targetWork == null || sourceWork == null
                || targetPatriarch == null) {
            throw new IllegalArgumentException(
                    "调用PoiUtil.copyRow()方法时，targetRow、sourceRow、targetWork、sourceWork、targetPatriarch都不能为空，故抛出该异常！");
        }

        // 设置行高
        targetRow.setHeight(sourceRow.getHeight());

        for (int i = sourceRow.getFirstCellNum(); i <= sourceRow.getLastCellNum(); i++) {
            HSSFCell sourceCell = sourceRow.getCell(i);
            HSSFCell targetCell = targetRow.getCell(i);

            if (sourceCell != null) {
                if (targetCell == null) {
                    targetCell = targetRow.createCell(i);
                }

                // 拷贝单元格，包括内容和样式
                copyCell(targetCell, sourceCell, targetWork, sourceWork, styleMap);

                // 拷贝单元格注释
                copyComment(targetCell, sourceCell, targetPatriarch);
            }
        }
    }

    /**
     * 功能：拷贝cell，依据styleMap是否为空判断是否拷贝单元格样式
     * 
     * @param targetCell
     *            不能为空
     * @param sourceCell
     *            不能为空
     * @param targetWork
     *            不能为空
     * @param sourceWork
     *            不能为空
     * @param styleMap
     *            可以为空
     */
    public static void copyCell(HSSFCell targetCell, HSSFCell sourceCell, HSSFWorkbook targetWork,
            HSSFWorkbook sourceWork, Map styleMap) {
        if (targetCell == null || sourceCell == null || targetWork == null || sourceWork == null) {
            throw new IllegalArgumentException(
                    "调用PoiUtil.copyCell()方法时，targetCell、sourceCell、targetWork、sourceWork都不能为空，故抛出该异常！");
        }

        // 处理单元格样式
        if (styleMap != null) {
            if (targetWork == sourceWork) {
                targetCell.setCellStyle(sourceCell.getCellStyle());
            } else {
                String stHashCode = "" + sourceCell.getCellStyle().hashCode();
                HSSFCellStyle targetCellStyle = (HSSFCellStyle) styleMap.get(stHashCode);
                if (targetCellStyle == null) {
                    targetCellStyle = targetWork.createCellStyle();
                    targetCellStyle.cloneStyleFrom(sourceCell.getCellStyle());
                    styleMap.put(stHashCode, targetCellStyle);
                }

                targetCell.setCellStyle(targetCellStyle);
            }
        }

        // 处理单元格内容
        switch (sourceCell.getCellType()) {
        case HSSFCell.CELL_TYPE_STRING:
            targetCell.setCellValue(sourceCell.getRichStringCellValue());
            break;
        case HSSFCell.CELL_TYPE_NUMERIC:
            targetCell.setCellValue(sourceCell.getNumericCellValue());
            break;
        case HSSFCell.CELL_TYPE_BLANK:
            targetCell.setCellType(HSSFCell.CELL_TYPE_BLANK);
            break;
        case HSSFCell.CELL_TYPE_BOOLEAN:
            targetCell.setCellValue(sourceCell.getBooleanCellValue());
            break;
        case HSSFCell.CELL_TYPE_ERROR:
            targetCell.setCellErrorValue(sourceCell.getErrorCellValue());
            break;
        case HSSFCell.CELL_TYPE_FORMULA:
            targetCell.setCellFormula(sourceCell.getCellFormula());
            break;
        default:
            break;
        }
    }

    /**
     * 功能：拷贝comment
     * 
     * @param targetCell
     * @param sourceCell
     * @param targetPatriarch
     */
    public static void copyComment(HSSFCell targetCell, HSSFCell sourceCell, HSSFPatriarch targetPatriarch)
            throws Exception {
        if (targetCell == null || sourceCell == null || targetPatriarch == null) {
            throw new IllegalArgumentException(
                    "调用PoiUtil.copyCommentr()方法时，targetCell、sourceCell、targetPatriarch都不能为空，故抛出该异常！");
        }

        // 处理单元格注释
        HSSFComment comment = sourceCell.getCellComment();
        if (comment != null) {
            HSSFComment newComment = targetPatriarch.createComment(new HSSFClientAnchor());
            newComment.setAuthor(comment.getAuthor());
            newComment.setColumn(comment.getColumn());
            newComment.setFillColor(comment.getFillColor());
            newComment.setHorizontalAlignment(comment.getHorizontalAlignment());
            newComment.setLineStyle(comment.getLineStyle());
            newComment.setLineStyleColor(comment.getLineStyleColor());
            newComment.setLineWidth(comment.getLineWidth());
            newComment.setMarginBottom(comment.getMarginBottom());
            newComment.setMarginLeft(comment.getMarginLeft());
            newComment.setMarginTop(comment.getMarginTop());
            newComment.setMarginRight(comment.getMarginRight());
            newComment.setNoFill(comment.isNoFill());
            newComment.setRow(comment.getRow());
            newComment.setShapeType(comment.getShapeType());
            newComment.setString(comment.getString());
            newComment.setVerticalAlignment(comment.getVerticalAlignment());
            newComment.setVisible(comment.isVisible());
            targetCell.setCellComment(newComment);
        }
    }

    /**
     * 功能：复制原有sheet的合并单元格到新创建的sheet
     * 
     * @param sheetCreat
     * @param sourceSheet
     */
    public static void mergerRegion(HSSFSheet targetSheet, HSSFSheet sourceSheet) throws Exception {
        if (targetSheet == null || sourceSheet == null) {
            throw new IllegalArgumentException("调用PoiUtil.mergerRegion()方法时，targetSheet或者sourceSheet不能为空，故抛出该异常！");
        }

        for (int i = 0; i < sourceSheet.getNumMergedRegions(); i++) {
            CellRangeAddress oldRange = sourceSheet.getMergedRegion(i);
            CellRangeAddress newRange = new CellRangeAddress(oldRange.getFirstRow(), oldRange.getLastRow(),
                    oldRange.getFirstColumn(), oldRange.getLastColumn());
            targetSheet.addMergedRegion(newRange);
        }
    }

    /**
     * 功能：重新定义HSSFColor.PINK的色值
     * 
     * @param workbook
     * @return
     */
    public static HSSFColor setMBorderColor(HSSFWorkbook workbook) {
        HSSFPalette palette = workbook.getCustomPalette();
        HSSFColor hssfColor = null;
        byte[] rgb = { (byte) 0, (byte) 128, (byte) 192 };
        try {
            hssfColor = palette.findColor(rgb[0], rgb[1], rgb[2]);
            if (hssfColor == null) {
                palette.setColorAtIndex(HSSFColor.PINK.index, rgb[0], rgb[1], rgb[2]);
                hssfColor = palette.getColor(HSSFColor.PINK.index);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return hssfColor;
    }

    /*
     * 合并单元格
     * 
     * @param sheet 要合并单元格的excel 的sheet
     * 
     * @param cellLine 要合并的列
     * 
     * @param startRow 要合并列的开始行
     * 
     * @param endRow 要合并列的结束行
     */
    public static void addMergedRegion(HSSFSheet sheet, int cellLine, int startRow, int endRow, HSSFWorkbook workBook) {

        HSSFCellStyle style = workBook.createCellStyle(); // 样式对象

        style.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);// 垂直
        style.setAlignment(HSSFCellStyle.ALIGN_CENTER);// 水平
        style.setBorderBottom(HSSFCellStyle.BORDER_THIN); //下边框
        style.setBorderLeft(HSSFCellStyle.BORDER_THIN);//左边框
        style.setBorderTop(HSSFCellStyle.BORDER_THIN);//上边框
        style.setBorderRight(HSSFCellStyle.BORDER_THIN);//右边框
        //style.setBorderBottom((short) 1);
        //style.setBottomBorderColor(HSSFColor.BLACK.index); // 设置单元格的边框颜色  
        style.setWrapText(true);
        // 获取第一行的数据,以便后面进行比较
        //String s_will = sheet.getRow(startRow).getCell(cellLine).getStringCellValue();
        String s_will = getCellValue(sheet.getRow(startRow).getCell(cellLine));

        int count = 0;
        for (int i = startRow + 1; i <= endRow; i++) {
            String s_current = getCellValue(sheet.getRow(i).getCell(cellLine));
            startRow = i;
            if (s_will.equals(s_current)) {
                count++;
            } else {
                s_will=s_current;
                if (count != 0) {
                    sheet.addMergedRegion(new CellRangeAddress(startRow - count-1, startRow-1, cellLine, cellLine)); // 合并单元格
                    HSSFRow row = sheet.getRow(startRow - count); // 获取合并单元格的第一行
                    //String cellValueTemp = row.getCell(cellLine).getStringCellValue(); // 获得第n个单元格的值
                    String cellValueTemp = getCellValue(row.getCell(cellLine)); // 获得第n个单元格的值
                    HSSFCell cell = row.createCell(cellLine); //重新创建单元格
                    cell.setCellValue(cellValueTemp); // 跨单元格显示的数据
                    cell.setCellStyle(style);
                    count = 0;
                }

            }
            // 由于上面循环中合并的单元放在有下一次相同单元格的时候做的，所以最后如果几行有相同单元格则要运行下面的合并单元格。
            if (i == endRow && count > 0) {
                sheet.addMergedRegion(new CellRangeAddress(endRow - count, endRow, cellLine, cellLine));
                String cellValueTemp = getCellValue(sheet.getRow(startRow - count).getCell(cellLine));
                HSSFRow row = sheet.getRow(startRow - count);
                HSSFCell cell = row.createCell(cellLine);
                cell.setCellValue(cellValueTemp); // 跨单元格显示的数据
                cell.setCellStyle(style); // 样式
            }
        }
    }


    /**
     * 
     * 
     * @Title: getCellValue
     * 
     * @Description: 对Excel的各个单元格的格式进行判断并转换
     * 
     * @param cell @return 设定文件
     * 
     * @author af
     * 
     * @return String 返回类型
     * 
     * @throws
     */
    @SuppressWarnings("unused")
    private static String getCellValue(HSSFCell cell) {
        String cellValue = ""; // 返回的单元格内容
        DecimalFormat df = new DecimalFormat("#");// 用来格式化除零外的数字
        if (cell == null) { // 如果此单元格没有内容，返回空字符串
            return "";
        }
        switch (cell.getCellType()) { // 判断单元格类型
        case HSSFCell.CELL_TYPE_STRING: // 字符串型
            cellValue = cell.getRichStringCellValue().getString().trim();// 获取去除空格后的单元格内容
            break;
        case HSSFCell.CELL_TYPE_NUMERIC: // 数字型
            cellValue = df.format(cell.getNumericCellValue()).toString();// 获取单元格内的数字并转为String
            break;
        case HSSFCell.CELL_TYPE_BOOLEAN: // 布尔型
            cellValue = String.valueOf(cell.getBooleanCellValue()).trim();// 获取去除空格后的单元格的值
            break;
        case HSSFCell.CELL_TYPE_FORMULA: // 公式
            cellValue = cell.getCellFormula(); // 返回单元格的公式；如（SUM(C4:E4)）
            break;
        default: // 其他类型统一返回空字符串
            cellValue = "";
        }
        return cellValue;
    }

}