Java Language
Primitive Datentypen

Einführung

Syntax

• int aInt = 8; // Der definierende (Nummer) Teil dieser int-Deklaration wird als Literal bezeichnet.

• int hexInt = 0x1a; // = 26; Sie können Literale mit Hexadezimalwerten vor 0x definieren .

• int binInt = 0b11010; // = 26; Sie können auch binäre Literale definieren. vorangestellt mit 0b .

• long goodLong = 10000000000L; // Integer-Literale sind standardmäßig vom Typ int. Durch das Hinzufügen des L am Ende des Literals sagen Sie dem Compiler, dass das Literal lang ist. Andernfalls würde der Compiler einen Fehler "Integer number too large" ausgeben.

• double aDouble = 3,14; // Fließkomma-Literale haben standardmäßig den doppelten Typ.

• Float aFloat = 3.14F; // Standardmäßig wäre dieses Literal doppelt gewesen (und hat den Fehler "Inkompatible Typen" verursacht), aber durch Hinzufügen eines F sagen wir dem Compiler, dass es sich um einen Float handelt.

Bemerkungen

byte a = 1;
byte b = 2;
byte c = (byte) (a + b);

Das int Primitive

Ein primitiver Datentyp wie int enthält Werte direkt in der verwendeten Variable, während eine mit Integer deklarierte Variable einen Verweis auf den Wert enthält.

Gemäß Java-API : "Die Integer-Klasse hüllt einen Wert des primitiven Typs int in ein Objekt ein. Ein Objekt vom Typ Integer enthält ein einzelnes Feld, dessen Typ int ist."

Standardmäßig ist int eine 32-Bit-Ganzzahl mit Vorzeichen. Es kann einen Minimalwert von -2 ³¹ und einen Maximalwert von 2 ³¹ - 1 speichern.

int example = -42;
int myInt = 284;
int anotherInt = 73;

int addedInts = myInt + anotherInt; // 284 + 73 = 357
int subtractedInts = myInt - anotherInt; // 284 - 73 = 211

Wenn Sie eine Nummer außerhalb dieses Bereichs speichern möchten, sollten Sie stattdessen long verwenden. Das Überschreiten des Wertebereichs von int führt zu einem Integer-Überlauf, wodurch der Wert, der den Bereich überschreitet, an der gegenüberliegenden Stelle des Bereichs hinzugefügt wird (Positiv wird negativ und umgekehrt). Der Wert ist ((value - MIN_VALUE) % RANGE) + MIN_VALUE oder ((value + 2147483648) % 4294967296) - 2147483648

int demo = 2147483647; //maximum positive integer
System.out.println(demo); //prints 2147483647
demo = demo + 1; //leads to an integer overflow
System.out.println(demo); // prints -2147483648

Die maximalen und minimalen Werte von int finden Sie unter:

int high = Integer.MAX_VALUE;    // high == 2147483647
int low = Integer.MIN_VALUE;     // low == -2147483648

Der Standardwert eines int ist 0

int defaultInt;    // defaultInt == 0

Das kurze Primitiv

Ein short ist eine vorzeichenbehaftete 16-Bit-Ganzzahl. Es hat einen Mindestwert von -2 ¹⁵ (-32.768) und einen Maximalwert von 2 ¹⁵ ‑1 (32.767).

short example = -48;
short myShort = 987;
short anotherShort = 17;

short addedShorts = (short) (myShort + anotherShort); // 1,004
short subtractedShorts = (short) (myShort - anotherShort); // 970

Die maximalen und minimalen Werte von short finden Sie unter:

short high = Short.MAX_VALUE;        // high == 32767
short low = Short.MIN_VALUE;         // low == -32768

Der Standardwert eines short ist 0

short defaultShort;    // defaultShort == 0

Das lange Primitiv

Standardmäßig ist long eine 64-Bit-Ganzzahl mit Vorzeichen (in Java 8 kann sie entweder vorzeichenbehaftet oder vorzeichenlos sein). Signiert, kann es einen Minimalwert von -2 ⁶³ und einen Maximalwert von 2 ⁶³ - 1 speichern und unsigniert einen Minimalwert von 0 und einen Maximalwert von 2 ⁶⁴ - 1

long example = -42;
long myLong = 284;
long anotherLong = 73;

