Java 개발자를 위한 Rust 정리

1public class Main {
2    public static void main(String[] args) {
3        // Java: 기본적으로 가변
4        int count = 0;
5        count = 5;           // 재할당 가능
6        final int MAX = 100; // 상수 (Rust const)
7        // MAX = 200;        // 컴파일 에러
8        var name = "Clean Code"; // 타입 추론 (Java 10+)
9        System.out.println(count + " " + MAX + " " + name);
10    }
11}

 1fn main() {
 2    let count = 0i32;
 3    // count = 5; // E0384
 4    let mut count2 = 0i32;
 5    count2 = 5;
 6    const MAX: u32 = 100;
 7    let name = "Clean Code";
 8    println!("{} {} {} {}", count, count2, MAX, name);
 9}
10

 1public class Main {
 2    public static void main(String[] args) {
 3        boolean b = true;
 4        int    i = 42;           // 32bit
 5        long   l = 9999999999L;  // 64bit
 6        double d = 3.14;         // 64bit
 7        char   c = 'A';          // UTF-16 2B
 8        String s = "hello";      // 힙 객체
 9        int    x = (int) 3.9;    // 캐스트→3
10        System.out.println(
11            b + " " + i + " " + l
12            + " " + d + " " + c
13            + " " + s + " " + x);
14    }
15}

 1fn main() {
 2    let b: bool = true;
 3    let i: i32  = 42;
 4    let l: i64  = 9999999999;
 5    let d: f64  = 3.14;
 6    let c: char = 'A';
 7    let s: &str = "hello";
 8    let x = 3.9f64 as i32;
 9    println!("{} {} {} {} {} {} {}", b, i, l, d, c, s, x);
10}
11

 1// 반환 타입이 앞에
 2static int add(int a, int b) {
 3    return a + b;
 4}
 5static void greet(String name) {
 6    System.out.println("Hello, " + name);
 7}
 8public static void main(String[] args) {
 9    int r = add(2, 3);
10    greet("Rust");
11    System.out.println(r); // 5
12}

