Aide-mémoire Java

Objectif

Les gens oublient. Surtout si vous écrivez dans différentes langues. Si vous le lisez avant d'écrire, vous pouvez faire beaucoup de progrès.

Type de données de base Type de données

Opérateurs Opérateurs

Opérateurs arithmétiques

5 + 2;		//7 ajout
5 - 2;		//3 soustraction
5 * 2;		//10 multiplication
5 / 2;		//2 division
5 % 2;		//1 surplus

y = ++x;	//Préfixe y= (x += 1);
y = x++;	//Postfix y= x; x = x + 1;

Opérateurs de comparaison

x < y;		//Moins que
x <= y;		//Moins que
x >= y;		//c'est tout
x > y;		//Excès
x == y;		//Équivalent
x != y;		//Inégal

Opérateurs logiques Opérateurs booléens

x && y;		// AND
x || y;		// OR
!x;			// NOT

String String

String str = "Chaîne";			//Initialisation

str.length();					//longueur
str.subString(start, end);		//commencer à finir-Découper 1
str1.eq­ual­s(str2);				//Jugement équivalent
str1.co­mpa­reT­o(str2);			  //Comparaison
// str1 < str2 -> -1
// str1 == str2 -> 0
// str1 > str2 -> 1

char c = str.charAt(i);				// String ->char i e caractère
char[] cs = str.toCharArray();		// String ->char entier

Conversion de type Conversion de données

int i = Intege­r.p­ars­eIn­t(­str);		// int <- String
int i = (int) d;					  // int <- double

double d = Double.pa­rse­Dou­ble­(s­tr);	// double <- String
double d = (double) i;				  // double <- int

String s = String.va­lue­Of(­i);			// String <- int
String s = String.va­lue­Of(­d);			// String <- double

Traitement numérique Math

Math.max(2, 5);		//5 plus grand
Math.min(2, 5);		//2 plus petits
Math.abs(-3);		//3 valeur absolue

Math.ceil(1.5);		// 2.0 arrondi
Math.floor(1.5);	// 1.0 troncature
Math.round(1.5);	// 2.0 arrondi

Math.pow(2, 10);	//1024 puissance
Math.sqrt(2);		// 1.414 ... racine carrée
Math.log10(1000);	//3 Logarithmique commune

Math.PI				//rapport de circonférence π
Math.E				//e Le bas du logarithme naturel

Formateur de formatage de chaîne

Je vais peut-être l'écrire bientôt.

Instructions de syntaxe de contrôle

if

if ( i > 0 ) {
 ­ ;
} else if ( i < 0 ) {
 ­ ­;
} else {
 ­ ­;
}

for / for-each

for ( int i = 0; i < max; i++ ) {
 ­ ­;
}

for ( var : colle­ction ) {
 ­ ­;
}

while / do-while

while ( i > 0 ) {
 ­ ­;
}

do {
 ­ ­;
} while ( i > 0 );

switch

switch ( i ) {
 ­ case 0:
 ­ ­ ­ ­;
 ­ ­ ­ ­break;
 ­ case 1:
 ­ ­ ­ ­;
 ­ ­ ­ ­break;
 ­ ­def­ault:
 ­ ­ ­ ­;
}

Array Array

Tableau à 1 dimension

//Initialisation
int[] num = new int[10];
Arrays.fill(num, 0);

//Copie profonde copie profonde
String[] copySrc = new String[10];	//Original
String[] copyDst = new String[10];	//Copier
copyDst = Arrays.copyOf(copySrc, copySrc.length);

Tableau multidimensionnel

//Initialisation
int[][] num = new int[10][10];
for (int i = 0; i < num.length; i++) {
	Arrays.fill(num[i], 0);
}

//Copie profonde
String[][] copySrc = new String[10][10];	//Original
String[][] copyDst = new String[10][10];	//Copier
for (int i = 0; i < copySrc.length; i++) {
	copyDst[i] = Arrays.copyOf(copySrc[i], copySrc[i].length);
}

Liste ArrayList

//Initialisation
List<String> list = new ArrayList<String>();

//Manipulation par objet
list.add(str);		//ajouter à
list.remove(str);	//Effacer
list.indexOf(str);	//Obtenir l'index
list.contains(str);	//Contrôle d'existence

//Fonctionnement par index
list.get(i);		//Obtenez i th
list.set(i, str);	//Remplacez-moi

HashMap HashMap

//Initialisation
// key -> int
// value -> String
HashMa­p<Integer, St­rin­g> hMap =­ new HashMa­p<Integer, String­>();

hMap.pu­t(­i­, ­str);		//ajouter à
hMap.ge­t(­i);			//Avoir
hMap.co­nta­ins­Key­(i);	//Contrôle d'existence

File d'attente de priorité

PriorityQueue<Integer> pQueue = new PriorityQueue<Integer>();
pQueue.offer(i);	//ajouter à
pQueue.peek(i);		//Obtenir (ne pas supprimer de la file d'attente)
pQueue.poll(i);		//Get (supprimer de la file d'attente)