Excel百万级别数据的导入和导出【详细代码】

news2025/2/27 4:57:03

代码层级结构

        

DurationAspect

package com.zhouyu.aspect;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.boot.SpringApplication;
import org.springframework.stereotype.Component;

import java.time.Duration;


@Component
@Aspect
public class DurationAspect {

    private static final Log logger = LogFactory.getLog(DurationAspect.class);

    @Around("execution(public void com.zhouyu.controller.SalariesController.exportExcel*(..))")
    public void exportExcel(ProceedingJoinPoint joinPoint) {
        long startTime = System.nanoTime();
        logger.info("开始导出：" + joinPoint.getSignature().getName());
        try {
            joinPoint.proceed();
        } catch (Throwable e) {
            throw new RuntimeException(e);
        } finally {
            Duration time = Duration.ofNanos(System.nanoTime() - startTime);
            logger.info("导出结束，消耗了：" + time.getSeconds() + "s");
        }

    }

    @Around("execution(public void com.zhouyu.controller.SalariesController.importExcel*(..))")
    public void importExcel(ProceedingJoinPoint joinPoint) {
        long startTime = System.nanoTime();
        logger.info("开始导入：" + joinPoint.getSignature().getName());
        try {
            joinPoint.proceed();
        } catch (Throwable e) {
            throw new RuntimeException(e);
        } finally {
            Duration time = Duration.ofNanos(System.nanoTime() - startTime);
            logger.info("导入结束，消耗了：" + time.getSeconds() + "s");
        }

    }
}

SalariesController

package com.zhouyu.controller;

import com.zhouyu.service.ExportService;
import com.zhouyu.service.ImportService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;



@RestController
public class SalariesController {

    @Resource
    private ExportService exportService;

    @Resource
    private ImportService importService;

    //方案一：查全表，写入一个sheet
    @GetMapping("export1")
    public void exportExcel1(HttpServletResponse response) throws IOException {
        exportService.exportExcel1(response);
    }

    //方案二：查全部，写入多个sheet
    @GetMapping("export2")
    public void exportExcel2(HttpServletResponse response) throws IOException {
        exportService.exportExcel2(response);
    }

    //方案三：分页查询，每页数据写入每个sheet
    @GetMapping("export3")
    public void exportExcel3(HttpServletResponse response) throws IOException {
        exportService.exportExcel3(response);
    }

    //方案四：多线程分页查询，每页数据写入多个sheet
    @GetMapping("export4")
    public void exportExcel4(HttpServletResponse response) throws IOException, InterruptedException {
        exportService.exportExcel4(response);
    }

    //excel的导入
    @PostMapping("import")
    public void importExcel(MultipartFile file) throws IOException {
        importService.importExcel(file);
        importService.importExcelAsync(file);
    }


}

Salaries

package com.zhouyu.domain;

import org.springframework.beans.factory.InitializingBean;

import javax.annotation.PostConstruct;
import java.util.Date;

/**
 * salaries实体类
 * */
public class Salaries {

    private Integer empNo;
    private Integer salary;
    private Date fromDate;
    private Date toDate;

    public Integer getEmpNo() {
        return empNo;
    }

    public void setEmpNo(Integer empNo) {
        this.empNo = empNo;
    }

    public Integer getSalary() {
        return salary;
    }

    public void setSalary(Integer salary) {
        this.salary = salary;
    }

    public Date getFromDate() {
        return fromDate;
    }

    public void setFromDate(Date fromDate) {
        this.fromDate = fromDate;
    }

    public Date getToDate() {
        return toDate;
    }

    public void setToDate(Date toDate) {
        this.toDate = toDate;
    }
}

SalariesListener

package com.zhouyu.listener;

import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.read.listener.ReadListener;
import com.baomidou.mybatisplus.extension.service.IService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zhouyu.domain.Salaries;
import com.zhouyu.mapper.SalariesMapper;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;



@Component
public class SalariesListener extends ServiceImpl<SalariesMapper, Salaries> implements ReadListener<Salaries>, IService<Salaries> {

