JAVA 使用Apache POI 百万数据导出 Excel表格与Excel转Java对象的工具类

最新推荐文章于 2022-07-14 08:40:23 发布
置顶 最新推荐文章于 2022-07-14 08:40:23 发布
阅读量360 收藏 2
点赞数 2
分类专栏： java 文章标签： java spring mysql json sql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44073315/article/details/103860709
版权

工具类

import org.apache.poi.xssf.streaming.SXSSFRow;
import org.apache.poi.xssf.streaming.SXSSFSheet;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import java.beans.PropertyDescriptor;
import java.io.File;
import java.io.FileInputStream;
import java.io.Serializable;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.text.DateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
public class ExcelUtil implements Serializable {

    private static int lastRow=50000;
    /**
     * List<List<String>>转excle，最多写65535行
     *
     * @param list
     * @return
     */
    public static XSSFWorkbook getExcel(List<List<String>> list) {

        XSSFWorkbook workbook = new XSSFWorkbook();//表格对象
        XSSFSheet sheet = workbook.createSheet();//第一个sheet（工作表）
        sheet.setDefaultColumnWidth(15);

        for (int i = 0; i < list.size(); i++) {
            List<String> strings = list.get(i);

            XSSFRow row = sheet.createRow(i);//0行

            for (int j = 0; j < strings.size(); j++) {
                String s = strings.get(j);


                row.createCell(j).setCellValue(s);//0列


            }
        }

        return workbook;
    }

    /**
     * 直接new新的excle写，最多写65535行
     *
     * @param list
     * @param <T>
     * @return
     */
    public static <T> XSSFWorkbook exportExcel(List<T> list) {
        XSSFWorkbook workbook = new XSSFWorkbook();//表格对象
        XSSFSheet sheet = workbook.createSheet();//第一个sheet（工作表）
        sheet.setDefaultColumnWidth(15);
        int a = 0;//为了设置表头的计数
        int b = 0;//为了跳过没有注解的字段

        for (int j = 0; j < list.size(); j++) {
            T t = list.get(j);
            XSSFRow row = null;
            if (a == 0) {
                row = sheet.createRow(j);//0行

            } else {
                row = sheet.createRow(j + 1);//0行
            }
            Field[] fields = t.getClass().getDeclaredFields();
            for (int i = 0; i < fields.length; i++) {
                if (fields[i].isAnnotationPresent(Excel.class)) {
                    if (a == 0) {
                        Excel annotation = fields[i].getAnnotation(Excel.class);
                        row.createCell(i - b).setCellValue(annotation.title());//0列


                    } else {

                        //设置是否允许访问，不是修改原来的访问权限修饰词。
                        fields[i].setAccessible(true);
                        String s = null;
                        try {
                            s = String.valueOf(fields[i].get(t));
                        } catch (IllegalAccessException e) {

                            e.printStackTrace();
                        }
                        if (s == null || "null".equals(s)) {
                            s = "";
                        }
                        row.createCell(i - b).setCellValue(s);//0列
                    }
                } else {
                    b++;

                }
                if (a == 0 && i == fields.length - 1) {
                    a = 1;
                    j--;
                }
            }
            b = 0;
        }
        return workbook;
    }

