Rust for Java Developers

15/2/2024
10-minute read

Why Java Developers Should Learn Rust

As Java developers, we’re accustomed to a battle-tested language with robust tooling, extensive libraries, and strong enterprise adoption. However, Rust brings a distinctive approach to systems programming that addresses some of Java’s limitations while maintaining similar safety guarantees.

Rust offers memory safety without garbage collection, fearless concurrency, and C-like performance—all enforced at compile time rather than runtime. For Java developers working on performance-critical systems, exploring Rust can expand your toolset and provide solutions to problems that are challenging to solve efficiently in Java.

Memory Management: From Garbage Collection to Ownership

Java’s automatic memory management frees developers from manual allocation and deallocation concerns, but introduces garbage collection pauses. Rust takes a different approach with its ownership system.

Java’s Approach

class Person {
    private String name;
    
    public Person(String name) {
        this.name = name;
    }
    
    // Java handles memory cleanup automatically
}

public void createPerson() {
    Person person = new Person("Alice");
    // person is eligible for garbage collection when it goes out of scope
}

Rust’s Approach

struct Person {
    name: String,
}

impl Person {
    fn new(name: String) -> Person {
        Person { name }
    }
}

fn create_person() {
    let person = Person::new(String::from("Alice"));
    // person is automatically dropped (deallocated) when it goes out of scope
}

Key Ownership Rules in Rust

Each value has a single owner variable
When the owner goes out of scope, the value is dropped
Ownership can be transferred (moved) but not shared, unless using references

Rust’s borrow checker enforces these rules at compile time, preventing memory leaks and use-after-free errors without runtime overhead.

Concurrency: From Synchronized Blocks to Ownership-Based Safety

Java’s concurrency model relies on locks, monitors, and the JVM’s memory model. Rust’s ownership system naturally extends to provide thread safety.

Java’s Approach

public class Counter {
    private int count = 0;
    
    public synchronized void increment() {
        count++;
    }
    
    public synchronized int getCount() {
        return count;
    }
}

// Using the counter in multiple threads
public void useCounter() {
    Counter counter = new Counter();
    
    Thread t1 = new Thread(() -> {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    });
    
    Thread t2 = new Thread(() -> {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    });
    
    t1.start();
    t2.start();
    
    t1.join();
    t2.join();
    
    System.out.println("Final count: " + counter.getCount());
}

Rust’s Approach

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

struct Counter {
    count: i32,
}

impl Counter {
    fn new() -> Counter {
        Counter { count: 0 }
    }
    
    fn increment(&mut self) {
        self.count += 1;
    }
    
    fn get_count(&self) -> i32 {
        self.count
    }
}

fn use_counter() {
    // Arc (Atomic Reference Counting) provides thread-safe shared ownership
    // Mutex ensures only one thread can access the counter at a time
    let counter = Arc::new(Mutex::new(Counter::new()));
    
    let mut handles = vec![];
    
    for _ in 0..2 {
        let counter_clone = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            for _ in 0..1000 {
                let mut counter = counter_clone.lock().unwrap();
                counter.increment();
            }
        });
        handles.push(handle);
    }
    
    for handle in handles {
        handle.join().unwrap();
    }
    
    println!("Final count: {}", counter.lock().unwrap().get_count());
}

The Rust compiler prevents data races at compile time by ensuring that:

Mutable data is not shared across threads without synchronization
Immutable data can be shared freely
Thread safety errors are caught before running the program

Error Handling: From Exceptions to Result Types

Java uses exceptions for error handling, which are checked at runtime. Rust employs the Result type, making error handling explicit and checked at compile time.

Java’s Approach

public class FileProcessor {
    public String readFile(String path) throws IOException {
        try (BufferedReader reader = new BufferedReader(new FileReader(path))) {
            StringBuilder content = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                content.append(line).append("\n");
            }
            return content.toString();
        }
    }
    
    public void processFile(String path) {
        try {
            String content = readFile(path);
            // Process content
            System.out.println("File processed successfully");
        } catch (IOException e) {
            System.err.println("Error processing file: " + e.getMessage());
        }
    }
}

Rust’s Approach

use std::fs::File;
use std::io::{self, Read};

fn read_file(path: &str) -> Result<String, io::Error> {
    let mut file = File::open(path)?;
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    Ok(content)
}

fn process_file(path: &str) {
    match read_file(path) {
        Ok(content) => {
            // Process content
            println!("File processed successfully");
        },
        Err(error) => {
            eprintln!("Error processing file: {}", error);
        }
    }
    
    // Alternative using the ? operator
    fn process_file_propagate(path: &str) -> Result<(), io::Error> {
        let content = read_file(path)?;
        // Process content
        println!("File processed successfully");
        Ok(())
    }
}

Rust’s approach offers several benefits:

Error handling is explicit in function signatures
The compiler ensures you handle all error cases
The ? operator provides concise error propagation similar to exceptions
Error types can be composed and transformed through the type system

Object-Oriented vs. Trait-Based Design

