Java集合框架：数组与集合长度获取及遍历方法详解

1. Java集合框架基础概念

在Java编程中，数组和集合是我们最常使用的数据结构。数组是一种固定长度的线性数据结构，而集合框架则提供了更加灵活的数据存储方式。Java集合框架主要包含三种核心接口：List、Set和Map，每种接口都有不同的特点和适用场景。

数组和集合最基础的操作之一就是获取元素数量。对于数组，我们使用length属性；对于字符串，使用length()方法；而对于集合类，则统一使用size()方法。这个看似简单的操作在实际开发中却经常被混淆，特别是对于初学者来说。

注意：数组的length是属性而非方法，所以不需要加括号，而字符串和集合的size相关操作都是方法，必须加括号。这是Java初学者最容易犯的错误之一。

2. 数组长度获取与遍历

2.1 基本数组的长度获取

数组是Java中最基础的数据结构，其长度在创建时就已经确定且不可改变。获取数组长度的方式非常简单：

java复制int[] numbers = {10, 20, 30, 40, 50};
int length = numbers.length;  // 正确：使用length属性
System.out.println("数组长度: " + length);  // 输出：数组长度: 5

// 错误示例：int length = numbers.length();  // 编译错误，数组没有length()方法

对于多维数组，获取长度时需要特别注意：

java复制int[][] matrix = {{1, 2}, {3, 4}, {5, 6}};
System.out.println(matrix.length);    // 输出3，表示第一维的长度
System.out.println(matrix[0].length); // 输出2，表示第二维的长度

2.2 数组遍历的几种方式

数组遍历是日常开发中最常见的操作之一，Java提供了多种遍历方式：

1. 传统for循环：最基础也是最灵活的遍历方式

java复制for (int i = 0; i < numbers.length; i++) {
    System.out.println("元素" + i + ": " + numbers[i]);
}

2. 增强for循环：语法更简洁，但无法获取当前索引

java复制for (int num : numbers) {
    System.out.println("元素: " + num);
}

3. 使用Arrays工具类：Java 8及以上版本推荐

java复制Arrays.stream(numbers).forEach(System.out::println);

实际开发建议：如果需要索引信息，使用传统for循环；如果只需要元素值，优先使用增强for循环或流式API，代码更简洁。

3. 字符串长度获取与字符遍历

3.1 字符串长度获取

字符串虽然不是集合，但作为最常用的数据类型之一，其长度获取方式也值得注意：

java复制String text = "Hello, 世界";
int length = text.length();  // 注意这里是方法，不是属性
System.out.println(length);  // 输出8（英文逗号和空格各占1，中文占1）

需要注意的是，length()方法返回的是字符串中UTF-16编码单元的个数，而不是实际字符数。对于包含Unicode补充字符的字符串，可能需要特殊处理：

java复制String emoji = "😊";
System.out.println(emoji.length());  // 输出2，因为emoji占用两个代码单元
System.out.println(emoji.codePointCount(0, emoji.length()));  // 输出1，正确获取字符数

3.2 字符串遍历方法

字符串的字符遍历也有多种方式：

1. charAt()方法：

java复制for (int i = 0; i < text.length(); i++) {
    char c = text.charAt(i);
    System.out.println("字符" + i + ": " + c);
}

2. 转换为字符数组：

java复制for (char c : text.toCharArray()) {
    System.out.println(c);
}

3. 使用Java 8的chars()方法：

java复制text.chars().forEach(c -> System.out.println((char)c));

性能提示：对于大量字符串处理，直接使用charAt()通常比转换为字符数组更高效，因为它避免了额外的数组创建开销。

4. List集合的长度与遍历

4.1 List基础特性

List是Java集合框架中最常用的接口之一，它具有以下特点：

• 有序集合，元素按插入顺序排列
• 允许重复元素
• 可以通过索引访问元素
• 动态扩容，无需手动管理容量

常见的List实现类包括：

• ArrayList：基于动态数组实现，随机访问快，中间插入/删除慢
• LinkedList：基于双向链表实现，随机访问慢，插入/删除快
• Vector：线程安全的ArrayList，但性能较低