    /**
     * 续写excle，最多超过100w条自动新增Sheet
     *
     * @param list
     * @param workbook
     * @param <T>
     * @return
     */
    public static <T> SXSSFWorkbook exportExcelBySXSS(List<T> list, SXSSFWorkbook workbook) {
        int a = 0;//为了设置表头的计数
        int b = 0;//为了跳过没有注解的字段
        int c = list.size();
        int d = 0;//续写的计数
        SXSSFSheet sheet = null;
        if (workbook == null) {
            workbook = new SXSSFWorkbook();//表格对象
            sheet = workbook.createSheet();//第一个sheet（工作表）
        } else {
            sheet = workbook.getSheetAt(workbook.getNumberOfSheets() - 1);
            a = 1;//为了设置表头的计数
            b = 0;//为了跳过没有注解的字段
            d = sheet.getLastRowNum();//续写的计数
            c = c + d;

        }
        sheet.setDefaultColumnWidth(15);
        int temp = 0;
        for (int j = d; j < c; j++) {
            T t = list.get(j - d);
            SXSSFRow row = null;
            if (a == 0) {
                row = sheet.createRow(j - temp);//0行

            } else {
                row = sheet.createRow(j + 1 - temp);//0行
            }
            int lastRowNum = workbook.getSheetAt(workbook.getNumberOfSheets() - 1).getLastRowNum();
            if (lastRowNum >= lastRow) {
                temp = j;
                a = 0;
                sheet = workbook.createSheet();
                row = sheet.createRow(0);//0行
            }
            Field[] fields = t.getClass().getDeclaredFields();
            for (int i = 0; i < fields.length; i++) {
                if (fields[i].isAnnotationPresent(Excel.class)) {
                    if (a == 0) {
                        Excel annotation = fields[i].getAnnotation(Excel.class);
                        row.createCell(i - b).setCellValue(annotation.title());//0列

                    } else {

                        //设置是否允许访问，不是修改原来的访问权限修饰词。
                        fields[i].setAccessible(true);
                        String s = null;
                        try {
                            PropertyDescriptor descriptor = new PropertyDescriptor(fields[i].getName(), t.getClass());
                            Method readMethod = descriptor.getReadMethod();
                            Object o = readMethod.invoke(t);
                            s = String.valueOf(o);//fields[i].get(t)
                        } catch (Exception e) {

                            e.printStackTrace();
                        }

                        if (s == null || "null".equals(s)) {
                            s = "";
                        }
                        row.createCell(i - b).setCellValue(s);//0列
                    }
                } else {
                    b++;

                }

                if (a == 0 && i == fields.length - 1) {
                    a = 1;
                    j--;
                }
            }
            b = 0;
        }

        return workbook;
    }


    /**
     * excel转对象,支持多个sheet，每个sheet必须要有表头 最多65535
     *
     * @param
     * @param t
     * @param <T>
     * @return
     * @throws Exception
     */
       public static <T> List<T> readExcel(XSSFWorkbook workbook,  Class<T> t) throws Exception {
      int count=  workbook.getNumberOfSheets() ;
        List<T> objects = new ArrayList<>();
        for (int temp = 0; temp <count; temp++) {
            XSSFSheet sheet = workbook.getSheetAt(temp);//第一个sheet（工作表）
            int lastRowNum = sheet.getLastRowNum();
            List<String> list = new ArrayList<>();

            if (lastRowNum == 0) {
                return null;
            }

            for (int i = 0; i < 1; i++) {
                XSSFRow row = sheet.getRow(i);
                int lastCellNum = row.getLastCellNum();
                for (int j = 0; j < lastCellNum; j++) {
                    XSSFCell cell = row.getCell(j);
                    String s = cell.toString();
                    list.add(s);
                }
            }


            for (int i = 1; i < lastRowNum+1; i++) {
                XSSFRow row = sheet.getRow(i);
                int lastCellNum = row.getLastCellNum();
                Constructor constructor = t.getConstructor();
                T o = (T) constructor.newInstance();
                for (int j = 0; j < lastCellNum; j++) {
                    XSSFCell cell = row.getCell(j);
                    String s = cell.toString();

                    // 获取obj类的字节文件对象
                    Class c = o.getClass();
                    Field[] fields = c.getDeclaredFields();
                    for (int k = 0; k < fields.length; k++) {


                        if (fields[k].isAnnotationPresent(Excel.class)) {
                            Excel annotation = fields[k].getAnnotation(Excel.class);
                            String title = annotation.title();
                            if (title.equals(list.get(j))) {
                                // 获取该类的成员变量
                                /*   Field f = c.getDeclaredField(fields[k].getName());*/

// 取消语言访问检查
                                Field f = c.getDeclaredField(fields[k].getName());
                                Class<?> type = f.getType();
                                f.setAccessible(true);
// 给变量赋值
                                Object obj=s;
                                if (type.equals(Integer.class)) {
                                    obj=Integer.valueOf(s);
                                }
                                if (type.equals(Double.class)) {
                                    obj=Double.valueOf(s);
                                }
                                if (type.equals(Long.class)) {
                                    obj=Long.valueOf(s);
                                }
                                if (type.equals(Byte.class)) {
                                    obj=Byte.valueOf(s);
                                }
                                if (type.equals(Short.class)) {
                                    obj=Short.valueOf(s);
                                }
                                if (type.equals(Boolean.class)) {
                                    obj=Boolean.valueOf(s);
                                }
                                if (type.equals(Float.class)) {
                                    obj=Float.valueOf(s);
                                }
                                if (type.equals(BigDecimal.class)) {
                                    obj=BigDecimal.valueOf(Long.valueOf(s));
                                }
                                if (type.equals(Date.class)) {
                                    obj=DateFormat.getInstance().parse(s);
                                }
                                f.set(o, obj);

                            }
                        }

                    }
             }
                objects.add(o);
        }

        }
        return objects;
    }


