EasyExcel 导出合并层级单元格

EasyExcel 导出合并层级单元格

一、案例

案例一

  • 1.相同订单号单元格进行合并

image-20250207145806662

合并结果

image-20250207145841217

案例二

  • 1.相同订单号的单元格进行合并
  • 2.相同订单号的总数和总金额进行合并

image-20250207150108895

合并结果

image-20250207150033347

案例三

  • 1.相同订单号的单元格进行合并
  • 2.相同订单号的商品分类进行合并
  • 3.相同订单号的总数和总金额进行合并
  • 4.相同订单号和相同商品分类的分类总数、分类总金额进行合并

image-20250207150213477

合并结果

image-20250207150139989

二、代码实现

相关依赖

<dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>easyexcel</artifactId>
        <version>3.2.1</version>
</dependency>

<dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
        <version>5.8.16</version>
</dependency>

<dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.26</version>
</dependency>
2.1 AbstractMergeStrategy
import com.alibaba.excel.write.handler.CellWriteHandler;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.Sheet;
public abstract class AbstractMergeStrategy implements CellWriteHandler {

    /**
     * 最大行索引
     */
    public final static int EXCEL_LAST_INDEX = 1048575;

    /**
     * 默认合并起始行
     */
    public final static int DEFAULT_START_ROW_INDEX = 1;

    /**
     * 合并抽象方法
     * @param sheet
     * @param cell
     */
    public abstract void merge(Sheet sheet, Cell cell);

    /**
     * 获取单元格值
     * @param cell 
     */
    public Object getCellValue(Cell cell) {
        return cell.getCellType() == CellType.STRING ? cell.getStringCellValue() : cell.getNumericCellValue();
    }
}
2.2 ColumnMergeStrategy
import cn.hutool.core.collection.CollUtil;
import com.alibaba.excel.metadata.Head;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.write.metadata.holder.WriteSheetHolder;
import com.alibaba.excel.write.metadata.holder.WriteTableHolder;
import com.easy.excel.demo.model.MergeRowColumn;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.util.CellRangeAddress;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 合并单元格策略：适用于列合并
 */
@Slf4j
public class ColumnMergeStrategy extends AbstractMergeStrategy {

    /**
     * 合并起始行索引
     */
    private int mergeStartRowIndex;

    /**
     * 合并结束行索引
     */
    private int mergeEndRowIndex;

    /**
     * 待合并的列（如果没有指定，则所有的列都会进行合并）
     */
    private List<Integer> mergeColumnIndexList;

    /**
     * 待合并的列父级依赖关系 <需要合并的列索引, 依赖的父级列索引>
     * key 需要合并的列, value 所依赖的父级列的列表    
     */
    private Map<Integer, List<Integer>> mergeColumnIndexMap = new HashMap<>();

    /**
     * 合并的行列索引数据(存储每列的数据合并的行列索引范围)
     */
    private Map<Integer, MergeRowColumn> mergeRowColumnMap = new HashMap<>();

    private Sheet sheet;

    public ColumnMergeStrategy() {
        this(DEFAULT_START_ROW_INDEX, EXCEL_LAST_INDEX);
    }

    public ColumnMergeStrategy(List<Integer> mergeColumnIndexList) {
        this(DEFAULT_START_ROW_INDEX, EXCEL_LAST_INDEX, mergeColumnIndexList);
    }

    public ColumnMergeStrategy(Map<Integer, List<Integer>> mergeColumnIndexMap) {
        this.mergeColumnIndexMap = mergeColumnIndexMap;
        this.mergeColumnIndexList = mergeColumnIndexMap.keySet().stream().collect(Collectors.toList());
        this.mergeStartRowIndex = DEFAULT_START_ROW_INDEX;
        this.mergeEndRowIndex = EXCEL_LAST_INDEX;
    }

    public ColumnMergeStrategy(int mergeStartRowIndex) {
        this(mergeStartRowIndex, EXCEL_LAST_INDEX);
    }

    public ColumnMergeStrategy(int mergeStartRowIndex, int mergeEndRowIndex) {
        this(mergeStartRowIndex, mergeEndRowIndex, new ArrayList<>());
    }

