Analyse von Operationsmethoden und grundlegenden Datentypen in Java (Sammlung)

Der folgende Editor bringt Ihnen einen Artikel über die grundlegenden Datentypen und Betriebsmethoden von Java (ein Artikel, den Sie unbedingt lesen müssen). Der Herausgeber findet es ziemlich gut, deshalb teile ich es jetzt mit Ihnen und gebe es als Referenz. Schauen Sie sich den Editor an

Kodierung

ASCII--0~127 65-A 97-a

Westeuropäische Codetabelle- - -ISO-8859-1---0-255---1 Byte

gb2312----0-65535---gbk---2 Bytes

Unicode-Kodierungssystem ---utf-8---3 Bytes

in f

Bit Byte Byte 1Byte = 8bit 1KB=1024B MB GB TB PB---in Computern Speichereinheit

Konstante

Ganzzahlkonstante---alle Ganzzahlen 3,99,107

Dezimalkonstante---alle Dezimalzahlen 3,5 100,9

Zeichenkonstante – verwenden Sie einfache Anführungszeichen, um einen Buchstaben, eine Zahl oder ein Symbol zu identifizieren " "q2" ""

Boolesche Konstante---wird zur Darstellung logischer Werte verwendet---wahr/falsch

leere Konstante- --null

5-Ganzzahl, 5.0-dezimal '5'-Zeichen "5"-Zeichenfolge '5.0'-falsche Schreibweise "5.0"-Zeichenfolge

Binärsystem Binärsystem: Vollständiges Binärsystem, 0~1 1+1=10 0b10011 0b0011, ab JDK1.7 ist es erlaubt, mit 0b zu beginnen, um eine Zahl zu identifizieren

Oktal: 0 bis 1, 0~7, 7+1=10. Es muss mit 0 06 015 beginnen

Dezimal: 0 bis 9

Hexadezimal: Vollständige Hexadezimalzahl, 0~9, A~F, 9 +1=A f+1=10 erfordert 0x als Anfang 0x5 0xad

Konvertierung der Basis

dezimal

Konvertierung der Basis

in binär: Teilen Sie weiter durch 2, um den Rest zu erhalten, und setzen Sie den Rest dann in umgekehrter Reihenfolge umBinär in Dezimalzahl umwandeln: von Beginnen Sie mit der niederwertigen Ordnung, multiplizieren Sie die Ordnung mit der Potenz von 2 und dann zusammenfassen

Binäre Konvertierung in Oktal: Ausgehend von der unteren Reihenfolge werden alle drei Ziffern in eine Gruppe unterteilt und die fehlenden drei Ziffern mit 0 aufgefüllt, was zu einer Oktalzahl führt. Ordnen Sie diese Zahlen in an Reihenfolge zur Konvertierung von Oktalzahlen in Binärzahlen: eins bis drei --- eine Oktalzahl erzeugt drei Binärziffern

Binärzahl in Hexadezimalzahl Basis: Der Prozess der Umwandlung von vier in eins

Variable

int i = 5;---Nein---Variable muss Zuerst deklarieren, dass Sie

System.out.println(i);

int i;<🎜 verwenden >

System.out.println(i); --- Nein ---- Variablen müssen vor der Verwendung initialisiert werden

Datentyp

Basisdatentyp

Numerischer Typ

Integer-Typ

Byte---Byte-Typ---1 Byte--- -2 ^7~2^7-1 --- -128~127

Byte b = 5; Byte b2 = -128;

kurz---kurz---2 Bytes-- - -2^15~2^15-1 --- -32768~32767

short s = 54; short s = -900;

int---integer---4 Bytes--- -2^31~2^31-1

int i = 100000;

int j = 100_000_000;--Zulässig ab JDK1.7. Diese werden während der Kompilierung automatisch ignoriert_ -> int j = 100000000;

int i = 00001111;---Octal

Der Standardtyp für Ganzzahlen in Java ist int

long---long integer---8 bytes--- -2^63~2^63-1---endet mit L zeigt an, dass diese Zahl eine lange Typzahl ist

long l = 3L ;

Float-Typ

float---einfache Genauigkeit---4 Bytes---muss mit f enden

float f = 3.2f;

double---double precision---8 bytes

Der Standard-Dezimaltyp in Java ist der Double-Typ

double d = 3.5;

double d = 4.6D; ---can

double d = 3.9e4; //Es ist wissenschaftliche Notation in Dezimalform

double d = 0x3p2; //Es ist hexadezimale wissenschaftliche Notation->

Zeichentyp

char---2 bytes--- 0 ~65535

char c = 'a';

char c = '中';

Boolean

boolean---true/false

boolean b = false;

Referenzdatentyp

Klasse ---Klassenschnittstelle ---Schnittstellenarray---[]

Datentypkonvertierung

Implizite Konvertierung/

Automatische Typkonvertierung

Regel 1: Kleine Typen können in große Typen konvertiert werden ---byte->short->int- >long float->double

Regel 2: Ganzzahlen können in Dezimalzahlen konvertiert werden, es kann jedoch zu Präzisionsverlusten kommen

byte b = 100;
int i = b;
long l = 63;---可以---当整数的值在int类型的范围内的时候，可以不用添加L这个结尾

