Rust 基本 api

关键字

关键字	作用	示例代码
let	变量绑定	let x = 5;
mut	声明可变变量	let mut x = 5;
const	声明常量，编译时确定值	const MAX_POINTS: u32 = 100_000;
static	声明全局变量	static HELLO_WORLD: &str = "Hello, world!";
fn	定义函数	fn main() { println!("Hello, world!"); }
mod	声明模块	mod my_module;
pub	声明公有性	pub fn public_function() {}
struct	定义结构体	struct Point { x: i32, y: i32 }
enum	定义枚举类型	enum Direction { Up, Down, Left, Right }
impl	为类型实现方法或特性	impl Point { fn new(x: i32, y: i32) -> Point { Point { x, y } } }
trait	定义特性（接口）	trait Drawable { fn draw(&self); }
match	模式匹配表达式	match number { 1 => println!("one"), 2 => println!("two"), _ => println!("other"), }
if / else	条件表达式	if x > 5 { println!("x is greater than 5"); } else { println!("x is 5 or less"); }

基本数据类型和数组

下面是Rust和Java中的基本数据类型和数组的对比表格，包括类型及代码示例：

数据类型	Rust 类型	Rust 示例代码	Java 类型	Java 示例代码
整数	i32	let x: i32 = 10;	int	int x = 10;
长整数	i64	let x: i64 = 10000000000;	long	long x = 10000000000L;
短整数	i16	let x: i16 = 1000;	short	short x = 1000;
字节	i8	let x: i8 = 100;	byte	byte x = 100;
浮点数	f32	let x: f32 = 3.14;	float	float x = 3.14f;
双精度浮点数	f64	let x: f64 = 3.1415926535;	double	double x = 3.1415926535;
布尔值	bool	let x: bool = true;	boolean	boolean x = true;
字符	char	let x: char = 'a';	char	char x = 'a';
字符串	&str 或 String	let x: &str = "Hello"; let y: String = String::from("Hello");	String	String x = "Hello";
数组	[i32; 3]	let arr: [i32; 3] = [1, 2, 3];	int[]	int[] arr = {1, 2, 3};

Rust 示例代码：

fn main() {
    // 整数
    let x: i32 = 10;
    println!("x: {}", x);

    // 长整数
    let y: i64 = 10000000000;
    println!("y: {}", y);

    // 短整数
    let z: i16 = 1000;
    println!("z: {}", z);

    // 字节
    let a: i8 = 100;
    println!("a: {}", a);

    // 浮点数
    let b: f32 = 3.14;
    println!("b: {}", b);

    // 双精度浮点数
    let c: f64 = 3.1415926535;
    println!("c: {}", c);

    // 布尔值
    let d: bool = true;
    println!("d: {}", d);

    // 字符
    let e: char = 'a';
    println!("e: {}", e);

    // 字符串
    let f: &str = "Hello";
    let g: String = String::from("Hello");
    println!("f: {}", f);
    println!("g: {}", g);

    // 数组
    let arr: [i32; 3] = [1, 2, 3];
    println!("arr: {:?}", arr);
}

Java 示例代码：

public class Main {
    public static void main(String[] args) {
        // 整数
        int x = 10;
        System.out.println("x: " + x);

        // 长整数
        long y = 10000000000L;
        System.out.println("y: " + y);

        // 短整数
        short z = 1000;
        System.out.println("z: " + z);

        // 字节
        byte a = 100;
        System.out.println("a: " + a);

        // 浮点数
        float b = 3.14f;
        System.out.println("b: " + b);

        // 双精度浮点数
        double c = 3.1415926535;
        System.out.println("c: " + c);

        // 布尔值
        boolean d = true;
        System.out.println("d: " + d);

        // 字符
        char e = 'a';
        System.out.println("e: " + e);

        // 字符串
        String f = "Hello";
        System.out.println("f: " + f);

        // 数组
        int[] arr = {1, 2, 3};
        System.out.println("arr: " + java.util.Arrays.toString(arr));
    }
}

集合容器

下面是Rust和Java中常见集合容器的对比表格，包括类型及代码示例：