    public ColumnMergeStrategy(int mergeStartRowIndex, int mergeEndRowIndex, List<Integer> mergeColumnIndexList) {
        this.mergeStartRowIndex = mergeStartRowIndex;
        this.mergeEndRowIndex = mergeEndRowIndex;
        this.mergeColumnIndexList = mergeColumnIndexList;
    }

    @Override
    public void afterCellDispose(WriteSheetHolder writeSheetHolder, WriteTableHolder writeTableHolder, List<WriteCellData<?>> list, Cell cell, Head head, Integer integer, Boolean isHead) {

        // 头不参与合并
        if (isHead) {
            return;
        }

        // 初始化 sheet
        if (sheet == null) {
            this.sheet = writeSheetHolder.getSheet();
        }

        // 如果当前行大于合并起始行则进行合并
        if (cell.getRowIndex() >= mergeStartRowIndex && cell.getRowIndex() <= mergeEndRowIndex) {
            // 判断是否是全列合并或者当前列在需要合并列中
            if (CollUtil.isEmpty(mergeColumnIndexList) || (CollUtil.isNotEmpty(mergeColumnIndexList) && mergeColumnIndexList.contains(cell.getColumnIndex()))) {
                // 合并单元格
                this.merge(writeSheetHolder.getSheet(), cell);
            }
        }
    }

    @Override
    public void merge(Sheet sheet, Cell cell) {
        // 当前单元格行、列索引
        int curRowIndex = cell.getRowIndex();
        int curColumnIndex = cell.getColumnIndex();

        // 当前单元格的值为
        Object curCellValue = this.getCellValue(cell);
        // 上一行的行索引
        int aboveRowIndex = curRowIndex - 1;
        if (aboveRowIndex < 0 || aboveRowIndex < mergeStartRowIndex) {
            // 初始化当前列的 合并区域范围
            MergeRowColumn mergeRowColumn = new MergeRowColumn(curRowIndex, curRowIndex, curColumnIndex, curColumnIndex);
            mergeRowColumnMap.put(curColumnIndex, mergeRowColumn);
            return;
        }

        // 获取上一个单元格
        Cell aboveCell = sheet.getRow(aboveRowIndex).getCell(curColumnIndex);

        // 上一个单元格的值
        Object aboveCellValue = this.getCellValue(aboveCell);

        // 判断上一个单元格是否能合并
        if (Objects.equals(curCellValue, aboveCellValue)) {
            boolean needMerge = true;

            // 父级列 列表
            List<Integer> parentColumnIndexList = mergeColumnIndexMap.get(curColumnIndex);
            if (parentColumnIndexList != null && !parentColumnIndexList.isEmpty()) {
                for (Integer parentColumnIndex : parentColumnIndexList) {
                    Cell mainCell = sheet.getRow(curRowIndex).getCell(parentColumnIndex);
                    Cell aboveMainCell = sheet.getRow(aboveRowIndex).getCell(parentColumnIndex);
                    Object mainCellValue = this.getCellValue(mainCell);
                    Object aboveMainCellValue = this.getCellValue(aboveMainCell);

                    // 所有主列都需要满足合并条件才能合并副列
                    if (!Objects.equals(mainCellValue, aboveMainCellValue)) {
                        needMerge = false;
                        break;
                    }
                }
            }

            // 允许合并
            if (needMerge){
                // 修改当前列的行合并索引范围
                MergeRowColumn mergeRowColumn = mergeRowColumnMap.get(curColumnIndex);
                mergeRowColumn.setEndRowIndex(curRowIndex);
            } else {
                // 合并已有的单元格,修改行索引指向
                mergeRowColumnCell(sheet, curRowIndex,curColumnIndex);
            }
        } else {
            // 合并已有的单元格,修改行索引指向
            mergeRowColumnCell(sheet, curRowIndex,curColumnIndex);
        }
    }

