Java, allgemein |
18.08.2022
Konvertieren einer List in ein Set 
ArrayList list = ...
Set set1 = new HashSet(list);
Set set2 = new TreeSet(list); // sortiert
10.08.2022
Konvertieren eines Set von Integern in ein Set von Strings 
Am einfachsten geht dies mit der Stream-API:
Set setOfInteger = new HashSet<>();
Set setOfStrings = setOfInteger.stream().map(e -> String.valueOf(e)).collect(Collectors.toSet());
oder
Set setOfInteger = new HashSet<>();
Set setOfString = setOfInteger.stream().map(String::valueOf).collect(Collectors.toSet());
09.08.2022
Stream-API 
Seit Java 8 gibt es die Stream API.
Diese ermöglicht Operationen auf Arrays und Listen durchzuführen.
Dabei hat die Erzeugung und Abarbeitung eines Streams keinen Einfluss auf die zugrunde liegende Datenstruktur!
Hier mal ein kleines Programm mit Beispielen:
package com.sowas.itwiki.snippets;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class StreamApi {
public static void main(String[] args){
System.out.println("---------- Bespiel 1: -----------");
// Beispiel 1: Ausgabe von Array-Inhalten (hier Zahlen):
int[] nums = new int[]{1, 2, 3, 4};
Arrays.stream(nums).forEach(n -> System.out.println(n));
System.out.println("---------- Bespiel 2: -----------");
// Beispiel 2: Ausgabe von List-Inhalten (hier Strings):
List list = Arrays.asList("Apfel", "Banane", "Birne", "Zitrone");
list.stream().forEach(s -> System.out.println(s));
System.out.println("---------- Bespiel 3: -----------");
// Beispiel 3: Ausgabe von gefilterten Liste-Inhalten (hier die Strings aus Beispiel 2):
List filteredList = list.stream().filter(s -> s.startsWith("B")).collect(Collectors.toList());
filteredList.forEach(s -> System.out.println(s));
System.out.println("---------- Bespiel 4: -----------");
// Beispiel 4: List-Inhalte von Beispiel 2 kommasepariert ausgeben:
System.out.println(list.stream().collect(Collectors.joining(", ")));
}
}
Die Ausgabe des Programms:
---------- Bespiel 1: -----------
1
2
3
4
---------- Bespiel 2: -----------
Apfel
Banane
Birne
Zitrone
---------- Bespiel 3: -----------
Banane
Birne
---------- Bespiel 4: -----------
Apfel, Banane, Birne, Zitrone
01.08.2022
Lese-schreib-Erlaubnis (read-write-permission) für ein Verzeichnis testen 
try {
// Einschalten des SecurityManager:
SecurityManager sm = new SecurityManager();
System.setSecurityManager(sm);
} catch (SecurityException se) {
// SecurityManager ist bereits gesetzt
}
boolean fHasPermission;
try {
AccessController.checkPermission(new FilePermission("/tmp/*", "read,write"));
fHasPermission = true;
} catch (SecurityException e) {
fHasPermission = false;
}
if (fHasPermission)
...
22.07.2022
Stacktrace ohne Exception 
Folgender Coder gibt einen Stacktrace aus ohne das vorher eine Exception geflogen ist:
for (int i=0; i< Thread.currentThread().getStackTrace().length; i++)
System.out.println(Thread.currentThread().getStackTrace()[i].getMethodName());
20.07.2022
String zu InputStream 
Manchmal braucht man einen InputStream für irgendeine Methode und hat aber einen String. Folgender Code hilft hierbei:
String myString = "huhu";
byte[] bytes = myString.getBytes(); // Mit Default Encoding
// byte[] bytes = myString.getBytes("UTF-8"); // Mit gesetzen Encoding, hier "UTF-8"
InputStream is = new ByteArrayInputStream(bytes);
if (is != null) {
...
}
12.07.2022
System.out in Datei umleiten 
Folgender Code ermöglicht das Umleiten von System.out.println(..) in eine Datei:
System.setOut(new PrintStream(new FileOutputStream("out.log")));
11.07.2022
Threads, Ende feststellen 
Ein Thread ist beendet, wenn die run()-Methode verlassen wurde.
Abfrage, bo Thread noch läuft:
// Einen Thread starten:
Thread thread = new MyThread();
thread.start();
// Abfragen, ob der Thread noch läuft:
if (thread.isAlive()) {
// Thread läuft noch...
} else {
// Thread ist beendet
}
Eine festgelegt Zeit auf den Thread warten:
// Einen Thread starten:
Thread thread = new MyThread();
thread.start();
// Eine festgelegte Zeit auf das Ende eines Threads warten:
long waitMillis = 10000; // 10 Sekunden
try {
thread.join(waitMillis);
if (thread.isAlive()) {
// Die 10 Sekunden sind um; der Thread läuft noch
} else {
// Thread ist beendet
}
} catch (InterruptedException e) {
// Thread wurde abgebrochen
}
Warten bis der Thread beendet ist:
// Einen Thread starten:
Thread thread = new MyThread();
thread.start();
// Warten bis der Thread beendet ist:
try {
thread.join();
// Code der hier steht wird abgearbeitet, wenn der Thread fertig ist.
} catch (InterruptedException e) {
// Thread wurde abgebrochen
}
08.07.2022
Threads, wait() und notify() 
Das Beispiel zeigt einen MasterThread, welcher einen ChildThread startet und sich dann „schlafen legt“ um anschließend von seinem eigenen ChildThread nach Fertigstellung des Selbigen wieder geweckt wird:
package com.sowas.itiwiki.snippets;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class MasterThread extends Thread {
private static ExecutorService service = Executors.newCachedThreadPool();
@Override
public void run() {
System.out.println("MasterThread startet");
synchronized(this) {
service.execute(new ChildThread(this));
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("MasterThread endet");
}
public static void main(String[] args) {
service.execute(new MasterThread());
}
}
Der ChildThread:
package com.sowas.itiwiki.snippets;
public class ChildThread implements Runnable {
private MasterThread masterThread;
ChildThread(MasterThread masterThread) {
this.masterThread = masterThread;
}
@Override
public void run() {
try {
System.out.println("ChildThread startet");
// hier läuft der ChildThread...
System.out.println("ChildThread endet");
} finally {
// Masterthread informieren, dass ChildThread fertig ist:
synchronized (masterThread) {
masterThread.notify();
}
}
}
}
08.07.2022
Umgebungsvariablen auslesen 
Im Beispiel wird die path-Variable des Betriebssystems ausgegeben:
String str = System.getenv("path");
System.out.prinln(str);