完整版Java类型

1. 基本数据类型（Primitive Types）

Java 有 8 种基本数据类型，这些类型直接存储值，占用固定内存，效率较高。它们不属于类，没有方法或属性。

基本数据类型	关键字	大小	取值范围
整数类型	`byte`	8 位	-128 到 127
整数类型	`short`	16 位	-32,768 到 32,767
整数类型	`int`	32 位	-2^31 到 2^31-1
整数类型	`long`	64 位	-2^63 到 2^63-1
浮点类型	`float`	32 位	单精度浮点数
浮点类型	`double`	64 位	双精度浮点数
字符类型	`char`	16 位	单个 Unicode 字符
布尔类型	`boolean`	不确定	`true` 和 `false`

2. 引用类型（Reference Types）

引用类型用于存储对象的引用，而不是对象本身。引用类型包括类、接口、数组、和枚举，它们在 Java 中用于更复杂的数据结构和逻辑控制。

Object obj 参数的含义

在方法定义参数类型 Object 表示可以传入任何对象类型，包含：

所有包装类（Integer、Double、Character 等）

自定义类

String 类型

其他引用类型（如数组、集合等）

2.1 类（Class）

Java 中的大部分数据类型都是通过类创建的，类可以表示数据和行为（即属性和方法）。
类的实例称为对象，类的类型即为引用类型。
示例：String、Integer、Double、Person 等自定义类。
java 复制代码
```
String str = "Hello, World!";
Person person = new Person("John", 25);
```

2.2 接口（Interface）

接口是一种特殊的引用类型，用于定义类的公共行为。
接口不能实例化，但可以被类实现，接口类型可以用于多态性，指定对象的行为。

示例：List、Map、Runnable 等都是接口类型。

java 复制代码

List<String> list = new ArrayList<>();  // List 是接口，ArrayList 是其实现
Runnable task = new MyRunnable();       // Runnable 是接口

2.3 数组（Array）

数组也是一种引用类型，表示一组相同类型的元素。

数组类型可以是基本数据类型数组（如 int[]）或引用类型数组（如 String[]）。

java 复制代码

int[] numbers = {1, 2, 3};           // int 类型的数组
String[] names = {"Alice", "Bob"};    // String 类型的数组

2.4 枚举（Enum）

枚举类型用于表示一组有限的、固定的常量值，通常用于表示状态或一组相关常量。

枚举类型是一个特殊的类，它使用 enum 关键字定义。

java 复制代码

enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

Day today = Day.MONDAY;

2.5 包装类（Wrapper Class）

包装类是基本数据类型的对象版本，用于在需要对象类型的场景中使用基本类型的值。
每种基本类型都有对应的包装类，例如 int 对应 Integer，double 对应 Double。
包装类除了存储基本类型值，还提供了许多实用方法，如 parseInt、toString 等。

基本类型包装类

int Integer

double Double

boolean Boolean

char Character

byte Byte

short Short

long Long

float Float
java 复制代码
```
Integer number = 42;
Boolean flag = true;
```

基本类型	包装类
`int`	`Integer`
`double`	`Double`
`boolean`	`Boolean`
`char`	`Character`
`byte`	`Byte`
`short`	`Short`
`long`	`Long`
`float`	`Float`

所有包装类都具有 toString() 方法 。这是因为所有包装类都继承自 Object 类，而 Object 类定义了 toString() 方法。因此，所有包装类（Integer、Double、Character 等）都可以调用 toString() 方法。

3. 使用包装类的场景

3.1. 集合框架的需求

使用原因 ：Java 集合框架（如 List、Set、Map 等）只能存储对象，不能存储基本数据类型。当我们需要在集合中存储数值类型的数据时，必须使用包装类将基本类型转换为对象。这在统计、数据处理等需要存储大量数值的场景中非常常见。

示例场景

假设我们要存储一个班级中所有学生的分数，并计算平均分。我们可以使用 List<Integer> 来存储这些分数，因为集合只能存储对象类型。

java 复制代码

List<Integer> scores = new ArrayList<>();
scores.add(85);  // 自动装箱，将 int 85 转换为 Integer 对象
scores.add(90);
scores.add(78);