//an "L" must be appended to the end of the number, because by default,
//numbers are assumed to be the int type. Appending an "L" makes it a long
//as 549755813888 (2 ^ 39) is larger than the maximum value of an int (2^31 - 1),
//"L" must be appended 
long bigNumber = 549755813888L;

long addedLongs = myLong + anotherLong; // 284 + 73 = 357
long subtractedLongs = myLong - anotherLong; // 284 - 73 = 211

Die maximalen und minimalen Werte von long finden Sie unter:

long high = Long.MAX_VALUE;    // high == 9223372036854775807L
long low = Long.MIN_VALUE;     // low == -9223372036854775808L

Der Standardwert von long ist 0L

long defaultLong;    // defaultLong == 0L

Hinweis: Der Buchstabe "L", der am Ende eines long Buchstabens angehängt wird, unterscheidet nicht zwischen Groß- und Kleinschreibung, es ist jedoch ratsam, Kapital zu verwenden, da es einfacher ist, sich von Ziffer 1 zu unterscheiden:

2L == 2l;            // true

Warnung: Java speichert Integer-Objektinstanzen im Bereich von -128 bis 127. Die Begründung wird hier erläutert: https://blogs.oracle.com/darcy/entry/boxing_and_caches_integer_valueof

Folgende Ergebnisse können gefunden werden:

Long val1 = 127L;
Long val2 = 127L;

System.out.println(val1 == val2); // true

Long val3 = 128L;
Long val4 = 128L;

System.out.println(val3 == val4); // false

Verwenden Sie den folgenden Code (ab Java 1.7), um 2 Object Long-Werte richtig zu vergleichen:

Long val3 = 128L;
Long val4 = 128L;

System.out.println(Objects.equal(val3, val4)); // true

Das Vergleichen eines primitiven long mit einem object long führt nicht zu einem falschen Negativ wie beim Vergleich von 2 Objekten mit == do.

Das boolesche Primitiv

Ein boolean kann einen von zwei Werten speichern, entweder " true oder " false

boolean foo = true;
System.out.println("foo = " + foo);                // foo = true

boolean bar = false;
System.out.println("bar = " + bar);                // bar = false

boolean notFoo = !foo;
System.out.println("notFoo = " + notFoo);          // notFoo = false

boolean fooAndBar = foo && bar;
System.out.println("fooAndBar = " + fooAndBar);    // fooAndBar = false

boolean fooOrBar = foo || bar;
System.out.println("fooOrBar = " + fooOrBar);      // fooOrBar = true

boolean fooXorBar = foo ^ bar;
System.out.println("fooXorBar = " + fooXorBar);    // fooXorBar = true

Der Standardwert eines boolean Werts ist false

boolean defaultBoolean;    // defaultBoolean == false

Das Byte-Primitiv

Ein byte ist eine vorzeichenbehaftete 8-Bit-Ganzzahl. Es kann einen Minimalwert von -2 ⁷ (-128) und einen Maximalwert von 2 ⁷ - 1 (127) speichern.

byte example = -36;
byte myByte = 96;
byte anotherByte = 7;

byte addedBytes = (byte) (myByte + anotherByte); // 103
byte subtractedBytes = (byte) (myBytes - anotherByte); // 89

Die maximalen und minimalen byte Werte finden Sie unter:

byte high = Byte.MAX_VALUE;        // high == 127
byte low = Byte.MIN_VALUE;         // low == -128

Der Standardwert eines byte ist 0

byte defaultByte;    // defaultByte == 0

Das Float-Primitiv

Ein float ist eine 32-Bit-Gleitkommazahl mit einfacher Genauigkeit (32 Bit). Standardmäßig werden Dezimalzahlen als Doppelte interpretiert. Um einen float zu erstellen, hängen Sie einfach ein f an das Dezimal-Literal an.

double doubleExample = 0.5;      // without 'f' after digits = double
float floatExample = 0.5f;       // with 'f' after digits    = float

float myFloat = 92.7f;           // this is a float...
float positiveFloat = 89.3f;     // it can be positive,
float negativeFloat = -89.3f;    // or negative
float integerFloat = 43.0f;      // it can be a whole number (not an int)
float underZeroFloat = 0.0549f;  // it can be a fractional value less than 0

Floats behandeln die fünf gängigen arithmetischen Operationen: Addition, Subtraktion, Multiplikation, Division und Modul.

Hinweis: Die folgenden Informationen können aufgrund von Fließkommafehlern geringfügig abweichen. Einige Ergebnisse wurden aus Gründen der Übersichtlichkeit und Lesbarkeit gerundet (dh das Druckergebnis des Additionsbeispiels war tatsächlich 34.600002).

