Java, allgemein

@MyAnnotation
class MyClass {
}

boolean annotationPresent = MyClass.class.isAnnotationPresent(MyAnnotation.class);

public enum Direction {
   NORTH,
   EAST,
   SOUTH,
   WEST;
}

for (Direction dir : Direction.values())
   System.out.println(dir);

ArrayList zahlungsreihe = ...
synchronized (zahlungsreihe) {
     zahlungsreihe.sort(new DateAndIntervalComparator());
} 

class ImmutableClass {
   private final HashMap map = new HashMap<>();
   
   public ImmutableClass() {
      map.put(0, BigInteger.ONE);
      for (int i = 1; i < 10; i++)
         map.put(i, BigInteger.valueof(i).multiply(map.get(i-1)));
   }

   public getFactor(int i) {
      if (i < 0 || i >= 10)
         throw new IllegalArgumentException();
      return map.get(i);
   }
}
// Die Klasse ImmutableClass kann bedenkenlos in Threads verwendet werden, obwohl sie eine Map enthält!
// Alle drei Bedingungen sind erfüllt

class ImmutableClass2 {
   private final HashMap map = new HashMap<>();
   
   public ImmutableClass3() {
      map.put(0, BigInteger.ONE);
      IntStream.rangeClosed(1, 10).forEach(i -> map.put(n, BigInteger.valueOf(i).multiply(map.get(i - 1))));
  }

  public getFactor(int i) {
    if (i < 0 || i > 10)
      throw new IllegalArgumentException();
    return map.get(i);
  }
}
// Diese Klasse ImmutableClass2 kann nicht(!) bedenkenlos in Threads verwendet werden!
// Warum? this wird an eine andere Klasse übergeben. Leider ist das nicht offensichtlich.
// Wir greifen auf die HashMap mit einem Lambda zu. Lambdas verhalten sich wie innere anonyme Klassen.
// Da die Map ein Feld der Klasse ist, wird (unsichtbar) ein this übergeben um auf die map zugreifen zu können. Böse Falle!

class ImmutableClass3 {
   private final HashMap map = new HashMap<>();
   
   public ImmutableClass3() {
      HashMap mapTemp = new HashMap<>();
      mapTemp.put(0, BigInteger.ONE);
      IntStream.rangeClosed(1, 10).forEach(i -> mapTemp.put(n, BigInteger.valueOf(i).multiply(mapTemp.get(i - 1))));
      map = mapTemp;
   }

   public getFactor(int i) {
      if (i < 0 || i >= 10)
         throw new IllegalArgumentException();
      return map.get(i);
   }
}
// Diese Klasse ImmutableClass3 kann wieder bedenkenlos in Threads verwendet werden!
// Warum? Der Stream arbeitet nun mit der temporären mapTemp. Dadurch ist kein Verweis auf this nötig und somit sind alle drei Bedingungen erfüllt.

int[] a = {1, 2, 3};                     // Erstes Array
int[] b = {4, 5};                        // Zweites Array
int[] c = new int[a.length + b.length];  // Drittes Array, welches die beiden ersten Arrays aufnehmen soll

// Möglichkeit 1:
System.arraycopy(a, 0, c, 0, a.length);         // Erstes Array "a" in Array "c" kopieren
System.arraycopy(b, 0, c, a.length, b.length);  // Zweites Array "b" in Array "c" kopieren

// Möglichkeit 2:
c = IntStream.concat(IntStream.of(a), IntStream.of(b)).toArray();

// Möglichkeit 3:
int index = 0;
for (int i : a) 
   c[index++] = i;
for (int i : b)
   c[index++] = i;

private synchronized (this) {
   // kritischer Code
}

ArrayList myList = new ArrayList<>();
private synchronized (myList) {
   myList = new ArrayList<>();
}

package com.sowas.itwiki.threadpool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadpoolExample {

   /**
    * Ein Task ist die Aufgabe, die der Thread erledigen soll
    */
   private class Task implements Runnable {
      private int taskId;

      public Task(int id) {
         this.taskId = id;
      }

      @Override
      public void run() {
         System.out.println("Task Id: " + this.taskId + " performed by " + Thread.currentThread().getName());
      }
   }

   public static void main(String args[]) {
      ExecutorService executerService = Executors.newFixedThreadPool(4); // create 4 worker threads in Thread Pool
      for (int i = 0; i < 10; i++) {
         executerService.submit(new Task(i));
      }
      executerService.shutdown();
      System.out.println("All done.");
   }
}