fn take_ownership(some_string: String) {
    println!("函數(shù)內(nèi)部接收到的: {}", some_string);
    // some_string在這里離開作用域，drop函數(shù)被自動調(diào)用，內(nèi)存被釋放
    println!("函數(shù)結(jié)束，some_string 的內(nèi)存被自動釋放");
}

fn main() {
    println!("=== 函數(shù)中的所有權(quán)轉(zhuǎn)移 ===");
    
    let s = String::from("hello");
    println!("調(diào)用函數(shù)前: s = {}", s);
    
    // s的所有權(quán)被移動到函數(shù)中
    take_ownership(s);
    
    // 這行會編譯錯誤！s的所有權(quán)已經(jīng)沒了
    // println!("調(diào)用函數(shù)后: s = {}", s);  // 取消注釋會報錯
    
    println!("s 的所有權(quán)已經(jīng)交給函數(shù)，再也回不來了");
}

fn take_and_give_back(some_string: String) -> String {
    println!("函數(shù)處理: {}", some_string);
    some_string  // 返回所有權(quán)
}

fn main() {
    println!("=== 所有權(quán)往返 ===");
    
    let s1 = String::from("hello");
    println!("調(diào)用函數(shù)前 - s1 = {}", s1);
    
    // s1的所有權(quán)移動到函數(shù)，然后返回給s2
    let s2 = take_and_give_back(s1);
    
    // s1已經(jīng)無效，但s2有效
    // println!("s1 = {}", s1);  // 錯誤！
    println!("調(diào)用函數(shù)后 - s2 = {}", s2);     // 正確！
    
    println!("所有權(quán)完成了一次往返旅行");
}

fn calculate_length(s: &String) -> usize {
    s.len()
    // 這里s離開作用域，但因為它是引用，不會drop實際數(shù)據(jù)
}

fn main() {
    println!("=== 引用：所有權(quán)的租借 ===");
    
    let s1 = String::from("hello");
    println!("s1 = {}", s1);
    
    // 傳遞引用，不轉(zhuǎn)移所有權(quán)
    let len = calculate_length(&s1);
    
    // s1仍然有效！
    println!("'{}' 的長度是 {}", s1, len);
    println!("看，s1 還在！我們只是'借'給了函數(shù)");
}

fn change(s: &mut String) {
    s.push_str(", world");
}

fn main() {
    println!("=== 可變引用 ===");
    
    let mut s = String::from("hello");
    println!("修改前: {}", s);
    
    change(&mut s);
    println!("修改后: {}", s);
    
    println!("我們成功修改了字符串，但沒有轉(zhuǎn)移所有權(quán)！");
}

fn main() {
    println!("=== 引用規(guī)則演示 ===");
    
    let mut s = String::from("hello");
    
    // 規(guī)則1：可以有多個不可變引用
    let r1 = &s;
    let r2 = &s;
    println!("r1 = {}, r2 = {}", r1, r2);
    
    // 規(guī)則2：只能有一個可變引用
    let r3 = &mut s;
    // let r4 = &mut s;  // 錯誤！不能同時有兩個可變引用
    r3.push_str(" world");
    println!("r3 = {}", r3);
    
    // 規(guī)則3：不能同時有可變和不可變引用
    // let r5 = &s;      // 錯誤！這里已經(jīng)有可變引用在使用
    // println!("{}", r5);
    
    println!("這些規(guī)則在編譯期防止了數(shù)據(jù)競爭！");
}

fn create_and_destroy() {
    let s = String::from("臨時字符串");
    println!("在函數(shù)中創(chuàng)建: {}", s);
    // 函數(shù)結(jié)束，s自動被釋放
}

// 這行會報錯！無法返回局部變量的引用
// fn dangerous_operation() -> &String {
//     let s = String::from("局部字符串");
//     &s  // 返回局部變量的引用 - 懸空指針！
// }

fn main() {
    println!("=== 所有權(quán)的實戰(zhàn)價值 ===");
    
    // 示例1：自動內(nèi)存管理
    create_and_destroy();
    println!("函數(shù)調(diào)用完成，內(nèi)存自動清理");
    
    // 示例2：防止懸空指針
    // 取消注釋下面的調(diào)用會看到編譯錯誤
    // let dangling_ref = dangerous_operation();
    
    println!("Rust在編譯期就阻止了我們創(chuàng)建懸空指針！");
    
    // 對比其他語言可能發(fā)生的情況：
    println!("在C++中，類似的代碼可能導(dǎo)致：");
    println!("1. 懸空指針");
    println!("2. 內(nèi)存泄漏"); 
    println!("3. 段錯誤");
    println!("但在Rust中，這些在編譯期就被阻止了！");
}

fn first_word(s: &String) -> &str {
    let bytes = s.as_bytes();
    
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    
    &s[..]
}