    /**
     * 检查给定的单元格是否在一个或多个合并区域中。
     *
     * @return 如果指定单元格是合并区域的一部分，则返回 true；否则返回 false。
     */
    private boolean isMergedRegion(Sheet sheet, Integer rowIndex, Integer columnIndex) {

        // 获取当前工作表中的所有合并区域数量
        int numMergedRegions = sheet.getNumMergedRegions();

        // 遍历所有合并区域
        for (int i = 0; i < numMergedRegions; i++) {
            CellRangeAddress region = sheet.getMergedRegion(i);

            // 检查指定的单元格是否在当前合并区域内
            if (region.isInRange(rowIndex, columnIndex)) {
                return true;
            }
        }
        return false;
    }


    /**
     * 合并区域单元格
     *
     * @param sheet
     * @param curRowIndex
     * @param curColumnIndex
     */
    private void mergeRowColumnCell(Sheet sheet, Integer curRowIndex, Integer curColumnIndex) {
        // 获取当前的列的合并区域索引对象
        MergeRowColumn mergeRowColumn = mergeRowColumnMap.get(curColumnIndex);
        // 合并单元格
        mergeCell(sheet, mergeRowColumn, curRowIndex, curColumnIndex);
    }

    /**
     * 手动合并最后的单元格
     * (最后一段单元格需要手动合并)
     */
    public void finalMergeCell() {
        // 遍历所有列的合并索引,合并最后的单元格
        for (Map.Entry<Integer, MergeRowColumn> entry : mergeRowColumnMap.entrySet()) {
            Integer columnIndex = entry.getKey();
            MergeRowColumn mergeRowColumn = entry.getValue();
            Integer endRowIndex = mergeRowColumn.getEndRowIndex();
            mergeCell(sheet, mergeRowColumn, endRowIndex, columnIndex);
        }
    }


    /**
     * 合并单元格
     *
     * @param sheet
     * @param mergeRowColumn
     * @param curRowIndex
     * @param curColumnIndex
     */
    private void mergeCell(Sheet sheet, MergeRowColumn mergeRowColumn,Integer curRowIndex, Integer curColumnIndex) {

        // 获取合并的行起始索引
        Integer startRowIndex = mergeRowColumn.getStartRowIndex();

        // 获取合并的行结束索引
        Integer endRowIndex = mergeRowColumn.getEndRowIndex();

        // 合并单元格(至少有两个单元格以上才能进行合并)
        if (startRowIndex < endRowIndex) {
            CellRangeAddress cellAddresses = new CellRangeAddress(startRowIndex, endRowIndex, curColumnIndex, curColumnIndex);
            // 判断起始单元格是否已经合并过了
            boolean mergedRegion = isMergedRegion(sheet, startRowIndex, curColumnIndex);
            if (!mergedRegion) {
                // 合并指定区域的单元格
                sheet.addMergedRegion(cellAddresses);
            }
        }
        // 重置合并索引(当前列的行指针下移)
        mergeRowColumn.setStartRowIndex(curRowIndex);
        mergeRowColumn.setEndRowIndex(curRowIndex);
    }
}

源码分析：

  • mergeRowColumnMap 是进行合并的关键所在，存储了所有需要合并的列的行合并区域索引，在遍历数据过程中，根据情况进行单元格合并然后偏移指针，或者只修改指针，这样就不需要频繁的进行合并操作。
2.3 MergeRowColumn
@NoArgsConstructor
@AllArgsConstructor
@Data
public class MergeRowColumn {

    /**
     * 开始行索引
     */
    private Integer startRowIndex;

    /**
     * 结束行索引
     */
    private Integer endRowIndex;

    /**
     * 开始列索引
     */
    private Integer startColumnIndex;

    /**
     * 结束列索引
     */
    private Integer endColumnIndex;
}

三、测试

案例测试代码

import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.util.DateUtils;
import com.alibaba.excel.write.metadata.WriteSheet;
import com.easy.excel.demo.handler.ColumnMergeStrategy;
import com.easy.excel.demo.model.OrderDetailEntity;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.File;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

@Slf4j
@SpringBootTest
public class EasyExcelDemoTest2 {

