Noch Mehr Basistypen:
byte, short, long, float

Mit dem Laden des Videos akzeptierst du die Datenschutzerklärung von YouTube. Wenn du die Menge an Daten reduzieren möchtest, die YouTube von dir sammelt, solltest du dich vorher aus deinem YouTube-Account ausloggen, das Speichern von Cookies für das Google-Ads-Programm deaktivieren und/oder Cookies im Browser blockieren.

YouTube immer automatisch laden

Inhaltsverzeichnis

Als Text lesen

Du kennst bereits Ganzzahlen (int), Fließkommazahlen (double), Wahrheitswerte (boolean), und Zeichen (char). Was soll es denn bitte noch alles geben?

Antwort: Genau das gleiche, nur anders.

Ich zeige dir folgendes Beispiel:

1
2
3
4
5
int number = 1;
for (int i = 0; i < 5; i++) {
    number *= 1000;
    System.out.println(number);
}
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Jeder normale Mensch würde folgende Ausgabe erwarten:

1000
1000000
1000000000
1000000000000
1000000000000000

Tatsächlich bekommen wir aber diese skurrile Antwort:

1000
1000000
1000000000
-727379968
-1530494976

Was zur Hölle geht hier ab?

In Java haben Ganzzahlen einen maximalen und minimalen Wert. Wird dieser Bereich über- oder unterschritten, so fängt man einfach von der anderen Seite an, weiter zu zählen.

Bei int liegt dieses Intervall zwischen -2.147.483.648 und 2.147.483.647 (also in etwa ±2 Milliarden). Für die Berechnung

1
int res = 2147483647 + 1;
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

ist das Ergebnis also -2147483648.

long

Möchte man mit größeren (oder kleineren) Zahlen hantieren, kann man den Basistyp long verwenden:

1
long largeNumber = 9000000000000L;
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Mit dem Suffix L am Ende der Zahl teilen wir dem Compiler mit, dass wir hier kein int, sondern ein long Literal verwenden wollen.

byte und short

Wenn es noch größere Ganzzahl-Typen als int gibt, warum dann nicht auch noch kleinere? Mit byte lässt sich eine 8 bit Ganzzahl speichern, mit short eine 16 bit Ganzzahl. (Für diese beiden Datentypen gibt es bislang leider keine speziellen Literal-Suffixe wie das L bei long.)

float

Analog zu byte, short, int, long bei Ganzzahlen, gibt es für Fließkommazahlen neben double den kleineren Fließkomma-Typ float. Variablen dieses Typs sind zwar auf deutlich weniger Nachkommastellen genau (ca. 7 statt ca. 15 bei double), können jedoch in manchen Situationen nützlich sein, um weniger Speicher zu verbrauchen. Ein float Literal lässt sich folgendermaßen einer Variable zuweisen:

1
float pi = 3.14159F;
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Hierbei fungiert das F wieder wie bei long als Hinweis an den Compiler, dass mit einem float (und nicht mit double) gearbeitet wird.

Übersicht Basistypen

Basistyp	Wertebereich		Informationsgehalt
`boolean`	false, true		1 bit*
`byte`	-128	127	8 bit
`short`	-32 768	32 767	16 bit
`int`	-2 147 483 648	2 147 483 647	32 bit
`long`	-9 223 372 036 854 775 808	9 223 372 036 854 775 807	64 bit
`char`	0	65 535	16 bit
`float`	±1.4·10^-45	±3.4028235·10³⁸	32 bit
`double`	±4.9·10^-324	±1.7976931348623157·10³⁰⁸	64 bit

*Tatsächliche Größe undefiniert

Und damit haben wir auch schon alle Basistypen in Java kennengelernt. Alle anderen Typen sind nicht-primitive Datentypen, also Klassen und klassenähnliche Strukturen.

Und wann soll ich welchen Basistyp verwenden?

Bei Ganzzahlen fällt deine erste Wahl immer auf int. Sollte der Zahlenbereich nicht ausreichen, verwendest du long.
Bei Fließkommazahlen verwendest du double, außer die Genauigkeit ist nicht so wichtig und du möchtest Speicherplatz sparen, dann float.
Wenn du mit Rohdaten arbeitest, beispielsweise beim Einlesen von Dateien, dann verwendest du byte.
boolean bzw. char verwendest du, wenn du mit Wahrheitswerten bzw. einzelnen Zeichen arbeitest.
short findet nur in sehr wenigen Einzelfällen Anwendung

Casting

Jetzt gibt es aber (wie immer) neu auftretende Probleme: Wie kann ich eine Variable eines Basistyps zu einer Variable eines anderen Basistyps konvertieren? Der Code

1
2
double d = 4.2;
int i = d;
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

liefert den Fehler

error: incompatible types: possible lossy conversion from double to int

Darin lässt sich auch schon genau das Problem ablesen: Bei der Umwandlung einer Fließkommazahl in eine Ganzzahl kann Information verloren gehen. Die Zahl 4.2 kann nicht exakt als Ganzzahl dargestellt werden. Mit einem sogenannten expliziten Cast lassen sich dennoch "größere" Datentypen in "kleinere" umwandeln:

1
2
double d = 4.2;
int i = (int) d; // Expliziter Cast
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Der Wert von i ist danach genau 4

Bei expliziten Casts von Fließkommazahlen zu Ganzzahlen wird immer abgerundet!

Analog dazu lassen sich auch andere Kombinationen von Basistypen konvertieren:

1
2
3
4
5
6
7
8
double d = 65.12345678901235;
long l  = (long) d;  // 65
int i   = (int) l;   // 65
short s = (short) d; // 65
float f = (float) d; // 65.12346
byte b  = (byte) f;  // 65
char c  = (char) i;  // 'A'
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

In die andere Richtung (von "kleinen" Typen zu "großen") ist kein expliziter Cast notwendig:

1
2
3
4
5
int i = 42;
long l   = i; // 42
float f  = i; // 42.0
double d = i; // 42.0
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Blick ich nicht, wann genau braucht man denn jetzt einen expliziten Cast?

Das kannst du folgendem Diagramm entnehmen:

Möchte man in Pfeilrichtung casten, benötigt man keinen expliziten Cast:

1
2
short s = 10;
float f = s; // Von short nach float ist in Pfeilrichtung
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Möchte man gegen die Pfeilrichtung casten, muss man explizit den Typen angeben, zu dem man casten möchte:

1
2
char c = 'A';
byte b = (byte) c; // Von char nach byte ist (zum Teil) gegen die Pfeilrichtung
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Von boolean und nach boolean kann nicht gecastet werden.

In dieser Aufgabe sollst du eine Methode average() implementieren, die den Mittelwert ("Durchschnitt") aller Zahlen im Array numbers als double zurückgibt.

Der Mittelwert von Zahlen a₁, a₂, ..., a_n lässt sich folgendermaßen berechnen: (a₁ + a₂ + ... + a_n) / n

Beachte hierbei, dass bei Ganzzahldivisionen in Java abgerundet wird. Wir wollen hier aber ein genaueres Ergebnis!

Verwende zum Aufsummieren der einzelnen Zahlen keinen Fließkomma-Typen, da sonst Ungenauigkeiten entstehen können!

Mit dem Laden des Online Editors akzeptierst du die Datenschutzerklärung von JDoodle, einem Produkt der Nutpan pty Ltd (Australien). JDoodle verwendet die Tools reCAPTCHA und Google Analytics, wodurch Daten an Google übertragen werden können. Ich habe leider keinen Einfluss auf diesen Prozess. Du kannst Google Analytics über ein Browserplugin deaktivieren.

Online Editor immer automatisch laden

Die korrekte Ausgabe lautet 4.904444914285714E8, wohingegen 4.90444491E8 explizit falsch ist!

Häufige Fehlerquellen

Ergebnis negativ: Beim Aufsummieren der Zahlen entsteht eine sehr große Zahl. Reicht da noch int?
Ergebnis ist 4.90444491E8: Du dividierst zwei Ganzzahlen, dabei wird abgerundet. Berechne das Ergebnis stattdessen als Fließkommazahl!

Lösungsvorschlag

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
public class ArrayCalculator {
    private int[] numbers;
    public ArrayCalculator(int[] numbers) {
        this.numbers = numbers;
    }
    public double average() {
        long sum = 0L; /* Muss long sein, weil der Wertebereich
                          von int (für die Beispieleingabe) nicht ausreicht! */
        for (int i = 0; i < numbers.length; i++) {
            sum += numbers[i]; // Kein expliziter Cast von int nach long notwendig
        }
        double sumAsDouble = sum; // Kein expliziter Cast von long nach double notwendig
        double lengthAsDouble = numbers.length; // Kein expliziter Cast von int nach double notwendig
        return sumAsDouble / lengthAsDouble; // Fließkommazahl-Division
        /*
         * Auch richtig, weil bei "Ganzzahl / Fließkommazahl"
         * ein impliziter Cast zur Fließkommazahl stattfindet:
         *
         *   double sumAsDouble = sum;
         *   return sumAsDouble / numbers.length;
         *
         * - ODER -
         *
         *   double lengthAsDouble = numbers.length;
         *   return sum / lengthAsDouble;
         *
         * Alternativ wäre auch ein expliziter Cast in Ordnung gewesen,
         * um sum vor der Division in eine Fließkommazahl umzuwandeln:
         *
         *   return ((double) sum) / numbers.length;
         *
         * - ODER -
         *
         *   return sum / ((double) numbers.length);
         *
         * - ODER -
         *
         *   return ((double) sum) / ((double) numbers.length);
         */
    }
    public static void main(String[] args) {
        int[] numbers = {-10, 2, 5, 99333444, 2111444555, 0, 1222333444};
        ArrayCalculator calc = new ArrayCalculator(numbers);
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Dir gefällt meine Arbeit?

Interesse an einer Zusammenarbeit?

Entwicklung von Desktopanwendungen
Datenanalyse & Machine Learning
Automatisierte Datenverarbeitung

>> timofriedl.com <<

Allgemein	Social	Rechtliches
Portfolio	Instagram	Datenschutz
Home	YouTube	Impressum
Über	TikTok
	Ko-fi

Noch Mehr Basistypen:byte, short, long, float