Przydatne konstrukcje w Javie

tablice, listy, for

• Tablica (stałej długości)

    int[] primes = {2, 3, 5, 7};
    System.out.println(primes.length);

    import java.util.Arrays;

    a = Arrays.copyOf(b, b.length)

• Lista (zmiennej długości)

    import java.util.ArrayList;  // Konkretna implementacja interfejsu List
    import java.util.List;

    List<Thread> threads = new ArrayList<>();
    threads.add(new Thread(new Foo()));
    System.out.println(threads.size());

• konstrukcja enhanced for (w innych językach znana jako for-each):

    for (int p : smallPrimes) ...
    for (thread: threads) ...

losowe int-y

import java.util.Random; // albo
import java.util.concurrent.ThreadLocalRandom;

...
    private static final Random random = new Random(); // albo
    private static final Random random = ThreadLocalRandom.current();

    ...
        a = random.nextInt(10);
    ...

toString

Żeby wygodnie wypisywać obiekty naszych klas warto definiować toString, np. tak:

    @Override
    public String toString() {
        StringBuilder s = new StringBuilder("[");
        s.append(getClass().getName());
        s.append(" ");
        s.append(7);
        s.append(" ");
        s.append(Arrays.toString(foo));
        s.append("]");
        return s.toString();
    }

lambdy

Gdy potrzebujemy przekazać funkcje do wykonania przez inną klasę, w Javie przekazujemy obiekt klasy implementujący interfejs np. Runnable.

W przypadku krótkich funkcji istnieje skrótowa składnią do definiowania takich obiektów, są to wyrażenia lambda.

• () -> { foo(); bar(); } repezentuje funkcję, która nie przyjmuje żadnych argumentów (pusty nawias przed strzałką), nie zwraca żadnej wartości (brak return) i której kod to wywołanie funkcji foo i bar. Jest to obiekt implementujący interfejs Runnable.
• Przykładowo, możemy utworzyć nowy wątek wykonujący tę funkcję:

      t = new Thread(() -> { foo(); bar(); });
      t.start();

• (X x) -> { return baz(x) + x == 0; } reprezentuje funkcję z jednym argumentem x, której kod wykonuje baz i zwraca (baz(x) + x == 0). Jest to obiekt implementujący interfejs Function<X, bool>.
• x -> baz(x) + x == 0 to to samo: typy są opcjonalne, nawiasy są opcjonalne jeśli jest tylko jeden argument, a zamiast { return expression; } wystarczy napisać samo expression.
• (X x, Y, y) -> Z(x + y) to obiekt implementujący interfejs BiFunction<X, Y, Z>.