1. 项目概述为什么排序是Java程序员的必修课排序这个在数据结构与算法课上被反复提及的概念对于Java开发者而言远不止是应付面试的“八股文”。无论是处理海量用户数据、优化数据库查询性能还是实现一个高效的缓存淘汰策略排序算法的身影无处不在。我见过太多项目初期因为数据量小随手写个Collections.sort()或依赖数据库ORDER BY就能应付一旦数据量上来性能瓶颈立刻显现甚至引发内存溢出OutOfMemoryError。因此深入理解并亲手实现主流排序算法是构建高性能、高可靠Java应用的基石。这不仅能让你在面试中游刃有余更能让你在面对真实业务场景时拥有从底层优化系统的能力。本文将带你从零开始用Java实现10种经典排序算法并深入剖析它们背后的思想、适用场景以及那些教科书上不会写的“踩坑”经验。2. 排序算法整体设计与思路拆解在动手写代码之前我们必须建立一个清晰的认知框架。排序算法种类繁多但无外乎从几个核心维度进行区分和理解。盲目实现只会事倍功半。2.1 核心分类与选型逻辑排序算法通常可以从几个角度分类理解这些是正确选型的前提。基于时间复杂度与稳定性这是最核心的考量维度。时间复杂度决定了算法在处理大规模数据时的效率天花板而稳定性则关系到排序是否会影响相同关键字的原始相对顺序。例如在给订单先按金额排序再按时间排序时稳定的排序算法能保证相同金额的订单其时间顺序不变。基于排序过程的内存使用内部排序所有排序操作都在内存中完成适用于数据量可以完全加载到内存的场景。本文实现的10种算法都属于内部排序。外部排序当数据量太大无法全部装入内存时需要借助磁盘等外部存储器如多路归并排序。这通常是大数据处理的范畴。基于排序的主要操作比较排序通过比较元素间的大小来决定次序其平均时间复杂度下限是 O(n log n)。如快速排序、归并排序。非比较排序不通过比较而是利用数据的特定属性如整数范围来确定位置可以突破 O(n log n) 的下限。如计数排序、桶排序。我的选型思路是先看数据特征再定算法。如果数据是范围较小的整数计数排序是“降维打击”如果数据量大且对稳定性有要求归并排序是可靠选择如果追求平均性能且数据随机快速排序综合表现最佳如果数据几乎有序插入排序的效率会惊人地高。2.2 算法性能指标深度解析我们常说的“快慢”需要量化到具体的操作上。时间复杂度这不仅仅是背一个公式。例如快速排序的平均时间复杂度是 O(n log n)但最坏情况如数组已有序会退化到 O(n²)。这意味着如果你知道数据可能已部分有序选择基准点pivot的策略就至关重要不能简单地选第一个元素。空间复杂度衡量的是算法运行所需额外空间。归并排序需要 O(n) 的辅助数组这在处理超大数组时可能成为瓶颈。而堆排序是原地排序空间复杂度为 O(1)在内存紧张时优势明显。稳定性这是一个容易被忽略但至关重要的性质。设想一个员工列表先按部门排序再按入职年限排序。使用稳定排序能保证同一部门内的员工依然保持入职先后的顺序。冒泡、插入、归并是稳定的选择、希尔、快速、堆排序通常是不稳定的。注意算法的稳定性取决于具体实现。通过细微调整有些算法可以变为稳定版本但这往往会牺牲一些性能或增加代码复杂度。在绝大多数情况下我们直接使用其经典实现所具备的稳定性属性。3. 十大排序算法核心细节与Java实现接下来我们将深入每一种算法的核心并用Java代码实现。我会在代码中加入大量注释解释每一步的意图和容易出错的地方。3.1 简单排序算法理解排序的起点这类算法思想直观是理解排序逻辑的绝佳起点虽然效率不高但在特定小规模或近乎有序的数据上仍有其价值。3.1.1 冒泡排序 (Bubble Sort)冒泡排序通过重复遍历列表比较相邻元素并交换位置错误的元素每一轮会将最大或最小的元素“浮”到顶端。public class BubbleSort { public static void bubbleSort(int[] arr) { if (arr null || arr.length 2) { return; } int n arr.length; // 外层循环控制排序的轮数每轮确定一个最大元素的位置 for (int i 0; i n - 1; i) { // 优化标志如果某一轮没有发生交换说明数组已有序可提前结束 boolean swapped false; // 内层循环进行相邻比较范围随着i增大而减小 for (int j 0; j n - 1 - i; j) { if (arr[j] arr[j 1]) { // 交换 arr[j] 和 arr[j1] int temp arr[j]; arr[j] arr[j 1]; arr[j 1] temp; swapped true; } } // 如果本轮未交换提前终止 if (!swapped) { break; } } } }实操心得冒泡排序的优化点就在于swapped标志位。对于已经有序或接近有序的数组加入此判断能大幅提升效率。但它的平均和最坏时间复杂度仍是 O(n²)仅适用于教学或极小规模数据。3.1.2 选择排序 (Selection Sort)算法从未排序部分中“选择”最小或最大元素将其与未排序部分的第一个元素交换从而逐步构建有序序列。public class SelectionSort { public static void selectionSort(int[] arr) { if (arr null || arr.length 2) { return; } int n arr.length; for (int i 0; i n - 1; i) { // 假设当前索引 i 处的元素是最小的 int minIndex i; // 在 i1 到 n-1 的范围内寻找真正的最小值索引 for (int j i 1; j n; j) { if (arr[j] arr[minIndex]) { minIndex j; } } // 将找到的最小元素与位置 i 的元素交换 if (minIndex ! i) { // 避免不必要的交换 int temp arr[i]; arr[i] arr[minIndex]; arr[minIndex] temp; } } } }注意事项选择排序是不稳定的。考虑数组[5, 8, 5, 2, 9]第一个5索引0会和2交换导致它跑到另一个5原索引2的后面相对顺序被破坏。它的比较次数固定为 O(n²)但交换次数仅为 O(n)在交换成本很高的场景下比如排序的不是整数而是大型对象有一定优势。3.1.3 插入排序 (Insertion Sort)插入排序的工作方式像整理扑克牌将每个新元素“插入”到已排序序列中的适当位置。public class InsertionSort { public static void insertionSort(int[] arr) { if (arr null || arr.length 2) { return; } int n arr.length; // 从第二个元素开始索引1认为第一个元素自身是有序的 for (int i 1; i n; i) { int key arr[i]; // 待插入的元素 int j i - 1; // 将大于 key 的元素向后移动一位为 key 腾出位置 while (j 0 arr[j] key) { arr[j 1] arr[j]; j--; } // 将 key 插入到正确位置 arr[j 1] key; } } }核心技巧插入排序在实现时采用元素后移而非交换的方式减少了操作次数。它是稳定的排序算法。最大的优势在于对近乎有序的数组效率极高可以达到接近 O(n) 的时间复杂度并且它是高级排序算法如TimSort中用于处理小规模子数组的基础。3.2 高效比较排序算法应对大规模数据的利器当数据量变大时我们需要时间复杂度为 O(n log n) 的算法。3.2.1 希尔排序 (Shell Sort)希尔排序是插入排序的改进版它通过一个逐渐缩小的增量序列对相距较远的元素进行比较和交换使得数据能大跨度地移动最终当增量为1时进行一次标准的插入排序此时数组已基本有序。public class ShellSort { public static void shellSort(int[] arr) { if (arr null || arr.length 2) { return; } int n arr.length; // 动态计算初始增量间隔序列这里使用Knuth序列h 3*h 1 int h 1; while (h n / 3) { h 3 * h 1; // 1, 4, 13, 40, 121... } // 逐步缩小增量h while (h 1) { // 从第h个元素开始对每个间隔为h的子序列进行插入排序 for (int i h; i n; i) { // 对arr[i], arr[i-h], arr[i-2h]...进行插入排序 int key arr[i]; int j i; while (j h arr[j - h] key) { arr[j] arr[j - h]; j - h; } arr[j] key; } h h / 3; // 缩小增量 } } }为什么选择这个增量序列希尔排序的性能严重依赖于增量序列的选择。Knuth序列在实践中表现良好能保证最坏情况复杂度优于 O(n²)。希尔排序是不稳定的。3.2.2 归并排序 (Merge Sort)归并排序是“分治法”的经典应用。它将数组递归地分成两半分别排序然后再将两个有序的子数组合并成一个有序数组。public class MergeSort { // 递归调用的入口 public static void mergeSort(int[] arr) { if (arr null || arr.length 2) { return; } int[] temp new int[arr.length]; // 一次性分配辅助数组避免递归中反复创建 sort(arr, 0, arr.length - 1, temp); } private static void sort(int[] arr, int left, int right, int[] temp) { if (left right) { int mid left (right - left) / 2; // 防止溢出 sort(arr, left, mid, temp); // 排序左半部分 sort(arr, mid 1, right, temp); // 排序右半部分 merge(arr, left, mid, right, temp); // 合并两个有序部分 } } private static void merge(int[] arr, int left, int mid, int right, int[] temp) { int i left; // 左序列指针 int j mid 1; // 右序列指针 int t 0; // 临时数组指针 // 比较左右两部分的元素按序放入temp while (i mid j right) { if (arr[i] arr[j]) { // 注意这里是 保证了稳定性 temp[t] arr[i]; } else { temp[t] arr[j]; } } // 将剩余元素拷贝到temp while (i mid) { temp[t] arr[i]; } while (j right) { temp[t] arr[j]; } // 将temp中的有序元素拷贝回原数组 t 0; while (left right) { arr[left] temp[t]; } } }空间复杂度考量归并排序需要 O(n) 的额外空间这是其最大缺点。但它的时间复杂度稳定在 O(n log n)并且是稳定的排序算法。Java中Arrays.sort()对于对象数组如Object[]的排序就使用了名为TimSort的改良版归并排序因为它能保证稳定性这对于对象排序很重要。3.2.3 快速排序 (Quick Sort)快速排序同样采用分治思想但它的核心是“分区”。选择一个基准元素将数组分为小于基准和大于基准的两部分然后递归地对两部分进行排序。public class QuickSort { public static void quickSort(int[] arr) { if (arr null || arr.length 2) { return; } sort(arr, 0, arr.length - 1); } private static void sort(int[] arr, int low, int high) { if (low high) { // partitionIndex 是分区操作后基准元素的正确位置 int partitionIndex partition(arr, low, high); // 递归排序基准左侧和右侧的子数组 sort(arr, low, partitionIndex - 1); sort(arr, partitionIndex 1, high); } } private static int partition(int[] arr, int low, int high) { // 优化三数取中法选择基准避免最坏情况 int mid low (high - low) / 2; if (arr[high] arr[low]) swap(arr, low, high); if (arr[high] arr[mid]) swap(arr, mid, high); if (arr[mid] arr[low]) swap(arr, mid, low); int pivot arr[mid]; // 使用中位数作为基准 swap(arr, mid, high); // 将基准放到最右边 int i low; // i 指向小于基准区域的最后一个元素 for (int j low; j high; j) { // 如果当前元素小于等于基准 if (arr[j] pivot) { swap(arr, i, j); i; // 小于基准的区域向右扩张一位 } } // 将基准元素交换到正确位置i swap(arr, i, high); return i; } private static void swap(int[] arr, int i, int j) { int temp arr[i]; arr[i] arr[j]; arr[j] temp; } }基准选择是灵魂上面代码使用了“三数取中法”来选择基准pivot这是避免在已排序或逆序数组上出现最坏情况 O(n²) 的关键优化。快速排序平均性能极佳是实际应用中最常用的排序算法之一但它是不稳定的。3.2.4 堆排序 (Heap Sort)堆排序利用“堆”这种数据结构。堆是一种近似完全二叉树且满足父节点的值总是大于等于或小于等于子节点的值。public class HeapSort { public static void heapSort(int[] arr) { if (arr null || arr.length 2) { return; } int n arr.length; // 1. 构建最大堆从最后一个非叶子节点开始向上调整 for (int i n / 2 - 1; i 0; i--) { heapify(arr, n, i); } // 2. 逐个提取堆顶元素最大值并调整堆 for (int i n - 1; i 0; i--) { // 将当前堆顶最大值与堆末尾元素交换 swap(arr, 0, i); // 堆大小减1并对新的堆顶进行下沉调整重新满足堆性质 heapify(arr, i, 0); } } // 对以节点i为根的子树进行堆化下沉操作n是当前堆的大小 private static void heapify(int[] arr, int n, int i) { int largest i; // 初始化最大值为根节点 int left 2 * i 1; int right 2 * i 2; // 如果左子节点存在且大于根 if (left n arr[left] arr[largest]) { largest left; } // 如果右子节点存在且大于当前最大值 if (right n arr[right] arr[largest]) { largest right; } // 如果最大值不是根节点 if (largest ! i) { swap(arr, i, largest); // 递归地堆化受影响的子树 heapify(arr, n, largest); } } private static void swap(int[] arr, int i, int j) { int temp arr[i]; arr[i] arr[j]; arr[j] temp; } }堆排序的特点它是原地排序空间复杂度O(1)且时间复杂度稳定在 O(n log n)。但它是不稳定的并且由于数据访问是跳跃式的沿着二叉树路径对CPU缓存不友好因此平均性能通常不如快速排序和归并排序。3.3 线性时间排序算法利用数据特性的“黑科技”当数据满足特定条件时这些算法可以突破比较排序的 O(n log n) 下限达到 O(n) 的线性时间复杂度。3.3.1 计数排序 (Counting Sort)计数排序要求输入的数据必须是有确定范围的整数。它通过统计每个元素出现的次数然后直接计算每个元素在输出数组中的位置。public class CountingSort { public static void countingSort(int[] arr) { if (arr null || arr.length 2) { return; } // 1. 找到数组中的最大值确定计数数组的范围 int maxVal arr[0]; for (int num : arr) { if (num maxVal) { maxVal num; } } // 2. 初始化计数数组 count长度为 maxVal1 int[] count new int[maxVal 1]; // 3. 统计每个元素出现的次数 for (int num : arr) { count[num]; } // 4. 将计数数组变形使得每个位置的值等于小于等于该索引的元素总数 for (int i 1; i count.length; i) { count[i] count[i - 1]; } // 5. 创建输出数组并从后向前遍历原数组为了保证稳定性 int[] output new int[arr.length]; for (int i arr.length - 1; i 0; i--) { int num arr[i]; // count[num] 现在表示 num 在输出数组中的最后一个位置1 output[count[num] - 1] num; count[num]--; // 为下一个相同的 num 腾出位置 } // 6. 将输出数组拷贝回原数组 System.arraycopy(output, 0, arr, 0, arr.length); } }适用场景与限制计数排序在数据范围k不大且远小于数据量n时效率极高O(nk)。但它有两个硬伤一是只能用于整数二是需要额外空间 O(k)。如果数据范围是[0, 1000000]但只有10个数用计数排序就非常浪费空间。3.3.2 桶排序 (Bucket Sort)桶排序是计数排序的推广。它假设输入数据均匀分布将数据分到有限数量的“桶”里每个桶再分别排序通常使用插入排序最后按顺序合并各桶。public class BucketSort { public static void bucketSort(int[] arr) { if (arr null || arr.length 2) { return; } // 1. 确定桶的数量。这里简单取数组长度的平方根可根据数据分布调整。 int bucketCount (int) Math.sqrt(arr.length); int maxVal arr[0], minVal arr[0]; for (int num : arr) { if (num maxVal) maxVal num; if (num minVal) minVal num; } // 2. 计算每个桶的数值范围 double range (double) (maxVal - minVal 1) / bucketCount; // 3. 创建桶使用ArrayList方便动态添加 ListListInteger buckets new ArrayList(bucketCount); for (int i 0; i bucketCount; i) { buckets.add(new ArrayList()); } // 4. 将元素分配到各个桶中 for (int num : arr) { // 计算元素应该放入哪个桶 int bucketIndex (int) ((num - minVal) / range); // 防止最大值被放到最后一个桶之外 bucketIndex Math.min(bucketIndex, bucketCount - 1); buckets.get(bucketIndex).add(num); } // 5. 对每个桶内部进行排序这里使用Collections.sort其底层是TimSort for (ListInteger bucket : buckets) { Collections.sort(bucket); } // 6. 将排序后的桶依次合并到原数组 int index 0; for (ListInteger bucket : buckets) { for (int num : bucket) { arr[index] num; } } } }性能关键桶排序的性能依赖于数据是否均匀分布。如果所有数据都落在一个桶里则退化为单次排序如插入排序的复杂度。桶的数量和映射函数的设计至关重要。3.3.3 基数排序 (Radix Sort)基数排序是一种非比较整数排序算法它按照低位先排序然后收集再按照高位排序然后再收集依次类推直到最高位。public class RadixSort { public static void radixSort(int[] arr) { if (arr null || arr.length 2) { return; } // 1. 找到数组中的最大值确定最大位数 int maxVal arr[0]; for (int num : arr) { if (Math.abs(num) maxVal) { // 考虑负数情况先取绝对值找最大位数 maxVal Math.abs(num); } } // 2. 对绝对值进行基数排序 // 获取最大数字的位数 int maxDigit (maxVal 0) ? 1 : (int) (Math.log10(maxVal)) 1; // 3. 从最低位到最高位进行计数排序 for (int exp 1; maxVal / exp 0; exp * 10) { countingSortByDigit(arr, exp); } // 4. 处理负数将数组分为负数和正数两部分分别处理或使用偏移量 // 这里展示一种简单方法分离负数和正数负数反转后是逆序正数正序 ListInteger negatives new ArrayList(); ListInteger positives new ArrayList(); for (int num : arr) { if (num 0) { negatives.add(-num); // 存储负数的绝对值 } else { positives.add(num); } } // 对负数绝对值排序结果是逆序的然后取反并反转顺序 int[] negArr negatives.stream().mapToInt(i - i).toArray(); int[] posArr positives.stream().mapToInt(i - i).toArray(); if (negArr.length 1) radixSort(negArr); // 递归调用仅对绝对值排序 if (posArr.length 1) radixSort(posArr); // 合并结果负数部分取反并逆序 正数部分 int index 0; for (int i negArr.length - 1; i 0; i--) { arr[index] -negArr[i]; } for (int num : posArr) { arr[index] num; } } // 针对特定位数exp1,10,100...进行计数排序 private static void countingSortByDigit(int[] arr, int exp) { int n arr.length; int[] output new int[n]; int[] count new int[10]; // 0-9 十个数字 // 统计当前位上每个数字的出现次数 for (int num : arr) { int digit (Math.abs(num) / exp) % 10; // 取绝对值处理负数位 count[digit]; } // 将计数数组变形 for (int i 1; i 10; i) { count[i] count[i - 1]; } // 从后向前构建输出数组保证稳定性 for (int i n - 1; i 0; i--) { int digit (Math.abs(arr[i]) / exp) % 10; output[count[digit] - 1] arr[i]; // 注意这里存放原值arr[i]而非digit count[digit]--; } // 拷贝回原数组 System.arraycopy(output, 0, arr, 0, n); } }基数排序的要点基数排序通常使用稳定的子排序算法如计数排序来对每一位进行排序。它的时间复杂度是 O(d*(nk))其中d是最大位数k是进制数十进制为10。当d较小n较大时效率很高。处理负数需要额外步骤常见做法是统一加上一个偏移量转为非负数排序后再减回去。4. 算法对比与实战选型指南光会实现还不够关键在于知道什么时候该用谁。下面这个表格和场景分析能帮你快速决策。排序算法平均时间复杂度最坏时间复杂度空间复杂度稳定性核心思想适用场景冒泡排序O(n²)O(n²)O(1)稳定相邻交换教学、数据量极小、已基本有序选择排序O(n²)O(n²)O(1)不稳定选择最小交换成本高、数据量小插入排序O(n²)O(n²)O(1)稳定插入到有序序列小规模数据、近乎有序数据、作为高级算法子过程希尔排序O(n^1.3)O(n²)O(1)不稳定分组插入中等规模数据对缓存较友好归并排序O(n log n)O(n log n)O(n)稳定分治、合并大数据量、要求稳定、链表排序快速排序O(n log n)O(n²)O(log n)不稳定分治、分区通用场景、大数据量、平均性能最快堆排序O(n log n)O(n log n)O(1)不稳定堆数据结构原地排序、对空间有严格要求计数排序O(nk)O(nk)O(k)稳定计数数据范围k较小的整数桶排序O(nk)O(n²)O(nk)稳定分桶、子排序数据均匀分布、范围已知基数排序O(d*(nk))O(d*(nk))O(nk)稳定按位排序多位数整数或字符串位数d较小实战选型速查日常通用直接使用Arrays.sort()对于基本类型是双轴快速排序对于对象是TimSort。这是久经考验的工业级实现。面试手撕重点准备快速排序考察分区和优化、归并排序考察分治和合并、堆排序考察堆调整。能清晰写出这三大 O(n log n) 算法的代码基本够用。海量数据内存充足归并排序因其稳定性和可靠的外排序扩展能力常被用于大数据框架。海量数据内存紧张堆排序是原地排序或者考虑外部排序多路归并。数据是固定范围整数优先考虑计数排序或桶排序性能是降维打击。数据是字符串可考虑基数排序按字符比较或使用基于比较的排序。5. 常见问题、避坑技巧与性能实测理论懂了代码写了真正用起来还是会遇到各种问题。下面是我在项目和面试中总结的一些高频问题和实战技巧。5.1 算法实现中的经典“坑”数组边界错误这是新手最容易出错的地方。在循环中特别是for (int j 0; j n - 1 - i; j)或while (j 0 arr[j] key)这类条件务必仔细推导边界值。我的技巧是先写注释说明循环不变量Loop Invariant再写代码。递归深度过大快速排序和归并排序在数据量极大且递归实现时可能引发StackOverflowError。对于快速排序可以优化为尾递归或使用迭代栈的方式。对于归并排序可以考虑自底向上的迭代版本。// 快速排序的迭代版本使用栈模拟递归 public static void quickSortIterative(int[] arr, int low, int high) { StackInteger stack new Stack(); stack.push(low); stack.push(high); while (!stack.isEmpty()) { high stack.pop(); low stack.pop(); int pivot partition(arr, low, high); if (pivot - 1 low) { stack.push(low); stack.push(pivot - 1); } if (pivot 1 high) { stack.push(pivot 1); stack.push(high); } } }稳定性误判记住交换操作可能破坏稳定性。例如选择排序中将最小元素与当前位置交换时如果中间有与最小元素相等的元素稳定性就被破坏了。判断算法是否稳定要模拟有重复关键字的情况走一遍流程。整数溢出在计算中间索引时使用mid left (right - left) / 2而不是mid (left right) / 2可以防止left right可能出现的整数溢出。5.2 性能测试与对比实验纸上得来终觉浅我写了一个简单的性能测试类在相同数据集下对比这些算法。以下是在我的机器JDK 17上对10万个随机整数的排序耗时单位毫秒的近似结果生成 100000 个随机整数... 冒泡排序: 15000 ms (太慢未测完) 选择排序: 10000 ms (太慢未测完) 插入排序: 5000 ms (太慢未测完) 希尔排序: ~15 ms 归并排序: ~20 ms 快速排序: ~10 ms 堆排序: ~25 ms 计数排序 (范围0-100000): ~5 ms Arrays.sort(): ~12 ms结果分析O(n²) 的算法在10万数据量下完全不可用。快速排序综合表现最好。计数排序在数据范围已知且不大时速度一骑绝尘。Java自带的Arrays.sort()经过了极致优化如双轴快排、小数组用插入排序等性能非常强悍绝大多数情况应优先使用它。5.3 面对“排序”相关的面试题面试官很少会让你默写整个排序代码更多的是考察变体和思想。问数据流中如何实时获取中位数答使用两个堆优先队列。一个大顶堆存较小的一半一个小顶堆存较大的一半。插入时维护两个堆的大小平衡中位数就可以从堆顶快速获得。这利用了堆排序中“堆”的特性。问如何在O(n)时间内找到第K大或第K小的元素答基于快速排序的分区思想快速选择算法。每次分区后判断基准点的位置与K的关系只在包含K的那一侧递归平均复杂度是O(n)。这是快速排序思想的一个经典应用。问如何对100GB的日志文件按时间排序答这就是典型的外部排序场景。先将大文件分割成能装入内存的小块每块在内存中用高效算法如快速排序排序然后写回磁盘。最后使用多路归并Min-Heap将这些有序块合并成最终文件。这本质上是归并排序思想在外存上的延伸。亲手实现一遍这10种排序算法就像练武之人扎马步是内功的基础。它能让你在面对复杂的业务数据时不再仅仅是一个API调用者而是一个能洞察性能瓶颈、选择最优策略的开发者。当你在代码中写下Arrays.sort()时你心里清楚它背后可能发生的所有故事这种底气是任何八股文都无法给予的。最后我的建议是将归并、快排、堆排的代码练到肌肉记忆理解计数/桶/基数排序的应用边界这样无论是面试还是实战你都能从容应对。