    /**
     * 案例一
     */
    @Test
    public void testMerge1(){
        File file = new File("order1.xlsx");
        WriteSheet writeSheet = EasyExcel.writerSheet("sheet1")
                .head(OrderDetailEntity.class)
                .registerWriteHandler(new ColumnMergeStrategy(Arrays.asList(0)))// 订单号
                .build();

        ExcelWriter excelWriter = EasyExcel.write(file).build();

        // 写入数据
        excelWriter.write(data(), writeSheet);

        // 手动合并最后的单元格(最后的单元格没有办法合并,需要手动进行合并)
        writeSheet.getCustomWriteHandlerList().stream().filter(handler -> handler instanceof ColumnMergeStrategy)
                .map(handler -> (ColumnMergeStrategy) handler)
                .forEach(handler -> handler.finalMergeCell());

        excelWriter.finish();
    }

    /**
     * 案例二
     */
    @Test
    public void testMerge2(){
        // 输出文件路径
        File file = new File("order2.xlsx");

        // 初始化列合并列父级依赖关系
        Map<Integer, List<Integer>> mergeColumnIndexMap = new HashMap<>();
        mergeColumnIndexMap.put(0, new ArrayList<>());//订单号
        mergeColumnIndexMap.put(10, Arrays.asList(0));//总数 ==> 订单号
        mergeColumnIndexMap.put(11, Arrays.asList(0));//总金额 ==> 订单号

        WriteSheet writeSheet = EasyExcel.writerSheet("sheet1")
                .head(OrderDetailEntity.class)
                .registerWriteHandler(new ColumnMergeStrategy(mergeColumnIndexMap))
                .build();

        ExcelWriter excelWriter = EasyExcel.write(file).build();

        excelWriter.write(data(), writeSheet);

        // 手动合并最后的单元格(分段数据注入时最后的单元格没有办法合并,需要手动进行合并)
        writeSheet.getCustomWriteHandlerList().stream().filter(handler -> handler instanceof ColumnMergeStrategy)
                .map(handler -> (ColumnMergeStrategy) handler)
                .forEach(handler -> handler.finalMergeCell());

        excelWriter.finish();
    }


    /**
     * 案例三
     */
    @Test
    public void testMerge3(){
        // 输出文件路径
        File file = new File("order3.xlsx");

        // 初始化列合并上级依赖关系
        Map<Integer, List<Integer>> mergeColumnIndexMap = new HashMap<>();
        mergeColumnIndexMap.put(0, new ArrayList<>());//订单号
        mergeColumnIndexMap.put(2, Arrays.asList(0));//商品分类 ==> 订单号
        mergeColumnIndexMap.put(8, Arrays.asList(0, 2));//分类总数 ==> 订单号,商品分类
        mergeColumnIndexMap.put(9, Arrays.asList(0, 2));//分类总金额 ==> 订单号,商品分类
        mergeColumnIndexMap.put(10, Arrays.asList(0));//总数 ==> 订单号
        mergeColumnIndexMap.put(11, Arrays.asList(0));//总金额 ==> 订单号

        WriteSheet writeSheet = EasyExcel.writerSheet("sheet1")
                .head(OrderDetailEntity.class)
                .registerWriteHandler(new ColumnMergeStrategy(mergeColumnIndexMap))
                .build();

        ExcelWriter excelWriter = EasyExcel.write(file).build();

        // 模拟分页查询数据
        for (int i = 0; i < 3; i++) {
            excelWriter.write(data(), writeSheet);
        }

        // 手动合并最后的单元格(分段数据注入时最后的单元格没有办法合并,需要手动进行合并)
        writeSheet.getCustomWriteHandlerList().stream().filter(handler -> handler instanceof ColumnMergeStrategy)
                .map(handler -> (ColumnMergeStrategy) handler)
                .forEach(handler -> handler.finalMergeCell());

        excelWriter.finish();
    }

