Was sind die acht wichtigsten Datentypen in Java?

Acht Hauptdatentypen: 1. Byte (Bit), die maximale Datenspeicherkapazität beträgt 255; 2. Short (Short Integer), die maximale Datenspeicherkapazität beträgt 65536; 3. Int (Integer), die maximale Datenspeicherkapazität ist 2 von 32 Potenz minus 1; 4. long (lange Ganzzahl), die maximale Datenspeicherkapazität beträgt 2 hoch 64 minus 5. float (Floatzahl mit einfacher Genauigkeit), nach dem muss f oder F hinzugefügt werden Zahl bei direkter Zuweisung; 6, double (doppelte Genauigkeit); 7. boolean (boolescher Typ);

Die Betriebsumgebung dieses Tutorials: Windows7-System, Java8-Version, DELL G3-Computer.

1. Die acht Grunddatentypen von Java

Es gibt acht Grundtypen von Java. Die Grundtypen können in drei Kategorien unterteilt werden: den Zeichentyp char, den booleschen Typ boolean und die numerischen Typen byte, short, int, long, float, double . Numerische Typen können in die Ganzzahltypen Byte, Short, Int, Long und die Gleitkommatypen Float und Double unterteilt werden. In JAVA gibt es keine vorzeichenlosen numerischen Typen. Ihr Wertebereich ist fest und ändert sich nicht bei Änderungen in der Maschinenhardwareumgebung oder im Betriebssystem. Tatsächlich gibt es in JAVA einen weiteren Grundtyp void, der auch über eine entsprechende Verpackungsklasse java.lang.Void verfügt, wir können ihn jedoch nicht direkt bearbeiten. Der Darstellungsbereich von 8 Medientypen ist wie folgt:

Byte: 8 Bit, die maximale Menge der gespeicherten Daten beträgt 255 und der Bereich der gespeicherten Daten liegt zwischen -128 und 127.

kurz: 16 Bit, die maximale Big Data-Speicherkapazität beträgt 65536 und der Datenbereich beträgt -32768~32767.

int: 32 Bit, die maximale Datenspeicherkapazität beträgt 2 hoch 32 minus 1, der Datenbereich ist negativ 2 hoch 31 plus plus 2 hoch 31 minus 1.

lang: 64 Bit, die maximale Datenspeicherkapazität beträgt 2 hoch 64 minus 1, der Datenbereich ist negativ 2 hoch 63 plus plus 2 hoch 63 minus 1.

float: 32 Bit, Datenbereich ist 3,4e-45~1,4e38, bei direkter Zuweisung muss f oder F nach der Zahl hinzugefügt werden.

double: 64 Bit, Datenbereich ist 4,9e-324~1,8e308, d oder D können bei der Zuweisung hinzugefügt oder nicht hinzugefügt werden.

boolean: Es gibt nur zwei Werte: wahr und falsch.

char: 16 Bit, speichert Unicode-Code, weist Werte in einfachen Anführungszeichen zu.

Java bestimmt die Größe jedes einfachen Typs. Diese Größen ändern sich nicht bei Änderungen in der Maschinenarchitektur. Diese Unveränderlichkeit der Größe ist einer der Gründe, warum Java-Programme in hohem Maße portierbar sind. Die folgende Tabelle listet die in Java definierten einfachen Typen, ihre belegten Binärziffern und die entsprechenden Wrapper-Klassen auf.

??

charshortIntlong Binärziffern1816163264

float	double	void				.
32	64	--
Wrapper-Klasse	Boolean	Byte	Character	Short	Integer	Long	Float	Doppelt	Leere

Für den Wertebereich der Grundtypen numerischer Typen müssen wir uns nicht erinnern, da ihre Werte in der entsprechenden Verpackungsklasse in Form von Konstanten definiert wurden. Zum Beispiel:

Basistyp Byte Binärziffern: Byte.SIZE Minimalwert: Byte.MIN_VALUE Maximalwert: Byte.MAX_VALUE

Basistyp Short Binärziffern: Short.SIZE Minimalwert: Short.MIN_VALUE Maximalwert: Short.MAX_VALUE

Basistyp char Anzahl der Binärziffern: Character.SIZE Minimalwert: Character.MIN_VALUE Maximalwert: Character.MAX_VALUE

Basistyp double Anzahl der Binärziffern: Double.SIZE Minimalwert: Double.MIN_VALUE Maximalwert: Double.MAX_VALUE

Hinweis: Die Mindestwerte der Typen float und double stimmen nicht mit den Werten von Float.MIN_VALUE und Double.MIN_VALUE überein. Tatsächlich beziehen sich Float.MIN_VALUE und Double.MIN_VALUE auf die kleinste mögliche positive Zahl dargestellt durch die Typen float bzw. double. Das heißt, es gibt eine Situation, in der der Float-Typ den Wert zwischen 0 und ±Float.MIN_VALUE nicht darstellen kann und der Double-Typ den Wert zwischen 0 und ±Double.MIN_VALUE nicht darstellen kann. Dies ist nicht überraschend, da Werte in diesen Bereichen außerhalb ihres Genauigkeitsbereichs liegen.

