C++中vector的大小与容量有何区别

# 1. Vector的基本概念**

Vector是一种动态数组，它可以根据需要自动调整大小。它存储相同类型元素的集合，并提供高效的插入、删除和访问操作。Vector的底层实现是一个连续的内存块，其中元素按顺序存储。

Vector的元素类型在创建时指定，并且不能在以后更改。Vector的容量是它可以容纳的元素的最大数量，而大小是当前存储的元素数量。容量可以动态调整，而大小会随着元素的添加或删除而自动更新。

# 2. Vector的容量与大小

### 2.1 Vector的容量

#### 2.1.1 容量的定义和获取

容量是指Vector可以容纳元素的最大数量，它是一个动态可调整的值。可以通过`capacity()`方法获取Vector的当前容量。

Vector<Integer> vector = new Vector<>();
int capacity = vector.capacity();

#### 2.1.2 容量的动态调整

Vector的容量可以根据需要进行动态调整。当向Vector中添加元素时，如果当前容量不足以容纳新元素，Vector会自动扩容。扩容的幅度通常是当前容量的一倍。

vector.add(1);
vector.add(2);
vector.add(3);
System.out.println(vector.capacity()); // 输出：4

### 2.2 Vector的大小

#### 2.2.1 大小的定义和获取

大小是指Vector中实际存储的元素数量。可以通过`size()`方法获取Vector的当前大小。

int size = vector.size();

#### 2.2.2 大小与容量的关系

Vector的大小永远不会超过其容量。当向Vector中添加元素时，如果当前容量不足以容纳新元素，Vector会自动扩容。当从Vector中删除元素时，Vector的大小会相应减小，但容量不会改变。

vector.add(4);
System.out.println(vector.size()); // 输出：4
System.out.println(vector.capacity()); // 输出：8

vector.remove(2);
System.out.println(vector.size()); // 输出：3
System.out.println(vector.capacity()); // 输出：8

### 2.3 容量与大小的性能影响

容量和大小的调整会对Vector的性能产生影响。

#### 2.3.1 容量调整的性能开销

容量调整涉及到重新分配内存空间，这可能会导致性能开销。扩容时，Vector需要分配更大的内存空间，并复制现有元素到新空间。缩容时，Vector需要释放多余的内存空间。

// 扩容
vector.ensureCapacity(16);

// 缩容
vector.trimToSize();

#### 2.3.2 大小调整的性能开销

大小调整涉及到元素的移动和重新排列，这也会导致性能开销。扩容时，Vector需要为新元素分配空间并移动现有元素。缩容时，Vector需要释放多余的空间并移动元素。

// 扩容
vector.add(5);

// 缩容
vector.remove(0);

# 3. 容量与大小的管理

### 3.1 容量的管理

#### 3.1.1 容量的预分配

容量预分配是提前为Vector分配比实际需要更大的容量，以避免在添加元素时频繁触发容量扩容操作。预分配容量可以通过`reserve()`方法实现。`reserve()`方法接收一个整数参数，指定预分配的容量大小。

#include <vector>

int main() {
  std::vector<int> v;
  v.reserve(100); // 预分配容量为 100
  // ...
  return 0;
}

**代码逻辑逐行解读：**

* 第 3 行：包含标准库头文件`<vector>`。
* 第 5 行：创建了一个空的Vector `v`。
* 第 6 行：使用`reserve()`方法预分配容量为 100。

**参数说明：**

* `reserve(size_t n)`：预分配容量为`n`。

#### 3.1.2 容量的扩容和缩容

当Vector的大小超过其容量时，Vector将自动扩容。扩容操作会重新分配一块更大的内存区域，并将现有元素复制到新区域。扩容后的容量通常是原容量的 2 倍或 1.5 倍。

如果Vector的大小小于其容量，可以通过`shrink_to_fit()`方法缩容Vector。缩容操作会释放多余的内存空间，使Vector的容量与大小相等。

#include <vector>

int main() {
  std::vector<int> v;
  v.reserve(10); // 预分配容量为 10
  // ...
  v.push_back(1); // 添加元素，触发扩容
  v.shrink_to_fit(); // 缩容 Vector
  // ...
  return 0;
}

**代码逻辑逐行解读：**

* 第 3 行：包含标准库头文件`<vector>`。
* 第 5 行：创建了一个空的Vector `v`，并预分配容量为 10。
* 第 7 行：添加一个元素，触发容量扩容。
* 第 8 行：使用`shrink_to_fit()`方法缩容Vector。

**参数说明：**

* `shrink_to_fit()`：缩容Vector，使容量与大小相等。

### 3.2 大小的管理

#### 3.2.1 大小的动态调整

Vector的大小可以通过`push_back()`、`pop_back()`、`clear()`等方法进行动态调整。`push_back()`方法在Vector末尾添加一个元素，`pop_back()`方法删除Vector末尾的元素，`clear()`方法清空Vector。

#include <vector>

int main() {
  std::vector<int> v;
  v.push_back(1); // 添加元素
  v.pop_back(); // 删除元素
  v.clear(); // 清空 Vector
  // ...
  return 0;
}

**代码逻辑逐行解读：**

* 第 3 行：包含标准库头文件`<vector>`。
* 第 5 行：创建了一个空的Vector `v`。
* 第 6 行：使用`push_back()`方法添加一个元素。
* 第 7 行：使用`pop_back()`方法删除一个元素。
* 第 8 行：使用`clear()`方法清空Vector。

**参数说明：**

* `push_back(const T& value)`：在Vector末尾添加一个值。
* `pop_back()`：删除Vector末尾的元素。
* `clear()`：清空Vector。

