Java Spickzettel

Zweck

Die Leute vergessen. Vor allem, wenn Sie in verschiedenen Sprachen schreiben. Wenn Sie es vor dem Schreiben lesen, können Sie große Fortschritte machen.

Grunddatentyp Datentyp

Operatoren Operatoren

Rechenzeichen

5 + 2;		//7 zusätzlich
5 - 2;		//3 Subtraktion
5 * 2;		//10 Multiplikation
5 / 2;		//2 Abteilung
5 % 2;		//1 Überschuss

y = ++x;	//Präfix y= (x += 1);
y = x++;	//Postfix y= x; x = x + 1;

Vergleichsoperatoren

x < y;		//Weniger als
x <= y;		//Weniger als
x >= y;		//das ist alles
x > y;		//Überschuss
x == y;		//Äquivalent
x != y;		//Nicht gleich

Logische Operatoren Boolesche Operatoren

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

String String

String str = "String";			//Initialisieren

str.length();					//Länge
str.subString(start, end);		//Anfang bis Ende-1 ausschneiden
str1.eq­ual­s(str2);				//Gleichwertiges Urteil
str1.co­mpa­reT­o(str2);			  //Vergleich
// str1 < str2 -> -1
// str1 == str2 -> 0
// str1 > str2 -> 1

char c = str.charAt(i);				// String ->char i th Charakter
char[] cs = str.toCharArray();		// String ->ganzer Saibling

Typkonvertierung Datenkonvertierung

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

Numerische Verarbeitung Math

Math.max(2, 5);		//5 größer
Math.min(2, 5);		//2 kleiner
Math.abs(-3);		//3 absoluter Wert

Math.ceil(1.5);		// 2.0 aufrunden
Math.floor(1.5);	// 1.0 Kürzung
Math.round(1.5);	// 2.0 Rundung

Math.pow(2, 10);	//1024 Leistung
Math.sqrt(2);		// 1.414 ... Quadratwurzel
Math.log10(1000);	//3 Gemeinsamer Logarithmus

Math.PI				//π Umfangsverhältnis
Math.E				//e Der Boden des natürlichen Logarithmus

String-Formatierung Formatierer

Ich kann es bald schreiben.

Steuerungssyntaxanweisungen

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

1-dimensionales Array

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

//Deep Copy Deep Copy
String[] copySrc = new String[10];	//Original
String[] copyDst = new String[10];	//Kopieren nach
copyDst = Arrays.copyOf(copySrc, copySrc.length);

Mehrdimensionales Array

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

//Tiefe Kopie
String[][] copySrc = new String[10][10];	//Original
String[][] copyDst = new String[10][10];	//Kopieren nach
for (int i = 0; i < copySrc.length; i++) {
	copyDst[i] = Arrays.copyOf(copySrc[i], copySrc[i].length);
}

Liste ArrayList

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

//Manipulation durch Objekt
list.add(str);		//hinzufügen
list.remove(str);	//Löschen
list.indexOf(str);	//Index abrufen
list.contains(str);	//Existenzprüfung

//Operation nach Index
list.get(i);		//Holen Sie sich i th
list.set(i, str);	//Ersetzen Sie i th

HashMap HashMap

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

hMap.pu­t(­i­, ­str);		//hinzufügen
hMap.ge­t(­i);			//Erhalten
hMap.co­nta­ins­Key­(i);	//Existenzprüfung

Prioritätswarteschlange

PriorityQueue<Integer> pQueue = new PriorityQueue<Integer>();
pQueue.offer(i);	//hinzufügen
pQueue.peek(i);		//Get (nicht aus der Warteschlange entfernen)
pQueue.poll(i);		//Get (aus der Warteschlange entfernen)