JAVA基础之数组和集合区别对比分析

// 1. 动态初始化：指定长度，元素为默认值
int[] arr1 = new int[3]; // 长度3，元素默认值为0、0、0
arr1[0] = 10; // 手动赋值第一个元素
// 2. 静态初始化：指定元素，长度自动为3
int[] arr2 = new int[]{10, 20, 30}; 
// 简化写法（仅声明时可用）
int[] arr3 = {10, 20, 30}; 
// 3. 引用数据类型数组初始化
String[] strArr = new String[2]; // 默认值为[null, null]
strArr[0] = "Java"; // 赋值第一个元素为字符串对象

// 1. 规则二维数组（每行长度相同）
int[][] matrix1 = new int[2][3]; // 2行3列，元素默认值为0
matrix1[0][1] = 5; // 给第1行第2列元素赋值
// 2. 不规则二维数组（每行长度可不同）
int[][] matrix2 = new int[2][]; // 先指定行数，不指定列数
matrix2[0] = new int[3]; // 第1行长度为3
matrix2[1] = new int[2]; // 第2行长度为2

for (int i = 0; i < matrix2.length; i++) { // 遍历行
    for (int j = 0; j < matrix2[i].length; j++) { // 遍历每行的元素
        System.out.print(matrix2[i][j] + " ");
    }
    System.out.println();
}

集合框架体系
├─ Collection（单列集合：存储单个元素）
│  ├─ List（有序、可重复、有索引）
│  │  ├─ ArrayList（底层数组，查询快、增删慢）
│  │  └─ LinkedList（底层双向链表，增删快、查询慢）
│  └─ Set（无序、不可重复、无索引）
│     ├─ HashSet（底层哈希表，增删查快，无序）
│     └─ TreeSet（底层红黑树，自动排序，有序）
└─ Map（双列集合：存储键值对Key-Value）
   ├─ HashMap（底层哈希表，无序、键唯一，允许null键/值）
   └─ TreeMap（底层红黑树，按键排序，有序，不允许null键）

List<String> list = new ArrayList<>();
list.add("apple");
list.add("banana");
list.add("cherry");
// 1. 获取迭代器对象
Iterator<String> iterator = list.iterator();
// 2. 遍历：hasNext()判断是否有下一个元素，next()获取元素并移动指针
while (iterator.hasNext()) {
    String element = iterator.next();
    if ("banana".equals(element)) {
        // 迭代器的remove()方法：删除当前遍历到的元素
        iterator.remove(); 
    }
    System.out.println(element); // 输出apple、banana、cherry（删除后集合中无banana）
}

// 语法：for (元素类型 变量名 : 集合/数组)
for (String element : list) {
    System.out.println(element); // 输出apple、cherry（已删除banana）
}

// 语法：collection.forEach(元素 -> 遍历逻辑)
list.forEach(element -> {
    if (element.startsWith("a")) { // 筛选以"a"开头的元素
        System.out.println(element); // 输出apple
    }
});

List<String> list = new ArrayList<>();
list.add("apple"); // 末尾添加元素
list.add(1, "banana"); // 索引1处插入元素（原元素后移）
String first = list.get(0); // 获取索引0的元素（apple）
list.set(0, "orange"); // 修改索引0的元素为orange
String removed = list.remove(1); // 删除索引1的元素（banana），返回被删除元素

LinkedList<String> list = new LinkedList<>();
list.addFirst("a"); // 链表开头添加元素
list.addLast("b"); // 链表末尾添加元素
String first = list.getFirst(); // 获取开头元素（a）
String last = list.getLast(); // 获取末尾元素（b）
String removedFirst = list.removeFirst(); // 删除并返回开头元素（a）
String removedLast = list.removeLast(); // 删除并返回末尾元素（b）

// 1. 构造方法
HashSet<String> set1 = new HashSet<>(); // 默认初始容量16，负载因子0.75
HashSet<String> set2 = new HashSet<>(20); // 指定初始容量
Set<String> temp = new ArrayList<>();
HashSet<String> set3 = new HashSet<>(temp); // 从其他Collection转换
// 2. 常用方法（与Collection一致，无特有方法）
set1.add("Java");
set1.add("Python");
set1.add("Java"); // 重复元素，add()返回false，集合中仅存1个"Java"
boolean hasPython = set1.contains("Python"); // true
set1.remove("Python"); // 删除元素，返回true
int size = set1.size(); // 1