// 计算平均分
int total = 0;
for (Integer score : scores) {
    total += score;  // 自动拆箱，将 Integer 转换为 int 参与运算
}
double average = total / (double) scores.size();
System.out.println("Average score: " + average);  // 输出: Average score: 84.3333

3.2. 需要表示 `null` 值的场合

使用原因 ：基本数据类型（如 int、double）不能表示 null，而包装类可以。这在数据库查询、数据初始化和用户输入处理中非常有用，因为 null 可以表示"未赋值"或"无效"状态。例如，当从数据库读取用户年龄时，未填写的年龄字段可以用 null 表示，而不是一个默认数值（如 0），以避免数据误解。

示例场景

假设我们从数据库中查询用户的年龄，如果用户未填写年龄，数据库会返回 null。在 Java 中，我们可以用 Integer 来存储用户年龄，以便准确表示"未填写"的状态。

java 复制代码

Integer age = null;  // 表示年龄未填写

// 判断是否填写了年龄
if (age == null) {
    System.out.println("Age is not provided.");
} else {
    System.out.println("Age: " + age);
}

3.3. 自动装箱和拆箱的便利性

使用原因：Java 支持自动装箱（基本类型自动转换为包装类）和自动拆箱（包装类自动转换为基本类型）。这种特性在集合和泛型的使用中尤其有用，因为我们可以直接操作基本类型的数值而无需手动转换，提升了代码的简洁性和可读性。

示例场景

假设我们有一个整数集合，想要将其中所有的分数加上 5 分。在遍历集合时，自动拆箱和装箱可以让我们直接进行数值操作，而无需手动转换。

java 复制代码

List<Integer> scores = Arrays.asList(80, 85, 90);
List<Integer> updatedScores = new ArrayList<>();

for (Integer score : scores) {
    updatedScores.add(score + 5);  // 自动拆箱为 int，计算后自动装箱为 Integer
}
System.out.println("Updated scores: " + updatedScores);  // 输出: [85, 90, 95]

3.4. 使用包装类的实用方法和常量

使用原因 ：包装类提供了许多实用方法和常量，便于数值转换、格式化、边界检查等操作。例如，Integer.parseInt() 可以将字符串转换为整数，Double.isNaN() 用于判断数值是否为 NaN，Integer.MAX_VALUE 表示 int 的最大值。这些方法和常量使得包装类在数据处理和异常值检测中非常方便。

示例场景

假设我们从用户输入中获取一个字符串，并将其解析为整数。如果用户输入的是非数字内容，系统需要抛出异常。我们还可以检查浮点运算是否为 NaN 值。

java 复制代码

try {
    int value = Integer.parseInt("123");  // 将字符串 "123" 转换为整数
    System.out.println("Parsed value: " + value);
} catch (NumberFormatException e) {
    System.out.println("Invalid number format");
}

double result = 0.0 / 0.0;  // 计算无效值
if (Double.isNaN(result)) {
    System.out.println("Result is NaN (not a number)");
}

3.5. 泛型类型的需求

使用原因：Java 泛型只能接受引用类型，不能直接使用基本数据类型。这使得包装类在泛型类和方法中不可或缺。泛型设计使代码更具通用性和类型安全性，而包装类的引入确保了基本类型的兼容性。

示例场景

假设我们创建一个泛型类 Box，用于存储任意类型的数据。在泛型中，我们必须使用包装类来存储数值类型的数据。

java 复制代码

class Box<T> {
    private T value;
    public Box(T value) { this.value = value; }
    public T getValue() { return value; }
}

Box<Integer> intBox = new Box<>(100);  // 必须使用 Integer 而非 int
System.out.println("Boxed value: " + intBox.getValue());  // 输出: Boxed value: 100

3.6. 多态性和对象方法调用

使用原因 ：包装类作为对象，能够享受面向对象编程的特性，例如多态性和对象方法调用。Java 的 Number 类是 Integer、Double 等包装类的父类，可以用作这些包装类的通用类型。此外，包装类的对象可以直接调用许多实用方法。

示例场景

假设我们编写一个方法，接收 Number 类型的参数。这种多态性允许该方法接受 Integer、Double 等所有包装类类型的数值参数。

java 复制代码

public static void printDoubleValue(Number num) {
    System.out.println("Double value: " + num.doubleValue());
}

printDoubleValue(new Integer(10));   // 自动转为 double
printDoubleValue(new Double(15.5));

