九大排序算法汇总+性能分析实验报告（插入排序、希尔排序、折半插入排序、冒泡排序、归并排序、快速排序、基数排序、堆排序、选择排序）
一、实验目的和要求
1.熟练掌握九种排序算法原理和时间复杂度
2.综合比较各种排序算法时间性能
3.排序算法实验经验总结
二、实验内容与方法
1.插入排序
思路：从第一张开始拿牌，将这张牌前面的牌数比这张牌大的往后挪。
没有比这张牌大的就放在这空隙中，那么到最后，每张牌前面的牌的大小都比自己小
步骤：
用一个指针j代表他前面的牌，如果j这张牌比自己大，就让他往后面挪
如果这张牌没自己大，就把自己放前面的牌后面（保证牌大小是从小到大）
插入排序代码
void insertionSort(vector& arr) {
for (int i = 1; i = 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}
2.希尔排序（shell排序）
思路：先进行分组，不断细分。每组进行分别插入排序，这个算法优点是可以不用一位一位的移动并且减少逆序对数量
越往后移动的次数越来越少，相较于一步一步移动，根据分组跳着移动，能够更快的移动到自己真正的位置
步骤：
第一步分组，从每组n/2个数开始，每次每组大小除以二，直到每个组一个数，即朴素插入排序
第二步从第gap到n每个数往回跳gap步，落脚点j就是他所在的分组，进行插入排序
第三步重复一二步，在分成每个组一个数进行最后一次排序，即得到有序数列
shell排序代码
void shellSort(vector& arr) {
int n = arr.size();
for (int gap = n / 2; gap > 0; gap >>= 1) {
for (int i = gap; i = 0 && arr[j] > temp; j -= gap) {
arr[j + gap] = arr[j];
}
arr[j + gap] = temp;
}
}
}
3.折半插入排序
思路：插牌的时候一张牌一张牌看太慢了，所以用眼睛找一下该插入的位置（二分做眼睛找位置）
折半插入排序代码
void binaryInsertionSort(vector& arr) {
for (int i = 1; i < arr.size(); i++) {
int key = arr[i];
int left = 0, right = i - 1;
while (left key) {
right = mid - 1;
}
else {
left = mid + 1;
}
}
for (int j = i - 1; j >= left; j--) { //将要找的位置的最右面数开始到找到的位置都往后挪，为插入的数腾位置
arr[j + 1] = arr[j];
}
arr[left] = key;
}
}
4.冒泡排序
思路：每次都是将数组中最大的泡泡挪到最后
若数组没发生挪动说明每个泡泡后面的泡泡都比他大
冒泡排序代码
void bubbleSort(vector& arr) {
bool flag = true;
for (int i = 0; i < arr.size() - 1 && flag; i++) {
flag = false;
for (int j = 0; j arr[j + 1]) {
swap(arr[j], arr[j + 1]);
flag = true;
}
}
}
}
5.归并排序
思路：先将每个数分到一个文件夹中，而后合并每两个文件夹，使合并后的大文件夹是有序的，最终合并到一个文件里
步骤：
第一步将数列不断二分，分成小片段，对小片段进行操作
第二步开出两个空间，分别存两个文件夹的数
第三步为完成将两个空间（这两个空间数都是有序的）中最小的数提出了，放数组里。
所以用两个指针i，j 分别比较两个空间内第一个数（即该空间最小数）将较小的放入数组，被放入的空间指针++
第四步当有一个空间的数全都放入了数组里，则直接将剩余空间的所有数放入数组里
当从小文件合并到大文件之后，就得到有序数列
归并排序代码
void merge(vector& arr, int l, int m, int r) {
int n1 = m - l + 1;
int n2 = r - m;
vector L(n1), R(n2);
for (int i = 0; i < n1; i++) {
L[i] = arr[l + i];
}
for (int j = 0; j < n2; j++) {
R[j] = arr[m + 1 + j];
}
int i = 0, j = 0, k = l;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
}
else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
void mergeSort(vector& arr, int l, int r) {
if (l < r) {
int m = l + (r - l) / 2;
mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
6.快速排序
思路：分治思想 保证每个数左边的数都比他小，右边的数都比他大
步骤：
第一步让最后一个数成为基准privot
第二步确认指针i，如果从开始到最后有数比基准小，交换指针指向的数和这个数，则i和i左边的数一定是小于基准的
（刚开始arr[i]是最左边的数，将小于基准的数和arr[i]进行交换，即将小于基准的数放在左边）
第三步将i+1位置与基准交换，则基准的左边一定是小于基准的，基准右边的一定是大于基准的
第四步从调整整个数组的基准，到每个数都是基准（即确保每个数的左边小于基准，右边大于基准）得到有序数列
快速排序代码
int partition(vector& arr, int low, int high) {
int pivot = arr[high];
int i = low - 1;
for (int j = low; j < high; j++) {
if (arr[j] < pivot) {
i++;
swap(arr[i], arr[j]);
}
}
swap(arr[i + 1], arr[high]);
return i + 1;
}
void quickSort(vector& arr, int low, int high) {
if (low < high) {
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}
7.基数排序
思路：用空间换时间，比较两个数是高位大小比低位大小更重要，
所以我们低位开始，相同位层进行排序，后面操作影响前面排序顺序即高位重要性高于低位，
每个位层的排序为一个轮次，排序到最后就得到了有序
步骤：
第一步找到最高位，求出轮次的次数
第二步开出一个备用空间用来存每个轮次的结果
第三步开出十个桶进行位层排序，将这些数进行重要性分级
第四步求前缀和，画出分区，将不同重要级区分开来
第五步将桶中的数存进备用空间
第六步更新数组
第七步重复三四五六步得到有序数列
基数排序代码
void countSort(vector& arr, int exp) {
int n = arr.size();
vector output(n);
vector count(10, 0);
for (int i = 0; i < n; i++) {
count[(arr[i] / exp) % 10]++;
}
for (int i = 1; i = 0; i--) {
output[count[(arr[i] / exp) % 10] - 1] = arr[i];
count[(arr[i] / exp) % 10]--;
}
for (int i = 0; i < n; i++) {
arr[i] = output[i];
}
}
void radixSort(vector& arr) {
int maxVal = *max_element(arr.begin(), arr.end());
for (int exp = 1; maxVal / exp > 0; exp *= 10) {
countSort(arr, exp);
}
}
8.堆排序
思路：利用堆的性质找到最大值，再用选择排序原理进行排序
步骤：
第一步先构建堆结构（根的值最大，每个节点一定是他那个子树的最大值，但不和同层的有什么关系）
第二步将根（最大值）与最后一个元素交换，使得保证最后的节点是最大值
第三步将被交换的元素放回堆里，使得剩余元素再次构成堆结构，保证根是最大值
第四步 循环二三步，使得从最后到开始是从大到小，即得到开始到结束是从小到大
堆排序代码
void heapify(vector& arr, int n, int i) {
int largest = i;
int l = 2 * i + 1;
int r = 2 * i + 2;
if (l arr[largest]) {
largest = l;
}
if (r arr[largest]) {
largest = r;
}
if (largest != i) {
swap(arr[i], arr[largest]);
heapify(arr, n, largest);
}
}
void treeSelectionSort(vector& arr) {
int n = arr.size();
for (int i = n / 2 - 1; i >= 0; i--) {
heapify(arr, n, i);
}
for (int i = n - 1; i > 0; i--) {
swap(arr[0], arr[i]);
heapify(arr, i, 0);
}
}
9.选择排序
思路：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。重复第二步，直到所有元素均排序完毕。
选择排序代码
void selectionSort(vector& arr) {
int n = arr.size();
for (int i = 0; i < n - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
swap(arr[i], arr[minIndex]);
}
}
三、实验步骤和过程
1.算法性能分析
说明：通过C++语言实现多种排序方式，分别对这些排序算法进行测试。记录数据与绘制对数图表如下。本实验选取的理论值基准均为数据规模为1000000时的测试数据。 但由于设备能力有限，数据来源于其他博客，本文附上的代码只是简单的对比各个排序算法在100000数据量时的运行时间对比，让读者能够更直观的看到各个排序算法时间复杂度方面的差距，从而更好的理解这些算法。
理论上各个算法的时间复杂度、空间复杂度和稳定性如下表，其中堆排序、快速排序和归并排序复杂度是（
（图片来源：https://blog.csdn.net/ytusdc/article/details/102528482）
2.算法对比分析
实验步骤：分别对各个排序算法进行运行时间的测量，数据规模从10-1000000。通过记录每个算法运行的时间，记录成表格，绘制成折线图。来更直观的比对每种排序算法的时间复杂度优劣，进而分析其优缺点。
| 冒泡排序 | 插入排序 | 折半插入排序 | 希尔排序 | 归并排序 | 堆排序 | 快速排序 | 基数排序 | 选择排序 | |
| 10 | 0.0005 | 0.0004 | 0.0004 | 0.00053 | 3.40E-06 | 0.00017 | 1.00E-08 | 0.00027 | 4.00E-04 |
| 100 | 0.00105 | 0.0015 | 0.0013 | 0.0021 | 2.60E-05 | 0.00105 | 1.00E-08 | 0.00039 | 1.30E-03 |
| 1000 | 0.00458 | 0.00305 | 0.00185 | 0.00604 | 0.0003 | 0.0016 | 0.000095 | 0.000565 | 0.00205 |
| 10000 | 0.4713 | 0.11115 | 0.0789 | 0.01395 | 0.008 | 0.0024 | 0.00145 | 0.00304 | 0.0915 |
| 100000 | 46.2717 | 10.1205 | 6.6959 | 0.0556 | 0.1246 | 0.0407 | 0.0178 | 0.0256 | 9.6635 |
| 1000000 | 4569.76 | 1059.13 | 736.441 | 0.6744 | 1.30895 | 0.4247 | 0.20835 | 0.1802 | 921.265 |
（图片原创）
根据图表可以将这几个排序算法分成三类：
第一类，简单排序。即冒泡、选择和插入排序。这几种排序方法的优点在于简单直观，代码好写，并且在数据规模较小时运算速度有些微优势。缺点在于，当数据规模增大时，简单排序的耗时会很快增加到令人难以忍受的程度。因此，这三种排序算法适用于数据规模小的情况。推荐插入排序和选择排序。
第二类，希尔排序、归并排序和堆排序。这三种排序的时间复杂度优于O(
第三类，快速排序、基数排序和计数排序。基数排序和计数排序时间复杂度到达线性级别。而快速排序复杂度中隐含的常数因子很小，是(
四、实验结论和体会
实验结论：在处理小规模数据排序问题时，插入排序和选择排序是较好的选择，冒泡排序也是可选的算法。在数据规模较大时，应该选择希尔排序、堆排序、归并排序、快速排序、基数排序或基数排序。并且，数据规模大时，若采用归并排序、快速排序、基数排序或计数排序，需要考虑空间复杂度的问题。
实验体会：我们需要应对不同情况使用不同的排序算法。待排序数据的规模，极差，类型和基础有序度，都是我们选择排序算法时需要考虑的东西。不同的排序算法适合不同的数据，当我们遇到问题时不要只盯着一种排序算法用，还需要考虑数据性质。
五、实验代码
//大作业：八大排序算法（ 插入排序 希尔排序 折半插入排序 树形选择排序 冒泡排序
// 归并排序 快速排序 基数排序）
#include
#include
#include
#include
#include
using namespace std;
// 插入排序
/*
思路：从第一张开始拿牌，将这张牌前面的牌数比这张牌大的往后挪。
没有比这张牌大的就放在这空隙中，那么到最后，每张牌前面的牌的大小都比自己小
用一个指针j代表他前面的牌，如果j这张牌比自己大，就让他往后面挪
如果这张牌没自己大，就把自己放前面的牌后面（保证牌大小是从小到大）
*/
void insertionSort(vector& arr) {
for (int i = 1; i = 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}
// 希尔排序
/*
思路：先进行分组，不断细分。每组进行分别插入排序，这个算法优点是可以不用一位一位的移动并且减少逆序对数量
越往后移动的次数越来越少，相较于一步一步移动，根据分组跳着移动，能够更快的移动到自己真正的位置
第一步分组，从每组n/2个数开始，每次每组大小除以二，直到每个组一个数，即朴素插入排序
第二步从第gap到n每个数往回跳gap步，落脚点j就是他所在的分组，进行插入排序
第三步重复一二步，在分成每个组一个数进行最后一次排序，即得到有序数列
*/
void shellSort(vector& arr) {
int n = arr.size();
for (int gap = n / 2; gap > 0; gap >>= 1) {
for (int i = gap; i = 0 && arr[j] > temp; j -= gap) {
arr[j + gap] = arr[j];
}
arr[j + gap] = temp;
}
}
}
// 折半插入排序
/*
思路：插牌的时候一张牌一张牌看太慢了，所以用眼睛找一下该插入的位置（二分做眼睛找位置）
*/
void binaryInsertionSort(vector& arr) {
for (int i = 1; i < arr.size(); i++) {
int key = arr[i];
int left = 0, right = i - 1;
while (left key) {
right = mid - 1;
}
else {
left = mid + 1;
}
}
for (int j = i - 1; j >= left; j--) { //将要找的位置的最右面数开始到找到的位置都往后挪，为插入的数腾位置
arr[j + 1] = arr[j];
}
arr[left] = key;
}
}
// 冒泡排序
/*
思路：每次都是将数组中最大的泡泡挪到最后
若数组没发生挪动说明每个泡泡后面的泡泡都比他大
*/
void bubbleSort(vector& arr) {
bool flag = true;
for (int i = 0; i < arr.size() - 1 && flag; i++) {
flag = false;
for (int j = 0; j arr[j + 1]) {
swap(arr[j], arr[j + 1]);
flag = true;
}
}
}
}
// 归并排序
/*
思路：先将每个数分到一个文件夹中，而后合并每两个文件夹，使合并后的大文件夹是有序的，最终合并到一个文件里
第一步将数列不断二分，分成小片段，对小片段进行操作
第二步开出两个空间，分别存两个文件夹的数
第三步为完成将两个空间（这两个空间数都是有序的）中最小的数提出了，放数组里。
所以用两个指针i，j 分别比较两个空间内第一个数（即该空间最小数）将较小的放入数组，被放入的空间指针++
第四步当有一个空间的数全都放入了数组里，则直接将剩余空间的所有数放入数组里
当从小文件合并到大文件之后，就得到有序数列
*/
void merge(vector& arr, int l, int m, int r) {
int n1 = m - l + 1;
int n2 = r - m;
vector L(n1), R(n2);
for (int i = 0; i < n1; i++) {
L[i] = arr[l + i];
}
for (int j = 0; j < n2; j++) {
R[j] = arr[m + 1 + j];
}
int i = 0, j = 0, k = l;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
}
else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
void mergeSort(vector& arr, int l, int r) {
if (l < r) {
int m = l + (r - l) / 2;
mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
// 快速排序
/*
思路：分治思想 保证每个数左边的数都比他小，右边的数都比他大
第一步让最后一个数成为基准privot
第二步确认指针i，如果从开始到最后有数比基准小，交换指针指向的数和这个数，则i和i左边的数一定是小于基准的
（刚开始arr[i]是最左边的数，将小于基准的数和arr[i]进行交换，即将小于基准的数放在左边）
第三步将i+1位置与基准交换，则基准的左边一定是小于基准的，基准右边的一定是大于基准的
第四步从调整整个数组的基准，到每个数都是基准（即确保每个数的左边小于基准，右边大于基准）得到有序数列
*/
int partition(vector& arr, int low, int high) {
int pivot = arr[high];
int i = low - 1;
for (int j = low; j < high; j++) {
if (arr[j] < pivot) {
i++;
swap(arr[i], arr[j]);
}
}
swap(arr[i + 1], arr[high]);
return i + 1;
}
void quickSort(vector& arr, int low, int high) {
if (low < high) {
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}
// 基数排序
/*
思路：用空间换时间，比较两个数是高位大小比低位大小更重要，
所以我们低位开始，相同位层进行排序，后面操作影响前面排序顺序即高位重要性高于低位，
每个位层的排序为一个轮次，排序到最后就得到了有序
第一步找到最高位，求出轮次的次数
第二步开出一个备用空间用来存每个轮次的结果
第三步开出十个桶进行位层排序，将这些数进行重要性分级
第四步求前缀和，画出分区，将不同重要级区分开来
第五步将桶中的数存进备用空间
第六步更新数组
第七步重复三四五六步得到有序数列
*/
void countSort(vector& arr, int exp) {
int n = arr.size();
vector output(n);
vector count(10, 0);
for (int i = 0; i < n; i++) {
count[(arr[i] / exp) % 10]++;
}
for (int i = 1; i = 0; i--) {
output[count[(arr[i] / exp) % 10] - 1] = arr[i];
count[(arr[i] / exp) % 10]--;
}
for (int i = 0; i < n; i++) {
arr[i] = output[i];
}
}
void radixSort(vector& arr) {
int maxVal = *max_element(arr.begin(), arr.end());
for (int exp = 1; maxVal / exp > 0; exp *= 10) {
countSort(arr, exp);
}
}
// 堆排序
/*
第一步先构建堆结构（根的值最大，每个节点一定是他那个子树的最大值，但不和同层的有什么关系）
第二步将根（最大值）与最后一个元素交换，使得保证最后的节点是最大值
第三步将被交换的元素放回堆里，使得剩余元素再次构成堆结构，保证根是最大值
第四步 循环二三步，使得从最后到开始是从大到小，即得到开始到结束是从小到大
*/
void heapify(vector& arr, int n, int i) {
int largest = i;
int l = 2 * i + 1;
int r = 2 * i + 2;
if (l arr[largest]) {
largest = l;
}
if (r arr[largest]) {
largest = r;
}
if (largest != i) {
swap(arr[i], arr[largest]);
heapify(arr, n, largest);
}
}
void treeSelectionSort(vector& arr) {
int n = arr.size();
for (int i = n / 2 - 1; i >= 0; i--) {
heapify(arr, n, i);
}
for (int i = n - 1; i > 0; i--) {
swap(arr[0], arr[i]);
heapify(arr, i, 0);
}
}
// 选择排序
/*
思路：每次都是找到最小的数，放在最前面
*/
void selectionSort(vector& arr) {
int n = arr.size();
for (int i = 0; i < n - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
swap(arr[i], arr[minIndex]);
}
}
int main() {
int n = 100000;
vector arr;
// 以当前时间作为随机数种子
unsigned seed = chrono::system_clock::now().time_since_epoch().count();
mt19937 gen(seed);
uniform_int_distribution dis(1, 1000000); // 生成 1 到 1000 之间的随机数
for (int i = 0; i < n; i++) {
arr.push_back(dis(gen));
}
// 插入排序
vector insertionArr = arr;
auto start1 = chrono::high_resolution_clock::now();
insertionSort(insertionArr);
auto end1 = chrono::high_resolution_clock::now();
auto duration1 = chrono::duration_cast(end1 - start1);
cout << "插入排序时间（毫秒）: " << duration1.count() << endl;
// 希尔排序
vector shellArr = arr;
auto start2 = chrono::high_resolution_clock::now();
shellSort(shellArr);
auto end2 = chrono::high_resolution_clock::now();
auto duration2 = chrono::duration_cast(end2 - start2);
cout << "希尔排序时间（毫秒）: " << duration2.count() << endl;
// 折半插入排序
vector binaryInsertionArr = arr;
auto start3 = chrono::high_resolution_clock::now();
binaryInsertionSort(binaryInsertionArr);
auto end3 = chrono::high_resolution_clock::now();
auto duration3 = chrono::duration_cast(end3 - start3);
cout << "折半插入排序时间（毫秒）: " << duration3.count() << endl;
// 冒泡排序
vector bubbleArr = arr;
auto start4 = chrono::high_resolution_clock::now();
bubbleSort(bubbleArr);
auto end4 = chrono::high_resolution_clock::now();
auto duration4 = chrono::duration_cast(end4 - start4);
cout << "冒泡排序时间（毫秒）: " << duration4.count() << endl;
// 归并排序
vector mergeArr = arr;
auto start5 = chrono::high_resolution_clock::now();
mergeSort(mergeArr, 0, n - 1);
auto end5 = chrono::high_resolution_clock::now();
auto duration5 = chrono::duration_cast(end5 - start5);
cout << "归并排序时间（毫秒）: " << duration5.count() << endl;
// 快速排序
vector quickArr = arr;
auto start6 = chrono::high_resolution_clock::now();
quickSort(quickArr, 0, n - 1);
auto end6 = chrono::high_resolution_clock::now();
auto duration6 = chrono::duration_cast(end6 - start6);
cout << "快速排序时间（毫秒）: " << duration6.count() << endl;
// 基数排序
vector radixArr = arr;
auto start7 = chrono::high_resolution_clock::now();
radixSort(radixArr);
auto end7 = chrono::high_resolution_clock::now();
auto duration7 = chrono::duration_cast(end7 - start7);
cout << "基数排序时间（毫秒）: " << duration7.count() << endl;
// 树形选择排序
vector treeSelectionArr = arr;
auto start8 = chrono::high_resolution_clock::now();
treeSelectionSort(treeSelectionArr);
auto end8 = chrono::high_resolution_clock::now();
auto duration8 = chrono::duration_cast(end8 - start8);
cout << "树形选择排序时间（毫秒）: " << duration8.count() << endl;
// 选择排序
vector selectionArr = arr;
auto start9 = chrono::high_resolution_clock::now();
selectionSort(selectionArr);
auto end9 = chrono::high_resolution_clock::now();
auto duration9 = chrono::duration_cast(end9 - start9);
cout << "选择排序时间（毫秒）: " << duration9.count() << endl;
return 0;
}
参考博客
链接：https://blog.csdn.net/weixin_52828997/article/details/128568924
本文来自网络，不代表协通编程立场，如若转载，请注明出处：https://net2asp.com/a221e08921.html
相关推荐
-
java实习心得总结(八篇)
java实习心得总结(篇一) 此次只实训了短短的三周。虽说时间很短，但其中的每一天都使我收获很大、受益匪浅，它不但极大地加深了我对一些理论知识的理解，不仅使我在理论上对…
-
IDEA2023创建Maven Archetype和创建旧版本Maven的区别，主要是针对Maven Archtype。
IDEA2023创建Maven Archetype和创建旧版本Maven的区别，主要是针对Maven Archtype。 使用配置： 编译器：idea JDK：jdk 17 注意：…
-
【java】使用 BeanUtils.copyProperties 11个坑(注意事项)
文章目录 背景 第1个坑： 类型不匹配 第2个坑: `BeanUtils.copyProperties`是浅拷贝 第3个坑：属性名称不一致 第4个坑：Null 值覆盖 第5个坑：注…
-
java使用jdbcTemplate查询并插入百万级数据解决方案
背景：使用JdbcTemplate查询500万数据，然后插入到数据库。 这么多的数据按照普通的方式直接查询然后插入，服务器肯定会挂掉，我尝试过使用分页查询的方式去进行分批查询插入，…
-
SpringBoot动态导出word文档（完美实整教程 复制即可使用，不能实现你找我）
背景 最近有一个需求是需要动态导出合同、订单等信息，导出一个word文档供客户进行下载查看。 需要导出的word文件，主要可以分为两种类型。 导出固定内容和图片的word文档 导出…
-
解决Correct the classpath of your application so that it contains compatible versions
springboot启动失败 报错Correct the classpath of your application so that it contains compatible …
-
java大文件上传，大文件下载解决方案
一.大文件上传解决方案： 普通的Servlet文件上传： 使用Java Servlet技术，通过表单提交文件，然后在服务器端使用流将文件写入磁盘。这适用于小文件，但不太适合大文件，…
-
java如何将对象转换为map？如何将map转换为对象？
目录 1、使用 BeanUtils 2、ObjectMapper 3、Gson 4、Jackson 5、手动进行转换 1、使用 BeanUtils BeanUtil…
-
【js】JavaScript清除所有（多个）定时器的方法：
文章目录 一、停止单个定时器 二、暂停与恢复定时器 三、使用Promise来管理定时器 四、使用ES6特性管理定时器 五、案例（定时获取页面列表数据） 一、停止单个定时器 #在某些…
-
如何mock当前类的私有方法
背景 基础知识 mockito单元测试：它的做法是mock掉当前类的所有外部依赖，保障自己的代码没有问题。举个例子，如果数据库查询的语句出了问题，单元测试不会测试出来。因为它直接m…