    /**
     * 续写excle，超过100w条自动新增Sheet，可手动设置dateBase字段转前端展示字段
     *
     * @param list
     * @param workbook
     * @param <T>
     * @return
     */

    public static <T> SXSSFWorkbook exportExcelBySXSS(List<T> list, SXSSFWorkbook workbook, HashMap<String,ExcelTableToString> hashMap) {
        int a = 0;//为了设置表头的计数
        int b = 0;//为了跳过没有注解的字段
        int c = list.size();
        int d = 0;//续写的计数
        SXSSFSheet sheet = null;
        if (workbook == null) {
            workbook = new SXSSFWorkbook();//表格对象
            sheet = workbook.createSheet();//第一个sheet（工作表）
        } else {
            sheet = workbook.getSheetAt(workbook.getNumberOfSheets() - 1);
            a = 1;//为了设置表头的计数
            b = 0;//为了跳过没有注解的字段
            d = sheet.getLastRowNum();//续写的计数
            c = c + d;

        }
        sheet.setDefaultColumnWidth(15);
        int temp = 0;

        for (int j = d; j < c; j++) {
            T t = list.get(j - d);
            SXSSFRow row = null;
            if (a == 0) {
                row = sheet.createRow(j - temp);//0行

            } else {
                row = sheet.createRow(j + 1 - temp);//0行
            }
            int lastRowNum = workbook.getSheetAt(workbook.getNumberOfSheets() - 1).getLastRowNum();
            if (lastRowNum >= lastRow) {
                temp = j;
                a = 0;
                sheet = workbook.createSheet();
                row = sheet.createRow(0);//0行
            }
            Field[] fields = t.getClass().getDeclaredFields();
            for (int i = 0; i < fields.length; i++) {
                if (fields[i].isAnnotationPresent(Excel.class)) {
                    Excel annotation = fields[i].getAnnotation(Excel.class);
                    String     title = annotation.title();
                    if (a == 0) {

                        row.createCell(i - b).setCellValue(title);//0列

                    } else {

                        //设置是否允许访问，不是修改原来的访问权限修饰词。
                        fields[i].setAccessible(true);
                        String s = null;
                        try {
                            PropertyDescriptor descriptor = new PropertyDescriptor(fields[i].getName(), t.getClass());
                            Method readMethod = descriptor.getReadMethod();
                            Object o = readMethod.invoke(t);
                            ExcelTableToString excelTableToString = hashMap.get(title);
                            if (excelTableToString!=null){
                                o = excelTableToString.tableToString(o);
                            }
                            s = String.valueOf(o);//fields[i].get(t)
                        } catch (Exception e) {

                            e.printStackTrace();
                        }

                        if (s == null || "null".equals(s)) {
                            s = "";
                        }
                        row.createCell(i - b).setCellValue(s);//0列
                    }
                } else {
                    b++;

                }

                if (a == 0 && i == fields.length - 1) {
                    a = 1;
                    j--;
                }
            }
            b = 0;
        }

        return workbook;
    }