fn main() {
    println!("=== 所有權(quán)綜合練習(xí) ===");
    
    // 場景1：所有權(quán)轉(zhuǎn)移
    let s1 = String::from("Rust");
    let s2 = s1;
    // s1 不能再使用
    
    // 場景2：克隆
    let s3 = String::from("所有權(quán)");
    let s4 = s3.clone();
    // s3 和 s4 都可以使用
    
    // 場景3：引用
    let s5 = String::from("hello world");
    let word = first_word(&s5);
    // s5 仍然可用
    
    println!("s2 = {}", s2);
    println!("s3 = {}, s4 = {}", s3, s4);
    println!("s5 = '{}', 第一個單詞是 '{}'", s5, word);
    
    // 場景4：可變引用
    let mut s6 = String::from("hello");
    {
        let r1 = &mut s6;
        r1.push_str(" rust");
    } // r1離開作用域，現(xiàn)在可以創(chuàng)建新的引用
    
    let r2 = &s6;
    println!("s6 = {}", r2);
    
    println!("\n=== 所有權(quán)規(guī)則總結(jié) ===");
    println!("? 每個值都有唯一所有者");
    println!("? 所有權(quán)可以轉(zhuǎn)移（移動）");
    println!("? 可以使用clone進(jìn)行深度復(fù)制");
    println!("? 引用允許借用而不取得所有權(quán)");
    println!("? 編譯期保證內(nèi)存安全");
}

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;
    println!("{}", s1);  // 錯誤！
}

// Java中的內(nèi)存管理
public class MemoryDemo {
    public void processData() {
        // 創(chuàng)建大量臨時對象
        for (int i = 0; i < 100000; i++) {
            String temp = new String("Object " + i);
            process(temp);
        }
        // 垃圾回收器在不確定的時間清理這些對象
    }
    
    private void process(String data) {
        // 處理數(shù)據(jù)
    }
}

// Rust中的內(nèi)存管理
fn process_data() {
    // 在棧上分配，極速創(chuàng)建和銷毀
    for i in 0..100000 {
        let temp = format!("Object {}", i);
        process(&temp);
        // temp在這里立即被丟棄，無需等待GC
    }
}

fn process(data: &str) {
    // 處理數(shù)據(jù)
}

// 或者使用更高效的方式
fn efficient_process_data() {
    let mut buffer = String::with_capacity(1024);
    for i in 0..100000 {
        buffer.clear();
        write!(&mut buffer, "Object {}", i).unwrap();
        process(&buffer);
    }
}

// Java中的多態(tài)調(diào)用
abstract class Animal {
    abstract void makeSound();
}

class Dog extends Animal {
    void makeSound() {
        System.out.println("Woof");
    }
}

class Cat extends Animal {
    void makeSound() {
        System.out.println("Meow");
    }
}

public class PolymorphismDemo {
    public void processAnimals(List<Animal> animals) {
        for (Animal animal : animals) {
            animal.makeSound(); // 虛方法調(diào)用 - 性能開銷！
        }
    }
}

// Rust中的零成本抽象
trait Animal {
    fn make_sound(&self);
}

struct Dog;
impl Animal for Dog {
    fn make_sound(&self) {
        println!("Woof");
    }
}

struct Cat;
impl Animal for Cat {
    fn make_sound(&self) {
        println!("Meow");
    }
}

// 方式1：靜態(tài)分發(fā) - 編譯時生成特化版本
fn process_animals_static<T: Animal>(animals: &[T]) {
    for animal in animals {
        animal.make_sound(); // 直接調(diào)用，可能被內(nèi)聯(lián)！
    }
}

// 方式2：動態(tài)分發(fā) - 顯式選擇運(yùn)行時多態(tài)
fn process_animals_dynamic(animals: &[&dyn Animal]) {
    for animal in animals {
        animal.make_sound(); // 通過vtable調(diào)用，但顯式標(biāo)注
    }
}

// Java Stream的隱藏開銷
public class StreamDemo {
    public void processData(List<String> data) {
        List<String> result = data.stream()
            .filter(s -> s.length() > 5)        // 中間操作 - 創(chuàng)建新Stream
            .map(s -> s.toUpperCase())          // 中間操作 - 再創(chuàng)建新Stream  
            .sorted()                           // 狀態(tài)ful操作 - 可能分配數(shù)組
            .collect(Collectors.toList());      // 終端操作 - 分配結(jié)果列表
        
        // 看似一行代碼，背后可能分配了多個臨時對象
    }
    
    // 更糟糕的例子 - 裝箱開銷
    public int sumLengths(List<String> data) {
        return data.stream()
            .map(String::length)                // 產(chǎn)生Integer對象，不是int！
            .reduce(0, Integer::sum);           // 拆箱求和
    }
}

