Einführung in Java Primitives

1. Übersicht

Die Java-Programmiersprache bietet acht primitive Datentypen.

In diesem Artikel werden wir uns daran erinnern, was Primitive sind, und sie durchgehen.

2. Primitive Datentypen

Die acht in Java definierten Grundelemente sind int , byte , short , long , float , double , boolean und char - diese werden nicht als Objekte betrachtet und repräsentieren Rohwerte.

Sie werden direkt auf dem Stapel gespeichert (weitere Informationen zur Speicherverwaltung in Java finden Sie in diesem Artikel).

Schauen wir uns die Speichergröße, die Standardwerte und Beispiele für die Verwendung der einzelnen Typen an.

Beginnen wir mit einer Kurzreferenz:

Art Größe (Bits) Minimum Maximal Beispiel
Byte 8 -27 27– 1 Byte b = 100;
kurz 16 -215 215–1 kurz s = 30_000;
int 32 -231 231–1 int i = 100_000_000;
lange 64 -263 263– 1 lang l = 100_000_000_000_000;
schweben 32 -2-149 (2-2-23) · 2127 float f = 1,456f;
doppelt 64 -2-1074 (2-2-52) · 21023 doppeltes f = 1,456789012345678;
verkohlen 16 0 216– 1 char c = 'c';
Boolescher Wert 1 - - - - Boolescher Wert b = wahr;

2.1. int

Der erste primitive Datentyp, den wir behandeln werden, ist int . Der int- Typ wird auch als Ganzzahl bezeichnet und enthält einen weiten Bereich von nicht gebrochenen Zahlenwerten.

Insbesondere speichert Java es mit 32 Bit Speicher . Mit anderen Worten kann es Werte von -2.147.483.648 (-231) bis 2.147.483.647 (231-1) darstellen.

In Java 8 ist es möglich, einen vorzeichenlosen Ganzzahlwert bis zu 4.294.967.295 (232-1) mithilfe neuer spezieller Hilfsfunktionen zu speichern.

Wir können ein int einfach deklarieren :

int x = 424_242; int y;

Der Standardwert eines ohne Zuweisung deklarierten int ist 0.

Wenn die Variable in einer Methode definiert ist, müssen wir einen Wert zuweisen, bevor wir ihn verwenden können.

Wir können alle Standard-Arithmetikoperationen für int s ausführen . Beachten Sie jedoch, dass Dezimalwerte abgeschnitten werden, wenn Sie diese für Ganzzahlen ausführen.

2.2. Byte

Byte ist ein primitiver Datentyp ähnlich wie int , außer dass er nur 8 Bit Speicher belegt . Warum nennen wir es also ein Byte? Da die Speichergröße so klein ist, kann das Byte nur die Werte von -128 (-27) bis 127 (27 - 1) enthalten.

Wir können Byte erstellen :

byte b = 100; byte empty;

Der Standardwert für Byte ist ebenfalls 0.

2.3. kurz

Die nächste Station auf unserer Liste der primitiven Datentypen in Java ist kurz .

Wenn wir Speicherplatz sparen möchten und das Byte zu klein ist, können wir den Typ auf halbem Weg zwischen den beiden verwenden: kurz .

Bei 16 Bit Speicher ist es halb so groß wie int und doppelt so groß wie Byte . Der Bereich möglicher Werte liegt zwischen -32.768 (-215) und 32.767 (215-1).

kurz wird wie folgt deklariert:

short s = 202_020; short s;

Ähnlich wie bei den anderen Typen ist der Standardwert 0. Wir können auch alle Standardarithmetik verwenden.

2.4. lange

Unser letzter primitiver Datentyp für Ganzzahlen ist lang .

lang ist der große bruder von int . Es ist in 64 Bit Speicher gespeichert, sodass es einen wesentlich größeren Satz möglicher Werte enthalten kann.

Die möglichen Werte eines Longs liegen zwischen -9.223.372.036.854.775.808 (-263) und 9.223.372.036.854.775.807 (263-1).

Wir können einfach eins deklarieren:

long l = 1_234_567_890; long l;

