# Calculator_2025

**Repository Path**: tomyedu/Calculator_2025

## Basic Information

- **Project Name**: Calculator_2025
- **Description**: 一款支持混合运算的计算器
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-04-24
- **Last Updated**: 2025-06-03

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Java Collections Framework 详解

## 1. 什么是Collection框架？

Collection框架是Java提供的一套用于存储和操作对象集合的类和接口。它位于java.util包中，是Java中最常用的框架之一。

## 2. Collection框架的主要接口

### 2.1 Collection接口
Collection是Collection框架的根接口，它定义了集合的基本操作：
- 添加元素：add(E e)
- 删除元素：remove(Object o)
- 清空集合：clear()
- 判断是否包含：contains(Object o)
- 获取大小：size()
- 判断是否为空：isEmpty()

### 2.2 List接口
List是有序集合，允许重复元素：
- ArrayList：基于动态数组实现，随机访问快
- LinkedList：基于双向链表实现，插入删除快
- Vector：线程安全的ArrayList
- Stack：继承自Vector，实现后进先出(LIFO)

### 2.3 Set接口
Set是不允许重复元素的无序集合：
- HashSet：基于HashMap实现，无序
- LinkedHashSet：保持插入顺序的HashSet
- TreeSet：基于红黑树实现，自然排序

### 2.4 Queue接口
Queue是队列接口，用于处理先进先出(FIFO)的数据：
- LinkedList：可作队列使用
- PriorityQueue：优先级队列
- ArrayDeque：双端队列

## 3. 常用操作示例

### 3.1 List操作
```java
List<String> list = new ArrayList<>();
list.add("苹果");
list.add("香蕉");
list.add("橙子");
System.out.println(list.get(0)); // 输出：苹果
```

### 3.2 Set操作
```java
Set<String> set = new HashSet<>();
set.add("苹果");
set.add("香蕉");
set.add("苹果"); // 重复元素不会被添加
System.out.println(set.size()); // 输出：2
```

### 3.3 Queue操作
```java
Queue<String> queue = new LinkedList<>();
queue.offer("第一个");
queue.offer("第二个");
System.out.println(queue.poll()); // 输出：第一个
```

## 4. 使用建议

1. 需要频繁随机访问元素时，使用ArrayList
2. 需要频繁插入删除元素时，使用LinkedList
3. 需要保证元素唯一性时，使用Set
4. 需要按照特定顺序处理元素时，使用Queue
5. 需要线程安全时，考虑使用Collections.synchronizedXXX()方法包装集合

## 5. 注意事项

1. 集合中只能存储对象，不能存储基本数据类型（需要使用包装类）
2. 使用泛型可以避免类型转换问题
3. 注意集合的并发修改问题
4. 合理选择集合类型可以提高程序性能

## 6. 性能比较

| 集合类型 | 获取 | 插入 | 删除 | 内存占用 |
|---------|------|------|------|----------|
| ArrayList | O(1) | O(n) | O(n) | 低 |
| LinkedList | O(n) | O(1) | O(1) | 高 |
| HashSet | O(1) | O(1) | O(1) | 中 |
| TreeSet | O(log n) | O(log n) | O(log n) | 中 |

## 7. 最佳实践

1. 优先使用接口而不是具体实现
2. 使用泛型来保证类型安全
3. 在循环中修改集合时使用Iterator
4. 及时释放不需要的集合对象
5. 根据实际需求选择合适的集合类型 

## 8. 各接口及实现类的基本操作详解

### 8.1 Collection接口基本操作
```java
Collection<String> collection = new ArrayList<>();
// 添加元素
collection.add("元素1");
collection.addAll(Arrays.asList("元素2", "元素3"));

// 删除元素
collection.remove("元素1");
collection.removeAll(Arrays.asList("元素2", "元素3"));
collection.clear();

// 查询操作
boolean isEmpty = collection.isEmpty();
int size = collection.size();
boolean contains = collection.contains("元素1");
boolean containsAll = collection.containsAll(Arrays.asList("元素1", "元素2"));

// 转换为数组
Object[] array = collection.toArray();
String[] strArray = collection.toArray(new String[0]);

// 迭代操作
Iterator<String> iterator = collection.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    // 处理元素
}
```