4.2 获取List大小

List使用size()方法获取元素数量：

java复制List<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Orange");

int size = fruits.size();  // 3
System.out.println("列表大小: " + size);

与数组不同，List的大小是动态变化的：

java复制fruits.remove("Banana");
System.out.println(fruits.size());  // 2

fruits.clear();
System.out.println(fruits.size());  // 0

4.3 List遍历方式

1. 传统for循环（适合需要索引的场景）：

java复制for (int i = 0; i < fruits.size(); i++) {
    System.out.println("水果" + i + ": " + fruits.get(i));
}

2. 增强for循环（简洁，但无索引）：

java复制for (String fruit : fruits) {
    System.out.println(fruit);
}

3. 迭代器（可在遍历时安全删除元素）：

java复制Iterator<String> it = fruits.iterator();
while (it.hasNext()) {
    String fruit = it.next();
    if (fruit.equals("Banana")) {
        it.remove();  // 安全删除当前元素
    }
}

4. Java 8 forEach：

java复制fruits.forEach(System.out::println);
// 或
fruits.forEach(fruit -> System.out.println(fruit.toUpperCase()));

性能比较：ArrayList的随机访问(get)是O(1)时间复杂度，而LinkedList是O(n)。因此，对于LinkedList应避免使用传统for循环，优先使用迭代器或增强for循环。

5. Set集合的长度与遍历

5.1 Set基础特性

Set接口代表一个不允许重复元素的集合，主要特点包括：

• 元素唯一性（基于equals()和hashCode()判断）
• 通常不保证顺序（具体取决于实现类）
• 没有索引概念，不能通过位置访问元素

常用Set实现类：

• HashSet：基于哈希表实现，无序，查询最快
• LinkedHashSet：保持插入顺序的HashSet
• TreeSet：基于红黑树实现，元素自动排序

5.2 获取Set大小

与List类似，Set也使用size()方法获取元素数量：

java复制Set<Integer> numbers = new HashSet<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(2);  // 重复元素不会被添加

System.out.println(numbers.size());  // 3

5.3 Set遍历方式

由于Set没有索引，遍历方式相对有限：

1. 增强for循环：

java复制for (Integer num : numbers) {
    System.out.println(num);
}

2. 迭代器：

java复制Iterator<Integer> it = numbers.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

3. Java 8 forEach：

java复制numbers.forEach(System.out::println);

4. 转换为数组（不推荐）：

java复制for (Object num : numbers.toArray()) {
    System.out.println(num);
}

重要提示：Set的遍历顺序是不确定的（除了LinkedHashSet和TreeSet）。不要依赖HashSet的元素顺序，因为它在不同JVM实现或不同运行时刻可能不同。

6. Map集合的长度与遍历

6.1 Map基础特性

Map存储键值对(key-value)数据，主要特点包括：

• 每个键唯一，值可以重复
• 基本的Map实现不保证顺序
• 常用实现类：HashMap、LinkedHashMap、TreeMap

6.2 获取Map大小

Map使用size()方法获取键值对数量：

java复制Map<String, Integer> scores = new HashMap<>();
scores.put("Alice", 90);
scores.put("Bob", 85);
scores.put("Charlie", 95);

System.out.println(scores.size());  // 3

6.3 Map遍历方式

Map的遍历相对复杂，因为需要同时处理键和值：

1. 遍历键集合：

java复制for (String name : scores.keySet()) {
    System.out.println("Key: " + name);
}

2. 遍历值集合：

java复制for (Integer score : scores.values()) {
    System.out.println("Value: " + score);
}

3. 遍历键值对集合（推荐）：