集合类型	Rust 类型	Rust 示例代码	Java 类型	Java 示例代码
动态数组	Vec<T>	let mut v: Vec<i32> = Vec::new(); v.push(1);	ArrayList<T>	ArrayList<Integer> list = new ArrayList<>(); list.add(1);
定长数组	[T; N]	let arr: [i32; 3] = [1, 2, 3];	int[]	int[] arr = {1, 2, 3};
哈希表	HashMap<K, V>	use std::collections::HashMap; let mut map = HashMap::new(); map.insert("key", "value");	HashMap<K, V>	HashMap<String, String> map = new HashMap<>(); map.put("key", "value");
哈希集合	HashSet<T>	use std::collections::HashSet; let mut set = HashSet::new(); set.insert(1);	HashSet<T>	HashSet<Integer> set = new HashSet<>(); set.add(1);
双端队列	VecDeque<T>	use std::collections::VecDeque; let mut deque: VecDeque<i32> = VecDeque::new(); deque.push_back(1);	LinkedList<T>	LinkedList<Integer> deque = new LinkedList<>(); deque.add(1);
二叉堆	BinaryHeap<T>	use std::collections::BinaryHeap; let mut heap = BinaryHeap::new(); heap.push(1);	PriorityQueue<T>	PriorityQueue<Integer> heap = new PriorityQueue<>(); heap.add(1);
链表	LinkedList<T>	use std::collections::LinkedList; let mut list = LinkedList::new(); list.push_back(1);	LinkedList<T>	LinkedList<Integer> list = new LinkedList<>(); list.add(1);
B树映射	BTreeMap<K, V>	use std::collections::BTreeMap; let mut map = BTreeMap::new(); map.insert("key", "value");	TreeMap<K, V>	TreeMap<String, String> map = new TreeMap<>(); map.put("key", "value");
B树集合	BTreeSet<T>	use std::collections::BTreeSet; let mut set = BTreeSet::new(); set.insert(1);	TreeSet<T>	TreeSet<Integer> set = new TreeSet<>(); set.add(1);

Rust 示例代码：

fn main() {
    // 动态数组
    let mut v: Vec<i32> = Vec::new();
    v.push(1);
    println!("{:?}", v);

    // 定长数组
    let arr: [i32; 3] = [1, 2, 3];
    println!("{:?}", arr);

    // 哈希表
    use std::collections::HashMap;
    let mut map = HashMap::new();
    map.insert("key", "value");
    println!("{:?}", map);

    // 哈希集合
    use std::collections::HashSet;
    let mut set = HashSet::new();
    set.insert(1);
    println!("{:?}", set);

    // 双端队列
    use std::collections::VecDeque;
    let mut deque: VecDeque<i32> = VecDeque::new();
    deque.push_back(1);
    println!("{:?}", deque);

    // 二叉堆
    use std::collections::BinaryHeap;
    let mut heap = BinaryHeap::new();
    heap.push(1);
    println!("{:?}", heap);

    // 链表
    use std::collections::LinkedList;
    let mut list = LinkedList::new();
    list.push_back(1);
    println!("{:?}", list);

    // B树映射
    use std::collections::BTreeMap;
    let mut map = BTreeMap::new();
    map.insert("key", "value");
    println!("{:?}", map);

    // B树集合
    use std::collections::BTreeSet;
    let mut set = BTreeSet::new();
    set.insert(1);
    println!("{:?}", set);
}

Java 示例代码：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        // 动态数组
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        System.out.println(list);

        // 定长数组
        int[] arr = {1, 2, 3};
        System.out.println(Arrays.toString(arr));

        // 哈希表
        HashMap<String, String> map = new HashMap<>();
        map.put("key", "value");
        System.out.println(map);

        // 哈希集合
        HashSet<Integer> set = new HashSet<>();
        set.add(1);
        System.out.println(set);

        // 双端队列
        LinkedList<Integer> deque = new LinkedList<>();
        deque.add(1);
        System.out.println(deque);

        // 二叉堆
        PriorityQueue<Integer> heap = new PriorityQueue<>();
        heap.add(1);
        System.out.println(heap);

        // 链表
        LinkedList<Integer> list2 = new LinkedList<>();
        list2.add(1);
        System.out.println(list2);

        // B树映射
        TreeMap<String, String> map2 = new TreeMap<>();
        map2.put("key", "value");
        System.out.println(map2);

        // B树集合
        TreeSet<Integer> set2 = new TreeSet<>();
        set2.add(1);
        System.out.println(set2);
    }
}

锁

下面是Rust和Java中锁的对比表格，包括类型及代码示例：

锁类型	Rust 类型	Rust 示例代码	Java 类型	Java 示例代码
互斥锁	std::sync::Mutex<T>	use std::sync::{Arc, Mutex}; let data = Arc::new(Mutex::new(0));	java.util.concurrent.locks.ReentrantLock	ReentrantLock lock = new ReentrantLock(); lock.lock(); try { /* critical section */ } finally { lock.unlock(); }
读写锁	std::sync::RwLock<T>	use std::sync::{Arc, RwLock}; let data = Arc::new(RwLock::new(0));	java.util.concurrent.locks.ReentrantReadWriteLock	ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock(); rwLock.readLock().lock(); try { /* read section */ } finally { rwLock.readLock().unlock(); }
条件变量	std::sync::Condvar	use std::sync::{Mutex, Condvar}; let pair = (Mutex::new(false), Condvar::new());	java.util.concurrent.locks.Condition	Condition condition = lock.newCondition(); lock.lock(); try { condition.await(); /* or condition.signal(); */ } finally { lock.unlock(); }
原子类型	std::sync::atomic::{AtomicBool, AtomicIsize, AtomicUsize}	use std::sync::atomic::{AtomicBool, Ordering}; let flag = AtomicBool::new(true); flag.store(false, Ordering::SeqCst);	java.util.concurrent.atomic.{AtomicBoolean, AtomicInteger, AtomicLong}	AtomicBoolean flag = new AtomicBoolean(true); flag.set(false);