// Rust迭代器的零成本抽象
fn process_data(data: &[String]) -> Vec<String> {
    data.iter()
        .filter(|s| s.len() > 5)           // 無分配 - 只是迭代器適配器
        .map(|s| s.to_uppercase())         // 可能分配新String，但明確可見
        .collect()                         // 一次分配結(jié)果向量
}

// 基本類型無裝箱開銷
fn sum_lengths(data: &[String]) -> usize {
    data.iter()
        .map(|s| s.len())                  // 直接返回usize，不是裝箱類型
        .sum()                             // 直接在棧上計算
}

// 更高效的原地處理
fn process_data_in_place(data: &mut [String]) {
    for item in data.iter_mut() {
        if item.len() > 5 {
            *item = item.to_uppercase();   // 原地修改，避免額外分配
        }
    }
}

// Java異常處理的隱藏成本
public class ExceptionDemo {
    public void processFile(String filename) {
        try {
            BufferedReader reader = new BufferedReader(
                new FileReader(filename));
            String line;
            while ((line = reader.readLine()) != null) {
                processLine(line);
            }
            reader.close();
        } catch (IOException e) {
            // 異常處理 - 昂貴的棧遍歷
            System.err.println("Error processing file: " + e.getMessage());
            e.printStackTrace(); // 更昂貴的棧跟蹤生成
        }
    }
    
    // 濫用異常的控制流
    public int findIndex(List<String> list, String target) {
        try {
            for (int i = 0; i < list.size(); i++) {
                if (list.get(i).equals(target)) {
                    throw new FoundException(i); // 極其低效！
                }
            }
            return -1;
        } catch (FoundException e) {
            return e.getIndex();
        }
    }
    
    private static class FoundException extends Exception {
        private final int index;
        public FoundException(int index) { this.index = index; }
        public int getIndex() { return index; }
    }
}

use std::fs::File;
use std::io::{self, BufRead, BufReader};

// Rust的錯誤處理 - 零成本抽象
fn process_file(filename: &str) -> Result<(), io::Error> {
    let file = File::open(filename)?;  // ?運(yùn)算符 - 編譯時錯誤傳播
    let reader = BufReader::new(file);
    
    for line in reader.lines() {
        let line = line?;              // 再次可能出錯
        process_line(&line);
    }
    
    Ok(()) // 明確返回成功
}

fn process_line(line: &str) {
    println!("處理: {}", line);
}

// 高效的控制流，無異常開銷
fn find_index(list: &[String], target: &str) -> Option<usize> {
    for (i, item) in list.iter().enumerate() {
        if item == target {
            return Some(i);  // 正常返回，無性能懲罰
        }
    }
    None // 明確表示未找到
}

// 組合錯誤處理
fn complex_operation() -> Result<String, String> {
    let config = "配置".to_string();
    let data = process_data(&config).map_err(|_| "處理錯誤")?;
    validate_data(&data).map_err(|_| "驗證錯誤")?;
    Ok(data)
}

fn process_data(config: &str) -> Result<String, ()> {
    Ok(format!("處理后的: {}", config))
}

fn validate_data(data: &str) -> Result<(), ()> {
    if data.len() > 0 { Ok(()) } else { Err(()) }
}

// Java并發(fā)編程的典型開銷
public class ConcurrentDemo {
    private final Map<String, Integer> cache = new HashMap<>();
    private final ReentrantLock lock = new ReentrantLock();
    
    // 方式1: synchronized方法 - 簡單但粗粒度
    public synchronized void updateCache(String key, Integer value) {
        cache.put(key, value);
    }
    
    // 方式2: 顯式鎖 - 更靈活但仍重
    public void updateCacheWithLock(String key, Integer value) {
        lock.lock();
        try {
            cache.put(key, value);
        } finally {
            lock.unlock();
        }
    }
    
    // 方式3: ConcurrentHashMap - 更好的選擇但仍非零成本
    private final ConcurrentMap<String, Integer> concurrentCache = 
        new ConcurrentHashMap<>();
    
    public void updateConcurrentCache(String key, Integer value) {
        concurrentCache.put(key, value); // 仍有內(nèi)部鎖開銷
    }
    
    // 原子變量的使用
    private final AtomicInteger counter = new AtomicInteger(0);
    
    public int increment() {
        return counter.incrementAndGet(); // 較高效，但仍有內(nèi)存屏障
    }
}

use std::sync::{Arc, Mutex};
use std::collections::HashMap;
use std::thread;

// 方式1: 基于所有權(quán)的線程創(chuàng)建
fn spawn_threads() {
    let data = vec![1, 2, 3, 4];
    
    // 移動語義確保數(shù)據(jù)安全轉(zhuǎn)移到線程
    let handle = thread::spawn(move || {
        println!("在新線程中處理數(shù)據(jù): {:?}", data);
        // data在這里被獨占訪問，無數(shù)據(jù)競爭
    });
    
    handle.join().unwrap();
}