1fn add(a: i32, b: i32) -> i32 { a + b }
2fn greet(name: &str) { println!("Hello, {}", name); }
3fn main() {
4    let r = add(2, 3);
5    greet("Rust");
6    println!("{}", r);
7}
8

 1public class Main {
 2    public static void main(String[] args) {
 3        int score = 85;
 4        // if는 문장 — 값 반환 불가
 5        if (score >= 90) System.out.println("A");
 6        else if (score >= 80) System.out.println("B");
 7        else System.out.println("C");
 8
 9        // switch expression (Java 14+)
10        String grade = switch (score / 10) {
11            case 10, 9 -> "A";
12            case 8     -> "B";
13            case 7     -> "C";
14            default    -> "F";
15        };
16        System.out.println(grade); // B
17
18        // for-each
19        int[] nums = {1, 2, 3};
20        for (int n : nums) System.out.println(n);
21    }
22}

 1fn main() {
 2    let score = 85i32;
 3
 4    // if는 표현식 — 값을 변수에 대입 가능
 5    // Java: if는 문장, 값 반환 불가
 6    let grade = if score >= 90 {
 7        "A"
 8    } else if score >= 80 {
 9        "B"
10    } else {
11        "C"
12    };
13    println!("{}", grade); // "B"
14
15    // for in — 이터레이터 기반
16    let nums = [1i32, 2, 3];
17    for n in &nums {
18        println!("{}", n);
19    }
20
21    // while
22    let mut i = 0i32;
23    while i < 3 {
24        i += 1;
25    }
26
27    // loop — 값 반환 가능 (Java에 없음)
28    let mut j = 0i32;
29    let result = loop {
30        j += 1;
31        if j >= 3 { break j * 10; }
32    };
33    println!("i={}, j={}, loop결과={}", i, j, result);
34}
35

 1public class Main {
 2    public static void main(String[] args) {
 3        // while
 4        int n = 0;
 5        while (n < 3) {
 6            System.out.print(n + " ");
 7            n++;
 8        }
 9        System.out.println();
10
11        // do-while (Rust에 없음 → loop로 대체)
12        int count = 0;
13        do { count++; } while (count < 5);
14        System.out.println("count: " + count);
15
16        // for (index) — Rust: for i in 0..5
17        for (int i = 0; i < 5; i++) {
18            System.out.print(i + " ");
19        }
20        System.out.println();
21
22        // for-each — Rust: for x in &list
23        String[] names = { "Simba", "Donald", "Nagini"};
24        for (String name : names) {
25            System.out.println("Animal: " + name);
26        }
27
28        // labeled break (Rust도 지원)
29        outer:
30        for (int x = 0; x < 3; x++) {
31            for (int y = 0; y < 3; y++) {
32                if (x == 1 && y == 1) break outer;
33                System.out.print(
34                    "(" + x + "," + y + ") ");
35            }
36        }
37        System.out.println();
38        // Java loop는 값 반환 불가
39        // Rust: let x = loop { break 42; };
40    }
41}
42

 1fn main() {
 2    // ─── loop — 무한 루프 + 값 반환 ──────────────
 3    let mut count = 0u32;
 4    let result = loop {
 5        count += 1;
 6        if count == 5 { break count * 2; } // break로 값 반환!
 7        // Java: while(true) + return/변수 → Rust만의 기능
 8    };
 9    println!("loop 결과: {}", result); // 10
10
11    // ─── while ────────────────────────────────────
12    let mut n = 0u32;
13    while n < 3 {
14        print!("{} ", n); // 0 1 2
15        n += 1;
16    }
17    println!();
18
19    // ─── for in — 이터레이터 기반 ─────────────────
20    for i in 0..5 {        // 0,1,2,3,4
21        print!("{} ", i);
22    }
23    println!();
24
25    for i in 0..=5 {       // 0,1,2,3,4,5 (inclusive)
26        print!("{} ", i);
27    }
28    println!();
29
30    // ─── for in 컬렉션 ────────────────────────────
31    let names = [ "Simba", "Donald", "Nagini"];
32    for name in &names {
33        println!("동물: {}", name);
34    }
35
36    // ─── enumerate — 인덱스 + 값 ──────────────────
37    for (i, name) in names.iter().enumerate() {
38        println!("[{}] {}", i, name);
39    }
40
41    // ─── 중첩 루프 레이블 (Java에도 있음) ──────────
42    'outer: for x in 0..3 {
43        for y in 0..3 {
44            if x == 1 && y == 1 {
45                break 'outer; // 외부 루프 탈출
46            }
47            print!("({},{}) ", x, y);
48        }
49    }
50    println!();
51}
52

 1import java.util.HashSet;
 2import java.util.Objects;
 3// #[derive] 대응 — Java는 직접 구현 or Lombok
 4public class Main {
 5    static class Book {
 6        final String title;
 7        final int pages;
 8        Book(String t, int p) { title=t; pages=p; }
 9
10        // #[derive(Debug)] → toString()
11        // #[derive(Debug)] → toString()
12        @Override
        public String toString() {
13            return "Book{'"
14                + title + "', "
15                + pages + "}";
16        }
17        @Override public boolean equals(Object o) {
18            if (!(o instanceof Book b)) return false;
19            return Objects.equals(title, b.title)
20                && pages == b.pages;
21        }
22        // #[derive(Hash)] → hashCode()
23        @Override public int hashCode() {
24            return Objects.hash(title, pages);
25        }
26    }
27    public static void main(String[] args) {
28        Book b1 =
            new Book("Clean Code", 431);
29        Book b2 = new Book(b1.title, b1.pages);
30        System.out.println(b1);           // toString
31        System.out.println(b1.equals(b2)); // equals
32        HashSet<Book> set =
            new HashSet<>();
33        set.add(b1); // hashCode 필요
34        System.out.println(set.size());    // 1
35        // Java: 직접 구현 or Lombok @Data
36        // Rust: #[derive(Debug, Clone,
        //         PartialEq, Hash)] 한 줄!
37    }
38}
39

 1#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 2struct Book {
 3    title: String,
 4    pages: u32,
 5}
 6impl Book {
 7    fn new(t: &str, p: u32) -> Self {
 8        Book { title: t.to_string(), pages: p }
 9    }
10}
11
12#[derive(Debug, Default)]
13struct Config {
14    timeout: u32,
15    verbose: bool,
16    name:    String,
17}
18
19fn main() {
20    let b1 = Book::new("Clean Code", 431);
21    let b2 = b1.clone();
22    println!("{:?}", b1);
23    println!("{}", b1 == b2); // true
24
25    use std::collections::HashSet;
26    let mut set = HashSet::new();
27    set.insert(b1);
28    println!("set: {}", set.len()); // 1
29
30    let cfg = Config::default();
31    println!("{:?}", cfg);
32}
33

 1public class Main {
 2    private String title;
 3    private int    pages;
 4
 5    public Main(String title, int pages) {
 6        this.title = title;
 7        this.pages = pages;
 8    }
 9    public String summary() {
10        return title + " (" + pages + "p)";
11    }
12    public boolean isLong() { return pages > 400; }
13    public static void main(String[] args) {
14        Main b = new Main("Clean Code", 431);
15        System.out.println(b.summary()); // Clean Code (431p)
16        System.out.println(b.isLong());  // true
17    }
18}

 1// 데이터만 정의
 2struct Book {
 3    title: String,
 4    pages: u32,
 5}
 6// 메서드는 impl 블록에 분리
 7impl Book {
 8    // 연관 함수 (Java 생성자/static)
 9    fn new(title: &str, pages: u32) -> Book {
10        Book { title: title.to_string(), pages }
11    }
12    // 인스턴스 메서드 (&self = Java this)
13    fn summary(&self) -> String {
14        format!("{} ({}p)", self.title, self.pages)
15    }
16    fn is_long(&self) -> bool { self.pages > 400 }
17}
18fn main() {
19    let b = Book::new("Clean Code", 431);
20    println!("{}", b.summary()); // Clean Code (431p)
21    println!("{}", b.is_long());  // true
22}

 1fn min_max(nums: &[i32]) -> (i32, i32) {
 2    let mut mn = nums[0]; let mut mx = nums[0];
 3    for &n in nums {
 4        if n < mn { mn = n; } if n > mx { mx = n; }
 5    }
 6    (mn, mx) // 튜플로 여러 값 반환
 7}
 8fn main() {
 9    let (lo, hi) = min_max(&[3,1,4,1,5]); // 구조 분해
10    println!("min={lo} max={hi}");
11    let pair: (i32, String) = (42, "hi".to_string());
12    println!("{} {}", pair.0, pair.1); // 인덱스 접근
13}

 1fn sum(nums: &[i32]) -> i32 { // &[T] = 슬라이스 뷰
 2    nums.iter().sum()
 3}
 4fn main() {
 5    let v = vec![1, 2, 3, 4, 5];
 6    println!("{}", sum(&v));       // 15
 7    println!("{}", sum(&v[1..4])); // 9
 8    let arr = [10, 20, 30];
 9    println!("{}", sum(&arr));     // 60
10    let s: &[i32] = &v[0..3];
11    println!("{:?}", s);           // [1, 2, 3]
12}

 1public class Main {
 2    static class Person {
 3        public    String name;   // 어디서든
 4        protected int    age;    // 패키지 + 서브클래스
 5                  String dept;   // package-private (기본)
 6        private   String secret; // 이 클래스만
 7        public String getName() { return name; }
 8    }
 9    public static void main(String[] args) {
10        Person p = new Person();
11        p.name = "Simba";
12        System.out.println(p.getName()); // Simba
13    }
14}

 1pub struct Person {
 2    pub name: String,    // 공개
 3        age:  u32,       // private (기본)
 4        secret: String, // private
 5}
 6impl Person {
 7    pub fn name(&self) -> &str { &self.name }
 8    fn helper(&self) { } // private
 9}