Rust 示例代码：

use std::sync::{Arc, Mutex, RwLock, Condvar};
use std::sync::atomic::{AtomicBool, Ordering};
use std::thread;

fn main() {
    // 互斥锁
    let data = Arc::new(Mutex::new(0));
    let data_clone = Arc::clone(&data);
    let handle = thread::spawn(move || {
        let mut num = data_clone.lock().unwrap();
        *num += 1;
    });
    handle.join().unwrap();
    println!("Mutex: {:?}", *data.lock().unwrap());

    // 读写锁
    let data = Arc::new(RwLock::new(0));
    {
        let mut w = data.write().unwrap();
        *w += 1;
    }
    {
        let r = data.read().unwrap();
        println!("RwLock: {:?}", *r);
    }

    // 条件变量
    let pair = Arc::new((Mutex::new(false), Condvar::new()));
    let pair_clone = Arc::clone(&pair);
    let handle = thread::spawn(move || {
        let (lock, cvar) = &*pair_clone;
        let mut started = lock.lock().unwrap();
        *started = true;
        cvar.notify_one();
    });

    let (lock, cvar) = &*pair;
    let mut started = lock.lock().unwrap();
    while !*started {
        started = cvar.wait(started).unwrap();
    }
    handle.join().unwrap();
    println!("Condition Variable: started = {:?}", *started);

    // 原子类型
    let flag = AtomicBool::new(true);
    flag.store(false, Ordering::SeqCst);
    println!("AtomicBool: {:?}", flag.load(Ordering::SeqCst));
}

Java 示例代码：

import java.util.concurrent.locks.*;
import java.util.concurrent.atomic.*;
import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // 互斥锁
        ReentrantLock lock = new ReentrantLock();
        lock.lock();
        try {
            // critical section
        } finally {
            lock.unlock();
        }

        // 读写锁
        ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
        rwLock.readLock().lock();
        try {
            // read section
        } finally {
            rwLock.readLock().unlock();
        }
        rwLock.writeLock().lock();
        try {
            // write section
        } finally {
            rwLock.writeLock().unlock();
        }

        // 条件变量
        ReentrantLock conditionLock = new ReentrantLock();
        Condition condition = conditionLock.newCondition();
        conditionLock.lock();
        try {
            condition.await(); // wait for condition
        } finally {
            conditionLock.unlock();
        }

        // 唤醒条件变量
        conditionLock.lock();
        try {
            condition.signal(); // signal condition
        } finally {
            conditionLock.unlock();
        }

        // 原子类型
        AtomicBoolean flag = new AtomicBoolean(true);
        flag.set(false);
        System.out.println("AtomicBoolean: " + flag.get());
    }
}

并发控制

下面是Rust和Java中并发控制的对比表格，包括常见并发控制机制及代码示例：