// 方式2: 智能指針共享
fn shared_state_concurrency() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];
    
    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }
    
    for handle in handles {
        handle.join().unwrap();
    }
    
    println!("最終計數(shù): {}", *counter.lock().unwrap());
}

// 方式3: 無鎖編程 - 基于所有權(quán)的通道
use std::sync::mpsc;

fn channel_based_concurrency() {
    let (tx, rx) = mpsc::channel();
    
    thread::spawn(move || {
        let val = String::from("hello");
        tx.send(val).unwrap();
        // 發(fā)送后失去所有權(quán)，防止后續(xù)使用
    });
    
    let received = rx.recv().unwrap();
    println!("收到: {}", received);
}

// 方式4: 基于作用域的線程 - 避免Arc開銷
fn scoped_threads() {
    let mut data = vec![1, 2, 3, 4];
    
    // 跨線程借用，但編譯器驗證安全性
    thread::scope(|s| {
        for i in 0..data.len() {
            s.spawn(|| {
                data[i] += 1;  // 編譯器確保安全并發(fā)訪問
            });
        }
    });
    
    println!("處理后的數(shù)據(jù): {:?}", data);
}

// Java泛型的類型擦除問題
import java.util.ArrayList;
import java.util.List;

public class GenericsDemo {
    // 編譯后都變成List<Object> - 類型信息丟失
    public void processStrings(List<String> strings) {
        // 運(yùn)行時不知道這是List<String>
        for (String s : strings) {
            System.out.println(s.length());
        }
    }
    
    public void processIntegers(List<Integer> integers) {
        // 運(yùn)行時不知道這是List<Integer>
        for (Integer i : integers) {
            System.out.println(i.intValue()); // 裝箱開銷！
        }
    }
    
    // 類型擦除導(dǎo)致的問題
    public void typeErasureIssues() {
        List<String> strings = new ArrayList<>();
        List<Integer> integers = new ArrayList<>();
        
        // 編譯時檢查通過，但運(yùn)行時類型相同
        System.out.println(strings.getClass() == integers.getClass()); // true!
        
        // 無法創(chuàng)建泛型數(shù)組
        // List<String>[] array = new List<String>[10]; // 編譯錯誤
        
        // instanceof檢查受限
        if (strings instanceof List) { // 警告，只能檢查到List
            // 無法檢查List<String>
        }
    }
    
    // 反射繞開類型安全 - 危險但有時必要
    @SuppressWarnings("unchecked")
    public void unsafeOperation(List<String> strings) {
        // 繞過編譯時檢查
        List rawList = strings;
        rawList.add(42); // 運(yùn)行時才拋出ClassCastException!
    }
}

// Rust泛型的單態(tài)化 - 零成本抽象
fn process_strings(strings: &[String]) {
    // 編譯器為每個具體類型生成特化代碼
    for s in strings {
        println!("長度: {}", s.len()); // 直接方法調(diào)用，可能內(nèi)聯(lián)
    }
}

fn process_integers(integers: &[i32]) {
    // 基本類型特化 - 無裝箱開銷
    for i in integers {
        println!("值: {}", i); // 直接棧操作
    }
}

// 泛型函數(shù) - 編譯時為每個調(diào)用類型生成特化版本
fn process<T: std::fmt::Display>(items: &[T]) {
    for item in items {
        println!("{}", item); // 靜態(tài)分發(fā)調(diào)用
    }
}

// 特化集合類型
fn specialized_collections() {
    // Vec<i32> - 連續(xù)內(nèi)存布局，無裝箱
    let numbers: Vec<i32> = vec![1, 2, 3, 4];
    
    // HashMap<String, i32> - 鍵值對特化布局
    let mut map: std::collections::HashMap<String, i32> = 
        std::collections::HashMap::new();
    map.insert("key".to_string(), 42);
    
    // 數(shù)組 - 棧分配，極致性能
    let array: [f64; 4] = [1.0, 2.0, 3.0, 4.0];
}

// 編譯時特化的威力
fn generic_algorithm<T: Copy + std::ops::Add<Output = T>>(a: T, b: T) -> T {
    a + b  // 為每個T生成特化代碼
}

// 使用示例
fn demonstrate_monomorphization() {
    // 為i32生成特化版本
    let int_result = generic_algorithm(1, 2);
    println!("整數(shù)結(jié)果: {}", int_result);
    
    // 為f64生成另一個特化版本  
    let float_result = generic_algorithm(1.0, 2.0);
    println!("浮點數(shù)結(jié)果: {}", float_result);
    
    // 每個調(diào)用都是直接機(jī)器碼，無運(yùn)行時類型檢查
}

fn main() {
    demonstrate_monomorphization();
}