Die minimalen und maximalen Werte von Float und Double werden in wissenschaftlicher Notation ausgegeben. Die „E+Zahl“ am Ende gibt an, wie oft die Zahl vor E mit 10 multipliziert werden soll. Beispielsweise ist 3,14E3 3,14×1000=3140 und 3,14E-3 ist 3,14/1000=0,00314.

Primitive Java-Typen werden auf dem Stapel gespeichert, sodass ihre Zugriffsgeschwindigkeit schneller ist als auf Instanzobjekten entsprechender Wrapper-Klassen, die auf dem Heap gespeichert sind. Ab Java 5.0 (1.5) kann die JAVA Virtual Machine (JavaVirtual Machine) die automatische Konvertierung zwischen Basistypen und ihren entsprechenden Wrapper-Klassen durchführen. Daher verwenden wir ihre Wrapper-Klassen genau wie Basistypen, wenn wir Zuweisungen, Parameterübertragungen und mathematische Operationen durchführen. Dies bedeutet jedoch nicht, dass Sie Methoden, die nur in ihren Wrapper-Klassen verfügbar sind, über Basistypen aufrufen können. Darüber hinaus verwenden die Wrapper-Klassen aller Grundtypen (einschließlich void) die endgültige Änderung, sodass wir sie nicht erben können, um neue Klassen zu erweitern, und auch keine ihrer Methoden überschreiben können.

Vorteile von Grundtypen: Die Datenspeicherung ist relativ einfach und die Betriebseffizienz ist relativ hoch.

Vorteile von Paketklassen: Einige sind einfach, zum Beispiel müssen die Elemente einer Sammlung Objekttypen sein, was der Java-Idee entspricht, dass alles so ist ein Objekt

2. Konstanten in Java

Hexadezimale Ganzzahlkonstanten: Wenn sie hexadezimal ausgedrückt werden, müssen sie mit 0x oder 0X beginnen, z. B. 0xff, 0X9A.

Oktale Ganzzahlkonstante: Oktal muss mit 0 beginnen, z. B. 0123, 034.

Langer Ganzzahltyp: Der lange Ganzzahltyp muss mit L enden, z. B. 9L, 342L.

Gleitkommakonstanten: Da der Standardtyp von Dezimalkonstanten Double ist, muss f (F) nach dem Float-Typ hinzugefügt werden. Variablen mit Dezimalzahlen haben standardmäßig auch den Typ double.

Zum Beispiel:

float f;
f=1.3f;//必须声明f。

Zeichenkonstanten: Zeichenkonstanten müssen in zwei einfache Anführungszeichen eingeschlossen werden (beachten Sie, dass Zeichenfolgenkonstanten in zwei doppelte Anführungszeichen eingeschlossen werden). Zeichen in Java belegen zwei Bytes. Einige häufig verwendete Escape-Zeichen:

①r bedeutet, dass Tastatureingaben akzeptiert werden, was dem Drücken der Eingabetaste

entspricht

②\n表示换行；

③\t表示制表符，相当于Table键；

④\b表示退格键，相当于Back Space键；

⑤\'表示单引号；

⑥\''表示双引号；

⑦\\表示一个斜杠\。

3. 数据类型之间的转换

1).简单类型数据间的转换,有两种方式:自动转换和强制转换,通常发生在表达式中或方法的参数传递时。

自动转换

具体地讲,当一个较"小"数据与一个较"大"的数据一起运算时,系统将自动将"小"数据转换成"大"数据,再进行运算。而在方法调用时,实际参数较"小",而被调用的方法的形式参数数据又较"大"时(若有匹配的,当然会直接调用匹配的方法),系统也将自动将"小"数据转换成"大"数据,再进行方法的调用,自然,对于多个同名的重载方法,会转换成最"接近"的"大"数据并进行调用。这些类型由"小"到"大"分别为 (byte，short，char)--int--long--float—double。这里我们所说的"大"与"小",并不是指占用字节的多少,而是指表示值的范围的大小。

①下面的语句可以在Java中直接通过：

byte b;
int i=b; 
long l=b; 
float f=b; 
double d=b;

②如果低级类型为char型，向高级类型（整型）转换时，会转换为对应ASCII码值，例如

char c='c'; int i=c;
System.out.println("output:"+i);

输出：output:99;

③对于byte,short,char三种类型而言，他们是平级的，因此不能相互自动转换，可以使用下述的强制类型转换。

short i=99 ; 
char c=(char)i; 
System.out.println("output:"+c);

输出：output:c;

强制转换

将"大"数据转换为"小"数据时，你可以使用强制类型转换。即你必须采用下面这种语句格式： int n=(int)3.14159/2;可以想象，这种转换肯定可能会导致溢出或精度的下降。

2)表达式的数据类型自动提升, 关于类型的自动提升，注意下面的规则。

①所有的byte,short,char型的值将被提升为int型；

②如果有一个操作数是long型，计算结果是long型；

③如果有一个操作数是float型，计算结果是float型；