10pub(crate) fn internal() {} // crate 내부만
11fn main() {
12    let p = Person {
13        name: "Simba".to_string(),
14        age: 5, secret: "roar".to_string(),
15    };
16    println!("{}", p.name()); // Simba
17}

 1import java.util.*;
 2public class Main {
 3    public static void main(String[] args) {
 4        int[] arr  = {1, 2, 3};
 5        int[] arr2 = new int[5]; // 0으로 초기화
 6        List<Integer> list = new ArrayList<>();
 7        list.add(1); list.add(2);
 8        List<String> names =
 9            List.of("Alice", "Bob"); // 불변
10        int[][] grid = new int[3][3];
11        System.out.println(
12            arr.length + " " + list.size()); // 3 2
13    }
14}

 1fn main() {
 2    let arr  = [1, 2, 3];     // [i32; 3] 고정
 3    let arr2 = [0; 5];         // [0,0,0,0,0]
 4    let mut list: Vec<i32> = Vec::new();
 5    list.push(1); list.push(2);
 6    let names = vec!["Alice", "Bob"]; // 매크로
 7    let grid: Vec<Vec<i32>> =
 8        (0..3).map(|_| vec![0; 3]).collect();
 9    println!("{} {}", arr.len(), list.len()); // 3 2
10    let _ = (arr2, names, grid);
11}

 1public class Main {
 2    public static void main(String[] args) {
 3        String s = "  Hello, Rust!  ";
 4        s.length();             // 16
 5        s.trim();               // "Hello, Rust!"
 6        s.toUpperCase();        // "  HELLO, RUST!  "
 7        s.contains("Rust");    // true
 8        s.replace("Rust","Java");
 9        s.split(",");
10        s.substring(2, 7);     // "Hello"
11        s.indexOf("Rust");     // 9
12        String.valueOf(42);     // "42"
13        Integer.parseInt("42"); // 42
14        System.out.println(s.trim()); // Hello, Rust!
15    }
16}

 1fn main() {
 2    let s = "  Hello, Rust!  ";
 3    println!("{}", s.len());          // 16 (바이트 수)
 4    println!("{}", s.trim());         // Hello, Rust!
 5    println!("{}", s.to_uppercase()); //   HELLO, RUST!  
 6    println!("{}", s.contains("Rust")); // true
 7    let r = s.replace("Rust", "Java");
 8    println!("{}", r); //   Hello, Java!  
 9    let parts: Vec<_> = s.split(',').collect();
10    println!("{:?}", parts); // ["  Hello", " Rust!  "]
11    println!("{}", &s[2..7]);  // Hello (슬라이스)
12    println!("{:?}", s.find("Rust")); // Some(9)
13    println!("{}", 42.to_string());  // 42
14    let n: i32 = "42".parse().unwrap();
15    println!("{}", n);  // 42
16}

 1import java.util.Optional;
 2public class Main {
 3    public static void main(String[] args) {
 4        Optional<String> name =
 5            Optional.of("Simba");
 6        // ifPresent = if let Some()
 7        name.ifPresent(n ->
 8            System.out.println("Name: " + n));
 9        // ifPresentOrElse = if let ... else
10        name.ifPresentOrElse(
11            n -> System.out.println(n),
12            () -> System.out.println("none"));
13        // while let 대응: 없음 (Iterator로 대체)
14        Optional<Integer> val =
15            Optional.of(3);
16        while (val.isPresent()) {
17            System.out.println(val.get());
18            val = Optional.empty();
19        }
20    }
21}

 1fn main() {
 2    let name: Option<String> =
 3        Some("Simba".to_string());
 4    // if let — Some일 때만 실행
 5    if let Some(n) = &name {
 6        println!("이름: {}", n); // Simba
 7    }
 8    // if let ... else
 9    if let Some(n) = &name {
10        println!("{}", n);
11    } else {
12        println!("없음");
13    }
14    // while let — None이 될 때까지 반복
15    let mut stack = vec![1, 2, 3];
16    while let Some(top) = stack.pop() {
17        println!("{}", top); // 3, 2, 1
18    }
19}
20

 1public class Main {
 2    public static void main(String[] args) {
 3        int day = 3;
 4        String name = switch (day) {
 5            case 1 -> "Mon";
 6            case 2 -> "Tue";
 7            case 3 -> "Wed";
 8            default -> "Other"; // 생략 가능 → 런타임 버그 위험
 9        };
10        System.out.println(name); // 수
11    }
12}

 1fn main() {
 2    let day = 3u32;
 3    let name = match day {
 4        1 => "월",
 5        2 => "화",
 6        3 => "수",
 7        _ => "기타", // 누락 시 컴파일 에러
 8    };
 9    println!("{}", name); // 수
10}

 1import java.io.*;
 2import java.nio.file.*;
 3public class Main {
 4    static String readFile(String path)
 5            throws IOException {
 6        try {
 7            return new String(
 8                Files.readAllBytes(Path.of(path)));
 9        } catch (IOException e) {
10            System.err.println("Error: " + e.getMessage());
11            throw e;
12        } finally {
13            System.out.println("finally: always runs");
14        }
15    }
16    public static void main(String[] args) {
17        try {
18            String content = readFile("test.txt");
19            System.out.println(content);
20        } catch (IOException e) {
21            System.out.println("File not found: " + e.getMessage());
22        }
23    }
24}

 1use std::{fs, io};
 2fn read_file(path: &str)
 3    -> Result<String, io::Error> {
 4    // ? = 에러 즉시 상위로 전파
 5    let content = fs::read_to_string(path)?;
 6    Ok(content)
 7}
 8fn main() {
 9    // 파일이 없으면 Err, 있으면 Ok
10    match read_file("test.txt") {
11        Ok(c)  => println!("{}", c),
12        Err(e) => println!("파일 없음: {}", e),
13    }
14    // finally 대응: Drop (스코프 끝 자동 실행)
15}

 1public class Main {
 2    interface Drawable {
 3        String shape();           // 필수 구현
 4        default void draw() {    // 선택적 오버라이드
 5            System.out.println("Draw: " + shape());
 6        }
 7    }
 8    static class Circle implements Drawable {
 9        public String shape() { return "Circle"; }
10        // draw()는 default 사용
11    }
12    public static void main(String[] args) {
13        Drawable c = new Circle();
14        c.draw(); // 그리기: 원
15    }
16}

 1trait Drawable {
 2    fn shape(&self) -> &str;    // 필수 구현
 3    fn draw(&self) {              // 기본 구현
 4        println!("그리기: {}", self.shape());
 5    }
 6}
 7struct Circle;
 8impl Drawable for Circle {
 9    fn shape(&self) -> &str { "원" }
10    // draw()는 기본 구현 사용
11}
12fn main() {
13    let c = Circle;
14    c.draw(); // 그리기: 원
15}

 1import java.util.Optional;
 2public class Main {
 3    static Optional<String> findUser(int id) {
 4        return id == 42
 5            ? Optional.of("Alice") : Optional.empty();
 6    }
 7    public static void main(String[] args) {
 8        Optional<String> opt = findUser(42);
 9        opt.orElse("unknown");        // default
10        opt.orElseGet(() -> "lazy");  // lazy default
11        opt.orElseThrow();             // throw if empty
12        opt.map(String::toUpperCase)
13           .filter(s -> s.length() > 3)
14           .ifPresent(System.out::println); // ALICE
15    }
16}

 1fn find_user(id: u32) -> Option<String> {
 2    if id == 42 {
 3        Some("Alice".to_string())
 4    } else { None }
 5}
 6fn main() {
 7    let opt = find_user(42);
 8    opt.as_deref()
 9        .unwrap_or("unknown");   // Alice
10    opt.map(|s| s.to_uppercase())
11       .filter(|s| s.len() > 3)
12       .map(|s| println!("{}", s));
13}

 1public class Main {
 2    sealed interface Shape permits Circle, Rect {}
 3    record Circle(double r) implements Shape {}
 4    record Rect(double w, double h) implements Shape {}
 5    static double area(Shape s) {
 6        if (s instanceof Circle c)
 7            return Math.PI * c.r() * c.r();
 8        else if (s instanceof Rect rc)
 9            return rc.w() * rc.h();
10        throw new IllegalArgumentException();
11    }
12    public static void main(String[] args) {
13        System.out.println(area(new Circle(3.0)));
14        System.out.println(area(new Rect(4.0, 5.0)));
15    }
16}

 1enum Shape {
 2    Circle { r: f64 },
 3    Rect   { w: f64, h: f64 },
 4}
 5fn area(s: &Shape) -> f64 {
 6    // match: 완전성 강제, 타입 분해 동시에
 7    match s {
 8        Shape::Circle { r }    => std::f64::consts::PI * r * r,
 9        Shape::Rect   { w, h } => w * h,
10    }
11}
12fn main() {
13    let c = Shape::Circle { r: 3.0 };
14    let r = Shape::Rect { w: 4.0, h: 5.0 };
15    println!("{:.2}", area(&c)); // 28.27
16    println!("{:.2}", area(&r)); // 20.00
17}
18

 1public class Main {
 2    // 1. interface 정의
 3    interface Sound {
 4        String makeSound();
 5        default void loud() {
 6            System.out.println(makeSound().toUpperCase());
 7        }
 8    }
 9    // 2. class에서 implements
10    static class Lion implements Sound {
11        private String name;
12        public Lion(String n) { this.name = n; }
13        public String makeSound() { return "Roar"; }
14    }
15    // 3. 사용
16    public static void main(String[] args) {
17        Sound a = new Lion("Simba"); // 자동 업캐스팅
18        System.out.println(a.makeSound()); // Roar
19    }
20}

 1// 1. trait 정의
 2trait Sound {
 3    fn make_sound(&self) -> String;
 4    fn loud(&self) { // 기본 구현
 5        println!("{}", self.make_sound().to_uppercase());
 6    }
 7}
 8// 2. struct 선언 (데이터)
 9struct Lion { name: String }
