Überblick über die Java-Grundlagen: grundlegende Datentypen und String-Typ

1. Grundlegende Datentypen

Es gibt 8 grundlegende Datentypen in Java, vier Ganzzahltypen (Byte, Short, Int, Long) und zwei Dezimaltypen Typen (float, double), ein Zeichentyp (char) und ein boolescher Typ (boolean)

类型	字节	取值范围
byte	1	-2^7 ~ 2^7 - 1
short	2	-2^15 ~ 2^15 - 1
int	4	-2^31 ~ 2^31 - 1
long	8	-2^63 ~ 2^63 - 1

(Ein Byte stellt eine 8-Bit-Binärdatei dar) float belegt 32 Bit, double belegt 64 Bit, char belegt 16 Bit und boolean belegt 1 Bit

Weil Java objektorientiert Da es sich um eine Sprache handelt, haben diese acht grundlegenden Datentypen entsprechende Verpackungsklassen: Byte, Short, Integer, Long, Float, Double, Character und Boolean. Die Zuordnung zwischen diesen acht Grundtypen und den entsprechenden Verpackungsarten erfolgt durch automatisches Ein- und Auspacken.

Integer a = 1; // 基本数据类型int自动装箱为Integer包装类(实际上在编译时会调用Integer .valueOf方法来装箱)int b = a;  // 自动拆箱（实际上会在编译调用intValue）

Was ist also der Unterschied zwischen

und new Integer(123)? Integer.valueOf(123)

erstellt jedes Mal ein Objekt und new Integer(123) verwendet Cache-Objekte. Wenn Integer.valueOf(123) also mehrmals verwendet wird, wird nur ein Verweis auf dasselbe Objekt erhalten. Integer.valueOf(123)

Integer a = new Integer(123);Integer b = new Integer(123);
System.out.println(x == y);    // falseInteger c = Integer.valueOf(123);Integer d = Integer.valueOf(123);
System.out.println(z == k);   // true

Der Compiler ruft die Methode

während des Autoboxing-Vorgangs auf, sodass mehrere mit Autoboxing erstellte Integer-Instanzen mit demselben Wert auf dasselbe Objekt verweisen. valueOf()

Integer m = 123;Integer n = 123;
System.out.println(m == n); // true

Bestimmen Sie gemäß dem Quellcode der Integer-Klasse bei Verwendung von

zunächst, ob sich der Wert im Cache-Pool befindet, und geben Sie in diesem Fall direkt den Inhalt des Cache-Pools zurück. valueOf()

public static Integer valueOf(int i) {    if (i >= IntegerCache.low && i <= IntegerCache.high)        return IntegerCache.cache[i + (-IntegerCache.low)];    return new Integer(i);
}

Aber wenn wir uns den Code unten

    Integer i1 = 128;    Integer i2 = 128;
    System.out.println(i1 == i2); //false

ansehen, stellen wir fest, dass er „false“ zurückgibt. Dies liegt daran, dass der Cache-Pool-Bereich in Integer ist: -128 ~ 127

private static class IntegerCache {
        static final int low = -128;        static final int high;        static final Integer cache[];        static {            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");            if (integerCacheHighPropValue != null) {                try {                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;

            cache = new Integer[(high - low) + 1];            int j = low;            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }        private IntegerCache() {}
    }

2 .String-Typ

Zusätzlich zu den acht oben genannten Grunddatentypen ist die String-Klasse auch der am häufigsten verwendete Typ beim Schreiben von Programmen.

Die String-Klasse wird als endgültig deklariert und kann daher nicht vererbt werden. Es verwendet intern ein char-Array zum Speichern von Daten und das Array wird als endgültig deklariert. Dies bedeutet, dass nach der Initialisierung des Wertarrays nicht auf andere Arrays verwiesen werden kann und es keine interne Methode von String zum Ändern des Wertarrays gibt, also String kann garantiert unveränderlich sein.

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

String.intern()

Mit String.intern() kann sichergestellt werden, dass String-Variablen mit demselben Inhalt auf dasselbe Speicherobjekt verweisen.