// addition
float result = 37.2f + -2.6f;  // result: 34.6

// subtraction
float result = 45.1f - 10.3f;    // result: 34.8

// multiplication
float result = 26.3f * 1.7f;   // result: 44.71

// division
float result = 37.1f / 4.8f;   // result: 7.729166

// modulus
float result = 37.1f % 4.8f;   // result: 3.4999971

Aufgrund der Art und Weise, wie Gleitkommazahlen gespeichert werden (dh in binärer Form), haben viele Zahlen keine exakte Darstellung.

float notExact = 3.1415926f;
System.out.println(notExact); // 3.1415925

Während die Verwendung von float für die meisten Anwendungen geeignet ist, sollten weder float noch double verwendet werden, um exakte Darstellungen von Dezimalzahlen (wie Geldbeträge) oder Zahlen zu speichern, bei denen eine höhere Genauigkeit erforderlich ist. Stattdessen sollte die BigDecimal Klasse verwendet werden.

Der Standardwert eines float ist 0.0f.

float defaultFloat;    // defaultFloat == 0.0f

Ein float ist auf einen Fehler von 1: 10 Millionen genau.

Hinweis: Float.POSITIVE_INFINITY , Float.NEGATIVE_INFINITY , Float.NaN sind float Werte. NaN steht für Ergebnisse von Operationen, die nicht bestimmt werden können, z. B. das Aufteilen von 2 unendlichen Werten. Außerdem sind 0f und -0f unterschiedlich, aber == ergibt true:

float f1 = 0f;
float f2 = -0f;
System.out.println(f1 == f2); // true
System.out.println(1f / f1); // Infinity
System.out.println(1f / f2); // -Infinity
System.out.println(Float.POSITIVE_INFINITY / Float.POSITIVE_INFINITY); // NaN

Das Doppelprimitiv

Ein double ist eine 64-Bit-Gleitkommazahl mit 64-Bit-Genauigkeit.

double example = -7162.37;
double myDouble = 974.21;
double anotherDouble = 658.7;

double addedDoubles = myDouble + anotherDouble; // 315.51
double subtractedDoubles = myDouble - anotherDouble; // 1632.91

double scientificNotationDouble = 1.2e-3;    // 0.0012

Aufgrund der Art und Weise, wie Gleitkommazahlen gespeichert werden, haben viele Zahlen keine exakte Darstellung.

double notExact = 1.32 - 0.42; // result should be 0.9
System.out.println(notExact); // 0.9000000000000001

Während die Verwendung von double für die meisten Anwendungen in Ordnung ist, sollten weder float noch double für genaue Zahlen wie z. B. Währung verwendet werden. Stattdessen sollte die BigDecimal Klasse verwendet werden

Der Standardwert eines double ist 0.0d

public double defaultDouble;    // defaultDouble == 0.0

Hinweis: Double.POSITIVE_INFINITY , Double.NEGATIVE_INFINITY , Double.NaN sind double Werte. NaN steht für Ergebnisse von Operationen, die nicht bestimmt werden können, z. B. das Aufteilen von 2 unendlichen Werten. Außerdem sind 0d und -0d verschieden, aber == ergibt true:

double d1 = 0d;
double d2 = -0d;
System.out.println(d1 == d2); // true
System.out.println(1d / d1); // Infinity
System.out.println(1d / d2); // -Infinity
System.out.println(Double.POSITIVE_INFINITY / Double.POSITIVE_INFINITY); // NaN

Das char primitive

A char speichern kann ein einziges 16-Bit - Unicode - Zeichen. Ein Zeichenliteral wird in einfache Anführungszeichen gesetzt

char myChar = 'u';
char myChar2 = '5';
char myChar3 = 65; // myChar3 == 'A'

Es hat einen Mindestwert von \u0000 (0 in der Dezimaldarstellung, auch Nullzeichen genannt ) und einen Höchstwert von \uffff (65.535).

Der Standardwert eines char wird \u0000 .

char defaultChar;    // defaultChar == \u0000

Um einen Char of ' Wert zu definieren ' muss eine Escape-Sequenz (Zeichen mit vorangestelltem Backslash) verwendet werden:

char singleQuote = '\'';

Es gibt auch andere Escape-Sequenzen:

char tab = '\t';
char backspace = '\b';
char newline = '\n';
char carriageReturn = '\r';
char formfeed = '\f';
char singleQuote = '\'';
char doubleQuote = '\"'; // escaping redundant here; '"' would be the same; however still allowed
char backslash = '\\';
char unicodeChar = '\uXXXX' // XXXX represents the Unicode-value of the character you want to display

Sie können ein deklarieren char eines Unicode - Zeichen.

char heart = '\u2764';
System.out.println(Character.toString(heart)); // Prints a line containing "❤".

Es ist auch möglich, ein char hinzuzufügen. Um beispielsweise durch jeden Kleinbuchstaben zu iterieren, können Sie Folgendes tun:

for (int i = 0; i <= 26; i++) {
    char letter = (char) ('a' + i);
    System.out.println(letter);
}

Negative Darstellung

Java und die meisten anderen Sprachen speichern negative Integralzahlen in einer Darstellung, die als 2-Komplement- Notation bezeichnet wird.

Für eine eindeutige binäre Darstellung eines Datentyps mit n Bits werden Werte wie folgt codiert:

Die niedrigstwertigen n-1 Bits speichern eine positive ganze Zahl x in integraler Darstellung. Der signifikanteste Wert speichert ein Bit mit dem Wert s . Der durch diese Bits dargestellte Wert ist

x - s * 2 ^n-1

dh wenn das höchstwertige Bit 1 ist, ist ein Wert, der nur um 1 größer ist als die Anzahl, die Sie mit den anderen Bits darstellen könnten ( 2 n-2 + 2 n-3 + ... + 2 1 + 2 0 = 2 n-1 - 1 ) wird abgezogen, wodurch eine eindeutige binäre Darstellung für jeden Wert von - 2 ^n-1 (s = 1; x = 0) bis 2 ^n-1 - 1 (s = 0; x = 2 ^n-1 - 1).

Dies hat auch den schönen Nebeneffekt, dass Sie die binären Darstellungen hinzufügen können, als ob sie positive binäre Zahlen wären:

v1 = x1 - s1 * 2n-1
v2 = x2 - s2 * 2n-1

x1 + x2 - 2n-1 = x1 + x2 - s2 * 2n-1
              = v1 + v2

(x1 + x2) mod 2n-1 = x1 + x2 - 2n-1
                  = v1 + v2

(x1 + x2) mod 2n-1 - 2n-1 = (x1 + x2 - 2n-1) - 2n-1
                         = (x1 - s1 * 2n-1) + (x2 - s2 * 2n-1)
                         = v1 + v2

Beachten Sie, dass diese Tatsache das Finden der binären Darstellung des additiven Inversen (dh des negativen Werts) vereinfacht:

Beachten Sie, dass das Hinzufügen des bitweisen Komplements zu der Zahl dazu führt, dass alle Bits 1 sind. Fügen Sie 1 hinzu, um den Wert zum Überlauf zu bringen, und Sie erhalten das neutrale Element 0 (alle Bits 0).

Der negative Wert einer Zahl i kann also berechnet werden (wobei hier eine mögliche Aufstiegsmöglichkeit nach int ignoriert wird).

(~i) + 1

Beispiel: negativen Wert von 0 ( byte ) nehmen:

Das Ergebnis der Negierung von 0 ist 11111111 . Addiert man 1, erhält man einen Wert von 100000000 (9 Bit). Da ein byte nur 8 Bits byte kann, wird der Wert ganz links abgeschnitten und das Ergebnis lautet 00000000

Speicherverbrauch von Primitiven vs. Boxed Primitiven

Boxed-Objekte benötigen immer 8 Byte für die Typ- und Speicherverwaltung. Da die Größe der Objekte immer ein Vielfaches von 8 ist, benötigen Boxed-Typen insgesamt 16 Byte . Darüber hinaus beinhaltet jede Verwendung eines geschachtelten Objekt Speicher eine Referenz , die für weitere 4 oder 8 Bytes ausmacht, in Abhängigkeit von dem JVM und JVM - Optionen.

Bei datenintensiven Vorgängen kann der Speicherverbrauch die Leistung erheblich beeinflussen. Der Speicherbedarf steigt bei Verwendung von Arrays noch weiter: Für ein float[5] -Array werden nur 32 Byte benötigt. Ein Float[5] der 5 verschiedene Nicht-Null-Werte speichert, erfordert insgesamt 112 Byte (bei 64 Bit ohne komprimierte Zeiger erhöht sich dieser Wert auf 152 Byte).