    /**
     * 随机生成测试数据
     * @return
     */
    private Collection<?> data() {

        Map<String, List<String>> productMap = getProductMap();

        List<String> statusList = Arrays.asList("待发货", "已发货", "运输中", "待取货", "已完成");

        List<OrderDetailEntity> dataList = new ArrayList<>();

        Random random = new Random();
        int orderCount = random.nextInt(2) + 5;

        for (int i = 0; i < orderCount; i++) {
            String orderCode = "PL" + DateUtils.format(new Date(), "yyyyMMddHHmm") + "000" + i;
            int orderDetailCount = random.nextInt(10) + 1;

            List<OrderDetailEntity> detailEntities = new ArrayList<>();

            Map<String, BigDecimal> categoryTotalQuantityMap = new HashMap<>();
            Map<String, BigDecimal> categoryTotalPriceMap = new HashMap<>();
            BigDecimal totalQuantity = BigDecimal.ZERO;
            BigDecimal totalPrice = BigDecimal.ZERO;

            for (int j = 0; j < orderDetailCount; j++) {
                String orderDetailCode = UUID.randomUUID().toString();
                String productCategory = new ArrayList<String>(productMap.keySet()).get(random.nextInt(productMap.size()));
                List<String> productList = productMap.get(productCategory);
                String productCode = "SKU" + (random.nextInt(1000)+1000);
                String productName = productList.get(random.nextInt(productList.size())) + "-A" + random.nextInt(50);
                BigDecimal price = new BigDecimal(random.nextInt(2000) + 800);
                BigDecimal quantity = new BigDecimal(random.nextInt(5) + 1);
                String status = statusList.get(random.nextInt(statusList.size()));

                String key = orderCode + "-" + productCategory;
                BigDecimal categoryTotalQuantity = categoryTotalQuantityMap.get(key);
                if (categoryTotalQuantity == null) {
                    categoryTotalQuantity = quantity;
                } else {
                    categoryTotalQuantity = categoryTotalQuantity.add(quantity);
                }
                categoryTotalQuantityMap.put(key, categoryTotalQuantity);

                BigDecimal categoryTotalPrice = categoryTotalPriceMap.get(key);
                if (categoryTotalPrice == null) {
                    categoryTotalPrice = price.multiply(quantity);
                } else {
                    categoryTotalPrice = categoryTotalPrice.add(price.multiply(quantity));
                }
                categoryTotalPriceMap.put(key, categoryTotalPrice);

                totalQuantity = totalQuantity.add(quantity);
                totalPrice = totalPrice.add(price.multiply(quantity));

                detailEntities.add(OrderDetailEntity.builder()
                        .orderCode(orderCode)
                        .orderDetailCode(orderDetailCode)
                        .productCategory(productCategory)
                        .productCode(productCode)
                        .productName(productName)
                        .price(price)
                        .quantity(quantity)
                        .status(status)
                        .build());
            }

            for (OrderDetailEntity item : detailEntities) {
                String key = item.getOrderCode() + "-" + item.getProductCategory();
                item.setCategoryTotalQuantity(categoryTotalQuantityMap.get(key));
                item.setCategoryTotalPrice(categoryTotalPriceMap.get(key));
                item.setTotalQuantity(totalQuantity);
                item.setTotalPrice(totalPrice);
            }
            detailEntities = detailEntities.stream()
                    .sorted(Comparator.comparing(OrderDetailEntity::getOrderCode)
                            .thenComparing(OrderDetailEntity::getProductCategory))
                    .collect(Collectors.toList());

            dataList.addAll(detailEntities);
        }
        return dataList;
    }

    private Map<String, List<String>> getProductMap() {
        Map<String, List<String>> productMap = new HashMap<>();
        // 家电
        List<String> householdList = new ArrayList<>();
        householdList.add("电视机");
        householdList.add("冰箱");
        householdList.add("洗衣机");
        householdList.add("空调");
        productMap.put("家电", householdList);
        // 数码产品
        List<String> digitalList = new ArrayList<>();
        digitalList.add("手机");
        digitalList.add("摄影机");
        digitalList.add("电脑");
        digitalList.add("照相机");
        digitalList.add("投影仪");
        digitalList.add("智能手表");
        productMap.put("数码产品", digitalList);
        // 健身器材
        List<String> gymEquipmentList = new ArrayList<>();
        gymEquipmentList.add("动感单车");
        gymEquipmentList.add("健身椅");
        gymEquipmentList.add("跑步机");
        productMap.put("健身器材", gymEquipmentList);
        return productMap;
    }
}

OrderDetailEntity