3.7. 比较和排序

使用原因 ：包装类实现了 Comparable 接口，因此支持对象的排序和比较操作。基本数据类型不具备对象的功能，而包装类提供的比较和排序接口使其可以直接用于集合的排序需求。在排序和优先级管理场景中，包装类广泛用于 List、Set 等集合的排序操作中。

示例场景

假设我们有一个学生分数的列表，想要按照分数从小到大排序。包装类 Integer 支持比较操作，可以直接在 Collections.sort() 中使用。

java 复制代码

List<Integer> scores = Arrays.asList(88, 75, 90, 85);
Collections.sort(scores);  // 自动排序
System.out.println("Sorted scores: " + scores);  // 输出: [75, 85, 88, 90]

4.四种常用类型

4.1. `String` 类型

String 是 Java 中用于存储和处理文本数据的类。String 是不可变的，即一旦创建，字符串的内容就不能更改。每次对字符串进行修改时，都会创建一个新的 String 对象。

特点

不可变性 ：字符串在创建后不可修改，修改字符串时会创建新的 String 对象。
字符串池：Java 会将字符串字面量存储在一个字符串池（String Pool）中，以节省内存并提高性能。
丰富的字符串操作方法 ：String 类提供了多种方法，如 length()、substring()、charAt()、equals()、compareTo() 等，用于各种字符串操作。

常用方法

java 复制代码

String str = "Hello, World!";

// 获取字符串长度
int length = str.length();  // 13

// 获取子字符串
String sub = str.substring(0, 5);  // "Hello"

// 字符串比较
boolean isEqual = str.equals("Hello, World!");  // true

// 转换为大写
String upper = str.toUpperCase();  // "HELLO, WORLD!"

在 Java 中，String 类型的对象可以通过两种方式创建：

直接赋值 （字符串字面量）：例如 String str1 = "Java";

这种方式会在 字符串池（String Pool） 中查找是否已有相同内容的字符串。

如果字符串池中存在该内容的字符串，则会复用池中的对象。

如果不存在，则会在字符串池中创建一个新对象。

使用 new 关键字 ：例如 String str3 = new String("Java");

这种方式会直接在 堆内存 中创建一个新的 String 对象，而不使用字符串池。

即使内容相同，这样创建的对象也会与字符串池中的对象不同。
String 和 char 的相互转换

是的，String 和 char 类型可以相互转换。以下是常用的转换方法：
从 String 提取 char ：可以使用 charAt(int index) 方法从 String 中提取指定位置的字符。
java 复制代码
String str = "Hello";
char ch = str.charAt(1);  // 提取第二个字符 'e'
将 char 转换为 String ：可以直接使用 Character.toString(char ch) 或 String.valueOf(char ch)，也可以通过字符串拼接的方式将 char 转换为 String。
java 复制代码
char ch = 'A';
String str = Character.toString(ch);  // 转换为 "A"
// 或者使用
String str2 = String.valueOf(ch);     // 转换为 "A"

示例

java 复制代码

String str1 = "Java";
String str2 = "Java";
String str3 = new String("Java");

// str1 和 str2 指向字符串池中的同一对象
System.out.println(str1 == str2);  // true

// str3 是新创建的对象，虽然内容相同，但不是同一对象
System.out.println(str1 == str3);  // false
System.out.println(str1.equals(str3));  // true，内容相等

== 和 equals 的区别

== 运算符 ：用于比较两个引用是否指向同一个对象，即比较两个对象的内存地址 。

str1 == str3 比较的是两个字符串引用是否指向同一对象。

因为 str1 指向字符串池中的对象，而 str3 是一个新创建的对象，所以 str1 == str3 为 false。

equals 方法 ：用于比较两个字符串的内容是否相等。

str1.equals(str3) 比较的是两个字符串内容是否相同。

即使两个字符串对象的引用不同，只要内容相同，equals 方法也会返回 true。

String str1 = "Java"; 和 String str2 = "Java";

这两个字符串都是通过字面量创建的，Java 作为字符串内容会被存储在字符串池中。

因此，str1 和 str2 指向的是字符串池中的同一个对象。

String str3 = new String("Java");

使用 new 关键字创建的字符串对象总是会在堆内存中创建一个新对象。