Regel 3: Zeichentypen können in Ganzzahlen konvertiert werden

int i = 5;
float f = i;
long l = 6;
float f = l;

definiert die Variable c vom Typ char Bei den gespeicherten Daten handelt es sich nicht um eine Überprüfung der spezifischen Zeichenkodierung. Beim Zuweisen eines Werts zum Kurztyp muss überprüft werden, ob die dem Zeichen entsprechende Kodierung innerhalb des Wertebereichs des Kurztyps liegt. Die diesem Zeichen entsprechende spezifische Codierung kann derzeit nicht ermittelt werden, da der Wertebereich des Kurztyps nicht vollständig mit dem Zeichentyp überlappt. Um zu verhindern, dass der Bereich überschritten wird, ist eine Zuweisung nicht zulässig.

char c = ‘a';
int i = c;

Explizite Konvertierung/Casting

short s = ‘a';---可以
char c = 100;---可以
char c = ‘a';
short s = c;---不可以

short s = 97;
char c = s;--不可以

Operatoren

long l = 54;
int i = (int)l;
double d = 3.5;
int i = (int)d;---小数强转成整数的时候，小数部分直接舍弃
double类型不能精确存储小数
Hexadecimal--十六进制
Decimal--十进制
Octal---八进制
Binary--二进制

Arithmetische Operatoren

+Addieren-Subtrahieren*Multiplikation/Division% Modulo++Auto-Inkrementieren--Auto-Dekrementieren+String-VerkettungHinweis:

1. Nach Abschluss der Ganzzahloperation muss das Ergebnis eine Ganzzahl sein

2. 整数除以0的时候，编译通过，运行报错---ArimeticException---算术异常

3. 小数除以0的结果是Infinity

4. 0/0.0的结果是NaN---Not a Number---非数字

5. byte/short类型在运算的时候会自动提升为int类型

%取余运算
-5%3=-2 -4%3=-1 -3%7=-3
5%-3=2 7%-2=1 2%-8=2
-5%-3=-2 -9%-3=0

对于负数的取余，先按照正数的取余运算，看取余符号左边的数字的符号，如果左边是负数，那么结果就是负数

5%1.2=0.2 6%1.3=0.8
4.3%1.4=0.1
++/--

对于++在原来的基础上自增1

int i = 5;
int j = ++i;---> i自增1，然后将i的值赋值给j---先自增，再运算
int j = i++;--->先获取i的值5，i自增变成6，然后将获取的值5赋值给j---先运算，再自增
int i = 3;
int j = ++i * 2;-> j = 8;
int j = i++ * 2;->j = 6
int i = 6;
int j = i++ + ++i;->i = 8; j = 14;
int j = ++i + i++;->i = 8; j = 14
byte b = 5;
b++;---JVM在底层会对结果进行强制类型转换，将结果再转换为byte类型
char c = ‘a';
System.out.println(c + 4);--可以
char c2 = ‘d';
System.out.println(c + c2);---提升为int类型之后再进行运算
+ 字符串拼接运算
“a” + “b”---> “ab”
“a” + 3---> “a3”
“a” + true-> “atrue”
2 + 4 + “f”-> “6f”
“f” + 2 + 4-> “f24”

赋值运算符

= += -= *= /= %= &= |= ^= <<= >>= >>>= ~=
int i= 5;
i += 3; -> i = i + 3; -> i = 8;
i -= 2;-> i = i - 2;-> i = 3;
int j;
j += 4;---不行
int i = 5;
i += i -= i *= 5;--> i = -15;
i = 5 + ( 5 - (5 * 5)) ;
i += i -= i *= ++i;--->i = -20;
i += i*= i-= (i++ + --i);---> i = -20;
i = 5 + ( 5 * (5 - (5 + 5)));
byte b = 5;
b += 3;---可以
byte b = 125;
b += 3;---可以--- -128

比较/关系运算符

==相等 !=不等 > < >= <= instanceof
3 == 4;-> false
instanceof---判断对象与类的关系的--只能用于引用数据类型
String s = “abd”;
System.out.println(s instanceof String);---true
System.out.println(“def” instanceof String);---true

逻辑运算符

用于运算逻辑值

&与 |或 !非 ^异或 &&短路与 ||短路或
true&true=true true&false=false false&true=false false&false=false
true|true=true true|false=true false|true=true false|false=false
!true=false !false=true
true^true=false true^false=true false^true=true false^false=false

对于&&，如果前一个表达式的值为false，那么就能确定整个表达式的值为false，&&后边的运算就不再进行了

三元/三目/条件运算符

逻辑值?表达式1:表达式2

如果逻辑值为true，执行表达式1；反之执行表达式2

int i = 5, j = 7;
i > j ? System.out.println(i): System.out.println(j);---不行！三元运算符运算完成之后必须有结果！

double d = i > j ? i * 2.5 : j;---两个表达式的返回值类型要么一致，要么相容

从控制台获取数据

import java.util.Scanner; //写在package之下，class 之上
Scanner s = new Scanner(System.in);
int i = s.nextInt();
double d = s.nextDouble();
String str = s.nextLine();
String str2 = s.next();

Das obige ist der detaillierte Inhalt vonAnalyse von Operationsmethoden und grundlegenden Datentypen in Java (Sammlung). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!