Wie bei anderen Integer-Typen ist auch der Standardwert 0. Wir können alle Arithmetik für lange verwenden , die für int funktioniert .

2.5. schweben

Wir repräsentieren grundlegende Bruchzahlen in Java unter Verwendung des Float- Typs. Dies ist eine Dezimalzahl mit einfacher Genauigkeit. Das heißt, wenn wir sechs Dezimalstellen überschreiten, wird diese Zahl weniger genau und eher eine Schätzung.

In den meisten Fällen ist uns der Präzisionsverlust egal. Wenn unsere Berechnung jedoch absolute Genauigkeit erfordert (z. B. finanzielle Operationen, Landung auf dem Mond usw.), müssen wir bestimmte Typen verwenden, die für diese Arbeit entwickelt wurden. Weitere Informationen finden Sie in der Java-Klasse Big Decimal.

This type is stored in 32 bits of memory just like int. However, because of the floating decimal point its range is much different. It can represent both positive and negative numbers. The smallest decimal is 1.40239846 x 10-45, and the largest value is 3.40282347 x 1038.

We declare floats the same as any other type:

float f = 3.145f; float f;

And the default value is 0.0 instead of 0. Also, notice we add the f designation to the end of the literal number to define a float. Otherwise, Java will throw an error because the default type of a decimal value is double.

We can also perform all standard arithmetic operations on floats. However, it's important to note that we perform floating point arithmetic very differently than integer arithmetic.

2.6. double

Next, we look at double – its name comes from the fact that it's a double-precision decimal number.

It's stored in 64 bits of memory. Which means it represents a much larger range of possible numbers than float.

Although, it does suffer from the same precision limitation as float does. The range is 4.9406564584124654 x 10-324 to 1.7976931348623157 x 10308. That range can also be positive or negative.

Declaring double is the same as other numeric types:

double d = 3.13457599923384753929348D; double d;

The default value is also 0.0 as it is with float.Similar to float, we attach the letter D to designate the literal as a double.

2.7. boolean

The simplest primitive data type is boolean. It can contain only two values: true or false. It stores its value in a single bit.

However, for convenience, Java pads the value and stores it in a single byte.

Declare boolean like this:

boolean b = true; boolean b;

Declaring it without a value defaults to false. boolean is the cornerstone of controlling our programs flow. We can use boolean operators on them (i.e., and, or, etc.).

2.8. char

The final primitive data type to look at is char.

Also called a character, char is a 16-bit integer representing a Unicode-encoded character. Its range is from 0 to 65,535. Which in Unicode represents ‘\u0000' to ‘\uffff'.

For a list of all possible Unicode values check out sites like Unicode Table.

Let's now declare a char:

char c = 'a'; char c = 65; char c;

When defining our variables, we can use any character literal, and they will get automatically transformed into their Unicode encoding for us. A characters default value is ‘/u0000'.

2.9. Overflow

The primitive data types have size limits. But what happens if we try to store a value that's larger than the maximum value?

We run into a situation called overflow.

When an integer overflows, it rolls over to the minimum value and begins counting up from there.

Floating point number overflow by returning Infinity. When they underflow, they return 0.0.

Here's an example:

int i = Integer.MAX_VALUE; int j = i + 1; // j will roll over to -2_147_483_648 double d = Double.MAX_VALUE; double o = d + 1; // o will be Infinity

Underflow is the same issue except if we store a value smaller than the minimum value.

2.10. Autoboxing

Each primitive data type also has a full Java class implementation that can wrap it. For instance, the Integer class can wrap an int. There is sometimes a need to convert from the primitive type to its object wrapper (e.g., using them with generics).

Glücklicherweise kann Java diese Konvertierung für uns automatisch durchführen. Wir nennen diesen Prozess Autoboxing . Hier ist ein Beispiel:

Character c = 'c'; Integer i = 1;

3. Fazit

In diesem Tutorial haben wir die acht in Java unterstützten primitiven Datentypen behandelt.

Dies sind die Bausteine, die von den meisten, nicht allen Java-Programmen verwendet werden. Es lohnt sich also zu verstehen, wie sie funktionieren.