import com.alibaba.excel.annotation.ExcelProperty;
import com.alibaba.excel.annotation.write.style.*;
import com.alibaba.excel.enums.poi.BorderStyleEnum;
import com.alibaba.excel.enums.poi.FillPatternTypeEnum;
import com.alibaba.excel.enums.poi.HorizontalAlignmentEnum;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.math.BigDecimal;

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
// 头背景设置
@HeadStyle(fillPatternType = FillPatternTypeEnum.SOLID_FOREGROUND, horizontalAlignment = HorizontalAlignmentEnum.CENTER, borderLeft = BorderStyleEnum.THIN, borderTop = BorderStyleEnum.THIN, borderRight = BorderStyleEnum.THIN, borderBottom = BorderStyleEnum.THIN)
//标题高度
@HeadRowHeight(30)
//内容高度
@ContentRowHeight(20)
//内容居中,左、上、右、下的边框显示
@ContentStyle(horizontalAlignment = HorizontalAlignmentEnum.CENTER, borderLeft = BorderStyleEnum.THIN, borderTop = BorderStyleEnum.THIN, borderRight = BorderStyleEnum.THIN, borderBottom = BorderStyleEnum.THIN)
public class OrderDetailEntity {


    @ExcelProperty(value = "订单号")
    @ColumnWidth(25)
    private String orderCode;

    @ExcelProperty(value = "订单明细")
    @ColumnWidth(40)
    private String orderDetailCode;

    @ExcelProperty(value = "商品分类")
    @ColumnWidth(20)
    private String productCategory;

    @ExcelProperty(value = "商品编码")
    @ColumnWidth(20)
    private String productCode;

    @ExcelProperty(value = "商品名称")
    @ColumnWidth(20)
    private String productName;

    @ExcelProperty(value = "单价")
    @ColumnWidth(10)
    private BigDecimal price;

    @ExcelProperty(value = "数量")
    @ColumnWidth(10)
    private BigDecimal quantity;

    @ExcelProperty(value = "状态")
    @ColumnWidth(10)
    private String status;

    @ExcelProperty(value = "分类总数")
    @ColumnWidth(20)
    private BigDecimal categoryTotalQuantity;

    @ExcelProperty(value = "分类总金额")
    @ColumnWidth(20)
    private BigDecimal categoryTotalPrice;

    @ExcelProperty(value = "总数")
    @ColumnWidth(10)
    private BigDecimal totalQuantity;

    @ExcelProperty(value = "总金额")
    @ColumnWidth(10)
    private BigDecimal totalPrice;
}

参考文章

https://blog.csdn.net/xhmico/article/details/141814528

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/966122.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

WPF 进度条(ProgressBar)示例一

WPF 进度条(ProgressBar)示例一

本文讲述&#xff1a;WPF 进度条(ProgressBar)简单的样式修改和使用。 进度显示界面&#xff1a;使用UserControl把ProgressBar和进度值以及要显示的内容全部组装在UserControl界面中&#xff0c;方便其他界面直接进行使用。 <UserControl x:Class"DefProcessBarDemo…
阅读更多...
LabVIEW自定义测量参数怎么设置?

LabVIEW自定义测量参数怎么设置?

以下通过一个温度采集案例&#xff0c;说明在 LabVIEW 中设置自定义测量参数的具体方法&#xff1a; 案例背景 ​ 假设使用 NI USB-6009 数据采集卡 和 热电偶传感器 监测温度&#xff0c;需自定义以下参数&#xff1a; 采样率&#xff1a;1 kHz 输入量程&#xff1a;0~10 V&a…
阅读更多...
新能源产业的质量革命：六西格玛培训如何重塑制造竞争力

新能源产业的质量革命：六西格玛培训如何重塑制造竞争力

在新能源行业狂飙突进的今天&#xff0c;企业若想在全球供应链中占据高地&#xff0c;仅靠技术突破已远远不够。制造效率的毫厘之差&#xff0c;可能成为市场话语权的千里之距。某光伏巨头曾因电池片良率低于行业均值1.5%&#xff0c;导致年损失超2.3亿元——这恰恰印证了六西格…
阅读更多...
（11）gdb 笔记（4）：设置执行方向 set exec-direction，