### 8.2 List接口特有操作
```java
List<String> list = new ArrayList<>();
// 位置相关操作
list.add(0, "第一个元素");  // 在指定位置添加
list.set(0, "新元素");      // 替换指定位置的元素
list.remove(0);            // 删除指定位置的元素
String element = list.get(0);  // 获取指定位置的元素

// 查找操作
int index = list.indexOf("元素");  // 查找元素第一次出现的位置
int lastIndex = list.lastIndexOf("元素");  // 查找元素最后一次出现的位置

// 子列表操作
List<String> subList = list.subList(1, 3);  // 获取子列表

// 排序操作
Collections.sort(list);  // 自然排序
Collections.sort(list, Collections.reverseOrder());  // 逆序排序
```

### 8.3 Set接口特有操作
```java
Set<String> set = new HashSet<>();
// 集合运算
Set<String> otherSet = new HashSet<>();
set.addAll(otherSet);      // 并集
set.retainAll(otherSet);   // 交集
set.removeAll(otherSet);   // 差集

// TreeSet特有操作
TreeSet<Integer> treeSet = new TreeSet<>();
treeSet.add(5);
treeSet.add(3);
treeSet.add(7);

// 获取最大最小值
Integer first = treeSet.first();    // 获取最小元素
Integer last = treeSet.last();      // 获取最大元素

// 获取子集
SortedSet<Integer> headSet = treeSet.headSet(5);     // 小于5的元素
SortedSet<Integer> tailSet = treeSet.tailSet(5);     // 大于等于5的元素
SortedSet<Integer> subSet = treeSet.subSet(3, 7);    // 大于等于3且小于7的元素
```

### 8.4 Queue接口特有操作
```java
Queue<String> queue = new LinkedList<>();
// 添加元素
queue.offer("元素1");    // 添加元素，失败返回false
queue.add("元素2");      // 添加元素，失败抛出异常

// 获取并移除元素
String element1 = queue.poll();    // 获取并移除队首元素，队列为空返回null
String element2 = queue.remove();  // 获取并移除队首元素，队列为空抛出异常

// 仅获取元素
String peek = queue.peek();        // 获取队首元素但不移除，队列为空返回null
String element = queue.element();  // 获取队首元素但不移除，队列为空抛出异常

// 双端队列特有操作
Deque<String> deque = new ArrayDeque<>();
deque.addFirst("第一个");    // 在队首添加
deque.addLast("最后一个");   // 在队尾添加
deque.removeFirst();        // 移除并返回队首元素
deque.removeLast();         // 移除并返回队尾元素
deque.getFirst();           // 获取队首元素
deque.getLast();            // 获取队尾元素
```

### 8.5 线程安全的集合操作
```java
// 创建线程安全的集合
List<String> syncList = Collections.synchronizedList(new ArrayList<>());
Set<String> syncSet = Collections.synchronizedSet(new HashSet<>());
Map<String, String> syncMap = Collections.synchronizedMap(new HashMap<>());

// 使用线程安全的集合类
Vector<String> vector = new Vector<>();  // 线程安全的ArrayList
Stack<String> stack = new Stack<>();     // 线程安全的栈
ConcurrentHashMap<String, String> concurrentMap = new ConcurrentHashMap<>();  // 线程安全的HashMap
```

### 8.6 集合工具类操作
```java
// 排序
List<Integer> numbers = new ArrayList<>(Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6));
Collections.sort(numbers);  // 自然排序
Collections.sort(numbers, Collections.reverseOrder());  // 逆序排序

// 查找
int index = Collections.binarySearch(numbers, 5);  // 二分查找

// 填充
Collections.fill(numbers, 0);  // 用0填充所有元素

// 复制
List<Integer> dest = new ArrayList<>(Arrays.asList(0, 0, 0, 0, 0, 0, 0, 0));
Collections.copy(dest, numbers);

// 最大最小值
Integer max = Collections.max(numbers);
Integer min = Collections.min(numbers);

// 频率统计
int frequency = Collections.frequency(numbers, 1);  // 统计1出现的次数

// 反转
Collections.reverse(numbers);

// 随机打乱
Collections.shuffle(numbers);
```

## 9. 使用场景示例

### 9.1 List使用场景
- 存储有序数据，如用户操作日志
- 需要频繁按索引访问数据
- 需要保存重复元素
```java
// 用户操作日志示例
List<LogEntry> userLogs = new ArrayList<>();
userLogs.add(new LogEntry("用户登录", LocalDateTime.now()));
userLogs.add(new LogEntry("查看商品", LocalDateTime.now()));
// 按时间顺序展示日志
for (LogEntry log : userLogs) {
    System.out.println(log);
}
```

