Separates Watches-Fenster in IntelliJ IDEA aktivieren

In den neueren Versionen der Java-IDE IntelliJ IDEA wurde die Ansicht des Variables– und des Watches-Fensters standardmäßig zusammengelegt. Damit können alle aktuell aktiven Variablen und die selbstdefinierten Watches in einem Fenster betrachtet werden.

Standardmäßig ist das Variablen- und das Watch-Fenster zu einem Fenster zusammengefasst

Dem ein oder anderen mag diese neue Ansicht zu unübersichtlich sein. Die alte Ansicht ist nicht aus der IDE verschwunden, so das diese wieder aktiviert werden kann. Dazu muss dann Brillensymbol in der vertikalen Symbolleiste des Fensters ausgewählt werden.

Die alte Ansicht kann wieder aktiviert werden

Damit wird die alte Ansicht, in der die aktiven Variablen und die Watches wieder getrennt sind, aktiviert.

Maps unter Java mit computeIfAbsent nutzen

Wenn eine Map unter Java etwas komplexer wird, wie z.B. folgende Map:

Map<String, List<String>> testMap = new HashMap<>();

wird das befüllen derselbigen interessant. In diesem Beispiel soll ein Key und ein neuer Value für die Liste vom Typ String hinzugefügt werden. Damit dies funktioniert muss überprüft werden ob der Key bereits existiert und wenn dies nicht der Fall ist, ein neuer Key angelegt werden. Im kompletten Beispiel sieht das Ganze so aus:

String key = "ABC";
String valueForList = "DEF";

Map<String, List<String>> testMap = new HashMap<>();

if(!testMap.containsKey(key)) {
    testMap.put(key, new ArrayList<>());
} 

testMap.get(key).add(valueForList);

Einfacher und unkomplizierter ist es die Methode computeIfAbsent zu nutzen, welche seit Java 8 in der Definition des Map-Interfaces enthalten ist. Mit der Nutzung der Methode verkürzt sich das Beispiel wie folgt:

String key = "ABC";
String valueForList = "DEF";

Map<String, List<String>> testMap = new HashMap<>();
testMap.computeIfAbsent(key, s -> new ArrayList<>()).add(valueForList);

Damit wird automatisch eine neue ArrayList angelegt, wenn der entsprechende Schlüssel noch nicht hinterlegt ist. Anschließend kann der entsprechende Wert für die Liste hinzugefügt werden.

Java Exceptions in Strings verpacken

Wenn in einem Java-Programm etwas schiefläuft so, wird in den meisten Fällen eine Exception erzeugt und diese nach oben im Stack durchgereicht, bis sie behandelt wird. Manchmal ist es notwendig die Exception bzw. Teile davon in einen String umzuwandeln. Natürlich kann die Exception nun mühsam von Hand auseinander genommen und in einen String konvertiert werden. Sinnvoller ist es die Hilfsmethoden aus der Utility-Bibliothek Guava zu nutzen:

String stacktrace = Throwables.getStackTraceAsString(e);

Bei der Methode getStackTraceAsString wird der Stacktrace der betreffenden Exception in einen String umgewandelt. Neben dieser Methode existieren weitere Methoden rund um das Exception-Handling in der Klasse Throwables. Einfacher wird das Ganze, wenn ein Logger genutzt wird und in diesem die Exception auftauchen soll:

Logger logger = LoggerFactory.getLogger(new Exception().fillInStackTrace().getStackTrace()[0].getClassName());
logger.error("Exception: ", e);

In diesem Fall bieten die meisten Logger die Möglichkeit an, das Throwable direkt als Parameter zu übergeben. Die weitere Verarbeitung der Exception wird anschließend vom Logger erledigt.

Konvertierungen zwischen alter und neuer Datums- und Zeit-API