并发控制类型	Rust 类型	Rust 示例代码	Java 类型	Java 示例代码
线程	std::thread	`use std::thread; let handle = thread::spawn(		{ println!("Hello from a thread!"); }); handle.join().unwrap();`	java.lang.Thread	Thread t = new Thread(() -> System.out.println("Hello from a thread!")); t.start(); t.join();
线程池	threadpool::ThreadPool	`use threadpool::ThreadPool; let pool = ThreadPool::new(4); pool.execute(		{ println!("Hello from a thread pool!"); });`	java.util.concurrent.ExecutorService	ExecutorService pool = Executors.newFixedThreadPool(4); pool.submit(() -> System.out.println("Hello from a thread pool!")); pool.shutdown();
消息传递	std::sync::mpsc	use std::sync::mpsc; let (tx, rx) = mpsc::channel(); tx.send(1).unwrap(); println!("Received: {}", rx.recv().unwrap());	java.util.concurrent.BlockingQueue	BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(); queue.put(1); System.out.println("Received: " + queue.take());
互斥锁	std::sync::Mutex<T>	`use std::sync::{Arc, Mutex}; let data = Arc::new(Mutex::new(0)); let data_clone = Arc::clone(&data); let handle = thread::spawn(move		{ let mut num = data_clone.lock().unwrap(); *num += 1; }); handle.join().unwrap();`	java.util.concurrent.locks.ReentrantLock	ReentrantLock lock = new ReentrantLock(); lock.lock(); try { // critical section } finally { lock.unlock(); }
读写锁	std::sync::RwLock<T>	`use std::sync::{Arc, RwLock}; let data = Arc::new(RwLock::new(0)); let data_clone = Arc::clone(&data); let handle = thread::spawn(move		{ let mut num = data_clone.write().unwrap(); *num += 1; }); handle.join().unwrap();`	java.util.concurrent.locks.ReentrantReadWriteLock	ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock(); rwLock.writeLock().lock(); try { // write section } finally { rwLock.writeLock().unlock(); }
条件变量	std::sync::Condvar	`use std::sync::{Mutex, Condvar}; let pair = Arc::new((Mutex::new(false), Condvar::new())); let pair_clone = Arc::clone(&pair); let handle = thread::spawn(move		{ let (lock, cvar) = &*pair_clone; let mut started = lock.lock().unwrap(); *started = true; cvar.notify_one(); }); let (lock, cvar) = &*pair; let mut started = lock.lock().unwrap(); while !*started { started = cvar.wait(started).unwrap(); } handle.join().unwrap();`	java.util.concurrent.locks.Condition	Condition condition = lock.newCondition(); lock.lock(); try { condition.await(); } finally { lock.unlock(); }

Rust 示例代码：

use std::thread;
use std::sync::{Arc, Mutex, RwLock, Condvar, mpsc};
use threadpool::ThreadPool;

fn main() {
    // 线程
    let handle = thread::spawn(|| {
        println!("Hello from a thread!");
    });
    handle.join().unwrap();

    // 线程池
    let pool = ThreadPool::new(4);
    pool.execute(|| {
        println!("Hello from a thread pool!");
    });

    // 消息传递
    let (tx, rx) = mpsc::channel();
    thread::spawn(move || {
        tx.send(1).unwrap();
    });
    println!("Received: {}", rx.recv().unwrap());

    // 互斥锁
    let data = Arc::new(Mutex::new(0));
    let data_clone = Arc::clone(&data);
    let handle = thread::spawn(move || {
        let mut num = data_clone.lock().unwrap();
        *num += 1;
    });
    handle.join().unwrap();
    println!("Mutex: {:?}", *data.lock().unwrap());

    // 读写锁
    let data = Arc::new(RwLock::new(0));
    {
        let mut w = data.write().unwrap();
        *w += 1;
    }
    {
        let r = data.read().unwrap();
        println!("RwLock: {:?}", *r);
    }

    // 条件变量
    let pair = Arc::new((Mutex::new(false), Condvar::new()));
    let pair_clone = Arc::clone(&pair);
    let handle = thread::spawn(move || {
        let (lock, cvar) = &*pair_clone;
        let mut started = lock.lock().unwrap();
        *started = true;
        cvar.notify_one();
    });

    let (lock, cvar) = &*pair;
    let mut started = lock.lock().unwrap();
    while !*started {
        started = cvar.wait(started).unwrap();
    }
    handle.join().unwrap();
    println!("Condition Variable: started = {:?}", *started);
}

Java 示例代码：

import java.util.concurrent.*;
import java.util.concurrent.locks.*;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // 线程
        Thread t = new Thread(() -> {
            System.out.println("Hello from a thread!");
        });
        t.start();
        t.join();

        // 线程池
        ExecutorService pool = Executors.newFixedThreadPool(4);
        pool.submit(() -> {
            System.out.println("Hello from a thread pool!");
        });
        pool.shutdown();
        pool.awaitTermination(1, TimeUnit.MINUTES);

        // 消息传递
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();
        new Thread(() -> {
            try {
                queue.put(1);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
        System.out.println("Received: " + queue.take());

        // 互斥锁
        ReentrantLock lock = new ReentrantLock();
        lock.lock();
        try {
            // critical section
        } finally {
            lock.unlock();
        }

        // 读写锁
        ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
        rwLock.writeLock().lock();
        try {
            // write section
        } finally {
            rwLock.writeLock().unlock();
        }
        rwLock.readLock().lock();
        try {
            // read section
        } finally {
            rwLock.readLock().unlock();
        }

        // 条件变量
        ReentrantLock conditionLock = new ReentrantLock();
        Condition condition = conditionLock.newCondition();
        conditionLock.lock();
        try {
            condition.await(); // wait for condition
        } finally {
            conditionLock.unlock();
        }

        // 唤醒条件变量
        conditionLock.lock();
        try {
            condition.signal(); // signal condition
        } finally {
            conditionLock.unlock();
        }
    }
}

“类”定义

下面是Rust和Java中类定义的对比表格，包括类型及代码示例：

类定义特性	Rust	Rust 示例代码	Java	Java 示例代码
类定义	struct	struct Person { name: String, age: u32 }	class	class Person { String name; int age; }
类的实现	impl	impl Person { fn new(name: String, age: u32) -> Person { Person { name, age } } }	class methods	class Person { Person(String name, int age) { this.name = name; this.age = age; } }
访问修饰符	无（默认公开）	pub struct Person { pub name: String, pub age: u32 }	public, private, protected	public class Person { public String name; private int age; }
属性	struct 字段	struct Person { name: String, age: u32 }	类字段	class Person { String name; int age; }
方法	impl 块	impl Person { fn greet(&self) { println!("Hello, {}!", self.name); } }	类方法	class Person { void greet() { System.out.println("Hello, " + name + "!"); } }
继承	无（使用 trait 作为替代）	trait Greet { fn greet(&self); } impl Greet for Person { fn greet(&self) { println!("Hello, {}!", self.name); } }	extends	class Employee extends Person { Employee(String name, int age) { super(name, age); } }
接口	trait	trait Describable { fn describe(&self) -> String; }	interface	interface Describable { String describe(); }
实现接口	impl 块	impl Describable for Person { fn describe(&self) -> String { format!("{} ({})", self.name, self.age) } }	implements	class Person implements Describable { public String describe() { return name + " (" + age + ")"; } }

Rust 示例代码：

// 定义一个结构体
pub struct Person {
    pub name: String,
    pub age: u32,
}

// 为结构体实现方法
impl Person {
    // 构造函数
    pub fn new(name: String, age: u32) -> Person {
        Person { name, age }
    }

    // 示例方法
    pub fn greet(&self) {
        println!("Hello, {}!", self.name);
    }
}

// 定义一个 trait
pub trait Describable {
    fn describe(&self) -> String;
}

// 为结构体实现 trait
impl Describable for Person {
    fn describe(&self) -> String {
        format!("{} ({})", self.name, self.age)
    }
}

fn main() {
    let person = Person::new(String::from("Alice"), 30);
    person.greet();
    println!("{}", person.describe());
}

Java 示例代码：

// 定义一个类
public class Person {
    public String name;
    private int age;

    // 构造函数
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 示例方法
    public void greet() {
        System.out.println("Hello, " + name + "!");
    }
}

// 定义一个接口
interface Describable {
    String describe();
}

// 为类实现接口
public class Person implements Describable {
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String describe() {
        return name + " (" + age + ")";
    }

    public static void main(String[] args) {
        Person person = new Person("Alice", 30);
        person.greet();
        System.out.println(person.describe());
    }
}

定义方法和函数

下面是Rust和Java中定义方法和函数的对比表格，包括类型及代码示例：

特性	Rust	Rust 示例代码	Java	Java 示例代码
函数定义	fn 关键字	fn add(a: i32, b: i32) -> i32 { a + b }	无特定关键字（方法）	int add(int a, int b) { return a + b; }
方法定义	impl 块中的函数	impl Person { fn greet(&self) { println!("Hello, {}!", self.name); } }	类中的方法	class Person { void greet() { System.out.println("Hello, " + name + "!"); } }
静态方法	impl 块中的关联函数	impl Person { fn new(name: String, age: u32) -> Person { Person { name, age } } }	static 关键字	class Person { static Person create(String name, int age) { return new Person(name, age); } }
构造函数	没有特殊语法，通常使用关联函数	impl Person { fn new(name: String, age: u32) -> Person { Person { name, age } } }	构造函数	class Person { Person(String name, int age) { this.name = name; this.age = age; } }
默认参数	不支持（可以通过 Option 实现）	fn greet(name: Option<&str>) { match name { Some(name) => println!("Hello, {}!", name), None => println!("Hello!"), } }	支持（方法重载或默认参数）	void greet() { System.out.println("Hello!"); } void greet(String name) { System.out.println("Hello, " + name + "!"); }
可变参数	... 语法	fn sum(numbers: &[i32]) -> i32 { numbers.iter().sum() }	... 语法	int sum(int... numbers) { return Arrays.stream(numbers).sum(); }

Rust 示例代码：

// 函数定义
fn add(a: i32, b: i32) -> i32 {
    a + b
}

// 定义一个结构体
pub struct Person {
    pub name: String,
    pub age: u32,
}

// 为结构体实现方法
impl Person {
    // 关联函数，类似于静态方法
    pub fn new(name: String, age: u32) -> Person {
        Person { name, age }
    }

    // 示例方法
    pub fn greet(&self) {
        println!("Hello, {}!", self.name);
    }
}

// 可变参数函数
fn sum(numbers: &[i32]) -> i32 {
    numbers.iter().sum()
}

// 默认参数实现
fn greet(name: Option<&str>) {
    match name {
        Some(name) => println!("Hello, {}!", name),
        None => println!("Hello!"),
    }
}

fn main() {
    // 调用函数
    println!("3 + 4 = {}", add(3, 4));

    // 创建结构体实例并调用方法
    let person = Person::new(String::from("Alice"), 30);
    person.greet();

    // 调用可变参数函数
    let numbers = vec![1, 2, 3, 4, 5];
    println!("Sum: {}", sum(&numbers));

    // 调用带有默认参数的函数
    greet(Some("Alice"));
    greet(None);
}

Java 示例代码：

// 函数定义（在类中作为方法）
public class Utils {
    // 静态方法，类似于Rust中的关联函数
    public static int add(int a, int b) {
        return a + b;
    }

    // 可变参数函数
    public static int sum(int... numbers) {
        return Arrays.stream(numbers).sum();
    }
}

// 定义一个类
public class Person {
    public String name;
    private int age;

    // 构造函数
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 示例方法
    public void greet() {
        System.out.println("Hello, " + name + "!");
    }

    // 静态方法
    public static Person create(String name, int age) {
        return new Person(name, age);
    }

    // 带有默认参数的方法
    public void greet(String name) {
        System.out.println("Hello, " + name + "!");
    }

    public void greet() {
        System.out.println("Hello!");
    }

    public static void main(String[] args) {
        // 调用静态方法
        System.out.println("3 + 4 = " + Utils.add(3, 4));

        // 创建类实例并调用方法
        Person person = new Person("Alice", 30);
        person.greet();

        // 调用可变参数函数
        System.out.println("Sum: " + Utils.sum(1, 2, 3, 4, 5));

        // 调用带有默认参数的方法
        person.greet("Alice");
        person.greet();
    }
}

OOP

下面是Rust和Java在面向对象编程（OOP）方面的对比表格，包括类定义、继承、多态、封装、接口及其实现的相关特性及代码示例：

特性	Rust	Rust 示例代码	Java	Java 示例代码
类定义	struct	struct Person { name: String, age: u32 }	class	class Person { String name; int age; }
构造函数	关联函数	impl Person { fn new(name: String, age: u32) -> Self { Self { name, age } } }	构造函数	Person(String name, int age) { this.name = name; this.age = age; }
方法定义	impl 块	impl Person { fn greet(&self) { println!("Hello, {}!", self.name); } }	类中的方法	void greet() { System.out.println("Hello, " + name + "!"); }
继承	不支持直接继承，使用 trait 作为替代	trait Greet { fn greet(&self); } impl Greet for Person { fn greet(&self) { println!("Hello, {}!", self.name); } }	extends 关键字	class Employee extends Person { Employee(String name, int age) { super(name, age); } }
多态	trait	fn greet_all(greeters: &Vec<&dyn Greet>) { for greeter in greeters { greeter.greet(); } }	接口实现	interface Greeter { void greet(); } void greetAll(List<Greeter> greeters) { for (Greeter greeter : greeters) { greeter.greet(); } }
封装	模块系统，字段私有化	pub struct Person { name: String, age: u32 }	访问控制修饰符	public class Person { private String name; private int age; }
接口	trait	trait Describable { fn describe(&self) -> String; }	interface 关键字	interface Describable { String describe(); }
实现接口	impl 块	impl Describable for Person { fn describe(&self) -> String { format!("{} ({})", self.name, self.age) } }	implements 关键字	class Person implements Describable { public String describe() { return name + " (" + age + ")"; } }

Rust 示例代码：

// 定义一个结构体
pub struct Person {
    name: String,
    age: u32,
}

// 为结构体实现构造函数和方法
impl Person {
    pub fn new(name: String, age: u32) -> Person {
        Person { name, age }
    }

    pub fn greet(&self) {
        println!("Hello, {}!", self.name);
    }
}

// 定义一个 trait
pub trait Describable {
    fn describe(&self) -> String;
}

// 为结构体实现 trait
impl Describable for Person {
    fn describe(&self) -> String {
        format!("{} ({})", self.name, self.age)
    }
}

// 定义另一个结构体，实现相同的 trait
pub struct Employee {
    name: String,
    age: u32,
    job_title: String,
}

impl Employee {
    pub fn new(name: String, age: u32, job_title: String) -> Employee {
        Employee { name, age, job_title }
    }
}

impl Describable for Employee {
    fn describe(&self) -> String {
        format!("{} ({}) - {}", self.name, self.age, self.job_title)
    }
}

fn greet_all(greeters: &Vec<&dyn Describable>) {
    for greeter in greeters {
        println!("{}", greeter.describe());
    }
}

fn main() {
    let person = Person::new(String::from("Alice"), 30);
    let employee = Employee::new(String::from("Bob"), 40, String::from("Engineer"));

    let greeters: Vec<&dyn Describable> = vec![&person, &employee];
    greet_all(&greeters);
}

Java 示例代码：

// 定义一个类
public class Person {
    private String name;
    private int age;

    // 构造函数
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 方法
    public void greet() {
        System.out.println("Hello, " + name + "!");
    }

    // 实现接口方法
    public String describe() {
        return name + " (" + age + ")";
    }
}

// 定义一个接口
interface Describable {
    String describe();
}

// 实现接口
class Employee extends Person implements Describable {
    private String jobTitle;

    public Employee(String name, int age, String jobTitle) {
        super(name, age);
        this.jobTitle = jobTitle;
    }

    @Override
    public String describe() {
        return super.describe() + " - " + jobTitle;
    }
}

public class Main {
    public static void greetAll(List<Describable> greeters) {
        for (Describable greeter : greeters) {
            System.out.println(greeter.describe());
        }
    }

    public static void main(String[] args) {
        Person person = new Person("Alice", 30);
        Employee employee = new Employee("Bob", 40, "Engineer");

        List<Describable> greeters = Arrays.asList(person, employee);
        greetAll(greeters);
    }
}

导入别的类

下面是Rust和Java中导入其他类的对比表格，包括类型及代码示例：

特性	Rust	Rust 示例代码	Java	Java 示例代码
导入本地模块	mod 和 use 关键字	mod person; use crate::person::Person;	import 关键字	import com.example.Person;
导入外部依赖模块	extern crate 和 use 关键字	use rand::Rng;	import 关键字	import org.apache.commons.lang3.StringUtils;
模块系统	文件和文件夹	mod person { pub struct Person { ... } }	包系统	package com.example; public class Person { ... }
结构体（类）定义	struct	struct Person { name: String, age: u32 }	class	class Person { String name; int age; }

Rust 示例代码：

src/main.rs 文件：

// 导入本地模块中的类
mod person;
use crate::person::Person;

fn main() {
    // 使用导入的类
    let person = Person::new(String::from("Alice"), 30);
    person.greet();
}

src/person.rs 文件：

// 定义模块中的结构体和方法
pub struct Person {
    pub name: String,
    pub age: u32,
}

impl Person {
    pub fn new(name: String, age: u32) -> Person {
        Person { name, age }
    }

    pub fn greet(&self) {
        println!("Hello, {}!", self.name);
    }
}

Java 示例代码：

src/main/java/com/example/Main.java 文件：

// 导入本地包中的类
import com.example.Person;

public class Main {
    public static void main(String[] args) {
        // 使用导入的类
        Person person = new Person("Alice", 30);
        person.greet();
    }
}

src/main/java/com/example/Person.java 文件：

// 定义包中的类
package com.example;

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void greet() {
        System.out.println("Hello, " + name + "!");
    }
}

引入依赖

下面是Rust和Java中引入依赖的对比表格，包括类型及代码示例：

特性	Rust	Rust 示例代码	Java	Java 示例代码
依赖管理工具	Cargo	Cargo.toml	Maven/Gradle	pom.xml（Maven）或 build.gradle（Gradle）
配置文件	Cargo.toml	[dependencies] rand = "0.8"	pom.xml（Maven）或 build.gradle（Gradle）	<dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-lang3</artifactId> <version>3.12.0</version> </dependency>（Maven） 或 implementation 'org.apache.commons:commons-lang3:3.12.0'（Gradle）
添加依赖	在配置文件中添加依赖项	[dependencies] rand = "0.8"	在配置文件中添加依赖项	<dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-lang3</artifactId> <version>3.12.0</version> </dependency>（Maven） 或 implementation 'org.apache.commons:commons-lang3:3.12.0'（Gradle）
使用依赖	extern crate 或 use 关键字	use rand::Rng;	import 关键字	import org.apache.commons.lang3.StringUtils;

Rust 示例代码：

Cargo.toml 文件：

[package]
name = "example"
version = "0.1.0"
edition = "2021"

[dependencies]
rand = "0.8"

main.rs 文件：

// 引入外部 crate
use rand::Rng;

fn main() {
    // 使用外部 crate 提供的功能
    let mut rng = rand::thread_rng();
    let n: u32 = rng.gen_range(0..10);
    println!("随机数: {}", n);
}

Java 示例代码：

pom.xml 文件（Maven）：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>example</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- 添加依赖 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.12.0</version>
        </dependency>
    </dependencies>
</project>

build.gradle 文件（Gradle）：

plugins {
    id 'java'
}

group 'com.example'
version '1.0-SNAPSHOT'

repositories {
    mavenCentral()
}

dependencies {
    // 添加依赖
    implementation 'org.apache.commons:commons-lang3:3.12.0'
}

Java 代码文件（例如 Main.java）：

// 引入外部依赖
import org.apache.commons.lang3.StringUtils;

public class Main {
    public static void main(String[] args) {
        // 使用外部依赖提供的功能
        String message = "   Hello, World!   ";
        String trimmedMessage = StringUtils.trim(message);
        System.out.println("Trimmed message: '" + trimmedMessage + "'");
    }
}

项目目录结构

下面是Rust和Java项目的典型目录结构对比表格，包括项目结构及代码示例：

项目特性	Rust	Java	说明
项目根目录	根目录包含 Cargo.toml 和 src 目录	根目录包含 pom.xml 或 build.gradle 和 src 目录	两种语言都在根目录放置项目配置文件和源代码目录
源代码目录	src 目录	src/main/java 目录	Rust的源代码直接放在 src 目录下，Java通常在 src/main/java 目录下
主程序文件	main.rs	Main.java	主程序文件是项目的入口点
模块文件	module_name.rs	ModuleName.java	模块或类文件
测试目录	tests 目录	src/test/java 目录	两种语言都在专门的目录放置测试代码

Rust 项目目录结构：

my_rust_project/
├── Cargo.toml
├── src/
│   ├── main.rs
│   ├── person.rs
│   └── lib.rs (可选)
└── tests/ (可选)
    ├── integration_test.rs (可选)

Cargo.toml 文件：

[package]
name = "my_rust_project"
version = "0.1.0"
edition = "2021"

[dependencies]

src/main.rs 文件：

// 导入本地模块中的类
mod person;
use crate::person::Person;

fn main() {
    // 使用导入的类
    let person = Person::new(String::from("Alice"), 30);
    person.greet();
}

src/person.rs 文件：

// 定义模块中的结构体和方法
pub struct Person {
    pub name: String,
    pub age: u32,
}

impl Person {
    pub fn new(name: String, age: u32) -> Person {
        Person { name, age }
    }

    pub fn greet(&self) {
        println!("Hello, {}!", self.name);
    }
}

Java 项目目录结构（使用 Maven）：

my_java_project/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── com/
│   │           └── example/
│   │               ├── Main.java
│   │               └── Person.java
│   └── test/
│       └── java/
│           └── com/
│               └── example/
│                   └── PersonTest.java (可选)

pom.xml 文件：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>my_java_project</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- 添加依赖 -->
    </dependencies>
</project>

src/main/java/com/example/Main.java 文件：

// 导入本地包中的类
import com.example.Person;

public class Main {
    public static void main(String[] args) {
        // 使用导入的类
        Person person = new Person("Alice", 30);
        person.greet();
    }
}

src/main/java/com/example/Person.java 文件：

// 定义包中的类
package com.example;

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void greet() {
        System.out.println("Hello, " + name + "!");
    }
}

编译、运行、部署

下面是Rust和Java在编译、运行、部署方面的对比表格，包括命令和代码示例：

步骤	Rust	Rust 示例命令	Java	Java 示例命令
编译	使用 cargo	cargo build	使用 javac 或构建工具	javac Main.java（直接编译）或 mvn compile（Maven）或 gradle build（Gradle）
运行	使用 cargo	cargo run	使用 java 或构建工具	java Main（直接运行）或 mvn exec:java（Maven）或 gradle run（Gradle）
部署	生成可执行文件或使用容器	可执行文件位于 target/release	生成JAR文件或WAR文件，部署到应用服务器或容器	mvn package 生成JAR文件，使用 java -jar 运行，或部署到Tomcat等服务器

Rust 编译、运行、部署示例：

编译

Rust使用Cargo进行编译：

cargo build

为了进行发布构建，使用以下命令：

cargo build --release

运行

使用Cargo运行项目：

cargo run

发布构建后的可执行文件位于 target/release 目录下，可以直接运行：

./target/release/my_rust_project

部署

Rust生成一个单独的可执行文件，可以直接分发和运行。可以将可执行文件拷贝到目标机器或打包为Docker容器。

Java 编译、运行、部署示例：

编译

直接编译Java文件：

javac src/main/java/com/example/Main.java

使用Maven编译：

mvn compile

使用Gradle编译：

gradle build

运行

直接运行Java文件：

java -cp src/main/java com.example.Main

使用Maven运行：

mvn exec:java -Dexec.mainClass="com.example.Main"

使用Gradle运行：

gradle run

部署

生成JAR文件：

mvn package

生成的JAR文件位于 target 目录，可以使用以下命令运行：

java -jar target/my_java_project-1.0-SNAPSHOT.jar

可以将JAR文件或者WAR文件部署到Tomcat等应用服务器。

Rust 项目示例：

src/main.rs 文件：

mod person;
use crate::person::Person;

fn main() {
    let person = Person::new(String::from("Alice"), 30);
    person.greet();
}

src/person.rs 文件：

pub struct Person {
    pub name: String,
    pub age: u32,
}

impl Person {
    pub fn new(name: String, age: u32) -> Person {
        Person { name, age }
    }

    pub fn greet(&self) {
        println!("Hello, {}!", self.name);
    }
}

Java 项目示例：

src/main/java/com/example/Main.java 文件：

package com.example;

import com.example.Person;

public class Main {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30);
        person.greet();
    }
}

src/main/java/com/example/Person.java 文件：

package com.example;

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void greet() {
        System.out.println("Hello, " + name + "!");
    }
}

部署到Docker（Rust示例）：

创建 Dockerfile：

FROM rust:1.54 as builder
WORKDIR /usr/src/myapp
COPY . .
RUN cargo build --release

FROM debian:buster-slim
COPY --from=builder /usr/src/myapp/target/release/my_rust_project /usr/local/bin/my_rust_project
CMD ["my_rust_project"]

构建并运行Docker镜像：

docker build -t my-rust-app .
docker run --rm -it my-rust-app

部署到Docker（Java示例）：

创建 Dockerfile：

FROM openjdk:11
COPY target/my_java_project-1.0-SNAPSHOT.jar /usr/app/
WORKDIR /usr/app
ENTRYPOINT ["java", "-jar", "my_java_project-1.0-SNAPSHOT.jar"]

构建并运行Docker镜像：

docker build -t my-java-app .
docker run --rm -it my-java-app