Java, allgemein

    Kommentare    Freigabe

Konvertieren einer List in ein Set

ArrayList list = ...
Set set1 = new HashSet(list);
Set set2 = new TreeSet(list);  // sortiert

    Kommentare    Freigabe

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());

    Kommentare    Freigabe

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

    Kommentare    Freigabe

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)
   ...

    Kommentare    Freigabe

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());

    Kommentare    Freigabe

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) {
   ...
}

    Kommentare    Freigabe

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")));

    Kommentare    Freigabe

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
}

    Kommentare    Freigabe

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();
         }
      }
   }
}

    Kommentare    Freigabe

Umgebungsvariablen auslesen

Im Beispiel wird die path-Variable des Betriebssystems ausgegeben:

String str = System.getenv("path");
System.out.prinln(str);