Im folgenden Beispiel verwenden s1 und s2 new String(), um zwei neue Objekte zu erstellen, und s3 erhält eine Objektreferenz über die Methode s1.intern(). Diese Methode konvertiert zunächst das von s1 referenzierte Objekt Fügen Sie es in den String-Pool (String-Konstanten-Pool) ein und geben Sie dann diese Objektreferenz zurück. Daher verweisen s3 und s1 auf dasselbe String-Konstanten-Pool-Objekt.

String s1 = new String("aaa");String s2 = new String("aaa");
System.out.println(s1 == s2);           // falseString s3 = s1.intern();
System.out.println(s1.intern() == s3);  // true

Wenn Sie „bbb“ verwenden, um eine String-Instanz in doppelten Anführungszeichen zu erstellen, wird das neu erstellte Objekt automatisch in den String-Pool eingefügt.

String s4 = "bbb";String s5 = "bbb";
System.out.println(s4 == s5);  // true

Vor Java 7 wurde der String-Konstantenpool im Laufzeitkonstantenpool platziert, der zur permanenten Generation gehörte. In Java 7 wird der String-Konstantenpool auf dem Heap platziert. Dies liegt daran, dass die permanente Generierung über begrenzten Speicherplatz verfügt, was in Szenarien, in denen Zeichenfolgen häufig verwendet werden, zu OutOfMemoryError-Fehlern führen kann.

Welche Vorteile hat dieses Design, wenn man weiß, dass String unveränderlich ist?

Die Notwendigkeit eines String-Pools

Der String-Konstantenpool (String-interner Pool) ist ein spezieller Speicherbereich im Java-Heap-Speicher beim Erstellen eines String-Objekts Stunde. Wenn dieser Zeichenfolgenwert bereits im Konstantenpool vorhanden ist, wird kein neues Objekt erstellt, sondern auf das vorhandene Objekt verwiesen.

2. Erlauben Sie String-Objekten, HashCode zwischenzuspeichern

Der Hash-Code von String-Objekten wird in Java häufig verwendet, beispielsweise in Containern wie hashMap .

Die Unveränderlichkeit der Zeichenfolge stellt die Einzigartigkeit des Hash-Codes sicher, sodass er sicher zwischengespeichert werden kann. Dies ist auch eine Methode zur Leistungsoptimierung, was bedeutet, dass Sie nicht jedes Mal einen neuen Hash-Code berechnen müssen

3 Sicherheit

String wird von vielen verwendet Java-Klassen (Bibliothek) werden als Parameter verwendet, z. B. die URL der Netzwerkverbindungsadresse, der Dateipfad und die für den Reflexionsmechanismus erforderlichen Zeichenfolgenparameter usw. Wenn die Zeichenfolge nicht festgelegt ist, führt dies zu verschiedenen Sicherheitsrisiken.

boolean connect(string s){  
    if (!isSecure(s)) {   
throw new SecurityException();   
}  
    // 如果在其他地方可以修改String,那么此处就会引起各种预料不到的问题/错误   
    causeProblem(s);  
}

4. Thread-Sicherheit

String-Unveränderlichkeit ist von Natur aus Thread-sicher und kann sicher in mehreren Threads verwendet werden.

Dieser Artikel enthält eine ausführliche Einführung.

String ist unveränderlich, gibt es also einen veränderlichen String?

stellt

StringBuffer und StringBuilder in Java bereit, die variabel sind. In String ist ein endgültiges Zeichenarray definiert, das also unveränderlich ist. Da StringBuffer und StringBuilder jedoch AbstractStringBuilder erben, ist aus dem Quellcode ersichtlich, dass es sich um variable Zeichenarrays handelt.

public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence{

rrree

Laut Quellcode können wir auch wissen, dass StringBuffer threadsicher ist und alle seine Methoden durch

geändert werden. synchronized

Verwandte Artikel:

Datentypen mit Grundkenntnissen in JavaScript_Grundkenntnisse

Grundlegende Datentypen und Streams in Java

Ähnliche Videos:

Überblick und Klassifizierung von Datentypen – JAVA-Anfänger-Video-Tutorial

Das obige ist der detaillierte Inhalt vonÜberblick über die Java-Grundlagen: grundlegende Datentypen und String-Typ. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!