#### 3.2.2 大小与容量的同步

Vector的大小和容量通常是不相等的。当大小超过容量时，Vector会自动扩容；当大小小于容量时，Vector不会自动缩容。可以通过`resize()`方法手动调整Vector的大小。

#include <vector>

int main() {
  std::vector<int> v;
  v.resize(10); // 调整大小为 10
  // ...
  return 0;
}

**代码逻辑逐行解读：**

* 第 3 行：包含标准库头文件`<vector>`。
* 第 5 行：创建了一个空的Vector `v`。
* 第 6 行：使用`resize()`方法调整Vector的大小为 10。

**参数说明：**

* `resize(size_t new_size)`：调整Vector的大小为`new_size`。

# 4. 容量与大小的性能影响

### 4.1 容量调整的性能开销

**4.1.1 容量扩容的开销**

当 Vector 的容量不足以容纳新元素时，需要进行容量扩容。扩容操作会涉及到以下步骤：

- **分配新内存：**为 Vector 分配一块新的、更大的内存空间。
- **复制数据：**将 Vector 中现有的元素复制到新分配的内存空间中。
- **更新指针：**将 Vector 的内部指针指向新分配的内存空间。

这些操作都会消耗一定的 CPU 时间和内存空间。扩容的开销与以下因素有关：

- **扩容倍数：**扩容倍数越大，需要复制的数据量就越大，开销也就越大。
- **Vector 的大小：**Vector 的大小越大，需要复制的数据量就越大，开销也就越大。

**4.1.2 容量缩容的开销**

当 Vector 的容量远大于其大小时，可以进行容量缩容。缩容操作会涉及到以下步骤：

- **释放多余内存：**释放 Vector 中多余的、未使用的内存空间。
- **更新指针：**将 Vector 的内部指针指向缩容后的内存空间。

缩容操作的开销相对较小，主要涉及到内存释放和指针更新。

### 4.2 大小调整的性能开销

**4.2.1 大小扩容的开销**

当 Vector 中添加新元素时，其大小会增加。如果 Vector 的容量不足以容纳新元素，则需要进行容量扩容。因此，大小扩容的开销与容量扩容的开销相同。

**4.2.2 大小缩容的开销**

当 Vector 中删除元素时，其大小会减小。如果 Vector 的容量远大于其大小，则可以进行容量缩容。因此，大小缩容的开销与容量缩容的开销相同。

### 性能影响总结

**容量调整的性能开销：**

- 容量扩容：消耗 CPU 时间和内存空间，开销与扩容倍数和 Vector 大小有关。
- 容量缩容：开销相对较小，主要涉及到内存释放和指针更新。

**大小调整的性能开销：**

- 大小扩容：与容量扩容的开销相同。
- 大小缩容：与容量缩容的开销相同。

为了优化性能，应尽量避免频繁的容量和大小调整。

# 5. 容量与大小的最佳实践

### 5.1 容量管理的最佳实践

#### 5.1.1 预分配容量的策略

* **根据预期元素数量预分配容量：**预先分配一个足够大的容量，以避免频繁的容量调整。
* **使用预分配因子：**在预分配容量时，使用一个因子（例如 1.5 或 2）来预留额外的空间，以应对元素数量的增长。
* **渐进式容量预分配：**随着元素数量的增加，逐步预分配容量，而不是一次性分配大量容量。

#### 5.1.2 避免频繁容量调整

* **仅在必要时调整容量：**只有当容量不足以容纳新元素时，才调整容量。
* **使用容量阈值：**设置一个容量阈值，只有当容量达到或超过该阈值时，才触发容量调整。
* **优化容量调整算法：**使用高效的容量调整算法，以最小化调整的性能开销。

### 5.2 大小管理的最佳实践

#### 5.2.1 及时调整大小

* **定期检查大小：**定期检查 Vector 的大小，并在必要时调整大小。
* **使用大小阈值：**设置一个大小阈值，当大小达到或超过该阈值时，触发大小调整。
* **优化大小调整算法：**使用高效的大小调整算法，以最小化调整的性能开销。

#### 5.2.2 避免频繁大小调整

* **仅在必要时调整大小：**只有当大小与容量之间存在较大差异时，才调整大小。
* **使用大小调整因子：**在调整大小时，使用一个因子（例如 0.5 或 0.75）来避免过度调整。
* **使用大小调整策略：**根据 Vector 的使用模式，选择合适的调整策略，例如缩小到一半或缩小到最小容量。

# 6.1 Vector的内存管理

### 6.1.1 内存分配和释放

Vector在创建时会分配一块连续的内存空间来存储元素。当向Vector中添加元素时，如果当前容量不足，Vector会自动扩容，分配更大的内存空间。当Vector中的元素被删除时，Vector会缩容，释放多余的内存空间。

内存分配和释放操作是由Java虚拟机(JVM)自动管理的。Vector本身不负责分配或释放内存，它只负责管理元素在内存中的存储。

### 6.1.2 内存碎片化问题

内存碎片化是指内存中存在大量不连续的小块空闲内存的情况。当Vector频繁地扩容和缩容时，可能会导致内存碎片化。

内存碎片化会影响Vector的性能，因为它会增加JVM分配和释放内存的开销。为了减少内存碎片化，可以采用以下策略：

- 预分配容量：在创建Vector时，可以预先分配一个足够大的容量，以避免频繁的扩容。
- 及时调整大小：当Vector中的元素数量发生较大变化时，及时调整Vector的大小，释放多余的内存空间。
- 使用对象池：对于经常创建和销毁的Vector对象，可以使用对象池来管理内存，避免频繁的内存分配和释放。