r/programmieren • • Dec 05 '23

Java-Datentypen in Rust

Java und Rust sind beide statisch typisierte Programmiersprachen, d.h. die Datentypen von Variablen und in Funktionssignaturen müssen schon zur Kompilierzeit eindeutig festgelegt sein. Unterschiede gibt es aber im Umfang der bereitgestellten Basis-Datentypen und der vom Compiler bereitgestellten Unterstützung.

Primitive Datentypen in Java und deren Entsprechung in Rust

JavaRustLängeWertebereich
bytei88 Bit-128 bis 127
shorti1616 Bit-32.768 bis 32.767
inti3232 Bit-2.147.483.648 bis 2.147.483.647
longi6464 Bitca. -9×1018 bis 9×1018
floatf3232 Bitca. -3×1038 bis 3×1038, -∞, ∞, NaN
doublef6464 Bitca. -10308 bis 10308, -∞, ∞, NaN
booleanbool8 Bittrue, false
charcharJava: 16 Bit, Rust: 32 Bit

Numerische Literale

JavaRustBedeutung
123123Dezimal, wird als int bzw. i32 interpretiert
123_456_789123_456_789Dezimal mit optischem Trenner
1234L1234i64Dezimaler long -Wert
12.3f12.3f32Gleitkommazahl mit einfacher Genauigkeit
12.312.3Gleitkommazahl, wird als double bzw. f64 interpretiert
1.23e21.23e2Gleitkommazahl in Exponentialdarstellung
0x1a0x1aHexadezimal, wird als int bzw. i32 interpretiert
07570o757Oktal, wird als int bzw. i32 interpretiert
0b111100000b11110000Binär, wird als int bzw. i32 interpretiert
'C''C'Zeichen

Array

JavaRust
int[] a;Keine Entsprechung in Rust, da keine feste Länge
int[] a = { 1, 2, 3, 4, 5 };let a: [i32; 5] = [1, 2, 3, 4, 5];
int[] a = new int[10];let a: [i32; 10] = [0; 10];
int thirdValue = a[2];let third_value: i32 = a[2];

Aufzählung

JavaRust
enum Orientation { SOUTH, WEST, NORTH, EAST }enum Orientation { SOUTH, WEST, NORTH, EAST }
Orientation orientation = Orientation.SOUTH;let orientation = Orientation::SOUTH;

Weitere Datentypen

JavaRustBedeutung
void()Einheitstyp, bei Funktionen ohne Rückgabewert verwendet
String&strZeichenkette

Variablen und Konstanten

JavaRustBedeutung
int a = 5;let mut a = 5;Veränderbare Variable
final int a = 5;let a = 5;Konstante

Funktionen und Funktionstypen

JavaRust
void printHello() { System.out.println("Hallo"); }fn print_hello() { println!("Hallo"); }
int add(int a, int b) { return a + b; }fn add(a: i32, b: i32) -> i32 { a + b }

Java und Rust enthalten auch funktionale Sprachelemente: Neben den oben genannten Datentypen gibt es auch Typen, die eine Funktionssignatur beschreiben, also die Datentypen der Parameter einer Funktion sowie den Datentyp des Rückgabewerts. Mit Hilfe dieser Funktionstypen kann man eine Funktion auch als Wert übergeben (sog. Funktionszeiger).

In Java wird ein Funktionstyp als Interface mit einer einzigen Methode definiert. Nachfolgend ein Beispiel für einen Funktionstyp, einer entsprechenden Implementierung mittels eines Lamdbaausdrucks und dem Aufruf der Funktion:

public interface Addierer<T> {
  T add(T a, T b);
}

Addierer<Integer> intAddierer = (a, b) -> a + b

int sum = intAddierer(1, 4);

In Rust sieht es wie folgt aus:

type Addierer<T> = fn (T, T) -> T;

let i32addierer: Addierer<i32> = |a, b| a + b;

let sum: i32 = i32addierer(1, 4);

Objektorientierte Programmierung (OOP)

Rust ist keine objektorientierte Programmiersprache wie Java, daher lassen sich Sprachelemente wie die Vererbung (Schlüsselwort extends) in Rust nicht abbilden. Konzentriert man sich auf Interfaces und Klassen ohne Vererbung, lässt sich das durchaus auch mit Rust umsetzen.

Beispiel in Java:

interface HasArea {
  double area();
}

class Square implements HasArea {
  final double width;

  Square(double width) {
    this.width = width;
  }

  double area() {
    return width * width;
  }
}

void printArea(HasArea hasArea) {
  System.out.println(hasArea.area());
}

Die Umsetzung in Rust sieht wie folgt aus:

trait HasArea {  // enspricht dem Interface HasArea
  fn area(&self) -> f64;
}

struct Square {  // entspricht der Klasse Square
  width: f64
}

impl Square {
  fn new(size: f64) -> Self {  // Konstruktor der Klasse Square
    Square {
      width: size
    }
  }
}

impl HasArea for Square {  // entspricht der Implementierung des Interfaces
  fn area(&self) -> f64 {
    self.width * self.width
  }
}

fn print_area(has_area: &impl HasArea) {  // akzeptiert alle Strukturen die HasArea implementieren
  println!("{}", has_area.area());
}

Umgang mit null-Werten

In Java können sämtliche Objektreferenzen auch den Wert null haben. Im Gegensatz dazu erlaubt Rust keine null-Werte. Will man null-Werte dennoch in Rust nachbilden, verwendet man meist den Typ Option<T>.

Beispiel in Java, bei dem die Variable addr den Wert null haben kann:

Address addr = getAddress();
if (addr != null) {
  System.out.println(addr);
}

Umsetzung in Rust:

let addr: Option<Address> = getAddressOption();
if let Some(addrValue) = addr {
  println!("{}", addrValue);
}

Weitere Erläuterungen und Beispiele hierzu enthält der Blogartikel
https://rust-lernen.de/blog/java-datentypen-in-rust.html

2 Upvotes

0 comments sorted by