float[]

Primitiv

Speichert 32-Bit Gleitkommazahlen. Halb so groß wie double[], aber mit geringerer Präzision — ideal für Grafik und große Datensätze.

Standardwert:0.0f

Größe:32 Bit

Minimum:±1.4 × 10⁻⁴⁵

Maximum:±3.4 × 10³⁸

Visualisierung

float[]— 5 Elemente

1.5

[0]

3.14

[1]

-0.25

[2]

100

[3]

0.001

[4]

Länge:5

Letzter Index:4

Standardwert:0.0f

Bits/Element:32 Bit

Deklaration

So reservierst du Speicher für einen float[].

// Deklaration (Standardwerte: 0.0f)
float[] koordinaten = new float[3];

// Grafik-typisch: Vertex-Koordinaten
float[] vertices = new float[9]; // 3 Dreiecks-Eckpunkte (x,y,z)

Initialisierung

Verschiedene Wege, ein float[] mit Werten zu befüllen.

// Initialisierung – 'f' Suffix PFLICHT!
float[] werte = {1.5f, 3.14f, -0.25f, 100.0f, 0.001f};

// Ohne f → double-Literal → Kompilierfehler!
// float x = 3.14;             // FEHLER: possible lossy conversion
float y = 3.14f;               // korrekt
float z = (float) 3.14;        // auch möglich (Cast)

// 3D-Vertex-Daten für OpenGL
float[] vertex = {0.0f, 1.0f, 0.0f,   // oben
                  -1.0f, -1.0f, 0.0f,  // unten-links
                  1.0f, -1.0f, 0.0f};  // unten-rechts

Typische Operationen

Zugriff, Änderung, Iteration und häufige Patterns mit float[].

float[] arr = {1.5f, 3.14f, -0.25f, 100.0f, 0.001f};

// Zugriff
float pi = arr[1];             // 3.14f

// Achtung: noch weniger präzise als double!
float a = 0.1f + 0.2f;        // 0.3f? → tatsächlich: 0.30000001f

// Vergleich immer mit Epsilon
float epsilon = 1e-6f;
if (Math.abs(a - 0.3f) < epsilon) { ... }

// float ↔ double Konvertierung
double d = arr[0];             // float → double (automatisch)
float f = (float) d;           // double → float (expliziter Cast)

// Nützlich für Grafik-Berechnungen
float laenge = (float) Math.sqrt(arr[0] * arr[0] + arr[1] * arr[1]);

import java.util.Arrays;
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));

Hintergründe & Details

float[] speichert 32-Bit-Gleitkommazahlen (IEEE 754 Single Precision) mit 7 signifikanten Dezimalstellen. Im Vergleich zu double[] belegt jedes Element nur 4 statt 8 Byte — halb so viel Speicher und Bandbreite.

Präzision ist der Haken: float hat nur ~7 Dezimalstellen Genauigkeit. 0.1f + 0.2f ergibt 0.30000001f, nicht 0.3f. Für finanzielle oder wissenschaftliche Berechnungen ist das inakzeptabel — nimm dort double[].

Wann float[] sinnvoll? Hauptsächlich in der 3D-Grafik (OpenGL, Vulkan, WebGL), Spieleentwicklung und Machine Learning. Grafik-GPUs verarbeiten float[] nativ und sind damit sehr schnell. In neuronalen Netzen werden Millionen von Gewichten als float[] gespeichert, was den Speicher- und Bandbreitenvorteil entscheidend macht.

Java Besonderheit: Alle Rechen-Operationen mit float werden intern zu double promoted. Erst das Ergebnis wird wieder auf float gerundet. Deshalb ist float-Arithmetik in Java nicht zwangsläufig schneller als double — der Vorteil liegt im Speicher.

short[]String[]