（11）gdb 笔记（4）：设置执行方向 set exec-direction，

&#xff08;28&#xff09;引入 record 后&#xff0c;可以 设置执行方向 set exec-direction &#xff1a; 实践&#xff1a; &#xff08;29&#xff09; &#xff08;33&#xff09; 谢谢
阅读更多...
redis持久化理论

redis持久化理论

0 前言 什么是持久化 redis操作都是在内存中&#xff0c;如果出现宕机的话&#xff0c;数据将不复存在&#xff0c;所以持久化是将内存中的数据刷盘到磁盘中&#xff0c;redis可以提供RDB和AOF将数据写入磁盘中。 一 持久化技术 本章节将介绍持久化RDB和AOF两个技术&#xf…
阅读更多...
25/2/7 ＜机器人基础＞雅可比矩阵计算 雅可比伪逆

25/2/7 ＜机器人基础＞雅可比矩阵计算 雅可比伪逆

雅可比矩阵计算 雅可比矩阵的定义 假设我们有一个简单的两个关节的平面机器人臂&#xff0c;其末端执行器的位置可以表示为&#xff1a; 其中&#xff1a; L1​ 和 L2 是机器人臂的长度。θ1​ 和 θ2是关节的角度。 计算雅可比矩阵 雅可比矩阵 JJ 的定义是将关节速度与末…
阅读更多...
鸿蒙UI（ArkUI-方舟UI框架）- 使用文本

鸿蒙UI（ArkUI-方舟UI框架）- 使用文本

返回主章节 → 鸿蒙UI&#xff08;ArkUI-方舟UI框架&#xff09; 文本使用 文本显示 (Text/Span) Text是文本组件&#xff0c;通常用于展示用户视图&#xff0c;如显示文章的文字内容。Span则用于呈现显示行内文本。 创建文本 string字符串 Text("我是一段文本"…
阅读更多...
科技赋能数字内容体验的核心技术探索

科技赋能数字内容体验的核心技术探索

内容概要 在数字化时代&#xff0c;科技的迅猛发展为我们的生活和工作带来了深刻的变革。数字内容体验已经成为人们获取信息和娱乐的重要途径&#xff0c;而这背后的技术支持则扮演着至关重要的角色。尤其是在人工智能、虚拟现实和区块链等新兴技术的推动下&#xff0c;数字内…
阅读更多...
详细教程 | 如何使用DolphinScheduler调度Flink实时任务

详细教程 | 如何使用DolphinScheduler调度Flink实时任务

Apache DolphinScheduler 非常适用于实时数据处理场景&#xff0c;尤其是与 Apache Flink 的集成。DolphinScheduler 提供了丰富的功能&#xff0c;包括任务依赖管理、动态调度、实时监控和日志管理&#xff0c;能够有效简化 Flink 实时任务的管理和部署。通过 DolphinSchedule…
阅读更多...
棋盘（二维差分）

棋盘（二维差分）

题目&#xff1a; 5396. 棋盘 题目 提交记录 讨论 题解 视频讲解 小蓝拥有 nnnn 大小的棋盘&#xff0c;一开始棋盘上全都是白子。 小蓝进行了 mm 次操作&#xff0c;每次操作会将棋盘上某个范围内的所有棋子的颜色取反(也就是白色棋子变为黑色&#xff0c;黑色棋子变…
阅读更多...
MySQL数据库基础（创建/删除 数据库/表）

MySQL数据库基础（创建/删除 数据库/表）

一、数据库的操作 1.1 显示当前数据库 语法&#xff1a;show databases&#xff1b; <1>show 是一个关键字&#xff0c;表示要执行的操作类型 <2>databases 是复数&#xff0c;表示显示所有数据库 上面的数据库中&#xff0c;除了java113&#xff0c;其它的数据库…
阅读更多...
【WebLogic】Oracle发布WebLogic 14c最新版本-14.1.2.0

【WebLogic】Oracle发布WebLogic 14c最新版本-14.1.2.0

