java按表格顺序读取excel单元格的图片

已于 2022-02-14 16:50:53 修改
阅读量2.3k 收藏 7
点赞数 1
分类专栏： 笔记 office-wps-poi java工具笔记 文章标签： java apache 开发语言
于 2022-01-17 20:59:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38567039/article/details/122548268
版权

   

<!-- POI -->
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>3.17</version>
            <scope>compile</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>xerces</groupId>
            <artifactId>xercesImpl</artifactId>
            <version>2.12.0</version>
            <scope>compile</scope>
            <optional>true</optional>
        </dependency>

wps的excel :

wps只能用workbook.getAllPictures();但是这种图片是没有顺序的 

List<PictureData> pictureDatas = (List<PictureData>) workbook.getAllPictures();

List lst = workbook.getAllPictures();

office的excel:

dasdasd()方法支持office的excel

主要是获取 byte[] data对象字节流然后就是图片文件的内容

//XSSFPictureData就可以直接获取到getData()的byte[]
 byte[] data = stringXSSFPictureDataMap.get(s).getData();
//将文件字节存储到本地
 FileOutputStream out = new FileOutputStream("d:/tiger/file");
//输出到本地目录,或者其他
 out.write(data);
package com.zz.bgf.utils;

import java.io.*;
import java.util.*;

import cn.hutool.poi.excel.WorkbookUtil;
import org.apache.poi.hssf.usermodel.HSSFClientAnchor;
import org.apache.poi.hssf.usermodel.HSSFPicture;
import org.apache.poi.hssf.usermodel.HSSFPictureData;
import org.apache.poi.hssf.usermodel.HSSFShape;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.PictureData;
import org.apache.poi.ss.usermodel.WorkbookFactory;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.util.List;

import org.apache.poi.POIXMLDocumentPart;
import org.apache.poi.hssf.usermodel.HSSFClientAnchor;
import org.apache.poi.hssf.usermodel.HSSFPicture;
import org.apache.poi.hssf.usermodel.HSSFPictureData;
import org.apache.poi.hssf.usermodel.HSSFShape;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.PictureData;
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.xssf.usermodel.XSSFClientAnchor;
import org.apache.poi.xssf.usermodel.XSSFDrawing;
import org.apache.poi.xssf.usermodel.XSSFPicture;
import org.apache.poi.xssf.usermodel.XSSFShape;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.openxmlformats.schemas.drawingml.x2006.spreadsheetDrawing.CTMarker;

/**
 * @since 2013-04-22

 * @author Gerrard

 * 获取excel中 图片，并得到图片位置，支持03 07 多sheet

 */
public class GetImgFromExcel {

    public static void main(String[] args) throws Exception {
        dasdasd();
//        extracted();
        //存储头像，并返回地址

        // 创建文件
//        File file = new File("C:\\Users\\Admin\\Desktop\\新建文件夹\\人物基本信息模板.xlsx");
//        InputStream input = new FileInputStream(file);
//        String fileExt =  file.getName().substring(file.getName().lastIndexOf(".") + 1);
//        Workbook wb = null;
//        Sheet sheet = null;
//        if (fileExt.equals("xls")) {
//            wb = (HSSFWorkbook) WorkbookFactory.create(input);
//        } else {
//            wb = new XSSFWorkbook(input);
//        }
        Sheet sheetAt = workbook.getSheetAt(0);
//        Sheet sheetAt2 = wb.getSheet("Sheet1");
//        getPictures2((XSSFSheet)sheetAt2);
    }

    /**
     * 获取图片和位置 (xlsx)
     * @param sheet
     * @return
     * @throws IOException
     */
    public static Map<String, PictureData> getPictures2(XSSFSheet sheet) throws IOException {
        Map<String, PictureData> map = new HashMap<String, PictureData>();
        List<POIXMLDocumentPart> list = sheet.getRelations();
        for (POIXMLDocumentPart part : list) {
            if (part instanceof XSSFDrawing) {
                XSSFDrawing drawing = (XSSFDrawing) part;
                List<XSSFShape> shapes = drawing.getShapes();
                for (XSSFShape shape : shapes) {
                    XSSFPicture picture = (XSSFPicture) shape;
                    XSSFClientAnchor anchor = picture.getPreferredSize();
                    CTMarker marker = anchor.getFrom();
                    String key = marker.getRow() + "-" + marker.getCol();
                    map.put(key, picture.getPictureData());
                }
            }
        }
        return map;
    }