即使内容相同，str3 也是一个新的对象，不会指向字符串池中的对象。

所以，str1 == str3 的结果为 false，因为它们不是同一个对象。

4.2. `Character` 类型

Character 是 char 基本数据类型的包装类，用于表示单个字符。Character 提供了大量实用方法，用于处理字符的属性，如判断字符类型（字母、数字、空格等）或大小写转换。

特点

字符操作方法 ：Character 类提供了多种方法，用于判断字符类型、转换大小写等。
字符编码 ：Character 基于 Unicode 设计，因此可以表示世界上几乎所有语言的字符。

常用方法

java 复制代码

Character charValue = Character.valueOf('A');  // 创建 Character 对象

// 判断是否为字母
boolean isLetter = Character.isLetter('A');  // true

// 判断是否为数字
boolean isDigit = Character.isDigit('1');  // true

// 转换为小写
char lower = Character.toLowerCase('B');  // 'b'

示例

java 复制代码

Character a = Character.valueOf('A');
Character b = Character.valueOf('A');

// 字符在范围内时可能会缓存
System.out.println(a == b);  // true

// 转换大小写
System.out.println(Character.toLowerCase('Z'));  // 'z'
System.out.println(Character.toUpperCase('z'));  // 'Z'

4.3. `Integer` 类型

Integer 是 int 基本数据类型的包装类。包装类允许在需要对象的场合使用基本类型，例如在集合框架中。Integer 提供了许多静态方法，方便整数的处理和转换。

特点

缓存机制 ：Java 对 -128 到 127 之间的整数进行缓存，若数值在此范围内且通过 Integer.valueOf 创建，则会返回相同的对象。
常用静态方法 ：Integer 提供了一些实用的静态方法，如 parseInt() 将字符串转为 int，valueOf() 创建 Integer 对象。

常用方法

java 复制代码

Integer intValue = Integer.valueOf(10);  // 创建 Integer 对象

// 将字符串转换为 int
int parsedInt = Integer.parseInt("123");  // 123

// 获取 Integer 的最大值
int maxValue = Integer.MAX_VALUE;  // 2147483647

Integer.parseInt("123") 的转换规则

Integer.parseInt("123") ：这个方法用于将字符串表示的数值转换为 int 类型。例如 Integer.parseInt("123") 的结果是 123。

非法输入的处理 ：如果输入的字符串不是有效的数字（如包含字母），则会抛出 NumberFormatException 异常，而不会进行任何转换。

例如，Integer.parseInt("abc") 会抛出异常，而不是转换为 ASCII 码。

示例

java 复制代码

Integer a = Integer.valueOf(100);
Integer b = Integer.valueOf(100);
Integer c = Integer.valueOf(200);

// a 和 b 指向相同的缓存对象
System.out.println(a == b);  // true

// c 不在缓存范围内，创建新对象
System.out.println(a == c);  // false

4.4. `Double` 类型

Double 是 double 基本数据类型的包装类，表示双精度浮点数。Double 用于存储和处理小数数据，在需要对象的场合使用。

特点

精度：双精度浮点数具有较高的精度，适合存储大范围或高精度的小数值。
NaN 和 Infinity ：Double 提供了 NaN（非数值）和 Infinity（无穷大）等特殊值，用于表示非法或超出范围的结果。
常用静态方法 ：Double 提供了将字符串转换为 double 的方法 parseDouble()，还可以使用 Double.valueOf() 创建 Double 对象。

常用方法

java 复制代码

Double doubleValue = Double.valueOf(5.5);  // 创建 Double 对象

// 将字符串转换为 double
double parsedDouble = Double.parseDouble("123.45");  // 123.45

// 检查是否为 NaN
boolean isNaN = Double.isNaN(0.0 / 0.0);  // true

// 获取 Double 的最大值
double maxValue = Double.MAX_VALUE;  // 1.7976931348623157E308

示例

java 复制代码

Double x = Double.valueOf(10.5);
Double y = Double.valueOf(10.5);

// 浮点数没有缓存机制，不同对象
System.out.println(x == y);  // false

// 内容相同
System.out.println(x.equals(y));  // true

`5.Vector`