    private static final Log logger = LogFactory.getLog(SalariesListener.class);
    // 创建一个固定线程数的线程池进行解析excel
    private ExecutorService executorService = Executors.newFixedThreadPool(20);

    //使用ThreadLocal保证线程并发安全
    private ThreadLocal<ArrayList<Salaries>> salariesList = ThreadLocal.withInitial(ArrayList::new);
    private static AtomicInteger count = new AtomicInteger(1);
    //一次批量导入的条数
    private static final int batchSize = 10000;

    @Resource
    private SalariesListener salariesListener;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void invoke(Salaries data, AnalysisContext context) {
        // 方案一：单线程逐行解析，单线程单行数据插入
        // 解析一行，导入数据库一行
//        saveOne(data);

        // 方案二，单线程逐行解析，单线程批量插入
        // 将解析的Salaries对象添加到集合当中进行批量导入
        salariesList.get().add(data);
        if (salariesList.get().size() >= batchSize) {
            //方案三：单线程插入数据库
//            saveData();
            //方案四：多线程插入数据库
            asyncSaveData();
        }
    }

    public void saveOne(Salaries data){
        save(data);
        logger.info("第" + count.getAndAdd(1) + "次插入1条数据");
    }

    //单线程插入数据库
    public void saveData() {
        if (!salariesList.get().isEmpty()) {
            // 批量写入
            saveBatch(salariesList.get(), salariesList.get().size());
            logger.info("第" + count.getAndAdd(1) + "次插入" + salariesList.get().size() + "条数据");
            //将List中的数据进行清空，重新对excel中的数据进行解析
            salariesList.get().clear();
        }

    }
    //多线程插入数据库
    public void asyncSaveData() {
        if (!salariesList.get().isEmpty()) {
            //将集合clone转换成Salaries的集合对象
            ArrayList<Salaries> salaries = (ArrayList<Salaries>) salariesList.get().clone();
            //将集合对象传递到线程当中去
            executorService.execute(new SaveTask(salaries, salariesListener));
            salariesList.get().clear();
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void doAfterAllAnalysed(AnalysisContext context) {
        logger.info("一个Sheet全部处理完");
        if (salariesList.get().size() >= batchSize) {
            saveData();
        }
    }

    /**
     * 创建线程的方式
     * 实现Runnable接口重写run方法
     * */
    static class SaveTask implements Runnable {

        private List<Salaries> salariesList;
        private SalariesListener salariesListener;

        public SaveTask(List<Salaries> salariesList, SalariesListener salariesListener) {
            this.salariesList = salariesList;
            this.salariesListener = salariesListener;
        }

        @Override
        public void run() {
            //监听器进行批量导入
            salariesListener.saveBatch(salariesList);
            logger.info("第" + count.getAndAdd(1) + "次插入" + salariesList.size() + "条数据");
        }
    }
}

SalariesMapper

package com.zhouyu.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.zhouyu.domain.Salaries;
import org.apache.ibatis.annotations.Mapper;


@Mapper
public interface SalariesMapper extends BaseMapper<Salaries> {

}

ExportService

package com.zhouyu.service;

import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.write.metadata.WriteSheet;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.zhouyu.domain.Salaries;
import com.zhouyu.mapper.SalariesMapper;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


@Service
public class ExportService {
    public static final String CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";

    @Resource
    private SalariesMapper salariesMapper;

    public void exportExcel1(HttpServletResponse response) throws IOException {

        setExportHeader(response);

        List<Salaries> salaries = salariesMapper.selectList(null);

        EasyExcel.write(response.getOutputStream(), Salaries.class).sheet().doWrite(salaries);
    }


    public void exportExcel2(HttpServletResponse response) throws IOException {

        setExportHeader(response);

        List<Salaries> salaries = salariesMapper.selectList(null);

        try (ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream(), Salaries.class).build()) {
            WriteSheet writeSheet1 = EasyExcel.writerSheet(1, "模板1").build();
            WriteSheet writeSheet2 = EasyExcel.writerSheet(2, "模板2").build();
            WriteSheet writeSheet3 = EasyExcel.writerSheet(3, "模板3").build();

            List<Salaries> data1 = salaries.subList(0, salaries.size() / 3);
            List<Salaries> data2 = salaries.subList(salaries.size() / 3, salaries.size() * 2 / 3);
            List<Salaries> data3 = salaries.subList(salaries.size() * 2 / 3, salaries.size());


            excelWriter.write(data1, writeSheet1);
            excelWriter.write(data2, writeSheet2);
            excelWriter.write(data3, writeSheet3);
        }
    }


    public void exportExcel3(HttpServletResponse response) throws IOException {

        setExportHeader(response);

        try (ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream(), Salaries.class).build()) {

            Long count = salariesMapper.selectCount(null);
            Integer pages = 10;
            Long size = count / pages;

            for (int i = 0; i < pages; i++) {
                WriteSheet writeSheet = EasyExcel.writerSheet(i, "模板" + i).build();

                Page<Salaries> page = new Page<>();
                page.setCurrent(i + 1);
                page.setSize(size);
                Page<Salaries> selectPage = salariesMapper.selectPage(page, null);

                excelWriter.write(selectPage.getRecords(), writeSheet);
            }
        }
    }