10// 3. impl Trait for Type (계약 이행)
11impl Sound for Lion {
12    fn make_sound(&self) -> String {
13        format!("{}: Roar", self.name)
14    }
15}
16fn main() {
17    let a = Lion { name: "Simba".to_string() };
18    println!("{}", a.make_sound()); // Simba: Roar
19    a.loud(); // SIMBA: ROAR
20}

 1import java.util.*;
 2public class Main {
 3    interface Sound { String makeSound(); }
 4    static class Lion implements Sound {
 5        String name; Lion(String n){name=n;}
 6        public String makeSound(){return name+": Roar~";}
 7    }
 8    static class Duck implements Sound {
 9        String name; Duck(String n){name=n;}
10        public String makeSound(){return name+": Quack!";}
11    }
12    public static void main(String[] args) {
13        // Java: 인터페이스 타입으로 쓰면 자동 동적 디스패치
14        Sound a = new Lion("Simba");  // 동적 디스패치
15        Sound b = new Duck("Donald"); // 동적 디스패치
16        System.out.println(a.makeSound()); // vtable 조회
17        // 이종 컬렉션
18        List<Sound> zoo = new ArrayList<>();
19        zoo.add(new Lion("Simba"));
20        zoo.add(new Duck("Donald"));
21        for (Sound s : zoo) System.out.println(s.makeSound());
22    }
23}

 1trait Sound { fn make_sound(&self) -> String; }
 2struct Lion { name: String }
 3struct Duck { name: String }
 4impl Sound for Lion {
 5    fn make_sound(&self) -> String {
 6        format!("{}: 으르렁~", self.name) }
 7}
 8impl Sound for Duck {
 9    fn make_sound(&self) -> String {
10        format!("{}: 꽥꽥!", self.name) }
11}
12fn main() {
13    // &dyn: 참조로 동적 디스패치 (fat pointer)
14    let lion = Lion { name: "Simba".to_string() };
15    let a: &dyn Sound = &lion; // 명시 필수!
16    a.make_sound(); // vtable 조회
17    // 이종 컬렉션 — Box<dyn> 소유
18    let zoo: Vec<Box<dyn Sound>> = vec![
19        Box::new(Lion { name: "Simba".to_string() }),
20        Box::new(Duck { name: "Donald".to_string() }),
21    ];
22    for s in &zoo {
23        println!("{}", s.make_sound());
24    }
25}

 1import java.util.*;
 2public class Main {
 3    interface Sound { String makeSound(); }
 4    static class Lion implements Sound {
 5        final String name; Lion(String n){name=n;}
 6        public String makeSound(){return name+": Roar~";}
 7    }
 8    static class Duck implements Sound {
 9        final String name; Duck(String n){name=n;}
10        public String makeSound(){return name+": Quack!";}
11    }
12    // <T extends Sound> — 컴파일 후 타입 소거
13    static <T extends Sound> void play(T animal) {
14        System.out.println(animal.makeSound());
15    }
16    // 호출 — 런타임에 vtable 조회
17    public static void main(String[] args) {
18        play(new Lion("Simba"));  // play(Sound) 1개만
19        play(new Duck("Donald")); // 같은 바이트코드
20    }
21}

 1trait Sound { fn make_sound(&self) -> String; }
 2struct Lion { name: String }
 3struct Duck { name: String }
 4impl Sound for Lion {
 5    fn make_sound(&self) -> String {
 6        format!("{}: 으르렁~", self.name)
 7    }
 8}
 9impl Sound for Duck {
10    fn make_sound(&self) -> String {
11        format!("{}: 꽥꽥!", self.name)
12    }
13}
14// <T: Sound> — 컴파일 시 타입별 코드 생성
15fn play<T: Sound>(animal: &T) {
16    println!("{}", animal.make_sound());
17}
18// 컴파일러 자동 생성: play__Lion, play__Duck ...
19fn main() {
20    let l = Lion { name: "Simba".to_string() };
21    let d = Duck { name: "Donald".to_string() };
22    play(&l); play(&d);
23}

 1public class Main {
 2    // Java enum: 상수 + 데이터 (필드+생성자 필요)
 3    enum Shape {
 4        CIRCLE, RECT, TRIANGLE;
 5        public boolean hasCorners() {
 6            return this != CIRCLE;
 7        }
 8    }
 9    // Java: 데이터를 담으려면 필드+생성자 필요
10    enum Option2 {
11        SOME, NONE;
12        Object value;  // 타입 불안전!
13    }
14    public static void main(String[] args) {
15        Shape s = Shape.CIRCLE;
16        String msg = switch (s) {
17            case CIRCLE   -> "Circle";
18            case RECT     -> "Rect";
19            case TRIANGLE -> "Triangle";
20        };
21        System.out.println(msg);
22    }
23}

 1enum Shape {
 2    Circle { radius: f64 },
 3    Rect   { w: f64, h: f64 },
 4    Triangle(f64, f64, f64),
 5    Point,
 6}
 7fn area(s: &Shape) -> f64 {
 8    match s {
 9        Shape::Circle { radius } =>
10            std::f64::consts::PI * radius * radius,
11        Shape::Rect { w, h } => w * h,
12        Shape::Triangle(a, b, c) => {
13            let s = (a + b + c) / 2.0;
14            (s*(s-a)*(s-b)*(s-c)).sqrt()
15        }
16        Shape::Point => 0.0,
17    }
18}
19fn main() {
20    let shapes = vec![
21        Shape::Circle { radius: 3.0 },
22        Shape::Rect { w: 4.0, h: 5.0 },
23        Shape::Triangle(3.0, 4.0, 5.0),
24    ];
25    for s in &shapes {
26        println!("{:.2}", area(s));
27    }
28}

 1import java.util.Optional;
 2public class Main {
 3    // Java: null 또는 Optional — 강제 아님
 4    static Optional<Double> divide(double a, double b) {
 5        return b == 0 ? Optional.empty()
 6                       : Optional.of(a / b);
 7    }
 8    public static void main(String[] args) {
 9        divide(10, 3)
10            .ifPresentOrElse(
11                v -> System.out.println(String.format("%.2f", v)),
12                () -> System.out.println("Division error"));
13        // Java: null 직접 반환도 가능 → NullPointerException 위험
14        Double unsafe = null; // 컴파일 OK, 런타임 NPE 위험
15    }
16}

 1// Option: null 없는 Rust의 핵심
 2// enum Option {{ Some(T), None }}
 3fn divide(a: f64, b: f64) -> Option<f64> {
 4    if b == 0.0 { None } else { Some(a / b) }
 5}
 6fn main() {
 7    // 안전한 나눗셈
 8    match divide(10.0, 3.0) {
 9        Some(v) => println!("결과: {:.2}", v),
10        None    => println!("나누기 불가"),
11    }
12    // ? 연산자로 체이닝
13    let result = divide(10.0, 2.0)
14        .map(|v| v * 2.0)
15        .filter(|&v| v > 5.0)
16        .unwrap_or(0.0);
17    println!("체이닝: {}", result); // 10
18}

 1import java.io.*;
 2public class Main {
 3    // Java: checked exception으로 에러 표현
 4    static int parse(String s) throws NumberFormatException {
 5        return Integer.parseInt(s);
 6    }
 7    public static void main(String[] args) {
 8        try {
 9            int n = parse("42");
10            System.out.println(n * 2); // 84
11        } catch (NumberFormatException e) {
12            System.err.println("Error: " + e.getMessage());
13        }
14        // Java: 예외 무시 가능 → 런타임 폭발
15        int risky = Integer.parseInt("abc");
16    }
17}

 1// Result: 에러를 타입으로 표현
 2// enum Result {{ Ok(T), Err(E) }}
 3fn parse_double(s: &str) -> Result<i32, String> {
 4    s.parse::<i32>()
 5        .map_err(|e| format!("파싱 실패: {}", e))
 6        .map(|n| n * 2)
 7}
 8fn main() {
 9    // match로 명시적 처리 — 무시 불가
10    match parse_double("42") {
11        Ok(n)  => println!("결과: {}", n), // 84
12        Err(e) => eprintln!("에러: {}", e),
13    }
14    // ? 연산자: Err이면 즉시 반환
15    let n = parse_double("abc").unwrap_or(0);
16    println!("기본값: {}", n); // 0
17}

 1public class Main {
 2    enum BookStatus { AVAILABLE, BORROWED, LOST;
 3        public boolean isAvailable() { return this == AVAILABLE; }
 4    }
 5    public static void main(String[] args) {
 6        BookStatus s = BookStatus.AVAILABLE;
 7        System.out.println(s.isAvailable()); // true
 8        String msg = switch (s) {
 9            case AVAILABLE -> "Available";
10            case BORROWED  -> "Borrowed";
11            case LOST      -> "Lost";
12        };
13        System.out.println(msg);
14    }
15}

 1enum BookStatus {
 2    Available,
 3    Borrowed { due_date: String },
 4    Lost(String),
 5}
 6
 7fn main() {
 8    let s = BookStatus::Borrowed {
 9        due_date: "2025-01-01".to_string(),
10    };
11    match s {
12        BookStatus::Available => {
13            println!("대출 가능");
14        }
15        BookStatus::Borrowed { due_date } => {
16            println!("반납일: {}", due_date);
17        }
18        BookStatus::Lost(reason) => {
19            println!("분실: {}", reason);
20        }
21    }
22}
23

 1import java.util.Optional;
 2class Main {
 3    static class Book {
 4        String title; Book(String t) { title = t; }
 5    }
 6    static Optional<Book> findBook(String t) {
 7        return "Clean Code".equals(t)
 8            ? Optional.of(new Book(t))
 9            : Optional.empty();
10    }
11    public static void main(String[] args) {
12        findBook("Clean Code").ifPresent(
              b -> System.out.println(b.title));
13        Book b = findBook("Unknown").orElseGet(
              () -> new Book("Default"));
14        System.out.println(b.title);
15        String t = findBook("Unknown").map(
              bk -> bk.title).orElse("none");
16        System.out.println(t);
17        System.out.println(
              findBook("Clean Code").isPresent());
18        System.out.println(
              findBook("Unknown").isEmpty());
19    }
20}

 1struct Book {
 2    title: String,
 3}
 4impl Book {
 5    fn new(t: &str) -> Self {
 6        Book { title: t.to_string() }
 7    }
 8}
 9
