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
    }
}