    /**
     * 多线程分页查询，每页数据写入多个sheet
     */
    public void exportExcel4(HttpServletResponse response) throws IOException, InterruptedException {

        setExportHeader(response);
        //查询数据库的总条数
        Long count = salariesMapper.selectCount(null);

        //多少个sheet
        Integer pages = 20;
        // 每个sheet的条数
        Long size = count / pages;
        // 创建固定的线程数（多少个sheet就创建多少个线程）
        ExecutorService executorService = Executors.newFixedThreadPool(pages);
        CountDownLatch countDownLatch = new CountDownLatch(pages);

        Map<Integer, Page<Salaries>> pageMap = new HashMap<>();
        for (int i = 0; i < pages; i++) {
            int finalI = i;
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    Page<Salaries> page = new Page<>();
                    page.setCurrent(finalI + 1);
                    page.setSize(size);
                    Page<Salaries> selectPage = salariesMapper.selectPage(page, null);

                    pageMap.put(finalI, selectPage);
                    countDownLatch.countDown();
                }
            });
        }

        countDownLatch.await();

        try (ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream(), Salaries.class).build()) {
            for (Map.Entry<Integer, Page<Salaries>> entry : pageMap.entrySet()) {
                Integer num = entry.getKey();
                Page<Salaries> salariesPage = entry.getValue();
                WriteSheet writeSheet = EasyExcel.writerSheet(num, "模板" + num).build();
                excelWriter.write(salariesPage.getRecords(), writeSheet);
            }
        }

        // https://github.com/alibaba/easyexcel/issues/1040
        // easyexcel不同的sheet页,支持并发写入操作吗 ,不支持
    }

    private static void setExportHeader(HttpServletResponse response) {
        response.setContentType(CONTENT_TYPE);
        response.setCharacterEncoding(StandardCharsets.UTF_8.name());
        response.setHeader("Content-disposition", "attachment;filename*=utf-8''" + "zhouyu.xlsx");
    }
}

ImportService

package com.zhouyu.service;

import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelReader;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.cache.Ehcache;
import com.alibaba.excel.cache.MapCache;
import com.alibaba.excel.read.builder.ExcelReaderBuilder;
import com.alibaba.excel.read.listener.ReadListener;
import com.alibaba.excel.read.metadata.ReadSheet;
import com.alibaba.excel.write.metadata.WriteSheet;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.zhouyu.domain.Salaries;
import com.zhouyu.listener.SalariesListener;
import com.zhouyu.mapper.SalariesMapper;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.*;

@Service
public class ImportService {

    @Resource
    private SalariesListener salariesListener;
    // 创建一个固定线程数的线程池进行解析excel
    private ExecutorService executorService = Executors.newFixedThreadPool(20);

    //方案一：导入excel，单线程进行解析，单线程进行导入excel
    public void importExcel(MultipartFile file) throws IOException {

        EasyExcel.read(file.getInputStream(), Salaries.class, salariesListener).doReadAll();
    }