    private static void extracted() throws IOException {
        //存储头像，并返回地址
        Workbook workbook = WorkbookUtil.createBook(new File("C:\\Users\\Admin\\Desktop\\aa\\dddddddddd.xlsx"));
        List<PictureData> pictureDatas = (List<PictureData>) workbook.getAllPictures();

        List lst = workbook.getAllPictures();
        int a=0;
        for (Iterator it = lst.iterator(); it.hasNext(); ) {
            PictureData pict = (PictureData)it.next();

            String ext = pict.suggestFileExtension();
            byte[] data = pict.getData();
            if (ext.equalsIgnoreCase("png")) {
                FileOutputStream out = new FileOutputStream(++a+"pict.jpg");
                out.write(data);
                out.close();
            }
        }
    }

    private static void dasdasd() throws Exception {
        int a=0;
//存储头像，并返回地址
        Workbook workbook = WorkbookUtil.createBook(new File("C:\\Users\\Admin\\Desktop\\aa\\人员信息.xlsx"));
        List<? extends PictureData> allPictures = workbook.getAllPictures();
        XSSFDrawing dp = (XSSFDrawing) workbook.getSheetAt(0).createDrawingPatriarch();
        List<XSSFShape> pics = dp.getShapes();
        for (XSSFShape pic : pics) {
            XSSFPicture inpPic = (XSSFPicture)pic;

            XSSFClientAnchor clientAnchor = inpPic.getClientAnchor();
            inpPic.getShapeName(); // узнаю название картинки
            PictureData pict = inpPic.getPictureData();
            FileOutputStream out = new FileOutputStream(++a+"pict.png");
            byte[] data = pict.getData();
            out.write(data);
            out.close();
            System.out.println("col1: " + clientAnchor.getCol1() + ", col2: " + clientAnchor.getCol2() + ", row1: " + clientAnchor.getRow1() + ", row2: " + clientAnchor.getRow2());
            System.out.println("x1: " + clientAnchor.getDx1() + ", x2: " + clientAnchor.getDx2() +  ", y1: " + clientAnchor.getDy1() +  ", y2: " + clientAnchor.getDy2());
        }

    }

    /**
     * @param args
     * @throws IOException
     * @throws InvalidFormatException
     */
    public static void main2(String[] args) throws InvalidFormatException, IOException {

        // 创建文件
        File file = new File("D:\\tiger\\资料\\数据导入模板\\人物基本信息模板.xlsx");

        // 创建流
        InputStream input = new FileInputStream(file);

        // 获取文件后缀名
        String fileExt =  file.getName().substring(file.getName().lastIndexOf(".") + 1);

        // 创建Workbook
        Workbook wb = null;

        // 创建sheet
        Sheet sheet = null;

        //根据后缀判断excel 2003 or 2007+
        if (fileExt.equals("xls")) {
            wb = (HSSFWorkbook) WorkbookFactory.create(input);
        } else {
            wb = new XSSFWorkbook(input);
        }

        //获取excel sheet总数
        int sheetNumbers = wb.getNumberOfSheets();

        // sheet list
        List<Map<String, PictureData>> sheetList = new ArrayList<Map<String, PictureData>>();

        // 循环sheet
        for (int i = 0; i < sheetNumbers; i++) {

            sheet = wb.getSheetAt(i);
            // map等待存储excel图片
            Map<String, PictureData> sheetIndexPicMap;

            // 判断用07还是03的方法获取图片
            if (fileExt.equals("xls")) {
                sheetIndexPicMap = getSheetPictrues03(i, (HSSFSheet) sheet, (HSSFWorkbook) wb);
            } else {
                sheetIndexPicMap = getSheetPictrues07(i, (XSSFSheet) sheet, (XSSFWorkbook) wb);
            }
            // 将当前sheet图片map存入list
            sheetList.add(sheetIndexPicMap);
        }

        printImg(sheetList);

    }