Vector 是 Java 中的一种动态数组实现类，位于 java.util 包中，因此它属于引用类型。与 ArrayList 类似，Vector 允许动态调整容量以容纳更多的元素，但与 ArrayList 不同的是，Vector 是线程安全的，所有方法都被同步（synchronized）修饰，因此可以在多线程环境中安全使用。

Vector 的主要特点

动态数组 ：Vector 是一个动态数组，可以自动调整容量。与普通数组不同，Vector 的大小不是固定的，它会根据需要自动扩展。
线程安全 ：Vector 是线程安全的，因为它的所有方法都被 synchronized 修饰。这样保证了在多线程环境中不会发生并发修改问题。
有序存储 ：Vector 按照插入顺序存储元素，即添加元素的顺序就是迭代时的顺序。
支持随机访问 ：Vector 通过索引可以快速访问元素，适合需要频繁按索引访问的场景。
扩容机制 ：Vector 默认的初始容量是 10，当容量不够时，会自动扩展到原容量的 2 倍，或者可以指定扩容因子来控制增长速度。

5.1. 创建 `Vector`

Vector 提供了多种构造方法，允许我们指定初始容量和容量增量（扩展大小）。

Vector()：创建一个默认容量为 10 的空向量。
Vector(int initialCapacity)：创建一个指定初始容量的空向量。
Vector(int initialCapacity, int capacityIncrement)：创建一个指定初始容量和容量增量的空向量。容量增量用于控制扩展速度。

java 复制代码

import java.util.Vector;

public class VectorCreationExample {
    public static void main(String[] args) {
        Vector<String> vector1 = new Vector<>();  // 默认容量 10
        Vector<String> vector2 = new Vector<>(20);  // 指定初始容量为 20
        Vector<String> vector3 = new Vector<>(10, 5);  // 初始容量 10，扩展增量 5

        System.out.println("Vector1 capacity: " + vector1.capacity());  // 输出: 10
        System.out.println("Vector2 capacity: " + vector2.capacity());  // 输出: 20
        System.out.println("Vector3 capacity: " + vector3.capacity());  // 输出: 10
    }
}

5.2. 添加元素

Vector 提供了多种方法来添加元素：

add(E e) ：将元素添加到 Vector 的末尾。
add(int index, E element)：在指定索引处插入元素。
addAll(Collection<? extends E> c) ：将另一个集合中的所有元素添加到 Vector。

java 复制代码

import java.util.Vector;

public class VectorAddExample {
    public static void main(String[] args) {
        Vector<String> vector = new Vector<>();
        vector.add("Alice");  // 添加到末尾
        vector.add("Bob");

        vector.add(1, "Charlie");  // 在索引 1 处插入 "Charlie"

        Vector<String> moreNames = new Vector<>();
        moreNames.add("David");
        moreNames.add("Eve");

        vector.addAll(moreNames);  // 将 moreNames 中的元素添加到 vector

        System.out.println("Vector after additions: " + vector);  // 输出: [Alice, Charlie, Bob, David, Eve]
    }
}

5.3. 访问和查询元素

Vector 支持通过索引访问元素，还可以检查元素是否存在，获取首尾元素等。

get(int index)：返回指定索引处的元素。
firstElement()：返回第一个元素。
lastElement()：返回最后一个元素。
contains(Object o) ：检查 Vector 是否包含指定的元素。
indexOf(Object o)：返回指定元素首次出现的索引位置。
size() ：返回 Vector 中的元素数量。

java 复制代码

import java.util.Vector;

public class VectorAccessExample {
    public static void main(String[] args) {
        Vector<String> vector = new Vector<>();
        vector.add("Alice");
        vector.add("Bob");
        vector.add("Charlie");

        // 访问元素
        System.out.println("First element: " + vector.firstElement());  // 输出: Alice
        System.out.println("Last element: " + vector.lastElement());    // 输出: Charlie
        System.out.println("Element at index 1: " + vector.get(1));     // 输出: Bob

        // 查询元素
        System.out.println("Contains 'Alice'? " + vector.contains("Alice"));  // 输出: true
        System.out.println("Index of 'Charlie': " + vector.indexOf("Charlie"));  // 输出: 2
        System.out.println("Vector size: " + vector.size());  // 输出: 3
    }
}

5.4. 更新元素

使用 set(int index, E element) 方法可以替换 Vector 中指定索引位置的元素。

java 复制代码

import java.util.Vector;

