Verwendet man in Java short oder byte?

Question

Abgesehen von der Verwendung von (byte[]) im Streaming sehe ich Byte und Short nicht wirklich oft verwendet. Andererseits habe ich gesehen, dass long verwendet wird, wenn der tatsächliche Wert |100| ist und byte besser geeignet wäre. Ist dies eine Folge der relativ günstigen Natur des Speichers oder ist dies nur eine Kleinigkeit, um die sich die Entwickler nicht kümmern müssen?

Answer 1

Sie werden bei der Programmierung von eingebetteten Geräten verwendet, die wenig Speicherplatz oder Festplattenkapazität haben. Zum Beispiel für Haushaltsgeräte und andere elektronische Geräte.

Byte wird auch in der Low-Level-Webprogrammierung verwendet, wo Sie Anfragen an Webserver mit Headern usw. senden.

Answer 2

El byte Datentyp wird häufig verwendet, wenn es um Rohdaten aus einer Datei oder einer Netzwerkverbindung geht, obwohl er meist als byte[] . Die short y short[] Typen werden häufig im Zusammenhang mit grafischen Benutzeroberflächen und der Bildverarbeitung (für Pixelpositionen und Bildgrößen) sowie bei der Tonverarbeitung verwendet.

Der Hauptgrund für die Verwendung von byte o short ist eine Frage der Klarheit. Der Programmcode besagt kategorielos, dass nur 8 oder 16 Bits zu verwenden sind, und wenn Sie versehentlich einen größeren Typ verwenden (ohne entsprechendes Typecast), erhalten Sie einen Kompilierungsfehler. (Zugegebenermaßen könnte dies auch als ein Ärgernis beim Schreiben des Codes angesehen werden ... aber auch hier zeigt das Vorhandensein der Typecasts dem Leser die Tatsache an, dass eine Trunkierung stattfindet.)

Sie erreichen keine Platzersparnis durch die Verwendung von byte o short in einfachen Variablen anstelle von int da die meisten Java-Implementierungen Stack-Variablen und Objektmitglieder an Wortgrenzen ausrichten. Primitive Array-Typen werden jedoch anders behandelt, d.h. Elemente von boolean , byte , char y short Arrays sind byte-ausgerichtet. Solange die Arrays jedoch nicht sehr groß oder zahlreich sind, tragen sie nicht wesentlich zum Gesamtspeicherverbrauch der Anwendung bei.

Ich vermute also, dass der Hauptgrund dafür, dass Entwickler keine byte o short so viel, wie Sie (als C-Entwickler?) vielleicht erwarten, ist, dass es wirklich keinen großen (oder oft gar keinen) Unterschied macht. Java-Entwickler neigen nicht dazu besetzen über die Speichernutzung, wie es C-Entwickler der alten Schule taten :-).

Answer 3

In einem 64-Bit-Prozessor sind die Register alle 64-Bit. Wenn also Ihre lokale Variable einem Register zugewiesen ist und ein Boolean, Byte, Short, Char, Int, Float, Double oder Long ist, wird kein Speicher verwendet und es werden keine Ressourcen gespart. Objekte sind 8-Byte-ausgerichtet, so dass sie immer ein Vielfaches von 8 Byte im Speicher einnehmen. Das bedeutet, dass Boolean, Byte, Short, Character, Integer, Long, Float und Double, AtomicBoolean, AtomicInteger, AtomicLong, AtomicReference alle die gleiche Menge an Speicher verwenden.

Wie bereits erwähnt, werden kurze Typen für Arrays und das Lesen/Schreiben von Datenformaten verwendet. Selbst dann wird short IMHO nicht sehr oft verwendet.

Es ist auch erwähnenswert, dass ein GB auf einem Server etwa 80 Pfund kostet, also ist ein MB etwa 8 Pence und ein KB etwa 0,008 Pence. Der Unterschied zwischen Byte und Long beträgt etwa 0,00006 Pence. Ihre Zeit ist mehr wert als das, vor allem, wenn Sie jemals einen Fehler haben, der auf einen zu kleinen Datentyp zurückzuführen ist.

Answer 4

Stephen C. obige Antwort ist falsch. (Leider habe ich nicht genug Rufpunkte, um einen Kommentar abzugeben, also muss ich hier eine Antwort posten)

Er erklärte

"Sie erzielen keine Platzersparnis, wenn Sie Byte oder Short in einfachen Variablen anstelle von Int verwenden, da die meisten Java-Implementierungen Stack-Variablen und Objektmitglieder an Wortgrenzen ausrichten.

Das ist nicht wahr. Das folgende Programm läuft auf Oracle JDK1.8.0 , mit jol

public class CompareShorts {
    public static void main(String[] args) {
        System.out.println(VM.current().details());
        System.out.println(ClassLayout.parseInstance(new PersonalDetailA()).toPrintable());
        System.out.println(ClassLayout.parseInstance(new PersonalDetailB()).toPrintable());
    }
}
class PersonalDetailA {
     short height;
     byte color;
     byte gender;
}

class PersonalDetailB{
     int height;
     int color;
     int gender;
}

Das Ergebnis:

# Running 64-bit HotSpot VM.
# Using compressed oop with 3-bit shift.
# Using compressed klass with 3-bit shift.
# Objects are 8 bytes aligned.
# Field sizes by type: 4, 1, 1, 2, 2, 4, 4, 8, 8 [bytes]
# Array element sizes: 4, 1, 1, 2, 2, 4, 4, 8, 8 [bytes]

com.hunterstudy.springstudy.PersonalDetailA object internals:
 OFFSET  SIZE    TYPE DESCRIPTION                               VALUE
      0     4         (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
      4     4         (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4         (object header)                           82 22 01 f8 (10000010 00100010 00000001 11111000) (-134143358)
     12     2   short PersonalDetailA.height                    0
     14     1    byte PersonalDetailA.color                     0
     15     1    byte PersonalDetailA.gender                    0
Instance size: 16 bytes
Space losses: 0 bytes internal + 0 bytes external = 0 bytes total

com.hunterstudy.springstudy.PersonalDetailB object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           e1 24 01 f8 (11100001 00100100 00000001 11111000) (-134142751)
     12     4    int PersonalDetailB.height                    0
     16     4    int PersonalDetailB.color                     0
     20     4    int PersonalDetailB.gender                    0
Instance size: 24 bytes
Space losses: 0 bytes internal + 0 bytes external = 0 bytes total

Wie Sie sehen können, benötigt die Klasseninstanz, die Shorts und Bytes verwendet, 16 Bytes, und die Klasseninstanz, die Ints verwendet, 24 Bytes. Es werden also acht Bytes Speicherplatz pro Klasseninstanz eingespart.

Answer 5

Arithmetik am byte s und short s ist ungeschickter als bei int s. Zum Beispiel, wenn b1 y b2 sind zwei byte Variablen, können Sie nicht schreiben byte b3 = b1 + b2 um sie hinzuzufügen. Der Grund dafür ist, dass Java intern niemals arithmetische Berechnungen durchführt, die kleiner sind als eine int , so dass der Ausdruck b1 + b2 hat Typ int auch wenn sie nur zwei byte Werte. Sie müssten Folgendes schreiben byte b3 = (byte) (b1 + b2) stattdessen.