Seit Java 8 verfügt die Programmiersprache über eine sinnvolle Datums- und Zeit-API. In den meisten Fällen kann diese API ohne weitere Probleme genutzt werden. Problematisch wird es nur, wenn die neue API im Zusammenhang mit Legacy-Code genutzt werden soll. Meist wird dort die Klasse Date aus dem Package java.util genutzt. Damit werden Methoden benötigt, um eine Brücke von der alten zur neuen API und umgekehrt zu schlagen. Um ein Date in eine LocalDateTime umzuwandeln, kann folgende Methode genutzt werden:

public static LocalDateTime convertToLocalDateTime(Date date) {
    return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
}

Soll der Wert, welcher in der LocalDateTime gespeichert ist, wieder in ein Date-Objekt konvertiert werden, kann folgende Methode genutzt werden:

public static Date convertToDate(LocalDateTime localDateTime) {
    return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
}

Bei diesen Konvertierungsmethoden ist zu beachten, dass die Zeitzonen bei der Konvertierung ignoriert werden. Stattdessen wird die Konvertierung mit der Standardzeitzone des Systems durchgeführt. Für die Konvertierung unter Berücksichtigung und Speicherung der Zeitzonen kann die Klasse ZonedDateTime genutzt werden. Die entsprechenden Methoden zur Konvertierung wären folgende:

public static ZonedDateTime convertToZonedDateTime(Date date, ZoneId zoneId) {
    return date.toInstant().atZone(zoneId);
}

public static Date convertToDate(ZonedDateTime zonedDateTime) {
    return Date.from(zonedDateTime.toInstant());
}

Bei der Konvertierung einer Date-Instanz in eine ZoneDateTime muss die entsprechende Zeitzone als ZoneId mitgegeben werden.

Probleme mit der Methode appendReplacement unter Java

Mit regulären Expressionen kann in einem String nach bestimmten Zeichenketten gesucht werden. Daneben ist es natürlich auch möglich diese Zeichenketten zu modifizieren und sie anschließend zu ersetzen. Unter Java würde das Ganze wie folgt aussehen:

private static String convertBlockquotes(String html) {

	Pattern patternBlockquote = Pattern.compile("<blockquote>(.+?)</blockquote>", Pattern.DOTALL);

	// Find all blockquote tags
	final Matcher matcher = patternBlockquote.matcher(html);
	StringBuffer stringBuffer = new StringBuffer(html.length());

	// Translate each tag
	while (matcher.find()) {

		// Get complete tag
		String group = matcher.group();

		// Remove tags
		group = group.replace("<blockquote>", "");
		group = group.replace("</blockquote>", "");

		// Replace old tag with markdown equivalent
		matcher.appendReplacement(stringBuffer, group);
	}

	matcher.appendTail(stringBuffer);
	return stringBuffer.toString();
}

Wenn nun in dem gefundenen String sich z.B. ein $-Zeichen (das Zeichen für Ersetzung im Kontext der Matcher-Klasse) befindet, wird spätestens bei der Zeile:

// Replace old tag with markdown equivalent
matcher.appendReplacement(stringBuffer, group);

ein Problem auftreten, welches sich in einer IllegalArgumentException äußert:

Exception in thread „main“ java.lang.IllegalArgumentException: Illegal group reference

Hintergrund ist das bestimmte Zeichen wie $ oder der Backslash maskiert werden müssen. Dies konnte manuell erledigt werden, bevor die Methode appendReplacement aufgerufen wird:

group = group.replace("$", "\\$");

Einfach ist es die integrierte Methode quoteReplacement zu nutzen:

group = Matcher.quoteReplacement(group);

Diese maskiert die entsprechenden Zeichen. Ein etwas andere Lösung ist es appendReplacement ohne neue Zeichenkette aufzurufen und diese anschließend an den StringBuffer anzufügen:

matcher.appendReplacement(stringBuffer, "");
stringBuffer.append(group);

Bei dieser Variante müssen keine Zeichen maskiert werden. Die vom JDK angedachte Variante ist allerdings die der Nutzung von quoteReplacement, so das diese bevorzugt werden sollte.