    /**
     * excel表达式写入方式 最多65535
     *   #{}
     * @param
     * @param
     * @param
     * @return
     * @throws Exception
     */
    public static XSSFWorkbook  writeExcel(File file ,HashMap<String,ExcelTableToString> map) throws Exception {

        XSSFWorkbook workbook = new XSSFWorkbook(new FileInputStream(file));//表格对象
        XSSFSheet sheet = workbook.getSheetAt(0);//第一个sheet（工作表）
        int lastRowNum = sheet.getLastRowNum();

        if (lastRowNum == 0) {
    return null;
        }
        for (int i = 1; i < lastRowNum; i++) {
            XSSFRow row = sheet.getRow(i);
            int lastCellNum = row.getLastCellNum();
            for (int j = 0; j < lastCellNum; j++) {
                XSSFCell cell = row.getCell(j);
                String s = cell.toString();
              if (s!=null&&!"".equals(s)){
                  int n = s.indexOf("#{");
                  int m = s.indexOf("}");
                  if (n!=-1&&m!=-1){
                      String substring = s.substring(n+2, m);
                      ExcelTableToString excelTableToString = map.get(substring);
                      Object o = excelTableToString.tableToString(substring);
                      cell.setCellValue(String.valueOf(o));
                  }

              }

            }

        }

    return  workbook;
    }


    /**
     * 续写excle，超过100w条自动新增Sheet，可手动设置dateBase字段转前端展示字段,手动设置当前续写是否要加表头
     *
     * @param list
     * @param workbook
     * @param <T>
     * @return
     */

    public static <T> SXSSFWorkbook exportExcelBySXSS(List<T> list, SXSSFWorkbook workbook, HashMap<String,ExcelTableToString> hashMap,Boolean flag) {
        int a = 0;//为了设置表头的计数
        int b = 0;//为了跳过没有注解的字段
        int c = list.size();
        int d = 0;//续写的计数
        SXSSFSheet sheet = null;
        if (workbook == null) {
            workbook = new SXSSFWorkbook();//表格对象
            sheet = workbook.createSheet();//第一个sheet（工作表）
        } else {
            sheet = workbook.getSheetAt(workbook.getNumberOfSheets() - 1);
            if (flag!=null&& flag==true){
                a=0;
                flag=false;
            }else {
                a = 1;//为了设置表头的计数
            }
            b = 0;//为了跳过没有注解的字段
            d = sheet.getLastRowNum();//续写的计数
            c = c + d;

        }
        sheet.setDefaultColumnWidth(15);
        int temp = 0;

        for (int j = d; j < c; j++) {
            T t = list.get(j - d);
            SXSSFRow row = null;
            if (a == 0) {
                row = sheet.createRow(j - temp);//0行

            } else {
                row = sheet.createRow(j + 1 - temp);//0行
            }
            int lastRowNum = workbook.getSheetAt(workbook.getNumberOfSheets() - 1).getLastRowNum();
            if (lastRowNum >= lastRow) {
                temp = j;
                a = 0;
                sheet = workbook.createSheet();
                row = sheet.createRow(0);//0行
            }
            Field[] fields = t.getClass().getDeclaredFields();
            for (int i = 0; i < fields.length; i++) {
                if (fields[i].isAnnotationPresent(Excel.class)) {
                    Excel annotation = fields[i].getAnnotation(Excel.class);
                    String     title = annotation.title();
                    if (a == 0) {

                        row.createCell(i - b).setCellValue(title);//0列

                    } else {

                        //设置是否允许访问，不是修改原来的访问权限修饰词。
                        fields[i].setAccessible(true);
                        String s = null;
                        try {
                            PropertyDescriptor descriptor = new PropertyDescriptor(fields[i].getName(), t.getClass());
                            Method readMethod = descriptor.getReadMethod();
                            Object o = readMethod.invoke(t);
                            ExcelTableToString excelTableToString = hashMap.get(title);
                            if (excelTableToString!=null){
                                o = excelTableToString.tableToString(o);
                            }
                            s = String.valueOf(o);//fields[i].get(t)
                        } catch (Exception e) {

                            e.printStackTrace();
                        }

                        if (s == null || "null".equals(s)) {
                            s = "";
                        }
                        row.createCell(i - b).setCellValue(s);//0列
                    }
                } else {
                    b++;

                }

                if (a == 0 && i == fields.length - 1) {
                    a = 1;
                    j--;
                }
            }
            b = 0;
        }

        return workbook;
    }