// 自定义Student类，实现Comparable接口，按学号升序排序
class Student implements Comparable<Student> {
    private int id;
    private String name;
    // 构造方法、getter/setter省略
    @Override
    public int compareTo(Student other) {
        // 按id升序：当前id - 其他id，返回正数则当前元素在后，负数在前
        return this.id - other.id; 
    }
}
// 使用TreeSet存储Student，自动按id升序排序
TreeSet<Student> studentSet = new TreeSet<>();
studentSet.add(new Student(3, "Alice"));
studentSet.add(new Student(1, "Bob"));
studentSet.add(new Student(2, "Charlie"));
// 遍历输出：Bob（id=1）、Charlie（id=2）、Alice（id=3）
for (Student s : studentSet) {
    System.out.println(s.getName());
}

// 存储String，按字符串长度降序排序（自定义比较器）
TreeSet<String> strSet = new TreeSet<>((s1, s2) -> {
    // 按长度降序：s2长度 - s1长度
    return s2.length() - s1.length(); 
});
strSet.add("apple"); // 5个字符
strSet.add("banana"); // 6个字符
strSet.add("pear"); // 4个字符
// 遍历输出：banana（6）、apple（5）、pear（4）
for (String s : strSet) {
    System.out.println(s);
}

// 创建Map对象（以HashMap为例）
Map<String, Integer> scoreMap = new HashMap<>();
// 1. 添加/修改键值对：键存在则覆盖值，返回旧值；键不存在则添加，返回null
Integer oldScore = scoreMap.put("Alice", 95); // null（首次添加）
oldScore = scoreMap.put("Alice", 98); // 95（覆盖旧值，返回旧值）
scoreMap.put("Bob", 88);
// 2. 删除键值对：根据键删除，返回被删除的值；键不存在返回null
Integer removedScore = scoreMap.remove("Bob"); // 88
// 3. 判断存在性
boolean hasAlice = scoreMap.containsKey("Alice"); // true（判断键是否存在）
boolean has98 = scoreMap.containsValue(98); // true（判断值是否存在）
// 4. 获取值：根据键获取值，键不存在返回null
Integer aliceScore = scoreMap.get("Alice"); // 98
// 5. 清空与长度
scoreMap.clear(); // 清空所有键值对
int size = scoreMap.size(); // 0（清空后长度为0）
boolean isEmpty = scoreMap.isEmpty(); // true

Map<String, Integer> scoreMap = new HashMap<>();
scoreMap.put("Alice", 95);
scoreMap.put("Bob", 88);
// 1. 获取所有键的集合
Set<String> keys = scoreMap.keySet();
// 2. 遍历键，获取对应值
for (String key : keys) {
    Integer value = scoreMap.get(key);
    System.out.println(key + " : " + value); // Alice:95, Bob:88
}

// 1. 获取所有键值对的集合
Set<Map.Entry<String, Integer>> entrySet = scoreMap.entrySet();
// 2. 遍历键值对
for (Map.Entry<String, Integer> entry : entrySet) {
    String key = entry.getKey();
    Integer value = entry.getValue();
    System.out.println(key + " : " + value); // Alice:95, Bob:88
}
// Lambda简化遍历（Java 8+）
scoreMap.entrySet().forEach(entry -> {
    System.out.println(entry.getKey() + " : " + entry.getValue());
});

// 1. 获取所有值的集合
Collection<Integer> values = scoreMap.values();
// 2. 遍历值
for (Integer value : values) {
    System.out.println(value); // 95, 88
}

// 1. 默认构造：初始容量16，负载因子0.75
Map<String, Integer> map1 = new HashMap<>();
// 2. 指定初始容量：负载因子默认0.75
Map<String, Integer> map2 = new HashMap<>(32);
// 3. 指定初始容量和负载因子
Map<String, Integer> map3 = new HashMap<>(32, 0.8f);
// 4. 从其他Map转换
Map<String, Integer> tempMap = new HashMap<>();
tempMap.put("a", 1);
Map<String, Integer> map4 = new HashMap<>(tempMap);