④如果有一个操作数是double型，计算结果是double型；

例， byte b; b=3; b=(byte)(b*3);//必须声明byte。

3)包装类过渡类型转换

一般情况下，我们首先声明一个变量，然后生成一个对应的包装类，就可以利用包装类的各种方法进行类型转换了。例如：

①当希望把float型转换为double型时：

float f1=100.00f;
Float F1=new Float(f1);
double d1=F1.doubleValue();//F1.doubleValue()为Float类的返回double值型的方法

②当希望把double型转换为int型时：

double d1=100.00;
Double D1=new Double(d1);
int i1=D1.intValue();

简单类型的变量转换为相应的包装类，可以利用包装类的构造函数。即：Boolean(boolean value)、Character(char value)、Integer(int value)、Long(long value)、Float(float value)、Double(double value)

而在各个包装类中，总有形为××Value()的方法，来得到其对应的简单类型数据。利用这种方法，也可以实现不同数值型变量间的转换，例如，对于一个双精度实型类，intValue()可以得到其对应的整型变量，而doubleValue()可以得到其对应的双精度实型变量。

4)字符串与其它类型间的转换

其它类型向字符串的转换

①调用类的串转换方法:X.toString();

②自动转换:X+"";

③使用String的方法:String.volueOf(X);

字符串作为值,向其它类型的转换

①先转换成相应的封装器实例,再调用对应的方法转换成其它类型

例如，字符中"32.1"转换double型的值的格式为:new Float("32.1").doubleValue()。也可以用:Double.valueOf("32.1").doubleValue()

②静态parseXXX方法

String s = "1";
byte b = Byte.parseByte( s );
short t = Short.parseShort( s );
int i = Integer.parseInt( s );
long l = Long.parseLong( s );
Float f = Float.parseFloat( s );
Double d = Double.parseDouble( s );

③Character的getNumericValue(char ch)方法

5）Date类与其它数据类型的相互转换

整型和Date类之间并不存在直接的对应关系，只是你可以使用int型为分别表示年、月、日、时、分、秒，这样就在两者之间建立了一个对应关系，在作这种转换时，你可以使用Date类构造函数的三种形式：

①Date(int year, int month, int date)：以int型表示年、月、日

②Date(int year, int month, int date, int hrs, int min)：以int型表示年、月、日、时、分

③Date(int year, int month, int date, int hrs, int min, int sec)：以int型表示年、月、日、时、分、秒

在长整型和Date类之间有一个很有趣的对应关系，就是将一个时间表示为距离格林尼治标准时间1970年1月1日0时0分0秒的毫秒数。对于这种对应关系，Date类也有其相应的构造函数：Date(long date)。

获取Date类中的年、月、日、时、分、秒以及星期你可以使用Date类的getYear()、getMonth()、getDate()、getHours()、getMinutes()、getSeconds()、getDay()方法，你也可以将其理解为将Date类转换成int。

而Date类的getTime()方法可以得到我们前面所说的一个时间对应的长整型数，与包装类一样，Date类也有一个toString()方法可以将其转换为String类。

有时我们希望得到Date的特定格式，例如20020324，我们可以使用以下方法，首先在文件开始引入，

import java.text.SimpleDateFormat;
import java.util.*;
java.util.Date date = new java.util.Date();
 
//如果希望得到YYYYMMDD的格式
SimpleDateFormat sy1=new SimpleDateFormat("yyyyMMDD");
String dateFormat=sy1.format(date);
 
//如果希望分开得到年，月，日
SimpleDateFormat sy=new SimpleDateFormat("yyyy");
SimpleDateFormat sm=new SimpleDateFormat("MM");
SimpleDateFormat sd=new SimpleDateFormat("dd");
String syear=sy.format(date);
String smon=sm.format(date);
String sday=sd.format(date);

总结：只有boolean不参与数据类型的转换

（1）.自动类型的转换：a.常数在表数范围内是能够自动类型转换的

b.数据范围小的能够自动数据类型大的转换（注意特例）

int到float，long到float，long到double 是不会自动转换的，不然将会丢失精度

c.引用类型能够自动转换为父类的

d.基本类型和它们包装类型是能够互相转换的

（2）.强制类型转换：用圆括号括起来目标类型，置于变量前

4.Java引用类型

Java有 5种引用类型（对象类型）：类 接口 数组 枚举 标注

引用类型：底层结构和基本类型差别较大

JVM的内存空间：（1）. Heap 堆空间：分配对象 new Student（）

（2）. Stack 栈空间：临时变量 Student stu

（3）.Code 代码区 ：类的定义，静态资源 Student.class

eg：Student stu = new Student（）； //new 在内存的堆空间创建对象

stu.study(); //把对象的地址赋给stu引用变量

上例实现步骤：a.JVM加载Student.class 到Code区

     b.new Student()在堆空间分配空间并创建一个Student实例；

     c.将此实例的地址赋值给引用stu， 栈空间；

更多编程相关知识，请访问：编程教学！！

Das obige ist der detaillierte Inhalt vonWas sind die acht wichtigsten Datentypen in Java?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!