    /**
     * 续写excle，超过5w条自动新增Sheet(最多65535)，可手动设置dateBase字段转前端展示字段,手动设置当前续写是否要加表头
     *
     * @param list
     * @param workbook
     * @param <T>
     * @return
     */

    public static <T> XSSFWorkbook exportExcelBySXSS(List<T> list, XSSFWorkbook workbook, HashMap<String,ExcelTableToString> hashMap,Boolean flag) {
        int a = 0;//为了设置表头的计数
        int b = 0;//为了跳过没有注解的字段
        int c = list.size();
        int d = 0;//续写的计数
        XSSFSheet sheet = null;
        if (workbook == null) {
            workbook = new XSSFWorkbook();//表格对象
            sheet = workbook.createSheet();//第一个sheet（工作表）
        } else {
            sheet = workbook.getSheetAt(workbook.getNumberOfSheets() - 1);
            if (flag!=null&& flag==true){
                a=0;
                flag=false;
            }else {
                a = 1;//为了设置表头的计数
            }
            b = 0;//为了跳过没有注解的字段
            d = sheet.getLastRowNum();//续写的计数
            c = c + d;

        }
        sheet.setDefaultColumnWidth(15);
        int temp = 0;

        for (int j = d; j < c; j++) {
            T t = list.get(j - d);
            XSSFRow row = null;
            if (a == 0) {
                row = sheet.createRow(j - temp);//0行

            } else {
                row = sheet.createRow(j + 1 - temp);//0行
            }
            int lastRowNum = workbook.getSheetAt(workbook.getNumberOfSheets() - 1).getLastRowNum();
            if (lastRowNum >= lastRow) {
                temp = j;
                a = 0;
                sheet = workbook.createSheet();
                row = sheet.createRow(0);//0行
            }
            Field[] fields = t.getClass().getDeclaredFields();
            for (int i = 0; i < fields.length; i++) {
                if (fields[i].isAnnotationPresent(Excel.class)) {
                    Excel annotation = fields[i].getAnnotation(Excel.class);
                    String     title = annotation.title();
                    if (a == 0) {

                        row.createCell(i - b).setCellValue(title);//0列

                    } else {

                        //设置是否允许访问，不是修改原来的访问权限修饰词。
                        fields[i].setAccessible(true);
                        String s = null;
                        try {
                            PropertyDescriptor descriptor = new PropertyDescriptor(fields[i].getName(), t.getClass());
                            Method readMethod = descriptor.getReadMethod();
                            Object o = readMethod.invoke(t);
                            ExcelTableToString excelTableToString = hashMap.get(title);
                            if (excelTableToString!=null){
                                o = excelTableToString.tableToString(o);
                            }
                            s = String.valueOf(o);//fields[i].get(t)
                        } catch (Exception e) {

                            e.printStackTrace();
                        }

                        if (s == null || "null".equals(s)) {
                            s = "";
                        }
                        row.createCell(i - b).setCellValue(s);//0列
                    }
                } else {
                    b++;

                }

                if (a == 0 && i == fields.length - 1) {
                    a = 1;
                    j--;
                }
            }
            b = 0;
        }

        return workbook;
    }


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

    }
}

注解

@Retention(RetentionPolicy.RUNTIME)
public @interface Excel {

    String title();//表头
}

函数接口

public interface ExcelTableToString {
    public Object tableToString(Object o);
}

实体类

public class User implements Serializable{
   @Excel(title = "id")
   Integer id ;
   @Excel(title = "姓名")
   String name;

   private String sex;
   @Excel(title = "年龄")
   String age;

   public User() {
   }

   public User(Integer id, String name, String age) {
       this.id = id;
       this.name = name;
       this.age = age;
   }