10fn find(t: &str) -> Option<Book> {
11    if t == "Clean Code" {
12        Some(Book::new(t))
13    } else {
14        None
15    }
16}
17
18fn main() {
19    // 1. match
20    match find("Clean Code") {
21        Some(b) => println!("match: {}", b.title),
22        None    => println!("없음"),
23    }
24
25    // 2. if let
26    if let Some(b) = find("Clean Code") {
27        println!("if let: {}", b.title);
28    }
29
30    // 3. unwrap (None → panic)
31    let b = find("Clean Code").unwrap();
32    println!("unwrap: {}", b.title);
33
34    // 4. unwrap_or_else
35    let title = find("없는책")
36        .map(|b| b.title)
37        .unwrap_or_else(|| "기본값".to_string());
38    println!("unwrap_or: {}", title);
39
40    // 5. map
41    let len: Option<usize> = find("Clean Code")
42        .map(|b| b.title.len());
43    println!("map: {:?}", len); // Some(10)
44
45    // 6. is_some / is_none
46    println!("{}", find("Clean Code").is_some());
47    println!("{}", find("없는책").is_none());
48}
49

 1import java.io.*;
 2import java.nio.file.*;
 3public class Main {
 4    static String readFile(String path)
 5            throws IOException {
 6        return Files.readString(Path.of(path));
 7    }
 8    static int divide(int a, int b) {
 9        if (b == 0)
10            throw new ArithmeticException("Division by zero");
11        return a / b;
12    }
13    public static void main(String[] args) {
14        try {
15            String s = readFile("book.txt");
16            System.out.println(s);
17        } catch (IOException e) {
18            System.err.println("Error: " + e.getMessage());
19        } finally {
20            System.out.println("always runs");
21        }
22    }
23}

 1use std::num::ParseIntError;
 2use std::fmt;
 3
 4// 커스텀 에러 타입
 5#[derive(Debug)]
 6enum AppError {
 7    Parse(ParseIntError),
 8    NegativeNumber(i32),
 9}
