可变数组（也称为动态数组）是一种可以在运行时动态增加或减少其大小的数据结构。由于其动态分配大小，灵活性增删改查，动态地管理内存（在需要时动态分配内存空间，以适应数据结构的大小变化，而不会浪费过多的内存空间）以及具有良好的性能特性。因此在许多编程任务中都是非常有用的数据结构。而在Java中最承担该角色的是某些List接口实现类，Go则有切片。那么今天我们来聊一聊ArrayList和SLICE
ArrayList
当提及可变数组时，Java中的ArrayList是一个常见的实现。下面是关于ArrayList的详细信息：
1. 数据结构：
ArrayList 是 Java 中的动态数组实现。它是基于数组的数据结构，可以根据需要自动增长和缩小。ArrayList 实现了 List 接口，因此可以存储任意类型的对象，并且可以通过索引访问这些对象。
2. 功能特点：
- 动态大小： ArrayList 的大小可以动态地增长或缩小。当添加元素时，如果底层数组已满，ArrayList 会自动重新分配更大的内存空间来容纳更多的元素。
- 随机访问： 由于 ArrayList 基于数组实现，因此支持通过索引进行快速随机访问。这使得访问、修改或删除元素的操作具有 O(1) 的时间复杂度。
- 插入和删除： ArrayList 支持在任意位置插入和删除元素。但是，在列表中间或开头进行插入或删除操作时，需要将后续元素向后移动，因此具有较高的时间复杂度。
- 允许重复元素： ArrayList 允许存储重复的元素，并且可以按照插入顺序保持元素的顺序。
- 不是线程安全的： ArrayList 不是线程安全的，如果多个线程同时访问或修改 ArrayList，可能会导致不确定的行为。如果需要在多线程环境中使用，可以考虑使用 Collections.synchronizedList 方法来获得一个线程安全的 ArrayList。
3. 构造方式：
在 Java 中，ArrayList 可以通过多种构造方式进行实例化。下面是一些常用的构造方式：
- 默认构造函数：
//这将创建一个空的 ArrayList，初始容量为 10。
ArrayList<E> list = new ArrayList<>();
下面是一个例子
// 创建一个空的 ArrayList
ArrayList<String> list = new ArrayList<>();
// 添加元素
list.add("Apple");
list.add("Banana");
list.add("Orange");
// 输出 ArrayList 内容
System.out.println("ArrayList elements: " + list);
- 指定初始容量的构造函数：
//这将创建一个空的 ArrayList，其初始容量由 initialCapacity 参数指定。
//如果知道大致要存储的元素数量，可以使用这个构造函数来提高性能，避免频繁的扩容操作。
ArrayList<E> list = new ArrayList<>(initialCapacity);
//举个例子
// 创建一个初始容量为 20 的 ArrayList
ArrayList<Integer> list = new ArrayList<>(20);
// 添加元素
for (int i = 1; i <= 20; i++) {
list.add(i);
}
// 输出 ArrayList 内容
System.out.println("ArrayList elements: " + list);- 使用 Collection 来初始化 ArrayList 的构造函数：
//这将创建一个包含指定集合中的元素的 ArrayList。元素将按照集合的迭代器返回的顺序排列。
ArrayList<E> list = new ArrayList<>(Collection<? extends E> c);
//举个例子
String[] array = {"Apple", "Banana", "Orange"};
// 使用 ArrayList 构造函数从 List 初始化 ArrayList
ArrayList<String> list = new ArrayList<>(Arrays.asList(array));
// 输出 ArrayList 内容
System.out.println("ArrayList elements: " + list);- 从另一个 ArrayList 复制元素的构造函数：
//这将创建一个包含指定 ArrayList 中的元素的新 ArrayList。元素的顺序将与原始 ArrayList 保持一致。
ArrayList<E> list = new ArrayList<>(ArrayList<? extends E> c);
//举个例子
// 创建一个包含指定集合中的元素的 ArrayList
ArrayList<String> sourceList = new ArrayList<>();
sourceList.add("Apple");
sourceList.add("Banana");
sourceList.add("Orange");
// 使用集合 sourceList 初始化 ArrayList
ArrayList<String> targetList = new ArrayList<>(sourceList);
// 输出 ArrayList 内容
System.out.println("ArrayList elements: " + targetList);- 使用匿名内部类来初始化
import java.util.ArrayList;
public class ArrayListExample {
public static void main(String[] args) {
// 使用匿名内部类初始化 ArrayList
ArrayList<String> list = new ArrayList<String>() {{
add("Apple");
add("Banana");
add("Orange");
}};
// 输出 ArrayList 内容
System.out.println("ArrayList elements: " + list);
}
}这些是 ArrayList 的常见构造方式，可以根据具体的需求和场景选择合适的构造函数来创建 ArrayList 对象。
4. 增删改查
ArrayList 提供了一系列的方法来进行增删改查等功能操作：
- 增加元素（Add）:
- add(E element): 向列表的末尾添加指定的元素。
- add(int index, E element): 在列表的指定位置插入指定的元素。
- addAll(Collection<? extends E> c): 将指定集合中的所有元素添加到列表的末尾。
- addAll(int index, Collection<? extends E> c): 将指定集合中的所有元素插入到列表的指定位置。
- 删除元素（Remove）:
- remove(Object o): 从列表中删除指定的元素，如果存在的话。
- remove(int index): 删除列表中指定位置的元素。
- removeAll(Collection<?> c): 删除列表中包含在指定集合中的所有元素。
- clear(): 清空列表中的所有元素。
- 修改元素（Modify）:
- set(int index, E element): 用指定的元素替换列表中指定位置的元素。
- 查找元素（Retrieve）:
- get(int index): 返回列表中指定位置的元素。
- indexOf(Object o): 返回列表中指定元素的第一个出现的索引，如果列表不包含此元素，则返回 -1。
- lastIndexOf(Object o): 返回列表中指定元素的最后一个出现的索引，如果列表不包含此元素，则返回 -1。
- 其他功能:
- size(): 返回列表中的元素数。
- isEmpty(): 如果列表不包含任何元素，则返回 true。
- contains(Object o): 如果列表包含指定的元素，则返回 true。
- toArray(): 返回包含列表中所有元素的数组。
这些方法提供了对 ArrayList 中元素的常见操作。ArrayList 作为一个动态数组，支持在任意位置插入和删除元素，允许元素的重复，并且具有较好的随机访问性能。因此，ArrayList 在很多情况下是一个非常实用的数据结构。
看例子
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class ArrayListExample {
public static void main(String[] args) {
// 创建一个空的 ArrayList
ArrayList<String> list = new ArrayList<>();
// 添加元素
list.add("Apple");
list.add("Banana");
list.add("Orange");
System.out.println("After adding elements: " + list);
// 在指定位置插入元素
list.add(1, "Grapes");
System.out.println("After inserting Grapes at index 1: " + list);
// 删除指定元素
list.remove("Banana");
System.out.println("After removing Banana: " + list);
// 删除指定位置的元素
list.remove(0);
System.out.println("After removing element at index 0: " + list);
// 修改指定位置的元素
list.set(0, "Strawberry");
System.out.println("After setting element at index 0 to Strawberry: " + list);
// 获取指定位置的元素
String fruit = list.get(1);
System.out.println("Element at index 1: " + fruit);
// 检查是否包含某个元素
boolean containsOrange = list.contains("Orange");
System.out.println("Contains Orange: " + containsOrange);
// 获取列表的大小
int size = list.size();
System.out.println("Size of the list: " + size);
// 清空列表
list.clear();
System.out.println("After clearing the list: " + list);
// 创建一个包含指定数组元素的 List
String[] array = {"Apple", "Banana", "Orange"};
List<String> tempList = Arrays.asList(array);
// 使用 ArrayList 构造函数从 List 初始化 ArrayList
ArrayList<String> arrayListFromList = new ArrayList<>(tempList);
System.out.println("ArrayList from List: " + arrayListFromList);
}
}5.遍历
遍历 ArrayList 有几种常用的方法，包括使用迭代器、for-each 循环以及普通的 for 循环。下面是这些方法的示例：
- 使用迭代器遍历 ArrayList:
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListTraversal {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Orange");
// 使用迭代器遍历 ArrayList
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String element = iterator.next();
System.out.println(element);
}
}
}- 使用 for-each 循环遍历 ArrayList:
import java.util.ArrayList;
public class ArrayListTraversal {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Orange");
// 使用 for-each 循环遍历 ArrayList
for (String element : list) {
System.out.println(element);
}
}
}- 使用普通的 for 循环遍历 ArrayList:
import java.util.ArrayList;
public class ArrayListTraversal {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Orange");
// 使用普通的 for 循环遍历 ArrayList
for (int i = 0; i < list.size(); i++) {
String element = list.get(i);
System.out.println(element);
}
}
}这些方法都可以用来遍历 ArrayList，你可以根据自己的喜好和代码风格选择合适的方法。通常情况下，使用 for-each 循环会更加简洁和直观，也可以配合stream进行操作。
小结
注意：ArrayList非线程安全使用时要注意，且只接受引用类型（可以存Integer但不能是int），这就意味着允许有null值。
slice
当谈到 Go 语言的切片（Slice）时，它是一个非常强大且常用的数据结构。切片提供了对序列的抽象，可以像数组一样访问元素，但它比数组更灵活、更强大。
1.数据结构
Go 语言中的切片（Slice）是一个动态长度的、灵活的数据结构，它是对数组的一个抽象。切片在底层的数据结构主要包括三个部分：
- 指针（Pointer）： 切片包含一个指向底层数组的指针，该指针指向数组中的第一个元素。通过指针，切片可以访问底层数组中的元素。
- 长度（Length）： 切片包含一个表示当前元素数量的长度字段。长度表示切片当前包含的元素数量，它不能超过底层数组的长度。
- 容量（Capacity）： 切片还包含一个表示可以容纳的最大元素数量的容量字段。容量表示切片从当前位置开始，到底层数组的末尾的元素数量。当向切片追加元素时，如果超过了切片的容量，Go 语言会自动扩展切片的容量，以保证足够的空间。
type slice struct {
array unsafe.Pointer // 指向底层数组的指针
len int // 切片当前长度
cap int // 切片当前容量
}在底层数组的基础上，切片提供了灵活的动态增长和缩减，这是因为切片可以通过修改其长度和容量字段来控制元素的数量。同时，由于切片是对底层数组的引用，因此对切片的操作也会影响到底层数组，反之亦然。
切片的底层数据结构使得它在内存中的表示比较轻量级，并且可以很方便地进行传递和复制。在实际开发中，切片是 Go 语言中常用的数据结构，用来处理动态大小的数据集合，例如字符串、字节数组等
2.重要特点
- 动态大小： 切片是动态大小的，可以根据需要动态增长或缩小。与数组不同，切片的长度可以在运行时改变。
- 引用数组： 切片是对底层数组的引用。在底层数组上进行操作会影响到切片，反之亦然。这意味着切片的创建和操作成本较低，因为它们不需要复制底层数组的数据。
- 灵活的索引操作： 切片支持灵活的索引操作，可以使用切片表达式来获取子切片或修改切片的内容。
3.构造方式
- 直接声明并初始化：
切片可以直接声明并初始化，使用 [] 表示切片，可以在 [] 中指定切片的长度和容量，也可以不指定。如果不指定长度和容量，切片的长度和容量都为 0。和数组不一样哦，数组至少还得三个dots[…]
// 声明一个切片并初始化
var slice1 []int // 声明一个空切片
slice2 := []int{1, 2, 3} // 声明并初始化一个切片- 通过数组进行切片：
可以通过数组来创建切片，通过指定数组的索引范围来获取子切片。
array := [5]int{1, 2, 3, 4, 5}
slice := array[1:3] // 从数组的索引 1 开始，到索引 3 结束，- 使用 make() 函数创建切片：
使用内置的 make() 函数来创建切片，该函数的语法为 make([]T, length, capacity)，其中 T 表示切片的元素类型，length 表示切片的长度，capacity 表示切片的容量。
slice := make([]int, 3, 5) // 创建一个长度为 3，容量为 5 的切片这里解释一下长度（len）和容量（cap）的问题
在 Go 语言中，len() 和 cap() 是两个用于切片（Slice）的内置函数，用于获取切片的长度和容量。
- len() 函数：
len() 函数用于获取切片中当前包含的元素数量，即切片的长度。
切片的长度是切片中当前存储的元素数量。
无论切片的容量如何，len() 函数都只返回当前切片中实际存储的元素数量。
- cap() 函数：
cap() 函数用于获取切片的容量，即切片的最大长度。
切片的容量是从切片的起始位置到底层数组末尾的元素数量。
切片的容量是底层数组中分配给切片的内存空间大小。
下面是一个示例来演示 len() 和 cap() 函数的用法及区别：
package main
import "fmt"
func main() {
// 创建一个数组
array := [5]int{1, 2, 3, 4, 5}
// 对数组进行切片
slice := array[1:3] // 从数组的索引 1 到索引 3（不包括索引 3）创建切片
// 打印切片的长度和容量
fmt.Println("Length of slice:", len(slice)) // 输出: 2
fmt.Println("Capacity of slice:", cap(slice)) // 输出: 4
// 打印切片的内容
fmt.Println("Elements of slice:", slice) // 输出: [2 3]
}在这个示例中，我们先创建了一个包含 5 个元素的数组。然后，我们从数组的索引 1 到索引 3（不包括索引 3）创建了一个切片。这个切片包含了数组的索引 1 和 2 处的元素。所以切片的长度是 2，容量是从索引 1 到数组末尾的元素数量，即 4。
4.增删改查
在 Go 语言中，切片（Slice）提供了丰富的操作方法，包括增加、删除、修改和查找元素等功能。下面是针对切片的常见操作示例：
- 增加元素：
使用 append() 函数向切片中添加元素。
package main
import "fmt"
func main() {
// 声明一个切片
slice := []int{1, 2, 3}
// 添加元素
slice = append(slice, 4)
fmt.Println("Slice after adding element:", slice) // 输出: [1 2 3 4]
}- 删除元素：
使用切片的切片操作或者 append() 函数配合切片的方式来删除元素。
package main
import "fmt"
func main() {
// 声明一个切片
slice := []int{1, 2, 3, 4, 5}
// 删除第三个元素（索引为 2）
slice = append(slice[:2], slice[3:]...)
fmt.Println("Slice after deleting element:", slice) // 输出: [1 2 4 5]
}- 修改元素：
使用索引直接修改切片中的元素。
package main
import "fmt"
func main() {
// 声明一个切片
slice := []int{1, 2, 3}
// 修改第二个元素（索引为 1）
slice[1] = 5
fmt.Println("Slice after modifying element:", slice) // 输出: [1 5 3]
}- 查找元素：
使用循环遍历切片并比较每个元素。
package main
import "fmt"
func main() {
// 声明一个切片
slice := []int{1, 2, 3, 4, 5}
// 查找元素 3
for i, v := range slice {
if v == 3 {
fmt.Println("Element 3 found at index:", i)
break
}
}
}这些示例演示了如何在 Go 中对切片进行增加、删除、修改和查找元素等操作。切片是 Go 语言中非常灵活和强大的数据结构，可以用来处理动态大小的数据集合。
5.遍历
这里跟数组一样，推荐使用for-range循环
package main
import "fmt"
func main() {
// 声明一个切片
slice := []int{1, 2, 3, 4, 5}
// 使用 range 遍历切片
for index, value := range slice {
fmt.Printf("Index: %d, Value: %d\n", index, value)
}
}####总结
切片不是线程安全的数据结构，如果多个 Goroutine 同时操作同一个切片，可能会出现数据竞争等问题。
关于append()和copy()这两个函数，我后面会专门写一下。
总结
总的来说，Go和Java在设计可变数组时实现了相同的功能，不过细节上相差还是很大的。