    /**
     * 获取Excel2003图片
     * @param sheetNum 当前sheet编号
     * @param sheet 当前sheet对象
     * @param workbook 工作簿对象
     * @return Map key:图片单元格索引（0_1_1）String，value:图片流PictureData
     * @throws IOException
     */
    public static Map<String, PictureData> getSheetPictrues03(int sheetNum,
                                                              HSSFSheet sheet, HSSFWorkbook workbook) {

        Map<String, PictureData> sheetIndexPicMap = new HashMap<String, PictureData>();
        List<HSSFPictureData> pictures = workbook.getAllPictures();
        if (pictures.size() != 0) {
            for (HSSFShape shape : sheet.getDrawingPatriarch().getChildren()) {
                HSSFClientAnchor anchor = (HSSFClientAnchor) shape.getAnchor();
                if (shape instanceof HSSFPicture) {
                    HSSFPicture pic = (HSSFPicture) shape;
                    int pictureIndex = pic.getPictureIndex() - 1;
                    HSSFPictureData picData = pictures.get(pictureIndex);
                    String picIndex = String.valueOf(sheetNum) + "_"
                            + String.valueOf(anchor.getRow1()) + "_"
                            + String.valueOf(anchor.getCol1());
                    sheetIndexPicMap.put(picIndex, picData);
                }
            }
            return sheetIndexPicMap;
        } else {
            return null;
        }
    }

    /**
     * 获取Excel2007图片
     * @param sheetNum 当前sheet编号
     * @param sheet 当前sheet对象
     * @param workbook 工作簿对象
     * @return Map key:图片单元格索引（0_1_1）String，value:图片流PictureData
     */
    public static Map<String, PictureData> getSheetPictrues07(int sheetNum,
                                                              XSSFSheet sheet, XSSFWorkbook workbook) {
        Map<String, PictureData> sheetIndexPicMap = new HashMap<String, PictureData>();

        for (POIXMLDocumentPart dr : sheet.getRelations()) {
            if (dr instanceof XSSFDrawing) {
                XSSFDrawing drawing = (XSSFDrawing) dr;
                List<XSSFShape> shapes = drawing.getShapes();
                for (XSSFShape shape : shapes) {
                    XSSFPicture pic = (XSSFPicture) shape;
                    XSSFClientAnchor anchor = pic.getPreferredSize();
                    CTMarker ctMarker = anchor.getFrom();
                    String picIndex = String.valueOf(sheetNum) + "_"
                            + ctMarker.getRow() + "_" + ctMarker.getCol();
                    sheetIndexPicMap.put(picIndex, pic.getPictureData());
                }
            }
        }

        return sheetIndexPicMap;
    }

    public static void printImg(List<Map<String, PictureData>> sheetList) throws IOException {

        for (Map<String, PictureData> map : sheetList) {
            Object key[] = map.keySet().toArray();
            for (int i = 0; i < map.size(); i++) {
                // 获取图片流
                PictureData pic = map.get(key[i]);
                // 获取图片索引
                String picName = key[i].toString();
                // 获取图片格式
                String ext = pic.suggestFileExtension();

                byte[] data = pic.getData();

                FileOutputStream out = new FileOutputStream("D:\\pic" + picName + "." + ext);
                out.write(data);
                out.close();
            }
        }

    }

}
package com.zz.bgf.utils;


import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.poi.POIXMLDocumentPart;
import org.apache.poi.hssf.usermodel.*;
import org.apache.poi.xssf.usermodel.*;
import org.openxmlformats.schemas.drawingml.x2006.spreadsheetDrawing.CTMarker;