10impl fmt::Display for AppError {
11    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
12        match self {
13            AppError::Parse(e)  =>
                  write!(f, "Parse error: {}", e),
14            AppError::NegativeNumber(n) =>
15                write!(f, "Negative: {}", n),
16        }
17    }
18}
19impl From<ParseIntError> for AppError {
20    fn from(e: ParseIntError) -> Self { AppError::Parse(e) }
21}
22
23// ? 연산자 — Err이면 즉시 반환
24fn parse_positive(s: &str) -> Result<u32, AppError> {
25    let n: i32 = s.parse()?; // ParseIntError → AppError::Parse
26    if n < 0 {
27        return Err(AppError::NegativeNumber(n));
28    }
29    Ok(n as u32)
30}
31
32fn main() {
33    // match로 명시적 처리
34    match parse_positive("42") {
35        Ok(n)  => println!("OK: {}", n),
36        Err(e) => println!("Error: {}", e),
37    }
38
39    // unwrap_or_else
40    let n = parse_positive("abc")
41        .unwrap_or_else(|e| {
42            println!("Recover: {}", e);
43            0u32
44        });
45    println!("Recovered: {}", n);
46
47    // map + and_then 체이닝
48    let doubled = parse_positive("5")
49        .map(|n| n * 2);
50    println!("doubled: {:?}", doubled); // Ok(10)
51
52    // 에러 변환
53    let result = parse_positive("-3");
54    println!("{:?}", result); // Err(NegativeNumber(-3))
55    println!("is_ok: {}", result.is_ok());
56    println!("is_err: {}", result.is_err());
57}
58

 1public class Main {
 2    public static void main(String[] args) {
 3        // Java 10+: var — 지역변수만, 필드/매개변수 불가
 4        var x = 42;                  // int 추론
 5        var list = new java.util.ArrayList<String>();
 6        // Java: 타입별 메서드 이름으로 해결
 7        int n = Integer.parseInt("42");
 8        double d = Double.parseDouble("3.14");
 9        // Java에는 turbofish 없음 — 제네릭 메서드 명시
10        java.util.Collections.<String>emptyList();
11        System.out.println(n + " " + d);
12    }
13}

 1use std::collections::HashMap;
 2fn main() {
 3    // 기본 추론 — 컴파일러가 타입 결정
 4    let x = 42;           // i32 기본
 5    let x = 42u8;         // suffix로 명시
 6    let x: u8 = 42;      // 어노테이션으로 명시
 7    // _ placeholder — 일부만 명시
 8    let v: Vec<_> = (0..).take(5)
 9        .map(|n| n * 2).collect();
10    // turbofish ::<> — 추론 불가할 때 타입 명시
11    let n = "42".parse::<i32>().unwrap();
12    let v = (0..).take(5).collect::<Vec<i32>>();
13    let sz = std::mem::size_of::<String>(); // 반드시 turbofish
14    // 지연 추론 — 나중에 확정
15    let mut map = HashMap::new(); // 타입 미확정
16    map.insert("key", 42i32); // HashMap<&str,i32> 확정
17    println!("{} {} {:?}", n, sz, v);
18}

 1public class Main {
 2    public static void main(String[] args) {
 3        // Java: 명시적 캐스팅 (데이터 손실 가능)
 4        double d = 3.99;
 5        int n = (int) d;      // 3 (소수점 버림)
 6        long l = n;            // 암묵적 확장
 7        // 문자열 변환
 8        String s = String.valueOf(42);
 9        int i = Integer.parseInt("42");
10        // 실패 가능 변환
11        try {
12            int x = Integer.parseInt("abc");
13        } catch (NumberFormatException e) {
14            System.out.println("failed");
15        }
16        System.out.println(n + " " + s + " " + i);
17    }
18}

 1use std::convert::TryFrom;
 2fn main() -> Result<(), Box<dyn std::error::Error>> {
 3    // as — 명시적 캐스팅 (항상 성공, 손실 가능)
 4    let d: f64 = 3.99;
 5    let n = d as i32;          // 3 (소수점 버림)
 6    let l = n as i64;          // 확장
 7    let b = 200u32 as u8;  // 200 (wrap)
 8    // From / Into — 안전한 변환
 9    let _s = String::from("hello");
10    let _s: String = "hello".into();
11    let _n = i64::from(42i32);
12    // TryFrom — 실패 가능 변환
13    let ok  = i8::try_from(100i32);
14    let err = i8::try_from(300i32);
15    // 문자열 변환
16    let _s = 42.to_string();
17    let m: i32 = "42".parse()?;
18    println!("{} {} {} {:?} {:?}", n, l, b, ok, err);
19    println!("parse: {}", m);
20    Ok(())
21}

 1public class Main {
 2    public static void main(String[] args) {
 3        // Java: 원시 타입 8개 + 박싱
 4        byte   b = 127;       // 8bit
 5        short  s = 32767;     // 16bit
 6        int    i = 2_147_483_647; // 32bit
 7        long   l = 9_999_999_999L; // 64bit L필수
 8        float  f = 3.14f;     // 32bit f필수
 9        double d = 3.14;      // 64bit 기본
10        // Java: int/Integer 박싱 구분
11        Integer boxed = 42; // 자동 박싱 → 힙
12        int unboxed = boxed;  // 자동 언박싱
13        // 오버플로: 조용히 wrap
14        int overflow = Integer.MAX_VALUE + 1; // -2147483648
15        System.out.println(overflow);
16    }
17}

 1fn main() {
 2    // Rust: 부호있는 정수 i8~i128, 없는 u8~u128
 3    let b: i8   = 127;         // 8bit  -128..127
 4    let s: i16  = 32_767;      // 16bit
 5    let i: i32  = 2_147_483_647; // 32bit 기본
 6    let l: i64  = 9_999_999_999; // 64bit
 7    let u: usize = 42;         // 포인터 크기
 8    let f: f32  = 3.14f32;     // suffix 필수
 9    let d: f64  = 3.14;        // 64bit 기본
10    // 박싱 없음 — int/Integer 구분 없음
11    let x: i32 = 42;           // 항상 스택값
12    // 오버플로: debug=panic, release=wrap
13    // 명시적 처리
14    let wrapped = i32::MAX.wrapping_add(1); // -2147483648
15    let checked = i32::MAX.checked_add(1); // None
16    println!("{} {:?}", wrapped, checked);
17}

 1class Main {
 2    public static void main(String[] args) {
 3        // Java: String은 힙, 불변
 4        String title = "Clean Code";
 5        System.out.println(title.length()); // 10
 6        // 가변 문자열
 7        StringBuilder sb = new StringBuilder("Clean");
 8        sb.append(" Code");
 9        System.out.println(sb);       // Clean Code
10        System.out.println(sb.length()); // 10
11    }
12}

