Hinzufuegen zu mapped Liste (:Map.computeIfAbsent)

Eine Liste innerhalb einer Map erweitern falls sie schon vorhanden ist oder sonst neu erstellen:

    private Map<Object, List<Object>> addToMappedList1(Map<Object, List<Object>> mapOfLists, Object key, Object newValue){

        if (mapOfLists.get(key) == null){
            mapOfLists.put(key, new ArrayList<>());
        }
        mapOfLists.get(key).add(newValue);
        return mapOfLists;
    }

Eleganter:

    private Map<Object, List<Object>> addToMappedList2(Map<Object, List<Object>> mapOfLists, Object key, Object newValue){

        mapOfLists.computeIfAbsent(key, k -> new ArrayList<>()).add(newValue);
        return mapOfLists;
    }

Mittels Stream API Flache Liste von Liste von Listen erstellen

Beispiel:

List<List<Object>> list = ...
List<Object> flat = 
    list.stream()
        .flatMap(List::stream)
        .collect(Collectors.toList());

(taken from)

 

Erklärung:

// List of Lists:
List<List<String>> listOfLists = new ArrayList<>();
listOfLists.add(Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));
listOfLists.add(Arrays.asList("Bern", "Chur", "Luzern"));

List<String> result = listOfLists.stream().flatMap(list -> list.stream()).collect(Collectors.toList());

Signatur von flatMap(..):

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

T : Das Element mit dem der Stream parametrisiert ist, auf dem flatMap(..) aufgerufen wird.

 

Von flatMap verlanges Functional interface:
Function<? super T, ? extends Stream<? extends R>> :

interface Function<T, R> {
   R apply(T t);
}

Das heisst bezüglich übergebener Funktion/Lambda-Expression:

Input von apply: Ist gleich dem Element-Parameter des Streams auf dem flatMap aufgerufen wird.

Output von apply: <? extends Stream<? extends R>>:
Ein Stream von irgendwas. –> Ich darf selbst bestimmen, was R dann wirklich ist. Dadurch, wie meine übergebene Funktion aktuell parametrisiert ist, wird R erst bestimmt.

    private List getAllAepfel(Map<UID, List<Apfel>> uidToApfelList) {
        List xq = uidToApfelList.values().stream().flatMap(List::stream).collect(Collectors.toList());
    }

Concurrency mit Spring – Scope beachten

Spring Scopes:

Aus MyKong:

5 types of bean scopes supported :

  1. singleton – Return a single bean instance per Spring IoC container
  2. prototype – Return a new bean instance each time when requested
  3. request – Return a single bean instance per HTTP request. *
  4. session – Return a single bean instance per HTTP session. *
  5. globalSession – Return a single bean instance per global HTTP session. *

In most cases, you may only deal with the Spring’s core scope – singleton and prototype, and the default scope is singleton.

P.S * means only valid in the context of a web-aware Spring ApplicationContext

Das heisst: Wenn das Bean mit Scope=“singleton“ (default) definiert ist, muss das Bean stateless sein.

Siehe auch: https://stackoverflow.com/questions/1745790/spring-singleton-session-scopes-and-concurrency

 

Schließen