public class ExcelUtils2 {
    // 默认单元格格式化日期字符串
    public static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    // 默认单元格内容为数字时格式
    private static DecimalFormat df = new DecimalFormat("0");
    // 格式化数字
    private static DecimalFormat nf = new DecimalFormat("0.00");

    /**
     * 读取Excel中sheet1的内容
     * @param file
     * @return ArrayList<ArrayList<Object>>
     */
    public static ArrayList<ArrayList<Object>> readExcel(File file) {
        if (file == null) {
            return null;
        }
        if (file.getName().endsWith("xlsx")) {
            // 处理ecxel2007
            return readExcel2007(file);
        } else if (file.getName().endsWith("xls")) {
            // 处理ecxel2003
            return readExcel2003(file);
        } else {
            return null;
        }
    }
    public static Map<String, XSSFPictureData> readExcelFile(File file) throws IOException {
        if (file == null) {
            return null;
        }
        if (file.getName().endsWith("xlsx")) {
            // 处理ecxel2007
            ArrayList<ArrayList<Object>> rowList = new ArrayList<ArrayList<Object>>();
            ArrayList<Object> oneRow = null;
            XSSFWorkbook workbook = new XSSFWorkbook(new FileInputStream(file));
            XSSFSheet sheet = workbook.getSheetAt(0);
            Map<String, XSSFPictureData> pictures2 = getPictures2(sheet);
            return pictures2;
        }
        return null;
    }

    /**
     * @param file
     * @return
     */
    private static ArrayList<ArrayList<Object>> readExcel2003(File file) {
        try {
            ArrayList<ArrayList<Object>> rowList = new ArrayList<ArrayList<Object>>();
            ArrayList<Object> oneRow = null;
            HSSFWorkbook workbook = new HSSFWorkbook(new FileInputStream(file));
            HSSFSheet sheet = workbook.getSheetAt(0);
            HSSFRow row;
            HSSFCell cell;
            Object value;
            for (int i = sheet.getFirstRowNum(); i < sheet.getPhysicalNumberOfRows(); i++) {
                row = sheet.getRow(i);
                oneRow = new ArrayList<Object>();
                if (row == null || checkRowNull2003(row)) {
                    continue;
                }
                for (int j = row.getFirstCellNum(); j < row.getPhysicalNumberOfCells(); j++) {
                    cell = row.getCell(j);
                    if (cell == null || cell.getCellType() == HSSFCell.CELL_TYPE_BLANK) {
                        if (j != row.getLastCellNum()) {
                            oneRow.add("");
                        }
                        continue;
                    }
                    switch (cell.getCellType()) {
                        case HSSFCell.CELL_TYPE_STRING:
                            value = cell.getStringCellValue();
                            break;
                        case HSSFCell.CELL_TYPE_BOOLEAN:
                            value = cell.getBooleanCellValue();
                            break;
                        case HSSFCell.CELL_TYPE_BLANK:
                            value = "";
                            break;
                        case HSSFCell.CELL_TYPE_NUMERIC:
                            if ("General".equals(cell.getCellStyle().getDataFormatString())) {
                                double doubleVal = cell.getNumericCellValue();
                                int intVal = (int) Math.round(doubleVal);
                                if (Double.parseDouble(intVal + ".0") == doubleVal) {
                                    value = df.format(intVal);
                                } else {
                                    value = nf.format(doubleVal);
                                }
                            } else {
                                value = ((Double)cell.getNumericCellValue()).toString();
                            }
                            break;
                        default:
                            value = cell.toString();
                            break;
                    }
                    oneRow.add(value);
                }
                rowList.add(oneRow);
            }
            return rowList;
        } catch (IOException e) {
            return null;
        }
    }