// 键为Integer（已实现Comparable），按键升序排序
Map<Integer, String> treeMap1 = new TreeMap<>();
treeMap1.put(3, "C");
treeMap1.put(1, "A");
treeMap1.put(2, "B");
// 遍历输出：1:A, 2:B, 3:C（按键升序）
for (Map.Entry<Integer, String> entry : treeMap1.entrySet()) {
    System.out.println(entry.getKey() + ":" + entry.getValue());
}

// 键为String，按字符串长度降序排序
Map<String, Integer> treeMap2 = new TreeMap<>((k1, k2) -> {
    return k2.length() - k1.length(); // 按键长度降序
});
treeMap2.put("apple", 5);
treeMap2.put("banana", 6);
treeMap2.put("pear", 4);
// 遍历输出：banana:6, apple:5, pear:4（按键长度降序）
for (Map.Entry<String, Integer> entry : treeMap2.entrySet()) {
    System.out.println(entry.getKey() + ":" + entry.getValue());
}

Map<Integer, String> treeMap = new TreeMap<>();
treeMap.put(1, "A");
treeMap.put(2, "B");
treeMap.put(3, "C");
treeMap.put(4, "D");
Integer firstKey = treeMap.firstKey(); // 获取最小键（1）
Integer lastKey = treeMap.lastKey(); // 获取最大键（4）
Integer lowerKey = treeMap.lowerKey(3); // 获取小于3的最大键（2）
Integer higherKey = treeMap.higherKey(3); // 获取大于3的最小键（4）
// 获取键≥2且<4的子Map（包含2，不包含4）
Map<Integer, String> subMap = treeMap.subMap(2, true, 4, false);
// 子Map内容：2:B, 3:C

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class UnmodifiableExample {
    public static void main(String[] args) {
        // 1. 创建可变集合
        List<String> mutableList = new ArrayList<>();
        mutableList.add("apple");
        // 2. 创建不可变视图
        List<String> immutableList = Collections.unmodifiableList(mutableList);
        // 3. 视图修改会抛异常
        // immutableList.add("banana"); // UnsupportedOperationException
        // 4. 原集合修改，视图会同步变化（浅拷贝特性）
        mutableList.add("banana");
        System.out.println(immutableList); // 输出：[apple, banana]
    }
}

import java.util.List;
import java.util.Map;
import java.util.Set;
public class ImmutableOfExample {
    public static void main(String[] args) {
        // 1. 创建不可变List
        List<String> immutableList = List.of("apple", "banana", "cherry");
        // 2. 创建不可变Set（元素不可重复）
        Set<Integer> immutableSet = Set.of(1, 2, 3);
        // 3. 创建不可变Map（键不可重复，最多10个键值对）
        Map<String, Integer> immutableMap = Map.of(
            "apple", 1,
            "banana", 2,
            "cherry", 3
        );
        // 修改操作均抛异常
        // immutableList.add("date"); // UnsupportedOperationException
        // immutableSet.remove(1); // UnsupportedOperationException
        // immutableMap.put("pear", 4); // UnsupportedOperationException
    }
}

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class ImmutableCollectorExample {
    public static void main(String[] args) {
        // 将Stream流中的字符串转为大写，收集为不可变List
        List<String> upperList = Stream.of("apple", "banana", "cherry")
            .map(String::toUpperCase)
            .collect(Collectors.toUnmodifiableList());
        // 修改抛异常
        // upperList.add("DATE"); // UnsupportedOperationException
        System.out.println(upperList); // 输出：[APPLE, BANANA, CHERRY]
    }
}

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>32.1.3-jre</version>
</dependency>

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
public class GuavaImmutableExample {
    public static void main(String[] args) {
        // 1. 用of()创建不可变List
        ImmutableList<String> list = ImmutableList.of("a", "b", "c");
        // 2. 用Builder创建不可变Map（支持任意长度）
        ImmutableMap<String, Integer> map = ImmutableMap.<String, Integer>builder()
            .put("a", 1)
            .put("b", 2)
            .put("c", 3)
            .build();
        // 修改抛异常
        // list.add("d"); // UnsupportedOperationException
    }
}