    //方案三
    public void importExcelAsync(MultipartFile file) {
        // 开20个线程分别处理20个sheet,往list里面添加20个任务
        List<Callable<Object>> tasks = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            int num = i;
            // 添加20个线程去解析excel
            tasks.add(() -> {
                EasyExcel.read(file.getInputStream(), Salaries.class, salariesListener)
                        .sheet(num).doRead();
                return null;
            });
        }

        try {
            //唤醒20个线程
            executorService.invokeAll(tasks);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

    }


}

SalariesService

package com.zhouyu.service;

import org.springframework.stereotype.Service;


@Service
public class SalariesService {

}

MyApplication

package com.zhouyu;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import java.util.ArrayList;

@SpringBootApplication
@EnableTransactionManagement
public class MyApplication {

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }

    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class);
    }
}

application.yml

spring:
  servlet:
    multipart:
      max-request-size: 30MB
      max-file-size: 1024MB
  datasource:
    username: erp   #mysql配置文件需要修改
    password: xxxxxx
    url: jdbc:mysql://127.0.0.1:3306/millionsdataeasyexcel?rewriteBatchedStatements=true&characterEncoding=utf-8&allowPublicKeyRetrieval=true&useSSL=false&serverTimezone=Asia/Shanghai
  main:
    allow-circular-references: true

salaries.sql