    /**
     * @param file
     * @return
     */
    private static ArrayList<ArrayList<Object>> readExcel2007(File file) {
        try {
            ArrayList<ArrayList<Object>> rowList = new ArrayList<ArrayList<Object>>();
            ArrayList<Object> oneRow = null;
            XSSFWorkbook workbook = new XSSFWorkbook(new FileInputStream(file));
            XSSFSheet sheet = workbook.getSheetAt(0);
            XSSFRow row;
            XSSFCell cell;
            Object value;
            for (int i = sheet.getFirstRowNum(); i < sheet.getPhysicalNumberOfRows(); i++) {
                row = sheet.getRow(i);
                oneRow = new ArrayList<Object>();
                if (row == null || checkRowNull2007(row)) {
                    continue;
                }
                for (int j = row.getFirstCellNum(); j < row.getPhysicalNumberOfCells(); j++) {
                    cell = row.getCell(j);
                    if (cell == null || cell.getCellType() == XSSFCell.CELL_TYPE_BLANK) {
                        if (j != row.getLastCellNum()) {
                            oneRow.add("");
                        }
                        continue;
                    }
                    switch (cell.getCellType()) {
                        case XSSFCell.CELL_TYPE_STRING:
                            value = cell.getStringCellValue();
                            break;
                        case XSSFCell.CELL_TYPE_BOOLEAN:
                            value = cell.getBooleanCellValue();
                            break;
                        case XSSFCell.CELL_TYPE_BLANK:
                            value = "";
                            break;
                        case XSSFCell.CELL_TYPE_NUMERIC:
                            if ("General".equals(cell.getCellStyle().getDataFormatString())) {
                                double doubleVal = cell.getNumericCellValue();
                                int intVal = (int) Math.round(doubleVal);
                                if (Double.parseDouble(intVal + ".0") == doubleVal) {
                                    value = df.format(intVal);
                                } else {
                                    value = nf.format(doubleVal);
                                }
                            } else {
                                value = ((Double)cell.getNumericCellValue()).toString();
                            }
                            break;
                        default:
                            value = cell.toString();
                            break;
                    }
                    oneRow.add(value);
                }
                rowList.add(oneRow);
            }
            return rowList;
        } catch (IOException e) {
            return null;
        }
    }

    /**
     * 判断行为空(xls)
     * @param row
     * @return
     */
    private static boolean checkRowNull2003(HSSFRow row) {
        for (int i = row.getFirstCellNum(); i < row.getPhysicalNumberOfCells(); i++) {
            HSSFCell cell = row.getCell(i);
            if (cell != null && cell.getCellType() != HSSFCell.CELL_TYPE_BLANK) {
                return false;
            }
        }
        return true;
    }

    /**
     * 判断行为空(xlsx)
     * @param row
     * @return
     */
    private static boolean checkRowNull2007(XSSFRow row) {
        for (int i = row.getFirstCellNum(); i < row.getPhysicalNumberOfCells(); i++) {
            XSSFCell cell = row.getCell(i);
            if (cell != null && cell.getCellType() != XSSFCell.CELL_TYPE_BLANK) {
                return false;
            }
        }
        return true;
    }
    /**
     * 获取图片和位置 (xls)
     * @param sheet
     * @return
     * @throws IOException
     */
    public static Map<String, HSSFPictureData> getPictures (HSSFSheet sheet) throws IOException {
        Map<String, HSSFPictureData> map = new HashMap<String, HSSFPictureData>();
        List<HSSFShape> list = sheet.getDrawingPatriarch().getChildren();
        for (HSSFShape shape : list) {
            if (shape instanceof HSSFPicture) {
                HSSFPicture picture = (HSSFPicture) shape;
                HSSFClientAnchor cAnchor = picture.getClientAnchor();
                HSSFPictureData pdata = picture.getPictureData();
                String key = cAnchor.getRow1() + "-" + cAnchor.getCol1(); // 行号-列号
                map.put(key, pdata);
            }
        }
        return map;
    }

