Code-Snippets

Strings aus einer Liste mit Trenner aneinander hängen:

List<String> exampleList = Arrays.asList(new String[]{"1", "2", "3"});

String delimiter = "";
StringBuilder builder = new StringBuilder();

for (String example : exampleList) {
   builder.append(delimiter).append(example);
   delimiter = ",";
}

System.out.println(builder.toString());

In der Schleife wird immer wieder das Komma der Variablen delimiter zugewiesen.
Ich finde das allerdings schöner, als noch irgendwelche Abfragen mit if machen zu müssen.

Kaufmännisches runden auf zwei Nachkommastellen:

double d = 5.12679;
d = ((double)(Math.round(d*100))) / 100;

System.out.println(d);

Im Beispiel wird auf zwei Nachkommastellen gerundet.

Das funktioniert so:
Die 5,12678 werden mit 100 mal genommen (512,678) und anschließend auf 513 grundet.
Danach wird 513 durch 100 geteilt, das ergibt 5,13.

Wer auf eine andere Nachkommstelle runden möchte, ersetzt die 100 durch etwas anderes (1000 = 3 Nachkommastellen, 10000 = 4 Nachkommastellen, usw.)

Führende Nullen:

int[] numbers = {1,2,3,4,5,6,7,8,9,10};
int paddingSize = 2;
String format = "%0" + paddingSize + "d";
for(int num : numbers) {
   System.out.println(String.format(format, num));
}

Im Beispiel werden einer Zahl so viele Nullen vorangestellt, bis die Breite von 2 (siehe paddingSize) erreicht ist.
Die Ausgabe sieht wie folgt aus:

01
02
03
04
05
06
07
08
09
10

Ein einfaches „shift“ Beispiel:

public void basicRightShift() {
	int value = 8;
	
	while (value > 0) {
		System.out.println("int value: " + value + " - binary value: " + Integer.toBinaryString(value));
		value = value >> 1;
	}
}

In dem Beispiel wird mit Hilfe des Shift-Operators >> immer ein Bit weiter nach rechts geschoben.
Die Ausgabe sieht so aus:

int value: 8 – binary value: 1000
int value: 4 – binary value: 100
int value: 2 – binary value: 10
int value: 1 – binary value: 1

Eine Ganzzahl in Zweierkomplemente zerlegen:

public void testCreateComplementsOfTwo() {
	Long value = 262L;
	
	List<Long> complementsOfTwo = createComplementsOfTwo(value);
	
	System.out.println("The value " + value + " consists of these complements: ");
	for (Long complement : complementsOfTwo) {
		System.out.println(complement);
	}
}
	
public List<Long> createComplementsOfTwo(Long value) {
	/** The maximum complement of two as binary value (based on Long) **/
	final long MAX_COMPLEMENT_OF_TWO =
			0b100000000000000000000000000000000000000000000000000000000000000L;
		
	final List<Long> complements = new ArrayList<>();
	Long currentComplement = MAX_COMPLEMENT_OF_TWO;
		
	if (value != null && value > 0) {
		while (currentComplement > 0) {
			if ((currentComplement & value) != 0) {
				complements.add(currentComplement);
			}
			currentComplement = currentComplement >> 1;
		}
	}

	return complements;
}

Das Beispiel zerlegt eine positive Ganzzahl (in diesem Fall 262) in seine Zweierkomplemente.
Die Ausgabe sieht wie folgt aus:

The value 262 consists of these complements:
256
4
2