数组类型本质解析：是对象还是原生类？

// Java 中的数组创建
int[] primitiveArray = new int[5];  // 原生类型数组
Integer[] objectArray = new Integer[5]; // 对象类型数组
 
// 内存布局差异
System.out.println(primitiveArray.getClass().getComponentType()); // int
System.out.println(objectArray.getClass().getComponentType());  // class java.lang.Integer

// JavaScript 中数组的对象特性
const arr = [1, 2, 3];
arr.customProperty = "我是自定义属性"; // 合法操作
console.log(arr.length); // 3 - 特殊行为
console.log(arr.customProperty); // "我是自定义属性"
 
// 方法调用
arr.push(4); // 继承自 Array.prototype

// 协变数组带来的类型安全问题
Object[] objArray = new String[10];
objArray[0] = 123; // ArrayStoreException 运行时异常
 
// 泛型与数组的冲突
// List<String>[] genericArray = new List<String>[10]; // 编译错误

// 原生数组 - 零开销抽象
int rawArray[10] = {0}; // 栈分配，无边界检查
 
// std::array - 现代封装
std::array<int, 10> stdArray{}; // 栈分配，有边界检查
 
// std::vector - 动态数组
std::vector<int> vectorArray; // 堆分配，动态扩容

# Python 列表的完全对象化
mixed_list = [1, "hello", [1, 2, 3], {"key": "value"}]
print(type(mixed_list))  # <class 'list'>
 
# 内存中的对象引用数组
import sys
print(sys.getsizeof(mixed_list))  # 仅包含引用指针的数组大小

// C 语言数组的内存布局
int contiguousArray[1000];
// 内存中：| int | int | int | ... | int |
//        4字节 4字节 4字节     4字节
 
// 遍历性能测试
for(int i = 0; i < 1000; i++) {
    contiguousArray[i] = i * 2; // 极佳的缓存局部性
}

// Java 对象数组的内存模型
class Node {
    int value;
    Node next;
}
 
Node[] nodeArray = new Node[1000];
// 内存中：| reference | reference | ... | reference |
//          8字节        8字节           8字节
// 实际对象分散在堆内存各处

// Go 语言的切片实现
arr := [5]int{1, 2, 3, 4, 5}  // 固定大小数组
slice := arr[1:4]              // 切片 - 动态视图
 
// 切片的动态扩容
slice = append(slice, 6, 7, 8) // 可能触发重新分配

// Rust 的所有权系统与数组
let arr: [i32; 5] = [1, 2, 3, 4, 5]; // 栈分配值类型
let slice: &[i32] = &arr[1..4];       // 借用切片
 
// 零成本抽象
for element in &arr {
    println!("{}", element); // 编译器优化为指针遍历
}

// 游戏引擎中的数组选择
struct Particle {
    float position[3];
    float velocity[3];
    float lifetime;
};
 
// 数据导向设计（DoD）
struct ParticleSystem {
    float* positions;  // 分离存储
    float* velocities;
    float* lifetimes;
    size_t count;
};

// TypeScript 中的类型安全数组
type User = {
    id: number;
    name: string;
    roles: Role[];
}
 
// 不可变数组操作
const updatedUsers = users.map(user => ({
    ...user,
    roles: [...user.roles, newRole]
}));

// TRAE IDE 能够识别复杂的数组类型推导
var matrix = new int[][]{
    {1, 2, 3},
    {4, 5, 6}
}; // 自动推断为 int[][] 类型
 
// 泛型数组创建的智能提示
List<String>[] arrayOfLists = TRAE_IDE.<String>createArrayOfLists(10);

// 原始代码
for(int i = 0; i < rows; i++) {
    for(int j = 0; j < cols; j++) {
        process(matrix[i][j]); // 缓存不友好的访问模式
    }
}
 
// TRAE IDE 建议优化
for(int j = 0; j < cols; j++) {
    for(int i = 0; i < rows; i++) {
        process(matrix[i][j]); // 缓存友好的列优先访问
    }
}