    /**
     * 获取图片和位置 (xlsx)
     * @param sheet
     * @return
     * @throws IOException
     */
    public static Map<String, XSSFPictureData> getPictures (XSSFSheet sheet) throws IOException {
        Map<String, XSSFPictureData> map = new HashMap<String, XSSFPictureData>();
        List<POIXMLDocumentPart> list = sheet.getRelations();
        for (POIXMLDocumentPart part : list) {
            if (part instanceof XSSFDrawing) {
                XSSFDrawing drawing = (XSSFDrawing) part;
                List<XSSFShape> shapes = drawing.getShapes();
                for (XSSFShape shape : shapes) {
                    XSSFPicture picture = (XSSFPicture) shape;
                    XSSFClientAnchor anchor = picture.getPreferredSize();
                    CTMarker marker = anchor.getFrom();
                    String key = marker.getRow() + "-" + marker.getCol();
                    map.put(key, picture.getPictureData());
                }
            }
        }
        return map;
    }
    public static Map<String, XSSFPictureData> getPictures2(XSSFSheet sheet) throws IOException {
        Map<String, XSSFPictureData> map = new HashMap<String, XSSFPictureData>();
        List<POIXMLDocumentPart> list = sheet.getRelations();
        for (POIXMLDocumentPart part : list) {
            if (part instanceof XSSFDrawing) {
                XSSFDrawing drawing = (XSSFDrawing) part;
                List<XSSFShape> shapes = drawing.getShapes();
                for (XSSFShape shape : shapes) {
                    XSSFPicture picture = (XSSFPicture) shape;
                    XSSFClientAnchor anchor = picture.getPreferredSize();
                    CTMarker marker = anchor.getFrom();
                    String key = marker.getRow() + "-" + marker.getCol();
                    map.put(key, picture.getPictureData());
                }
            }
        }
        return map;
    }
}