Java embraces traditional object-oriented programming with classes and inheritance. Rust provides a different paradigm based on traits, enabling composition over inheritance.

Java’s Class Hierarchy

abstract class Shape {
    abstract double area();
    abstract double perimeter();
}

class Rectangle extends Shape {
    private final double width;
    private final double height;
    
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    
    @Override
    double area() {
        return width * height;
    }
    
    @Override
    double perimeter() {
        return 2 * (width + height);
    }
}

class Circle extends Shape {
    private final double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    double area() {
        return Math.PI * radius * radius;
    }
    
    @Override
    double perimeter() {
        return 2 * Math.PI * radius;
    }
}

Rust’s Trait Implementation

trait Shape {
    fn area(&self) -> f64;
    fn perimeter(&self) -> f64;
}

struct Rectangle {
    width: f64,
    height: f64,
}

impl Shape for Rectangle {
    fn area(&self) -> f64 {
        self.width * self.height
    }
    
    fn perimeter(&self) -> f64 {
        2.0 * (self.width + self.height)
    }
}

struct Circle {
    radius: f64,
}

impl Shape for Circle {
    fn area(&self) -> f64 {
        std::f64::consts::PI * self.radius * self.radius
    }
    
    fn perimeter(&self) -> f64 {
        2.0 * std::f64::consts::PI * self.radius
    }
}

Key differences:

Rust separates data (structs) from behavior (traits)
Traits can be implemented for any type, even types from other crates
No inheritance hierarchy, favoring composition and trait bounds
Traits enable static dispatch by default, with dynamic dispatch available when needed

Building and Dependencies: From Maven/Gradle to Cargo

Java’s ecosystem relies on tools like Maven and Gradle for dependency management. Rust offers Cargo, which handles dependencies, building, testing, and documentation.

Maven (Java)

<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>my-app</artifactId>
    <version>1.0.0</version>
    
    <dependencies>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>31.1-jre</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

Cargo (Rust)

[package]
name = "my-app"
version = "1.0.0"
edition = "2021"

[dependencies]
serde = "1.0.152"
tokio = { version = "1.25.0", features = ["full"] }

[dev-dependencies]
criterion = "0.4.0"

Common Cargo commands:

cargo new my-project - Create a new project
cargo build - Build the project
cargo run - Build and run the project
cargo test - Run tests
cargo doc - Generate documentation
cargo publish - Publish a library to crates.io

Practical Example: Building a Simple REST API

Let’s implement a basic REST API in both Java and Rust to see the languages side by side in a real-world scenario.

Java Implementation (Spring Boot)

// Application.java
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

// User.java
public class User {
    private Long id;
    private String name;
    private String email;
    
    // Constructor, getters, setters
}

// UserController.java
import org.springframework.web.bind.annotation.*;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

@RestController
@RequestMapping("/users")
public class UserController {
    private final ConcurrentHashMap<Long, User> users = new ConcurrentHashMap<>();
    private final AtomicLong idGenerator = new AtomicLong(1);
    
    @GetMapping
    public List<User> getAllUsers() {
        return new ArrayList<>(users.values());
    }
    
    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        User user = users.get(id);
        if (user == null) {
            throw new UserNotFoundException(id);
        }
        return user;
    }
    
    @PostMapping
    public User createUser(@RequestBody User user) {
        long id = idGenerator.getAndIncrement();
        user.setId(id);
        users.put(id, user);
        return user;
    }
    
    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User updatedUser) {
        if (!users.containsKey(id)) {
            throw new UserNotFoundException(id);
        }
        updatedUser.setId(id);
        users.put(id, updatedUser);
        return updatedUser;
    }
    
    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        if (users.remove(id) == null) {
            throw new UserNotFoundException(id);
        }
    }
}

Rust Implementation (Actix-web)

// main.rs
use actix_web::{web, App, HttpServer, Responder, HttpResponse};
use serde::{Deserialize, Serialize};
use std::sync::{Mutex, Arc};
use std::collections::HashMap;

#[derive(Debug, Serialize, Deserialize, Clone)]
struct User {
    id: Option<u64>,
    name: String,
    email: String,
}

struct AppState {
    users: Mutex<HashMap<u64, User>>,
    next_id: Mutex<u64>,
}

async fn get_all_users(data: web::Data<Arc<AppState>>) -> impl Responder {
    let users = data.users.lock().unwrap();
    let user_list: Vec<User> = users.values().cloned().collect();
    HttpResponse::Ok().json(user_list)
}

async fn get_user_by_id(
    path: web::Path<u64>,
    data: web::Data<Arc<AppState>>
) -> impl Responder {
    let user_id = path.into_inner();
    let users = data.users.lock().unwrap();
    
    match users.get(&user_id) {
        Some(user) => HttpResponse::Ok().json(user.clone()),
        None => HttpResponse::NotFound().body(format!("User with ID {} not found", user_id))
    }
}