   public String getSex() {
       return sex;
   }

   public void setSex(String sex) {
       this.sex = sex;
   }

   public Integer getId() {
       return id;
   }

   public void setId(Integer id) {
       this.id = id;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public String getAge() {
       return age;
   }

   public void setAge(String age) {
       this.age = age;
   }
}

测试


public class test {
   public static void main(String[] args) throws Exception {
    List<User> list = new ArrayList<>();
    list.add(new User(1,"小明","12"));
    list.add(new User(2,"小李","13"));
    list.add(new User(3,"小张","14"));
       XSSFWorkbook sheets = ExcelUtil.exportExcel(list);
       FileOutputStream fileOutputStream = new FileOutputStream("D:/test.xlsx");
       sheets.write(fileOutputStream);
       fileOutputStream.flush();
       fileOutputStream.close();
       sheets.close();
   }
}
乐菜鸟
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
使用 poi 将 excel 转换为 JavaBean 对象
qq_35408156的博客
04-23 2272
1. 创建 maven 工程，pom.xml 如下 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://m...
java 读取本地excel 文件，将excel内容转换成java对象
热门推荐
普雅雷蒙达的博客
03-31 2万+
操作工具 eclipse + maven 1. java操作excel所使用的jar包 poi-ooxml        &lt;dependency&gt;      &lt;groupId&gt;org.apache.poi&lt;/groupId&gt;      &lt;artifactId&gt;poi-ooxml&lt;/artifactId&gt;      &lt;versi...
用excel生成java对象_Apache POI操作Excel导出JAVABEAN对象方法
weixin_36219894的博客
02-26 336
Apache POI操作Excel导出方法说明Apache的POI组件是Java操作Microsoft Office办公套件的强大API，其中对Word，Excel和PowperPoint都有支持，当然使用较多的还是Excel，因为Word和PowerPoint用程序动态操作的应用较少。本文主要介绍一下Excel的操作方法。HSSF－提供读写Microsoft ExcelXLS格式档案的功能...
通用POI读取Excel封装成JavaBean
qq_39623859的博客
07-02 1万+
通用POI读取Excel封装成JavaBean工作中需要开发一个通过客户上传的Excel，读取数据并更新数据库。解析Excel有很多开源工具，由于项目中有了POI依赖，所以我使用POI来完成此次开发。考虑到直接固定针对此类业务Excel文件开发，虽然简单，但将来如果又有其它的业务同样是需要Excel来提供数据，那么就还需要做Excel的特定解析，显然这样做的话，以后有多少个业务，就需要针对...
poiji:一个微型库，基于Apache POI将excel行转换为Java对象列表
05-12
Poiji Poiji是一个很小的Java库，它提供了一种从Excel工作表映射到Java类的方法。 在某种程度上，它使我们可以将指定excel数据的每一行转换为Java对象。 Poiji在后台使用 （Microsoft文档的Java API）来完成映射过程。 目录 入门 在您的Maven / Gradle项目中，首先添加相应的依赖项： 专家 < dependency> < groupId>com.github.ozlerhakan</ groupId> < artifactId>poiji</ artifactId> < version>3.1.0</ version> </ dependency> 摇动 dependencies { compile ' com.github.ozlerhakan:poiji:3.1.0 ' }
Java使用excel工具类导出对象功能示例
08-28
在使用Java excel工具类导出对象功能时，首先需要创建一个SXSSFWorkbook对象，该对象是Apache POI提供的一个高性能的Excel写入器，能够快速地将数据写入Excel文件中。然后，需要定义一个Sheet对象，该对象是Excel...
java中，list集合数据导出到excel表格通用工具类
07-27
在Java编程中，将List集合数据导出到Excel表格是一个常见的需求，特别是在数据分析、报表生成或数据导出等场景。本实例提供了一个通用工具类，能够处理多种不同类型的对象集合，实现了最大化的通用性，使得开发者...
java导出大批量(百万以上)数据的excel文件
08-30
- 使用SXSSFWorkbook：Apache POI库提供了SXSSFWorkbook类，这是一个基于流的Excel API，它可以在内存中仅保持最近使用的行，其余数据则写入磁盘，从而有效减少内存占用。 2. **分片导出**： - 如上述代码所示，...
Apache POI 导出Excel工具类的实现，超简单实用
09-25
本文将深入讲解如何使用Apache POI创建一个简单的Excel导出工具类。 1. **安装与引入Apache POI** 在开始之前，你需要在项目中添加Apache POI的依赖。如果你使用的是Maven，可以在pom.xml文件中添加以下依赖： ...
报表技术POI导入导出复杂样式Excel和百万数据（Java代码）.zip
最新发布
11-08
本文将深入探讨使用Apache POI库在Java环境中处理Excel文件，特别是涉及复杂样式和处理海量数据的场景。 Apache POI是Apache软件基金会的一个开源项目，主要为Microsoft Office格式提供读写支持，包括Excel、Word和...
java用poi解析excel2003和2007并封装成对象返回
04-21
NULL 博文链接：https://skyfar666.iteye.com/blog/1922052
Java实现树形层级结构的表格
07-24
Java实现的，将树形层级结构的数据转换成表格，通过打点的方式向表格中插入数据，支持行头表格、列头表格、交叉表格三种形式
使用poi读取上传的Excel文件，并将数据封装到java对象中
lyd的博客
11-11 1934
使用poi读取Excel文件，并将数据封装到java对象中Maven引入依赖Excel工具类 Maven引入依赖 <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi</artifactId> ...
java excel poi 封装_在java中使用Apache POI导出Excel文档，基本的工具类与Annotation封装，可对任意简单对象直接使用...
weixin_32968239的博客
02-16 202
在java中使用Apache POI导出Excel文档，基本的工具类与Annotation封装，可对任意简单对象直接使用做了个导出Excel文档的需求于是写了个泛用性挺高的工具，只要是简单对象都没问题。即对象Field的类型都为基本数据类型及其包装类、String、Date这些就可以。要是对象里边还有集合啊、对象啊啥的就不行了。挺简单的，就懒得传到Github了，写篇博客记录一下。既然要使用apa...
poi工具类java,基于POI的Excel工具类
weixin_34254464的博客
03-25 185
package com.kaishengit.excel;import com.kaishengit.pojo.ShopDTO;import org.apache.commons.lang.StringUtils;import org.apache.poi.hssf.usermodel.HSSFDateUtil;import org.apache.poi.ss.usermodel.Cell;imp...
Java利用第三方库POI解析Excel
qq_55135629的博客
07-14 1725
Java借助第三方库POI对Excel进行解析及写入
Java工具集-Excel行转换为对象工具类
逍遥云恋
06-09 705
代码示例 package com.simple.util.poi; import com.simple.util.time.DateUtil; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.lang3.StringUtils; import java.io.Serializable; import java.lang.reflect.Field; import java.util.Arra
Apache POI 工具类 [ PoiUtil ]
weixin_30642267的博客
01-04 848
pom.xml &lt;dependency&gt; &lt;groupId&gt;org.apache.poi&lt;/groupId&gt; &lt;artifactId&gt;poi-ooxml&lt;/artifactId&gt; &lt;version&gt;3.1...
Apache POI实现Excel文件上传、导出，工具类分享
adididada的博客
10-20 425
在开发一个积分商城的项目中，客户需求是可以通过excel文件导入防伪码信息。以便用户在前台输入商品上的防伪码兑换积分，所以花一点时间研究了JAVA对Excel的处理方式，这里作出记录，以便诸位学习和日后自己再次使用。 一. API概述 本次使用的对Excel的操作的API是Apache的POI项目，其Maven依赖如下： <dependency> <groupId>commons-io</gr
使用Apache POI实现Java导出EXCEL
有了这个基础类，我们可以编写一个Excel导出工具类，利用Java的反射机制来动态地根据对象的属性生成Excel表格。反射允许我们在运行时检查和操作类的信息，包括其字段和方法。以下是一个简化的示例，展示了如何使用...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值