### 9.2 Set使用场景
- 需要去重的数据存储
- 需要快速查找元素是否存在
- 需要集合运算
```java
// 用户标签去重示例
Set<String> userTags = new HashSet<>();
userTags.add("技术");
userTags.add("编程");
userTags.add("Java");
userTags.add("技术");  // 重复标签不会被添加
```

### 9.3 Queue使用场景
- 任务队列处理
- 消息队列
- 缓存实现
```java
// 任务队列示例
Queue<Task> taskQueue = new LinkedList<>();
taskQueue.offer(new Task("任务1"));
taskQueue.offer(new Task("任务2"));
while (!taskQueue.isEmpty()) {
    Task task = taskQueue.poll();
    task.execute();
}
```

## 10. Collection框架的继承关系

### 10.1 主要接口继承关系
```
Collection (接口)
├── List (接口)
│   ├── ArrayList
│   ├── LinkedList
│   ├── Vector
│   │   └── Stack
│   └── CopyOnWriteArrayList
│
├── Set (接口)
│   ├── HashSet
│   │   └── LinkedHashSet
│   ├── TreeSet
│   └── CopyOnWriteArraySet
│
└── Queue (接口)
    ├── PriorityQueue
    ├── ArrayDeque
    └── LinkedList
```

### 10.2 各接口的主要特点

#### 10.2.1 Collection接口
- 所有集合类的根接口
- 定义了集合的基本操作
- 主要方法：
  - add(E e)
  - remove(Object o)
  - contains(Object o)
  - size()
  - clear()
  - iterator()

#### 10.2.2 List接口
- 继承自Collection
- 特点：
  - 有序集合
  - 允许重复元素
  - 可以通过索引访问元素
- 主要实现类：
  - ArrayList：基于动态数组
  - LinkedList：基于双向链表
  - Vector：线程安全的ArrayList
  - Stack：继承自Vector，实现LIFO

#### 10.2.3 Set接口
- 继承自Collection
- 特点：
  - 不允许重复元素
  - 最多包含一个null元素
- 主要实现类：
  - HashSet：基于HashMap实现
  - LinkedHashSet：保持插入顺序的HashSet
  - TreeSet：基于红黑树实现，自然排序
  - CopyOnWriteArraySet：线程安全的Set

#### 10.2.4 Queue接口
- 继承自Collection
- 特点：
  - 用于处理FIFO（先进先出）的数据
  - 提供队列的基本操作
- 主要实现类：
  - LinkedList：可作队列使用
  - PriorityQueue：优先级队列
  - ArrayDeque：双端队列

### 10.3 特殊接口和类

#### 10.3.1 Deque接口
- 继承自Queue
- 特点：
  - 双端队列
  - 支持在两端添加和删除元素
- 主要实现类：
  - ArrayDeque
  - LinkedList

#### 10.3.2 SortedSet接口
- 继承自Set
- 特点：
  - 保证元素自然排序
  - 提供有序集合操作
- 主要实现类：
  - TreeSet

#### 10.3.3 NavigableSet接口
- 继承自SortedSet
- 特点：
  - 提供导航方法
  - 支持按顺序访问元素
- 主要实现类：
  - TreeSet

### 10.4 线程安全的集合类

#### 10.4.1 同步包装类
```java
// 通过Collections工具类创建同步集合
List<String> syncList = Collections.synchronizedList(new ArrayList<>());
Set<String> syncSet = Collections.synchronizedSet(new HashSet<>());
Map<String, String> syncMap = Collections.synchronizedMap(new HashMap<>());
```

#### 10.4.2 并发集合类
```java
// 并发包中的集合类
ConcurrentHashMap<String, String> concurrentMap = new ConcurrentHashMap<>();
CopyOnWriteArrayList<String> copyOnWriteList = new CopyOnWriteArrayList<>();
CopyOnWriteArraySet<String> copyOnWriteSet = new CopyOnWriteArraySet<>();
```

### 10.5 选择集合类的建议

1. 需要有序且允许重复元素：
   - 使用ArrayList或LinkedList
   - 频繁随机访问用ArrayList
   - 频繁插入删除用LinkedList

2. 需要去重：
   - 使用HashSet（无序）
   - 需要保持插入顺序用LinkedHashSet
   - 需要自然排序用TreeSet

3. 需要队列操作：
   - 普通队列用LinkedList
   - 优先级队列用PriorityQueue
   - 双端队列用ArrayDeque

4. 需要线程安全：
   - 使用同步包装类
   - 或使用并发集合类
   - 或使用Vector/Stack（不推荐，性能较差）