java复制for (Map.Entry<String, Integer> entry : scores.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

4. Java 8 forEach：

java复制scores.forEach((name, score) -> 
    System.out.println(name + ": " + score));

5. 使用迭代器：

java复制Iterator<Map.Entry<String, Integer>> it = scores.entrySet().iterator();
while (it.hasNext()) {
    Map.Entry<String, Integer> entry = it.next();
    System.out.println(entry.getKey() + " -> " + entry.getValue());
}

性能提示：entrySet()遍历通常比先获取keySet()再get(key)更高效，特别是对于大型Map，因为它减少了不必要的查找操作。

7. 集合遍历的性能优化与常见问题

7.1 遍历性能比较

不同集合和不同遍历方式的性能差异很大：

1. ArrayList：

   • 传统for循环最快
   • 增强for循环稍慢
   • forEach最慢（但有更好的可读性）

2. LinkedList：

   • 迭代器和增强for循环最快
   • 传统for循环非常慢（因为每次get(i)都要从头遍历）

3. HashMap：

   • entrySet()遍历最快
   • Java 8 forEach语法简洁但性能稍低

7.2 常见问题与解决方案

1. 并发修改异常：

java复制// 错误示例：
List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
for (String s : list) {
    if (s.equals("B")) {
        list.remove(s);  // 抛出ConcurrentModificationException
    }
}

// 正确做法：
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    if (it.next().equals("B")) {
        it.remove();  // 安全删除
    }
}

2. 空集合判断：

java复制// 不要用size() == 0判断空集合
if (collection.isEmpty()) {  // 更清晰高效
    // 处理空集合
}

3. 遍历时修改元素：

java复制// 对于对象集合，可以直接修改元素属性
List<Person> people = ...;
for (Person p : people) {
    p.setAge(p.getAge() + 1);  // 可以修改对象状态
}

// 但不能替换整个元素（会引发并发修改异常）
for (Person p : people) {
    p = new Person(...);  // 无效，不会改变集合内容
}

7.3 Java 8 Stream API遍历

对于复杂遍历操作，可以考虑使用Stream API：

java复制// 过滤和转换
list.stream()
    .filter(s -> s.length() > 3)
    .map(String::toUpperCase)
    .forEach(System.out::println);

// 并行处理大数据集
largeList.parallelStream()
         .filter(...)
         .forEach(...);

使用建议：对于简单遍历，传统方式更直观；对于复杂的数据处理流水线，Stream API提供了更清晰的表达方式。注意parallelStream只在数据量很大且操作耗时的情况下才有优势。

8. 实际应用中的最佳实践

1. 选择合适的集合类型：

   • 需要保持插入顺序 → ArrayList或LinkedHashSet
   • 需要快速查找 → HashSet或HashMap
   • 需要自动排序 → TreeSet或TreeMap
   • 需要线程安全 → ConcurrentHashMap或CopyOnWriteArrayList

2. 初始化集合大小：

java复制// 如果知道大概元素数量，预先设置容量可避免多次扩容
List<String> list = new ArrayList<>(1000);  // 初始容量1000
Map<String, Integer> map = new HashMap<>(1024);  // 初始容量1024

3. 不可变集合：

java复制// Java 9+ 创建不可变集合
List<String> immutableList = List.of("A", "B", "C");
Set<Integer> immutableSet = Set.of(1, 2, 3);
Map<String, Integer> immutableMap = Map.of("A", 1, "B", 2);

// Java 8及以下使用Collections
List<String> unmodifiableList = Collections.unmodifiableList(list);

4. 集合工具类：

java复制// 排序
Collections.sort(list);

// 二分查找
int index = Collections.binarySearch(sortedList, key);

// 填充
Collections.fill(list, "default");

// 频率统计
int freq = Collections.frequency(collection, element);

5. 集合与数组转换：

java复制// 集合转数组
String[] array = list.toArray(new String[0]);

// 数组转集合（返回的List是不可变的）
List<String> list = Arrays.asList(array);

// Java 8流式转换
List<Integer> list = Arrays.stream(array)
                          .map(Integer::parseInt)
                          .collect(Collectors.toList());

在大型项目开发中，合理选择和使用集合对性能和维护性至关重要。我建议在团队中制定统一的集合使用规范，比如什么时候用ArrayList vs LinkedList，什么时候该使用不可变集合等，这样可以避免很多潜在问题。