public class VectorUpdateExample {
    public static void main(String[] args) {
        Vector<String> vector = new Vector<>();
        vector.add("Alice");
        vector.add("Bob");
        vector.add("Charlie");

        // 更新元素
        vector.set(1, "Bob Updated");  // 更新索引 1 的元素

        System.out.println("Vector after update: " + vector);  // 输出: [Alice, Bob Updated, Charlie]
    }
}

5.5. 删除元素

Vector 提供了多种方法删除元素，可以通过索引删除，也可以按值删除，还可以清空 Vector。

remove(int index)：删除指定索引位置的元素。
remove(Object o)：删除首次出现的指定元素。
removeAll(Collection<?> c) ：删除 Vector 中包含在指定集合中的所有元素。
clear() ：清空 Vector，删除所有元素。

java 复制代码

import java.util.Vector;

public class VectorRemoveExample {
    public static void main(String[] args) {
        Vector<String> vector = new Vector<>();
        vector.add("Alice");
        vector.add("Bob");
        vector.add("Charlie");

        // 按索引删除元素
        vector.remove(1);  // 删除索引 1 的元素 "Bob"
        System.out.println("After removing index 1: " + vector);  // 输出: [Alice, Charlie]

        // 按值删除元素
        vector.remove("Alice");
        System.out.println("After removing Alice: " + vector);  // 输出: [Charlie]

        // 清空 Vector
        vector.clear();
        System.out.println("After clearing: " + vector);  // 输出: []
    }
}

5.6. 遍历 `Vector`

可以使用 for 循环、增强 for 循环或 Iterator 来遍历 Vector。

iterator() ：返回 Vector 的迭代器。
elements() ：返回 Enumeration 对象，适用于旧版本的代码，但现在更推荐使用 Iterator。

java 复制代码

import java.util.Iterator;
import java.util.Vector;

public class VectorIterationExample {
    public static void main(String[] args) {
        Vector<String> vector = new Vector<>();
        vector.add("Alice");
        vector.add("Bob");
        vector.add("Charlie");

        // 使用 for 循环
        System.out.println("Using for loop:");
        for (int i = 0; i < vector.size(); i++) {
            System.out.println(vector.get(i));
        }

        // 使用增强型 for 循环
        System.out.println("Using enhanced for loop:");
        for (String name : vector) {
            System.out.println(name);
        }

        // 使用 Iterator
        System.out.println("Using Iterator:");
        Iterator<String> iterator = vector.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

5.7. 扩容机制

当 Vector 的容量不足以容纳新元素时，会自动扩容。默认情况下，Vector 每次扩容为原容量的 2 倍。不过，可以通过构造方法指定扩展因子，控制每次扩容的增量。

java 复制代码

import java.util.Vector;

public class VectorCapacityExample {
    public static void main(String[] args) {
        Vector<Integer> vector = new Vector<>(3, 2);  // 初始容量为 3，扩展因子为 2

        // 添加元素触发扩容
        for (int i = 1; i <= 5; i++) {
            vector.add(i);
            System.out.println("Capacity after adding element " + i + ": " + vector.capacity());
        }
    }
}

完整版Java类型

1. 基本数据类型（Primitive Types）

2. 引用类型（Reference Types）

2.1 类（Class）

2.2 接口（Interface）

2.3 数组（Array）

2.4 枚举（Enum）

2.5 包装类（Wrapper Class）

3. 使用包装类的场景

3.1. 集合框架的需求

3.2. 需要表示 null 值的场合

3.3. 自动装箱和拆箱的便利性

3.4. 使用包装类的实用方法和常量

3.5. 泛型类型的需求

3.6. 多态性和对象方法调用

3.7. 比较和排序

4.四种常用类型

4.1. String 类型

4.2. Character 类型

4.3. Integer 类型

4.4. Double 类型

5.Vector

5.1. 创建 Vector

5.2. 添加元素

5.3. 访问和查询元素

5.4. 更新元素

5.5. 删除元素

5.6. 遍历 Vector

5.7. 扩容机制

3.2. 需要表示 `null` 值的场合

4.1. `String` 类型

4.2. `Character` 类型

4.3. `Integer` 类型

4.4. `Double` 类型

`5.Vector`

5.1. 创建 `Vector`

5.6. 遍历 `Vector`