1fn main() {
2    let slice: &str = "Clean Code";
3    let mut owned: String = String::from("Clean");
4    owned.push_str(" Code");
5    let r: &str = &owned;
6    println!("{} {} {}", slice, owned, r);
7}
8

 1// Java switch — default 없어도 컴파일됨
 2int pages = 450;
 3switch (pages / 100) {
 4    case 0: System.out.println("Thin");   break;
 5    case 1:
 6    case 2: System.out.println("Normal");   break;
 7    case 3:
 8    case 4: System.out.println("Thick"); break;
 9    // default 없음 → 컴파일 OK, 버그 위험!
10}
11// Java 14+ switch expression
12String size = switch (pages / 100) {
13    case 0     -> "Thin";
14    case 1, 2  -> "Normal";
15    case 3, 4  -> "Thick";
16    default    -> "Very Thick"; // default 필수
17};
18System.out.println(size); // 두꺼움
19// OR 패턴
20String day = "Sat";
21String kind = switch (day) {
22    case "Sat", "Sun" -> "Weekend";
23    default           -> "Weekday";
24};
25// if (null check) — Rust if let Some에 대응
26String title = "Clean Code"; // 직접 값 사용
27if (title != null) {
28    System.out.println("Found: " + title);
29}

 1fn main() {
 2    let pages: u32 = 450;
 3    let size = match pages {
 4        0..=100   => "얇음",
 5        101..=300 => "보통",
 6        301..=500 => "두꺼움",
 7        _         => "매우 두꺼움",
 8    };
 9    println!("{}", size);
10    let grade = match 85u32 {
11        90..=100 => "A",
12        80..=89  => "B",
13        70..=79  => "C",
14        _        => "F",
15    };
16    println!("{}", grade);
17    enum Msg { Move { x: i32, y: i32 }, Write(String), Quit }
18    let msg = Msg::Move { x: 10, y: 20 };
19    match msg {
20        Msg::Move { x, y } => println!("Move: ({}, {})", x, y),
21        Msg::Write(t) => println!("Write: {}", t),
22        Msg::Quit  => println!("Quit"),
23    }
24    match 7i32 {
25        x if x < 0       => println!("neg: {}", x),
26        x if x == 0      => println!("zero"),
27        x if x % 2 == 0 => println!("even: {}", x),
28        x               => println!("odd: {}", x),
29    }
30    let kind = match "Sat" {
31        "Sat" | "Sun" => "Weekend",
32        _ => "Weekday",
33    };
34    println!("{}", kind);
35    match (0, -2) {
36        (0, 0)         => println!("origin"),
37        (x, 0) | (0, x) => println!("axis: {}", x),
38        (x, y)         => println!("({}, {})", x, y),
39    }
40    if let Some(v) = Some(42) {
41        println!("val: {}", v);
42    }
43    let mut stack = vec![1i32, 2, 3];
44    while let Some(top) = stack.pop() {
45        println!("pop: {}", top);
46    }
47}

 1public class Main {
 2    static class Book {
 3        String title;
 4        Book(String t) { title = t; }
 5        Book deepCopy() { return new Book(title); }
 6    }
 7    public static void main(String[] args) {
 8        Book a = new Book("Clean Code");
 9        Book b = a;  // 참조 복사 — 같은 객체!
10        b.title = "Modified";
11        // Rust: let b = a; → a 무효 (E0382)
12        System.out.println(a.title); // "Modified"
13
14        // 깊은 복사
15        Book c = a.deepCopy();
16        c.title = "Another";
17        System.out.println(a.title); // "Modified"
18    }
19}

 1struct Book { title: String }
 2impl Book {
 3    fn new(t: &str) -> Self {
 4        Book { title: t.to_string() }
 5    }
 6}
 7
 8// 불변 빌림 — &Book
 9fn read(book: &Book) {
10    println!("{}", book.title);
11    // book.title = "X"; // 컴파일 에러! 수정 불가
12}
13
14// 가변 빌림 — &mut Book
15fn stamp(book: &mut Book) {
16    book.title.push_str(" [도장]");
17}
18
19fn main() {
20    // ── 소유권 이동 ────────────────────────────
21    let a = Book::new("Clean Code");
22    let b = a; // 소유권 이동 (move)
23    // println!("{}", a.title); // E0382: 이미 이동됨!
24    println!("{}", b.title); // OK
25
26    // ── 불변 빌림 ─────────────────────────────
27    let c = Book::new("Refactoring");
28    read(&c); // &c = c를 빌림
29    read(&c); // OK — 여러 번 빌릴 수 있음
30    println!("{}", c.title); // c는 여전히 유효
31
32    // ── 가변 빌림 ─────────────────────────────
33    let mut d = Book::new("SICP");
34    stamp(&mut d);
35    println!("{}", d.title); // "SICP [도장]"
36    // &mut 빌림 중에는 다른 빌림 불가 (안전 보장)
37}
38

 1public class Main {
 2    static class Book implements Cloneable {
 3        String title;
 4        int pages;
 5
 6        Book(String t, int p) {
 7            title = t;
 8            pages = p;
 9        }
10        @Override
11        public Book clone() {
12            try {
13                return (Book) super.clone();
14            } catch (CloneNotSupportedException e) {
15                throw new RuntimeException(e);
16            }
17        }
18        @Override
19        public String toString() {
20            return title + "(" + pages + "p)";
21        }
22    }
23    public static void main(String[] args) {
24        Book b1 = new Book("Clean Code", 431);
25        Book b2 = b1;         // 참조 복사 → 같은 객체
26        Book b3 = b1.clone(); // 깊은 복사 → 새 객체
27        b2.title = "Modified";
28        // b1, b2 같은 객체
29        System.out.println(b1.title); // "Modified"
30        // b3는 별도 객체
31        System.out.println(b3.title); // "Clean Code"
32        // Rust: #[derive(Clone)] 한 줄로 해결
33    }
34}
35

 1#[derive(Debug, Clone)]
 2struct Book {
 3    title: String,
 4    pages: u32,
 5}
 6
 7#[derive(Debug, Clone, Copy)]
 8struct Point {
 9    x: i32,
10    y: i32,
11}
12
13fn main() {
14    // Clone — 명시적 깊은 복사
15    let b1 = Book {
16        title: "Clean Code".to_string(),
17        pages: 431,
18    };
19    let b2 = b1.clone(); // 힙 데이터 복사
20    println!("{:?}", b1); // b1 여전히 유효
21    println!("{:?}", b2);
22
23    // Copy — 자동 비트 복사
24    let p1 = Point { x: 1, y: 2 };
25    let p2 = p1; // Copy → p1도 유효!
26    println!("{:?}", p1); // OK
27    println!("{:?}", p2);
28
29    // String은 Copy 불가 (힙 소유)
30    // let s1 = String::from("hello");
31    // let s2 = s1; // move → s1 무효
32}
33

 1import java.util.*;
 2public class Main {
 3    // Java: 참조로 전달하면 내부 수정 가능
 4    // 불변/가변 구분 없음 (final은 재할당만 막음)
 5    static void addItem(List<String> list) {
 6        list.add("new item"); // 수정 OK — 컴파일러 무관
 7    }
 8    static void readOnly(final List<String> list) {
 9        list.add("item"); // final이어도 내부 수정 가능!
10        // list = new ArrayList<>(); // 이것만 에러
11    }
12    public static void main(String[] args) {
13        List<String> v = new ArrayList<>();
14        v.add("a");
15        addItem(v);
16        System.out.println(v); // [a, new item]
17    }
18}

 1// &mut: 수정 허용, &: 읽기만
 2fn add_item(list: &mut Vec<String>) {
 3    list.push("new item".to_string());
 4}
 5fn read_only(list: &Vec<String>) {
 6    // list.push(...); // 컴파일 에러! &는 수정 불가
 7    println!("{:?}", list);
 8}
 9fn main() {
10    let mut v = vec!["a".to_string()];
11    add_item(&mut v); // &mut 명시 필요
12    read_only(&v);    // &만으로 읽기
13}

 1public class Main {
 2    static class Book {
 3        String title;
 4        int pages;
 5        Book(String t, int p) {
 6            title = t;
 7            pages = p;
 8        }
 9        @Override
10        public String toString() {
11            return "'" + title
12                + "' (" + pages + "p)";
13        }
14    }
15    public static void main(String[] args) {
16        // 기본 타입 → 스택 (값 직접 저장)
17        int     x = 42;    // 스택: 4B
18        boolean b = true;  // 스택: 1B
19
20        // 객체 → 항상 힙 (언어 차원 선택 불가)
21        Book book = new Book("Clean Code", 431);
22        // Object Header(12~16B)
23        // + title(ref 8B)
24        // + pages(int 4B)
25
26        System.out.println("Stack: " + x + ", " + b);
27        System.out.println("Heap(always): " + book);
28        // Rust: struct Book → 스택 (기본)
29        // Rust: Box::new(Book{..}) → 힙 (명시)
30    }
31}
32

 1#[derive(Debug)]
 2struct Book {
 3    title: String,
 4    pages: u32,
 5}
 6impl Book {
 7    fn new(t: &str, p: u32) -> Self {
 8        Book {
 9            title: t.to_string(),
10            pages: p,
11        }
12    }
13}
14
15trait Printable {
16    fn print_info(&self);
17}
18impl Printable for Book {
19    fn print_info(&self) {
20        println!(
21            "'{}' ({}p)",
22            self.title,
23            self.pages,
24        );
25    }
26}
27
28fn main() {
29    // 스택에 직접 (기본)
30    let book = Book::new("Clean Code", 431);
31    println!("스택: {:?}", book);
32
33    // Box::new() → 힙에 명시적 할당
34    let boxed = Box::new(
35        Book::new("Refactoring", 448)
36    );
37    println!("힙: {:?}", boxed);
38    boxed.print_info(); // 자동 역참조
39
40    // Box<dyn Trait> — 동적 디스패치
41    let d: Box<dyn Printable> = Box::new(
42        Book::new("SICP", 657)
43    );
44    d.print_info();
45
46    println!(
47        "Box 포인터: {}B, Book 직접: {}B",
48        std::mem::size_of::<Box<Book>>(),
49        std::mem::size_of::<Book>(),
50    );
51    // 스코프 끝 → 자동 Drop
52}
53

 1import java.util.*;
 2public class Main {
 3    public static void main(String[] args) {
 4        // Java: GC가 알아서 공유 관리
 5        String lion = "Simba";
 6        List<String> zoo1 = new ArrayList<>();
 7        List<String> zoo2 = new ArrayList<>();
 8        zoo1.add(lion);  // 두 리스트가 같은 객체 참조
 9        zoo2.add(lion);  // GC가 수명 관리
10        System.out.println(zoo1.get(0)); // Simba
11    }
12}

 1use std::rc::Rc;
 2fn main() {
 3    let lion = Rc::new("Simba");
 4    let zoo1 = Rc::clone(&lion); // 참조 카운트 +1
 5    let zoo2 = Rc::clone(&lion); // 참조 카운트 +1
 6    // 카운트 = 3. 모두 drop 되면 해제.
 7    println!("{} refs", Rc::strong_count(&lion)); // 3
 8} // 스코프 끝 → 카운트 0 → Drop

 1import java.util.function.*;
 2public static void main(String[] args) {
 3    Function<Integer, Integer> doubler = x -> x * 2;
 4    Function<Integer, Integer> addOne  = x -> x + 1;
 5    System.out.println(doubler.apply(5)); // 10
 6    System.out.println(addOne.apply(5));  // 6
 7
 8    Predicate<String> isLong = s -> s.length() > 5;
 9    System.out.println(isLong.test("Rust")); // false
10
11    BiFunction<Integer, Integer, Integer> add =
12        (a, b) -> a + b;
13    System.out.println(add.apply(3, 4)); // 7
14
15    // 캡처 (effectively final만 가능)
16    String prefix = "Book: ";
17    Function<String, String> label = t -> prefix + t;
18    System.out.println(label.apply("Clean Code"));
19    // prefix = "X"; // 에러
20}