数组与切片 #

fn main() {
    let arr = [1, 2, 3, 4, 5];
    println!("{:?}", arr);
    
    // 指定类型和大小
    let arr2: [i32; 5] = [1, 2, 3, 4, 5];
    println!("{:?}", arr2);
    
    // 重复元素
    let zeros = [0; 5];
    println!("{:?}", zeros);  // [0, 0, 0, 0, 0]
}

fn main() {
    let arr = [1, 2, 3, 4, 5];
    
    println!("第一个: {}", arr[0]);
    println!("最后一个: {}", arr[4]);
    
    // 越界检查
    // println!("{}", arr[5]);  // panic
}

fn main() {
    let mut arr = [3, 1, 4, 1, 5];
    
    // 长度
    println!("长度: {}", arr.len());
    
    // 是否为空
    println!("是否为空: {}", arr.is_empty());
    
    // 排序
    arr.sort();
    println!("排序后: {:?}", arr);
    
    // 反转
    arr.reverse();
    println!("反转后: {:?}", arr);
    
    // 填充
    arr.fill(0);
    println!("填充后: {:?}", arr);
}

fn main() {
    let arr = [1, 2, 3, 4, 5];
    
    // 迭代
    for x in arr {
        println!("{}", x);
    }
    
    // 带索引
    for (i, x) in arr.iter().enumerate() {
        println!("arr[{}] = {}", i, x);
    }
}

fn main() {
    let arr = [1, 2, 3, 4, 5];
    
    // 切片引用
    let slice: &[i32] = &arr;
    println!("{:?}", slice);
    
    // 部分切片
    let partial = &arr[1..4];
    println!("{:?}", partial);  // [2, 3, 4]
    
    // 从开头
    let first_two = &arr[..2];
    println!("{:?}", first_two);
    
    // 到结尾
    let last_three = &arr[2..];
    println!("{:?}", last_three);
}

fn main() {
    let arr = [1, 2, 3, 4, 5];
    let slice = &arr[1..4];
    
    println!("长度: {}", slice.len());
    println!("第一个: {}", slice[0]);
    
    // 迭代
    for x in slice {
        println!("{}", x);
    }
}

fn sum(slice: &[i32]) -> i32 {
    slice.iter().sum()
}

fn main() {
    let arr = [1, 2, 3, 4, 5];
    let vec = vec![1, 2, 3, 4, 5];
    
    println!("数组求和: {}", sum(&arr));
    println!("Vec求和: {}", sum(&vec));
}

fn main() {
    // 空Vec
    let mut v: Vec<i32> = Vec::new();
    
    // 使用宏
    let v2 = vec![1, 2, 3, 4, 5];
    
    // 指定容量
    let mut v3 = Vec::with_capacity(10);
    
    v.push(1);
    v.push(2);
    
    println!("{:?}", v);
    println!("{:?}", v2);
}

fn main() {
    let v = vec![1, 2, 3, 4, 5];
    
    // 索引访问
    println!("v[0] = {}", v[0]);
    
    // get方法
    match v.get(0) {
        Some(x) => println!("v[0] = {}", x),
        None => println!("越界"),
    }
}

fn main() {
    let mut v = vec![1, 2, 3];
    
    // 添加元素
    v.push(4);
    println!("push: {:?}", v);
    
    // 删除元素
    let last = v.pop();
    println!("pop: {:?}, v: {:?}", last, v);
    
    // 插入
    v.insert(1, 10);
    println!("insert: {:?}", v);
    
    // 删除指定位置
    v.remove(0);
    println!("remove: {:?}", v);
    
    // 清空
    v.clear();
    println!("clear: {:?}", v);
}

fn main() {
    let mut v = vec![1, 2, 3, 4, 5];
    
    // 不可变遍历
    for x in &v {
        print!("{} ", x);
    }
    println!();
    
    // 可变遍历
    for x in &mut v {
        *x *= 2;
    }
    println!("{:?}", v);
}

fn find_max(slice: &[i32]) -> Option<i32> {
    slice.iter().max().copied()
}

fn main() {
    let arr = [3, 1, 4, 1, 5, 9, 2, 6];
    
    match find_max(&arr) {
        Some(max) => println!("最大值: {}", max),
        None => println!("数组为空"),
    }
}

fn main() {
    let mut v = vec![3, 1, 4, 1, 5, 9, 2, 6];
    
    v.sort();
    println!("升序: {:?}", v);
    
    v.sort_by(|a, b| b.cmp(a));
    println!("降序: {:?}", v);
}

fn main() {
    let v = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    let evens: Vec<i32> = v.iter().filter(|x| *x % 2 == 0).copied().collect();
    println!("偶数: {:?}", evens);
}