tiger_angel
关注
专栏目录
java获取excel中指定列和位置的图片（浮动式和嵌入到单元格都支持）
luolearn的博客
09-20 1719
获取excel中插入浮动式和嵌入到单元格的图片
java 读取excel表格 内容、图片、图片自动上传、图片上传后回调上传地址，并赋值到图片表格位置
04-03
java 读取excel表格 内容、图片、自动上传、图片上传后回调上传地址，并赋值到图片表格位置, 该文件是一个java源码文件 根据自己的需求修改代码
java顺序获取excel图片
最新发布
a545132569的博客
11-10 208
【代码】java顺序获取excel图片。
java poi 解析excel中单元格内的图片，多张图片按照先后顺序进行排序
weixin_37797336的博客
09-14 2371
需求描述：在excel中一个单元格内，依次从左往右放入多张图片，解析的时候，按照图片的前后 顺序进行解析； 思路： poi提供解析图片的方法，但是同一个单元格内的多张图片，先后顺序没有提供相关方法，查找资料后发现，每个图片可以获取它的坐标，根据其坐标大小，可以对图片进行排序。 代码： 图片坐标如下图所示： 如上图所示，如果图片左右排放，可以按照dx1，dx2大小排序，如果图片上下排放，可以按照dy1,dy2大小进行排序。 ...
java使用POI读取Excel表格中的图片（包含嵌入单元格图片，浮动图片，xls-2003,xlsx-2007）
qq_23123177的博客
10-07 1万+
EasyExcel读取数据非常好用，但是不支持读取表格中的图片数据， java使用POI读取Excel表格中的图片（包含嵌入单元格图片，浮动图片，xls-2003,xlsx-2007）
Java读取Excel表格中的图片
热门推荐
普通还不自信的程序员
02-22 1万+
前言 excel的图片并不是直接嵌入单元格中的，但是在插入图片时可以设置图片格式，将图片放入单元格中，代码就可以根据行号与列号定位到响应的图片。 读取图片 不同版本的excel有不同的拓展名（.xls .xlsx），对应不同的方法。 所有的图片在excel中保存在一个集合中，以行列号为key，图片为value，将结果封装到map集合中，图片的格式为“HSSFPictureData”“XSSFPictureData”。 /** * 获取图片和位置 (xls) * @param sheet
java中excel分段读取_利用java反射机制实现读取excel表格中的数据
weixin_31586521的博客
03-02 782
如果直接把excel表格中的数据导入数据库，首先应该将excel中的数据读取出来。为了实现代码重用，所以使用了Object,而最终的结果是要获取一个list如List、List等，所以需要使用泛型机制去实现。下面会给出代码，可能会稍微复杂一点，但注释很清晰，希望大家耐心阅读。在上代码之前简单说一下思路：1.excel表格必须有表头，且表头中各列的值要与实体类的属性相同；2.先读取表头信息，然后获取...
java中，list集合数据导出到excel表格通用工具类
07-27
在Java编程中，将List集合数据导出到Excel表格是一个常见的需求，特别是在数据分析、报表生成或数据导出等场景。本实例提供了一个通用工具类，能够处理多种不同类型的对象集合，实现了最大化的通用性，使得开发者...
java使用poi带图片导出excel
渝小白的博客
11-24 2366
需求： 导出数据到excel中，数据中包含图片。 导入jar包： <!-- poi office poi.version:3.9--> <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi</artifactId> <version>3.9</version&g
java写入到excel表格乱码怎么办_java excel 写入与下载实现 （解决乱码问题）
weixin_36268255的博客
02-28 1419
情况描述：Excel的默认编码格式是 ANSI，但是 office 版本有很多旧版本的excel无法打开utf-8编码的文件，只能打开ANSI编码的文件 (如office2007版本)新版本的excel可以打开utf-8编码的文件，也能打开ANSI编码的文件 (如office2010版本)因此，不能只是输出一个文件然后给它命名为 .csv/.xlx 这样无法做到版本兼容解决方式：生成一个excel...
Picture.Java
11-09
好代码，你们可以下载，对你们会很有帮助的，不懂的人可以学习一下
java获取excel文件中的数据和图片
anyudong1016的博客
03-05 676
package com.yinghuo.platform.system.api.utils; import org.apache.poi.hssf.usermodel.HSSFCell; import org.apache.poi.hssf.usermodel.HSSFDateUtil; import org.apache.poi.hssf.usermodel.HSSFWorkbook; import org.apache.poi.poifs.filesystem.POIFSFileSystem; imp
java poi方式读取Excel的图片
h1403635700的博客
11-09 4078
JAVA poi读取excel表格
java解析Excel中图片
好记性不如烂笔头
06-18 1159
解析Excel中图片，支持2003和2007版本
java 表格 图片_Java解析excel表格中的图片的方式
weixin_30444625的博客
02-25 359
我们要用java解析首先得在项目中引入解析excel的相关包，我们这里使用的是apache的poi-3.12.jar来做开发。首先获取excel文件，获取文件的方式这里就不细说了，获取到文件后，将文件转成文件输入流FileInputStream fis = new FileInputStream(new File(pathname));//pathname文件路径定义方法getPictureFro...
java获取excel中图片的位置 （xls，xlsx）
Zx1817049184的博客
11-16 331
获取excel中图片的位置 （xls，xlsx）
java读取excel中的多图片
木子金丰的博客
09-17 9222
excel文件如图，获取张三的基本信息及图片信息。 代码如下： 需要导入poi相关的jar 版本3.9及以上 public class ReadExcel {    public static void main(String[] args) throws Exception {   InputStream inp = new FileInputStream("F:\\xxx.xls"
java 获取解析excel中的图片
杜海的博客
12-12 352
所有的图片在excel中保存在一个集合中，以行列号为key，图片为value，将结果封装到map集合中，图片的格式为“HSSFPictureData”“XSSFPictureData”。excel的图片并不是直接嵌入单元格中的，但是在插入图片时可以设置图片格式，将图片放入单元格中，代码就可以根据行号与列号定位到响应的图片。不同版本的excel有不同的拓展名（.xls .xlsx），对应不同的方法。从map拿到图片使用输出流将图片保存在本地。
Java POI 操作Excel：单元格与表格绘制
通过Apache POI，Java开发者能够实现对Excel文件的强大控制，无论是读取现有数据还是创建新的电子表格，甚至添加复杂的格式和图形。这个库提供了丰富的API，使得在Java中处理Excel变得非常灵活和高效。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值