Boxed Value Caches

Der Platzaufwand der Boxtypen kann durch die Boxed Value Caches bis zu einem gewissen Grad gemindert werden. Einige der geschachtelten Typen implementieren einen Cache von Instanzen. In der Integer Klasse werden beispielsweise Instanzen zwischengespeichert, um Zahlen im Bereich von -128 bis +127 . Dies reduziert jedoch nicht die zusätzlichen Kosten, die durch die zusätzliche Speicherumleitung entstehen.

Wenn Sie eine Instanz eines geschachtelten Typs erstellen, indem Sie entweder autoboxing oder die statische valueOf(primitive) -Methode aufrufen, versucht das Laufzeitsystem, einen zwischengespeicherten Wert zu verwenden. Wenn Ihre Anwendung viele Werte in dem zwischengespeicherten Bereich verwendet, kann dies den Speichernachteil bei der Verwendung von Boxed-Typen erheblich reduzieren. Wenn Sie Boxed Value-Instanzen "von Hand" erstellen, ist es valueOf besser, valueOf anstelle von new . (Die new Operation erstellt immer eine neue Instanz.) Wenn sich jedoch die Mehrheit Ihrer Werte nicht im zwischengespeicherten Bereich befindet, kann es schneller sein, new aufzurufen und die Cache-Suche zu speichern.

Grundelemente konvertieren

In Java können wir zwischen ganzzahligen Werten und Gleitkommawerten konvertieren. Auch kann , da jedes Zeichen in eine Zahl in der Unicode - Codierung entspricht, char können Typen zu und von den Ganzzahl- und Gleitkomma-Typen umgewandelt werden. boolean ist der einzige primitive Datentyp, der nicht in einen oder aus einem anderen primitiven Datentyp konvertiert werden kann.

Es gibt zwei Arten von Konvertierungen: Konvertierung erweitern und Konvertierung einschränken .

Eine Erweiterungskonvertierung liegt vor, wenn ein Wert eines Datentyps in einen Wert eines anderen Datentyps konvertiert wird, der mehr Bits als der frühere belegt. In diesem Fall tritt kein Datenverlust auf.

Dementsprechend ist eine Einengungskonvertierung, wenn ein Wert eines Datentyps in einen Wert eines anderen Datentyps konvertiert wird, der weniger Bits als der vorherige besetzt. In diesem Fall kann es zu Datenverlust kommen.

Java führt Konvertierungen automatisch aus. Wenn Sie jedoch eine engere Konvertierung durchführen möchten (wenn Sie sicher sind, dass kein Datenverlust auftritt), können Sie Java zwingen, die Konvertierung mit einem Sprachkonstrukt durchzuführen, das als cast .

Erweiterung der Konvertierung:

int a = 1;    
double d = a;    // valid conversion to double, no cast needed (widening)

Enge Umwandlung:

double d = 18.96
int b = d;       // invalid conversion to int, will throw a compile-time error
int b = (int) d; // valid conversion to int, but result is truncated (gets rounded down)
                 // This is type-casting
                 // Now, b = 18

Primitive Typen Cheatsheet

Tabelle mit Größe und Wertebereich aller Grundtypen:

Anmerkungen:

1. Die Java-Sprachspezifikation schreibt vor, dass signierte Integraltypen ( byte by long ) eine binäre Zweierkomplementdarstellung verwenden, und die Fließkommatypen verwenden standardmäßige binäre Fließkommadaten nach IEE 754.
2. Java 8 und höher stellen Methoden bereit, um vorzeichenlose arithmetische Operationen für int und long auszuführen. Während diese Methoden es einem Programm ermöglichen , Werte der jeweiligen Typen als unsigniert zu behandeln , bleiben die Typen mit Vorzeichen signierte Typen.
3. Der kleinste Fließpunkt, der oben angezeigt wird, ist subnormal . dh sie haben weniger Genauigkeit als ein normaler Wert. Die kleinsten Normalzahlen sind 1,175494351e-38 und 2,2250738585072014e-308
4. Ein char stellt üblicherweise eine Unicode / UTF-16 - Code - Einheit.
5. Obwohl ein boolean nur ein Informationsbit enthält, variiert seine Größe im Speicher abhängig von der Implementierung der Java Virtual Machine (siehe Boolean-Typ ).