Analyse des méthodes de fonctionnement et des types de données de base en Java (Collection)

L'éditeur suivant vous proposera un article sur les types de données de base et les méthodes de fonctionnement de Java (un article à lire absolument). L'éditeur le trouve plutôt bon, je vais donc le partager avec vous maintenant et le donner comme référence pour tout le monde. Suivons l'éditeur pour venir jeter un œil

Encodage

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

Code d'Europe occidentale table-- -ISO-8859-1---0-255---1 octet

gb2312----0-65535---gbk---2 octets

Unicode système d'encodage --- utf-8 --- 3 octets

en f

bit Octet octet 1 octet = 8 bits 1 Ko = 1024 Mo Mo Go To PB --- dans les ordinateurs Unité de stockage

Constante

Constante entière --- tous les entiers 3,99 107

Constante décimale --- tous décimaux 3,5 100,9

Constante de caractère --- utilisez des guillemets simples pour identifier une lettre, un chiffre ou un symbole 'a' '=' ' '

Constante de chaîne --- utilisez des guillemets doubles Identifiez un ou plusieurs caractères "abc" "234" "q2" ""

Constante booléenne---utilisée pour représenter des valeurs logiques---vrai/faux

constante vide- --null

5- entier, 5,0-décimal '5'-caractère "5"-chaîne '5.0'-mauvaise écriture "5.0"-chaîne

Système binaire

Système binaire : complet deux contre un, 0~1 1+1=10 0b10011 0b0011, à partir de JDK1.7, il est permis de commencer par 0b pour identifier un nombre Nombres binaires

Octal : 0 à 1, 0~7, 7+1=10. Il doit commencer par 0 06 015

Décimal : 0 à 9

Hexadécimal : un hexadécimal complet, 0~9,, A~F. , 9+1=A f+1=10 nécessite 0x comme début 0x5 0xad

Conversion de la base

décimalConversion de la base en binaire : continuez à diviser par 2 pour prendre le reste, puis mettez le reste dans l'ordre inverse

Convertir le binaire en décimal : à partir de l'ordre inférieur, multipliez l'ordre par la puissance de commande de 2 , puis résumez

Conversion binaire en octal : en commençant par l'ordre bas, divisez tous les trois chiffres en un groupe et remplissez 0 pour les trois chiffres manquants, ce qui donne un nombre octal, organisez ces nombres afin de convertir l'octal en binaire : un à trois --- un nombre octal produit trois chiffres binaires

Binaire en hexadécimal Base : Le processus de changement de quatre en un

Variable

int i = 5;---Non---La variable doit d'abord déclarer que vous utilisez

System.out.println(i);

int i;

System.out.println(i); --- Non ---- les variables doivent être initialisées avant utilisation

Type de données

Type de données de base

Type numérique

Type entier

octet---type d'octet---1 octet--- - 2^7~2^7-1 --- -128~127

octet b = 5 ; octet b2 = -128;

court---court---2 octets- -- -2^15~2^15-1 --- -32768~32767

court s = 54 ; court s = -900;

int---entier--- 4 octets --- -2^31~2^31-1

int i = 100000;

int j = 100_000_000;--Autorisé à partir de JDK1.7. Ceux-ci seront automatiquement ignorés lors de la compilation_ -> int j = 100000000;

int i = 00001111;---Octal

Le type d'entier par défaut en Java est int

long---long entier---8 octets--- -2^63~2^63-1---se terminant par L indique que ce nombre est un nombre de type long

long l = 3L ;

Type flottant

float---simple précision---4 octets---doit se terminer par f

float f = 3.2f;

double---double précision---8 octets

Le type décimal par défaut en Java est le type double

double d = 3.5;

double d = 4.6D; ---can

double d = 3.9e4; //C'est une notation scientifique en système décimal

double d = 0x3p2; //C'est une notation scientifique hexadécimale->

Caractère

char---2 octets--- 0 ~65535

char c = 'a';

char c = '中';

Booléen

booléen---vrai/faux

booléen b = faux;

Type de données de référence

Classe ---interface de classe ---tableau d'interfaces---[]

Conversion de type de données

Conversion implicite/Conversion de type automatique

Règle 1 : Les petits types peuvent être convertis en grands types ---byte->short->int- >long float->double

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

Règle 2 : Les entiers peuvent être convertis en décimaux, mais une perte de précision peut survenir

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

Règle 3 : Les types de caractères peuvent être convertis en entiers

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

définit une variable c de type char. Les données stockées sont un caractère. Il n'est pas nécessaire de vérifier le codage de caractère spécifique lors de l'attribution d'une valeur au type court, short doit vérifier si le codage correspondant au caractère est dans la plage de valeurs du type court. Le codage spécifique correspondant à ce caractère ne peut pas être déterminé pour le moment. Étant donné que la plage de valeurs du type court ne chevauche pas complètement le type char, afin d'éviter que la situation ne dépasse la plage, l'affectation n'est pas autorisée.

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

Conversion/casting explicite

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

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

Opérateurs

Opérateurs arithmétiques

+addition-soustraction*multiplication/division%modulo++auto-increment--auto-decrement+concaténation de chaînes

Remarque :

int i = 5210 / 1000 * 1000;--->i = 5000;

1. Une fois l'opération sur les entiers terminée, le résultat doit être un entier

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();

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!