/*
Navicat MySQL Data Transfer

Source Server         : Mysql
Source Server Version : 50717
Source Host           : localhost:3306
Source Database       : salaries

Target Server Type    : MYSQL
Target Server Version : 50717
File Encoding         : 65001

Date: 2023-06-24 10:17:18
*/

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for `salaries`
-- ----------------------------
DROP TABLE IF EXISTS `salaries`;
CREATE TABLE `salaries` (
  `emp_no` int(20) NOT NULL,
  `salary` int(200) DEFAULT NULL,
  `from_date` date DEFAULT NULL,
  `to_date` date DEFAULT NULL,
  PRIMARY KEY (`emp_no`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of salaries
-- ----------------------------

学习视频链接：百万数据快速导入导出，原来这么简单_哔哩哔哩_bilibili

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

MFC 截图功能实现（2）

MFC 截图功能实现（2）

上篇文章里面所用的截图是点击按钮就截取当前打开的界面&#xff0c;链接&#xff1a; MFC 截图功能实现_春蕾夏荷_728297725的博客-CSDN博客 这里所用的截图是可以选中区域&#xff0c;另存为目录等的操作&#xff1a; 效果&#xff1a; 选中区域&#xff1a; 菜单&#xf…
阅读更多...
javaee 任务调度，定时任务 多个任务同时执行

javaee 任务调度，定时任务 多个任务同时执行

错误的写法 如果按照下图的写法&#xff0c;两个任务不会同时执行&#xff0c;因为是一个线程&#xff0c;两个任务是串行的关系。 可以看到第二个任务是等第一个任务执行完以后&#xff0c;才执行的。 正确的写法 使用线程池&#xff0c;为每一个任务创建一个线程 可以看…
阅读更多...
Markdown中使用 LaTeX 编辑数学公式

Markdown中使用 LaTeX 编辑数学公式

Markdown中使用 LaTeX 编辑数学公式 1 介绍TeX&#xff08;计算机排版系统&#xff09;LaTeX&#xff08;TeX宏集&#xff09;KaTeX 和 MathJax 2 注意点单双美元符号包裹问题KaTeX 有些不支持 3 语法保留字符希腊字母希伯来字母二元运算符二元关系符几何符号逻辑符号集合符号箭…
阅读更多...
Linux下一切皆文件的理解

Linux下一切皆文件的理解

目录 一. 回顾上文 Linux底层进程和被打开文件的映射关系图&#xff1a; Linux部分源代码示意图如下&#xff1a; ​编辑 二.Linux下一切皆文件的核心理解 一. 回顾上文 在前两篇文章中&#xff0c;我论述了Linux系统中关于文件基础IO的一些内容&#xff1a; 1.有关于文件…
阅读更多...
RT-Thread-05-空闲线程和两个常用的钩子函数

RT-Thread-05-空闲线程和两个常用的钩子函数

空闲线程和两个钩子函数 空闲线程是一个比较特殊的系统线程&#xff0c;它具备最低优先级&#xff0c;当系统中无其他就绪线程可运行时&#xff0c;调度器将调度到空闲线程&#xff1b;空闲线程还负责一些系统资源回收以及将一些处于关闭状态的线程从线程调度列表中移除&#x…
阅读更多...
Nautilus Chain：模块化Layer3架构为RWA赛道构建基础设施

Nautilus Chain：模块化Layer3架构为RWA赛道构建基础设施

DeFi Summer后&#xff0c;加密行业经历了新一轮的爆发、增长后&#xff0c;整体的发展逐渐陷入滞缓。传统金融是一个经过了上百年发展的成熟市场&#xff0c;将800万亿美元体量的传统金融不断引入到链上有望推动加密行业迎来新一轮的质变。将传统资产以加密代币化的形式引入到…
阅读更多...
【从零开始学习JAVA | 第十七篇】抽象类与抽象方法

【从零开始学习JAVA | 第十七篇】抽象类与抽象方法

目录 前言&#xff1a; 抽象类与抽象方法&#xff1a; 抽象类&#xff1a; 抽象方法&#xff1a; 特点&#xff1a; 抽象类 抽象方法 注意事项 抽象类 与 抽象方法的意义 抽象类 抽象方法 前言&#xff1a; 在之前&#xff0c;如果我们要构建两个相同类型的类的时候&…
阅读更多...
【C++】泛型编程——模板进阶

【C++】泛型编程——模板进阶

文章目录 前言1. 模板参数的分类2. 非类型模板参数2.1 非类型模板参数的概念2.2 铺垫2.2 非类型模板参数的使用2.4 注意2.5 array的了解 3. 模板的特化3.1 概念3.2 函数模板特化3.3 类模板特化3.3.1 全特化3.3.2 偏特化部分特化参数更进一步的限制 4. 模板分离编译4.1 什么是分…
阅读更多...
基于TF-IDF算法个人文件管理系统——机器学习+人工智能+神经网络（附Python工程全部源码）

基于TF-IDF算法个人文件管理系统——机器学习+人工智能+神经网络（附Python工程全部源码）

目录 前言总体设计系统整体结构图系统流程图 运行环境模块实现1. 数据预处理2. 词频计算与数据处理3. 数据计算与对比验证 系统测试工程源代码下载其它资料下载 前言 本项目旨在通过应用TF-IDF算法&#xff0c;将新下载的课件进行自动分类整理。我们的方法是通过比较新文件中的…
阅读更多...
Matlab统计分析-相关系数

Matlab统计分析-相关系数

统计分析-相关系数 相关系数 (pearson与spearman) 皮尔逊 person相关系数和斯皮尔曼spearman等级相关系数&#xff0c;它们可用来衡量两个变量之间的**(线性)**相关性的大小&#xff0c;根据数据满足的不同条件&#xff0c;我们要选择不同的相关系数进行计算和分析。 基础概…
阅读更多...
C生万物 | 常见的六种动态内存错误

C生万物 | 常见的六种动态内存错误

学习过C语言中的动态内存函数&#xff0c;例如【malloc】、【calloc】、【realloc】、【free】&#xff0c;那它们在使用的过程中会碰到哪些问题呢&#xff0c;本本文我们一起来探讨下~ 1、对NULL指针的解引用操作 代码&#xff1a; void test() {int *p (int *)malloc(INT_…
阅读更多...
Sui链上事务处理概述

Sui链上事务处理概述

Sui通过其混合式交易处理方法&#xff0c;实现比其他区块链更快速和高效的性能。这种方法使得Sui的交易测试吞吐率达到每秒297,000次。从实际应用的角度来看&#xff0c;使用Sui的用户在apps和游戏中几乎能够获得实时响应。 在区块链世界中&#xff0c;交易是apps运作的基础&a…
阅读更多...
AutoHotKey脚本的循环：While和Loop

AutoHotKey脚本的循环：While和Loop

While AHK提供三种循环方法&#xff0c;分别是Loop, While和For&#xff0c;其中While和For在其他语言中都很常见&#xff0c;下面通过while循环&#xff0c;实现一个鼠标框选矩形尺寸的脚本 ; 来自官网的案例 CoordMode "Mouse", "Screen"~LButton:: {M…
阅读更多...
【文献分享】基于感知质量的滚动优化无人机导航

【文献分享】基于感知质量的滚动优化无人机导航

论文题目&#xff1a;Perception-aware Receding Horizon Navigation for MAVs 作者&#xff1a;Zhang, Zichao ; Scaramuzza, Davide 作者机构&#xff1a;苏黎世大学 论文链接&#xff1a;https://files.ifi.uzh.ch/rpg/website/rpg.ifi.uzh.ch/html/docs/ICRA18_Zhang.pd…
阅读更多...
【雕爷学编程】Arduino动手做（122）---BH1750光照传感器

【雕爷学编程】Arduino动手做（122）---BH1750光照传感器

37款传感器与执行器的提法&#xff0c;在网络上广泛流传&#xff0c;其实Arduino能够兼容的传感器模块肯定是不止这37种的。鉴于本人手头积累了一些传感器和执行器模块&#xff0c;依照实践出真知&#xff08;一定要动手做&#xff09;的理念&#xff0c;以学习和交流为目的&am…
阅读更多...
使用近10年，说说向大家推荐Linux系统的理由

使用近10年，说说向大家推荐Linux系统的理由

使用linux已经快十年了&#xff0c;一直想推荐身边的使用linux,但是一直没有分享。但是现在我想分享推荐了。下面我们一起聊聊为什么我向大家推荐linux。 为什么现在我想推荐了呢&#xff1f;是因为我自认为相对于同龄人来说&#xff0c;我使用桌面版的时间算是挺长的了&#…
阅读更多...
彻底搞懂什么是阿里云服务器vCPU？

彻底搞懂什么是阿里云服务器vCPU？

阿里云ECS服务器vCPU和CPU是什么意思&#xff1f;CPU和vCPU有什么区别&#xff1f;一台云服务器ECS实例的CPU选项由CPU物理核心数和每核线程数决定&#xff0c;CPU是中央处理器&#xff0c;一个CPU可以包含若干个物理核&#xff0c;通过超线程HT&#xff08;Hyper-Threading&am…
阅读更多...
走向计算机视觉的通用人工智能：从GPT和大型语言模型中汲取的经验教训 (下)...

走向计算机视觉的通用人工智能：从GPT和大型语言模型中汲取的经验教训 (下)...

点击蓝字 关注我们 关注并星标 从此不迷路 计算机视觉研究院 公众号ID&#xff5c;计算机视觉研究院 学习群&#xff5c;扫码在主页获取加入方式 论文地址&#xff1a;https://arxiv.org/pdf/2306.08641.pdf 计算机视觉研究院专栏 Column of Computer Vision Institute 人工智能…
阅读更多...
Matlab预测模型-灰色预测模型

Matlab预测模型-灰色预测模型

预测模型-灰色预测模型 灰色预测是对既含有已知信息又含有不确定信息的系统进行预测&#xff0c;就是对在一定范围内变化的、与时间有关的灰色过程进行预测。灰色预测对原始数据进行生成处理来寻找系统变动的规律&#xff0c;并生成有较强规律性的数据序列&#xff0c;然后建立…
阅读更多...
Linux学习[19]管线命令详解1---cut, grep, sort, wc, uniq

Linux学习[19]管线命令详解1---cut, grep, sort, wc, uniq

文章目录 1. 何为管线2. 摘取命令&#xff1a;cut, grep2.1 cut2.2 grep 3. 排序命令sort,wc,uniq3.1 sort3.2 uniq3.3 wc 总结 1. 何为管线 管线命令和Linux学习18里面的连续执行指令少许不同。他是只有在前面指令执行正确的时候&#xff0c;才会执行管线命令。 即这个管线命…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023