文章目录
在编程中，经常会遇到需要存储一系列数据的情况，并且这些数据的数量可能会随着程序的运行而变化。在这种情况下，使用传统的固定大小数组可能不是最好的选择，因为我们需要在创建数组时就确定其大小，之后不能轻易改变。
基础概念
ArrayList
ArrayList 是 Java 中的一种动态数组实现，它允许你在运行时动态地改变数组的大小。ArrayList 属于 Java 集合框架的一部分，提供了许多有用的方法来操作列表中的元素，如添加（add）、删除（remove）、查找（get）等。ArrayList 在内部使用一个数组来存储数据，当数组的空间不足时，它会自动调整数组的大小，通常是以一定的增长因子（如 50%）增加。
可变长度数组
“可变长度数组”这个术语有时会用来描述那些可以在程序执行过程中改变其大小的数组类型。这并不特指某一种具体的编程语言特性，而是指的是一种概念。例如，在 C 语言中有可变长度数组（Variable-Length Array, VLA），它们是在函数作用域内定义的数组，其大小可以取决于运行时计算出的值。而在其他一些语言中，如 Python 的 list 或者 JavaScript 的 Array，都是可以动态改变大小的数据结构。
ArrayList 与可变长度数组的区别
- 内存管理：
ArrayList在 Java 中由框架管理内存，程序员不需要关心底层数组的扩展或缩减。而在 C 语言中，VLA 的大小在声明时确定，并且必须在块结束前保持不变，尽管如此，还是需要手动管理内存。 - 语言支持：
ArrayList是特定于 Java 的集合类，提供了更多的功能和抽象层次。而像 Python 和 JavaScript 的内置列表和数组则更通用，并且通常也是该语言标准库的一部分。 - 性能：直接使用数组可能会比使用
ArrayList更高效，尤其是在频繁进行插入和删除操作的情况下。但是，对于非常大的数据集，ArrayList可能会有更好的性能，因为它避免了频繁的内存分配。
根据具体的应用场景和使用的编程语言，可以选择最适合的解决方案。如果需要一个可以动态扩展的数据结构，并且希望减少内存管理的工作量，那么 ArrayList 或类似的容器可能是更好的选择。
ArrayList 的具体应用场景：
ArrayList 在 Java 中是一个非常常用的数据结构，它适用于多种应用场景，特别是当你不确定数组的大小或者需要在运行时动态地改变数组大小时。下面列举了一些 ArrayList 的具体应用场景：
动态数据收集
当你不知道要收集多少数据时，可以使用 ArrayList。例如，从用户输入或文件中读取一系列记录，每读取一条记录就添加到 ArrayList 中。
import java.util.ArrayList;
import java.util.Scanner;
public class DataCollector {
public static void main(String[] args) {
ArrayList<String> records = new ArrayList<>();
Scanner scanner = new Scanner(System.in);
System.out.println("Enter records (type 'end' to finish):");
while (true) {
String line = scanner.nextLine();
if ("end".equalsIgnoreCase(line)) {
break;
}
records.add(line);
}
System.out.println("Collected " + records.size() + " records.");
}
}
数据排序和过滤
如果你需要对收集的数据进行排序或过滤，ArrayList 提供了许多方法来帮助你处理这些任务，如 sort() 方法用于排序，你可以提供自己的比较器来决定排序规则。
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class DataSorter {
public static void main(String[] args) {
ArrayList<Integer> numbers = new ArrayList<>();
Collections.addAll(numbers, 5, 3, 9, 1, 6);
// Sort the list
Collections.sort(numbers); // Uses natural ordering for Integer
System.out.println("Sorted numbers: " + numbers);
// Custom sorting with a Comparator
Collections.sort(numbers, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2.compareTo(o1); // Reverse order
}
});
System.out.println("Reverse sorted numbers: " + numbers);
}
}
数据持久化
有时候你需要将 ArrayList 中的数据保存到文件中或者从文件中读取数据。这可以通过序列化机制完成。
import java.io.*;
import java.util.ArrayList;
public class DataPersistence {
public static void main(String[] args) {
ArrayList<String> records = new ArrayList<>();
Collections.addAll(records, "Record 1", "Record 2", "Record 3");
try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("records.dat"))) {
out.writeObject(records);
} catch (IOException e) {
e.printStackTrace();
}
// Reading back from file
try (ObjectInputStream in = new ObjectInputStream(new FileInputStream("records.dat"))) {
ArrayList<String> readRecords = (ArrayList<String>) in.readObject();
System.out.println("Read records: " + readRecords);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}
实现队列
虽然 Java 提供了专门的队列接口 (Queue) 和实现类 (LinkedList 等)，但在某些情况下，你可以使用 ArrayList 来模拟队列的行为，比如通过维护两个索引来实现。
以上就是 ArrayList 的一些典型应用例子，当然，实际开发中还有更多场景可以使用 ArrayList，比如在 GUI 应用中管理组件列表，或者在网络编程中存储消息等。
除了前面提到的应用场景之外，ArrayList 还可以在很多其他情况下发挥作用。以下是几个额外的应用案例：
事件处理
在 GUI 编程或其他需要事件处理的地方，ArrayList 可以用来存储事件监听器。当某个事件发生时，可以遍历 ArrayList 并调用每个监听器的相应方法。
import java.util.ArrayList;
public class EventManager {
private ArrayList<EventListener> listeners = new ArrayList<>();
public void addListener(EventListener listener) {
listeners.add(listener);
}
public void removeListener(EventListener listener) {
listeners.remove(listener);
}
public void notifyListeners(Object event) {
for (EventListener listener : listeners) {
listener.onEvent(event);
}
}
}
interface EventListener {
void onEvent(Object event);
}
数据缓存
ArrayList 可以用来实现一个简单的缓存机制，存储最近访问过的数据项。当缓存满时，可以根据策略移除旧的数据项。
import java.util.ArrayList;
public class SimpleCache<K, V> {
private ArrayList<Pair<K, V>> cache = new ArrayList<>();
private int capacity;
public SimpleCache(int capacity) {
this.capacity = capacity;
}
public synchronized V get(K key) {
for (Pair<K, V> pair : cache) {
if (pair.getKey().equals(key)) {
return pair.getValue(); // Return the value and move it to front
}
}
return null; // Key not found
}
public synchronized void put(K key, V value) {
Pair<K, V> pair = new Pair<>(key, value);
if (!cache.contains(pair)) {
if (cache.size() >= capacity) {
cache.remove(cache.size() - 1); // Remove least recently used item
}
cache.add(0, pair); // Add to front of the list
}
}
}
class Pair<K, V> {
private K key;
private V value;
public Pair(K key, V value) {
this.key = key;
this.value = value;
}
public K getKey() {
return key;
}
public V getValue() {
return value;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Pair<?, ?> pair = (Pair<?, ?>) o;
return key.equals(pair.key);
}
@Override
public int hashCode() {
return key.hashCode();
}
}
多线程编程
在多线程环境中，ArrayList 可以用来同步多个线程之间的数据交换。需要注意的是，在多线程环境下使用 ArrayList 时，需要确保对其的操作是线程安全的，可以使用 Collections.synchronizedList 方法将其包装成线程安全的列表。
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadSafeExample {
private static final List<Integer> sharedList = Collections.synchronizedList(new ArrayList<>());
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(5);
for (int i = 0; i < 100; i++) {
final int index = i;
executor.execute(() -> sharedList.add(index));
}
executor.shutdown();
}
}
以上就是 ArrayList 的一些额外应用场景。总的来说，ArrayList 的灵活性使其成为处理动态数据集的理想选择，无论是在单线程还是多线程环境中。
————————————————
最后我们放松一下眼睛
扫一扫
608
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