根据Oracle官方产品经理的博客&#xff0c;Oracle于2024年12月20日正式对外发布了WebLogic 14c的第二个正式版本&#xff0c;版本号为 14.1.2.0.0 &#xff0c;目前官方已开放客户端下载。该版本除继续支持 Jakarta EE 8 版本外&#xff0c;还增加了对 Java SE 17&#xff08;J…
阅读更多...
SQL Server 数据库迁移到 MySQL 的完整指南

SQL Server 数据库迁移到 MySQL 的完整指南

文章目录 引言一、迁移前的准备工作1.1 确定迁移范围1.2 评估兼容性1.3 备份数据 二、迁移工具的选择2.1 使用 MySQL Workbench2.2 使用第三方工具2.3 手动迁移 三、迁移步骤3.1 导出 SQL Server 数据库结构3.2 转换数据类型和语法3.3 导入 MySQL 数据库3.4 迁移数据3.5 迁移存…
阅读更多...
springboot+vue导入ruoyi项目的框架

springboot+vue导入ruoyi项目的框架

一、介绍 RuoYi-Vue版本&#xff0c;采用了前后端分离的单体架构设计软件环境&#xff1a;JDK、Mysql、Redis、Maven、Node技术选型: Spring Boot、Spring Security、MyBatis、Jwt、Vue3、Element-Plus官方地址: https://gitee.com/y_project/RuoYi-Vue 官方推荐的版本如下&a…
阅读更多...
jvm 篇

jvm 篇

字节码的作用 ‌跨平台性‌&#xff1a;字节码是Java实现跨平台特性的关键。Java源代码编译成字节码后&#xff0c;可以在任何安装了Java虚拟机&#xff08;JVM&#xff09;的设备上运行&#xff0c;这使得Java应用程序能够在不同的操作系统和硬件平台上运行而无需重新编译。‌…
阅读更多...
【Springboot】Springboot 自定义线程池的参数配置最优是多少

【Springboot】Springboot 自定义线程池的参数配置最优是多少

博主介绍&#xff1a;✌全网粉丝22W&#xff0c;CSDN博客专家、Java领域优质创作者&#xff0c;掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域✌ 技术范围&#xff1a;SpringBoot、SpringCloud、Vue、SSM、HTML、Nodejs、Python、MySQL、PostgreSQL、大数据、物…
阅读更多...
【2】Cisco SD-WAN 组件介绍

【2】Cisco SD-WAN 组件介绍

1. 概述 Cisco SD-WAN 是一套基于软件定义的广域网（SD-WAN）解决方案，能够提供安全、可扩展且高效的网络连接。它通过集中的控制和智能路径选择，实现跨多个站点的可靠性、可见性和优化。 在 Cisco SD-WAN 体系架构中，主要由四个核心组件构成： vManage（管理平面） vSmart…
阅读更多...
测试中的第一性原理：回归本质的质量思维革命

测试中的第一性原理：回归本质的质量思维革命

在软件工程领域&#xff0c;测试活动常被惯性思维和经验主义所主导——测试用例库无限膨胀、自动化脚本维护成本居高不下、测试策略与业务目标渐行渐远。要突破这种困境&#xff0c;第一性原理&#xff08;First Principles Thinking&#xff09;提供了独特的解题视角&#xff…
阅读更多...
《chatwise：DeepSeek的界面部署》

《chatwise：DeepSeek的界面部署》

ChatWise&#xff1a;DeepSeek的界面部署 摘要 本文详细描述了DeepSeek公司针对其核心业务系统进行的界面部署工作。从需求分析到技术实现&#xff0c;再到测试与优化&#xff0c;全面阐述了整个部署过程中的关键步骤和解决方案。通过本文&#xff0c;读者可以深入了解DeepSee…
阅读更多...
机器学习在癌症分子亚型分类中的应用

机器学习在癌症分子亚型分类中的应用

学习笔记&#xff1a;机器学习在癌症分子亚型分类中的应用——Cancer Cell 研究解析 1. 文章基本信息 标题&#xff1a;Classification of non-TCGA cancer samples to TCGA molecular subtypes using machine learning发表期刊&#xff1a;Cancer Cell发表时间&#xff1a;20…
阅读更多...
最新文章

Copyright @ 2022~2023