async fn create_user(
    user: web::Json<User>,
    data: web::Data<Arc<AppState>>
) -> impl Responder {
    let mut new_user = user.into_inner();
    let mut next_id = data.next_id.lock().unwrap();
    let user_id = *next_id;
    *next_id += 1;
    
    new_user.id = Some(user_id);
    
    let mut users = data.users.lock().unwrap();
    users.insert(user_id, new_user.clone());
    
    HttpResponse::Created().json(new_user)
}

async fn update_user(
    path: web::Path<u64>,
    user: web::Json<User>,
    data: web::Data<Arc<AppState>>
) -> impl Responder {
    let user_id = path.into_inner();
    let mut updated_user = user.into_inner();
    updated_user.id = Some(user_id);
    
    let mut users = data.users.lock().unwrap();
    
    if !users.contains_key(&user_id) {
        return HttpResponse::NotFound().body(format!("User with ID {} not found", user_id));
    }
    
    users.insert(user_id, updated_user.clone());
    HttpResponse::Ok().json(updated_user)
}

async fn delete_user(
    path: web::Path<u64>,
    data: web::Data<Arc<AppState>>
) -> impl Responder {
    let user_id = path.into_inner();
    let mut users = data.users.lock().unwrap();
    
    if users.remove(&user_id).is_none() {
        return HttpResponse::NotFound().body(format!("User with ID {} not found", user_id));
    }
    
    HttpResponse::NoContent().finish()
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let app_state = Arc::new(AppState {
        users: Mutex::new(HashMap::new()),
        next_id: Mutex::new(1),
    });
    
    HttpServer::new(move || {
        App::new()
            .app_data(web::Data::new(app_state.clone()))
            .route("/users", web::get().to(get_all_users))
            .route("/users", web::post().to(create_user))
            .route("/users/{id}", web::get().to(get_user_by_id))
            .route("/users/{id}", web::put().to(update_user))
            .route("/users/{id}", web::delete().to(delete_user))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

Observations:

Rust requires explicit handling of shared state through Arc<Mutex<>> for thread safety
Java’s controller annotations are similar to Rust’s function routing
Rust enforces explicit error handling in each endpoint
Both solutions use JSON serialization for request/response bodies
Rust’s strong type system reduces runtime errors but requires more explicit type handling

Making the Transition: Practical Tips

Start with Rust’s Core Concepts

Ownership and Borrowing: Master these fundamentals before diving into complex applications
Type System: Understand how Rust’s static typing differs from Java’s approach
Error Handling: Practice using Result and Option types effectively

Leverage Your Java Experience

Java’s interfaces map conceptually to Rust’s traits
Collections in both languages have similar operations but different implementations
Threading concepts are applicable, though Rust enforces safety at compile time

Recommended Learning Path

Read “The Rust Programming Language” book (affectionately called “The Book”)
Build small command-line tools to practice core concepts
Implement data structures and algorithms to understand performance characteristics
Gradually introduce concurrency using thread::spawn, then move to higher-level abstractions
Explore async/await for non-blocking I/O operations

When to Use Rust vs. Java

Use Case	Recommended Language	Reason
Enterprise web applications	Java	Mature ecosystem, extensive libraries
Performance-critical systems	Rust	No GC pauses, predictable performance
Systems programming	Rust	Memory safety without runtime overhead
Desktop applications	Either	Java (JavaFX) for UI-heavy apps, Rust for performance-sensitive apps
Microservices	Either	Java for ease of development, Rust for resource efficiency
Embedded systems	Rust	No runtime or GC, fine-grained control
Developer tooling	Rust	Fast compilation, cross-platform binaries

Conclusion

For Java developers, Rust offers a compelling complement to your existing skillset. While the learning curve can be steep initially—particularly around ownership and borrowing—the benefits in performance, memory safety, and concurrency make it worthwhile.

The key is to approach Rust not as a replacement for Java, but as an additional tool that excels in different domains. By understanding both languages, you can choose the right one for each project based on its specific requirements and constraints.

Start small, leverage your existing programming knowledge, and gradually work your way up to more complex Rust applications. Your experience with Java’s strong typing and object-oriented design provides a solid foundation for learning Rust’s innovative approach to systems programming.

rust java programming performance systems-programming

Rust for Java Developers

Why Java Developers Should Learn Rust

Memory Management: From Garbage Collection to Ownership

Java’s Approach

Rust’s Approach

Key Ownership Rules in Rust

Concurrency: From Synchronized Blocks to Ownership-Based Safety

Java’s Approach

Rust’s Approach

Error Handling: From Exceptions to Result Types

Java’s Approach

Rust’s Approach

Object-Oriented vs. Trait-Based Design

Java’s Class Hierarchy

Rust’s Trait Implementation

Building and Dependencies: From Maven/Gradle to Cargo

Maven (Java)

Cargo (Rust)

Practical Example: Building a Simple REST API

Java Implementation (Spring Boot)

Rust Implementation (Actix-web)

Making the Transition: Practical Tips

Start with Rust’s Core Concepts

Leverage Your Java Experience

Recommended Learning Path

When to Use Rust vs. Java

Further Reading

Conclusion