java-practice-collections

import [Link];
import [Link];

class Answer {

// Change these boolean values to control whether you see

// the expected result and/or hints.
static boolean showExpectedResult = false;
static boolean showHints = false;

// Return the number of occurrences of word in source

static int getOccurrences(String source, String word) {
// Your code goes here.
return (int)
[Link]([Link]("\\.","").split("\\s+")).stream()
.filter(item-> [Link](word))
.count();
}
[Link](source.r;;;;;)

Splitting and Counting: Used split("\\s+") to handle splitting by whitespace and

counted
The split("\\s+") method is used to split a string into an array of substrings based on
one or more whitespace characters.
in javascript or typescript we use
const source: string = "Here is\tan example. Right here.";
const cleanedSource: string = [Link](/\./g, "");
const words: string[] = [Link](/\s+/);
________________
// Return a new list in reversed order
static List<Integer> getReversed(List<Integer> source) {
// Your code goes here.
return [Link]([Link]()-1, i -> i>=0, i-> i-1)
.map(source::get)
.collect([Link]());

// return new ArrayList<>();

}
Or
static List<Integer> getReversed(List<Integer> source) {
// Your code goes here.
return [Link](0, [Link]())
.mapToObj(i-> [Link]([Link]() -1 -i))
.collect([Link]());

// return new ArrayList<>();

}
or
static List<Integer> getReversed(List<Integer> source) {
// Your code goes here.
List<Integer> list = new ArrayList<>(source);
[Link](list);
return list;
}
or
static List<Integer> getReversed(List<Integer> source) {
// Your code goes here.
[Link](source);
return list;
}

_____________________________
static double getAverage(List<Integer> source) {
// Your code goes here.
return [Link]()
.mapToInt(Integer::valueOf)
.average()
.orElse(0.0);
}
or
static double getAverage(List<Integer> source) {
int sum= [Link]()
.mapToInt(Integer::valueOf).sum();
 long count = [Link]().count();
return count>0 ?(double) sum/count: 0.0;
}
or
// Return the average value of the source list
static double getAverage(List<Integer> source) {
return (double)
[Link]().mapToInt(Integer::valueOf).sum()/([Link]());
}
or
// Return the average value of the source list
static double getAverage(List<Integer> source) {

return [Link]().reduce(0, Integer::sum) / (double)

[Link]();
}
____________________________________
// Return the a list of words with 5 or fewer characters
static List<String> findFiveOrFewer(String source) {
// Your code goes here.
return [Link]([Link]("\\.",
"").split("\\s+")).stream()
.filter(a -> [Link]() <= 5)
.collect([Link]());
}
or
// Return the a list of words with 5 or fewer characters
static List<String> findFiveOrFewer(String source) {
// Your code goes here.
return [Link]([Link]("\\.", "").split("\\s+"))
.filter(a -> [Link]() <= 5)
.collect([Link]());
}

______________________________________

.boxed():

●​ Converts the IntStream to Stream<Integer> so it can be used in a

flatMap operation that works with object streams.

Why .mapToObj(j -> [Link](i, j))?

●​ Context: Within the flatMap operation, you're iterating over the

possible indices j that are greater than i.
●​ Purpose:
 ○​ mapToObj is a method used when working with primitive streams
like IntStream. It converts the primitive elements (in this
case, int values) into objects (in this case, List<Integer>).
○​ [Link](i, j) creates an immutable list containing the two
indices i and j. This list represents the pair of indices that
sum up to the target value.
●​ Why Not Just map?:
○​ map is typically used to transform elements within the same type
of stream. In the case of an IntStream, map would result in
another IntStream, but you need a Stream<List<Integer>> to
represent pairs of indices. Hence, mapToObj is used to convert
each int into an object of type List<Integer>.

Why .flatMap and Not .map?

●​ .map:
○​ map transforms each element in the stream into a new element. If
you used map, you would end up with a
Stream<Stream<List<Integer>>> when working with nested streams.
○​ This results in a nested structure, where each element of the
outer stream is itself a stream. This isn't what you want here
because it adds unnecessary complexity.
●​ .flatMap:
○​ flatMap is used to flatten such structures. It takes each
element (which is a stream) and flattens the resulting streams
into a single stream.
○​ In your case, for each index i, flatMap takes the stream of
index pairs (i, j) and flattens them into a single stream of
List<Integer> (pairs of indices).

Example Without Flattening

If you were to use map instead of flatMap, you'd end up with something like
this:

java
Copier le code
[Link](0, [Link]())
.boxed()
.map(i ->
[Link](i + 1, [Link]())
.filter(j -> [Link](i) + [Link](j) == target)
.mapToObj(j -> [Link](i, j))
)
.findFirst()
.orElseGet(ArrayList::new);
This code would result in a Stream<Stream<List<Integer>>>, which means a
stream of streams. This is not what you want because it introduces an extra
layer of streams. You need a flat structure, i.e., a Stream<List<Integer>>,
where each element is directly a list of indices.

Key Takeaway

●​ .mapToObj(j -> [Link](i, j)): Converts each index pair (i, j) into a
List<Integer> object representing the pair.
●​ .flatMap: Flattens the nested stream structure into a single stream of
index pairs.

In summary, .flatMap is used instead of .map to avoid creating a stream of

streams and to ensure you get a flat stream of index pairs directly. This
allows you to easily find the first matching pair and return it.

______________
static List<Integer> getIndices(List<Integer> source, int target) {
// Your code goes here.
return [Link](0,[Link]())
.boxed()
.flatMap(i-> [Link](i+1 , [Link]())
.filter(j -> [Link](i)+ [Link](j) == target)
.mapToObj(j -> [Link](i, j))
)
.findFirst()
.orElseGet(ArrayList::new);
}
for ( int i = 0; i< [Link]() - 1; i++){
Integer result = target - [Link](i);
if([Link](result)){
return [Link](i, [Link](result));
}

}
return new ArrayList<>();
_________________________________________________________________________
practice-it-java-arrays

How can you sort an array arr in Java?

​ [Link](arr);
What values does the following array hold?
Integer[] nums = new Integer[8];
​ eight null values
Which data structure is commonly used to implement an ArrayList?
​ Array

What happens if you access an invalid index in an array?

​ An index out of bounds exception is thrown.

What item can an object array not hold?

​ int // but integer

Which data structure has more overhead?

​ ArrayList
public class Main {
public static void main(String[] args) {
String[] list = new String[] {"A", "B" , "C", "D"};
for(int i = 1; i< [Link]; i++){
for(int j = 0; j<i; j++){
[Link](list[j]);
}
[Link]("");
}
}
}
to do rotation
La méthode computeIfAbsent est une méthode de la classe Map en Java qui facilite la
gestion des valeurs dans une carte (Map). Elle permet de créer et d'ajouter une nouvelle
valeur à la carte si la clé spécifiée est absente, tout en évitant les vérifications et les
conditions explicites pour la présence ou l'absence d'une valeur. Voici un aperçu détaillé de
son fonctionnement et de son utilisation :

Fonctionnement de computeIfAbsent
java
Copier le code
V computeIfAbsent(K key, Function<? super K, ? extends V>
mappingFunction);

●​ K key : La clé pour laquelle vous souhaitez ajouter ou récupérer une valeur.
●​ Function<? super K, ? extends V> mappingFunction : Une fonction qui calcule la
valeur à associer à la clé si elle est absente dans la carte. Cette fonction prend la clé
en entrée et retourne la valeur à ajouter.

Comportement

1.​ Si la clé est présente :

 ○​ Si la clé spécifiée est déjà présente dans la carte, la méthode renvoie la
valeur existante associée à cette clé. Aucune nouvelle valeur n'est calculée ni
ajoutée.
2.​ Si la clé est absente :
○​ Si la clé n'est pas présente dans la carte, la méthode appelle la fonction de
mappage fournie pour calculer la valeur.
○​ La valeur calculée est ensuite ajoutée à la carte pour la clé spécifiée, et cette
valeur est renvoyée.

Exemple

Voici un exemple simple qui illustre comment utiliser computeIfAbsent :

java
Copier le code
import [Link];
import [Link];

public class ComputeIfAbsentExample {

public static void main(String[] args) {
// Création d'une carte pour stocker les listes de chaînes
Map<String, List<String>> map = new HashMap<>();

// Ajouter un élément à la carte en utilisant

computeIfAbsent
[Link]("fruit", k -> new
ArrayList<>()).add("Apple");
[Link]("fruit", k -> new
ArrayList<>()).add("Banana");

// Afficher le contenu de la carte

[Link](map);
}
}

Explication

1.​ Création de la Carte :

○​ Une HashMap est créée pour stocker des listes de chaînes.
2.​ Utilisation de computeIfAbsent :
○​ [Link]("fruit", k -> new ArrayList<>()) vérifie
si la clé "fruit" est présente dans la carte.
 ○​ Si la clé est absente, la fonction de mappage k -> new ArrayList<>()
est appelée pour créer une nouvelle liste vide.
○​ La nouvelle liste est ensuite associée à la clé "fruit" et renvoyée.
○​ add("Apple") et add("Banana") ajoutent des éléments à la liste
associée à la clé "fruit".
3.​ Affichage :
○​ La carte contient maintenant une clé "fruit" avec une liste de chaînes
contenant "Apple" et "Banana".

Avantages de computeIfAbsent

●​ Simplifie le Code : Élimine le besoin de vérifier explicitement si la clé est présente

avant de créer et ajouter une valeur.
●​ Efficacité : Permet d'éviter des vérifications et des ajouts séparés, ce qui peut
améliorer la performance dans certains cas.
●​ Lisibilité : Rend le code plus clair et plus concis en combinant la vérification et
l'insertion en une seule opération.

Utilisation dans Votre Cas

Dans votre exemple :

java
Copier le code
[Link](typeDocument, k -> new HashMap<>());

Map<DocumentStatutEnum, List<Long>> statusMap =

[Link](typeDocument);

[Link](statutDocument, k -> new ArrayList<>());

[Link](statutDocument).add(dossierDocument);

●​ Première Utilisation : computeIfAbsent est utilisé pour s'assurer qu'une Map est
créée pour chaque TypeDocumentEnum dans groupedValidite. Si
typeDocument n'est pas présent, une nouvelle HashMap est créée et associée à
cette clé.
●​ Deuxième Utilisation : computeIfAbsent est utilisé pour s'assurer qu'une
List<Long> est créée pour chaque DocumentStatutEnum dans statusMap. Si
statutDocument n'est pas présent, une nouvelle ArrayList
[Link]().stream()
.flatMap(List::stream)
.forEach(dto -> {
if([Link]([Link]())){
[Link](dto);
}
});

forEach sur flatmap

boolean allDocumentsValid = [Link]().stream()

.flatMap(List::stream)
.allMatch(dto -> [Link]([Link]()));
allMatch

Map<TypeDocumentEnum, List<ControleStatutDocDto>> groupedByType =

[Link]()
.collect([Link](
type -> type,
type -> new ArrayList<>()
));

ici on map et les attribut avec lambda function

Set<Long> processedDocs = [Link]()
.map(result -> {
DocumentStatutEnum statutDocument =
(DocumentStatutEnum) result[0];
Long documentId = (Long) result[1];
return [Link](statutDocument) ? null :
documentId;
})
.filter(Objects::nonNull)
.collect([Link]());

ou return null et mettre objects::nonNull

corrige String binaire = [Link]([Link]()); (statut !=
null) ? return [Link](document, binaire) : return null;

ChatGPT a dit :
ChatGPT

La syntaxe de votre code a un problème, car vous ne pouvez pas utiliser une expression
ternaire pour retourner une valeur. Les expressions ternaires sont utilisées pour évaluer et
retourner une valeur, mais elles ne peuvent pas être combinées directement avec des
instructions de retour comme vous l'avez fait. Voici une version corrigée :

java
Copier le code
String binaire =
[Link]([Link]());
if (statut != null) {
return [Link](document, binaire);
} else {
return null;
}

Cette version utilise une condition if pour vérifier si statut est non nul, puis retourne la
valeur appropriée en fonction de cette condition.

______________________________________

Oui, vous pouvez obtenir un résultat de manière synchrone en utilisant le mécanisme de

blocage offert par les types réactifs comme Mono ou Flux dans le cadre de la
programmation réactive avec Project Reactor (souvent utilisé avec Spring WebFlux).

Voici comment vous pouvez faire cela :

1.​ Utiliser block() : Si votre méthode réactive retourne un Mono<T>, vous pouvez
appeler block() sur ce Mono pour attendre et récupérer la valeur de manière
synchrone.

Voici comment vous pouvez ajuster votre code pour récupérer le résultat de manière
synchrone sans utiliser subscribe :

WiDocDto wiDocDto = new WiDocDto([Link](),

[Link](), [Link](), listDoc);

// Récupérer le résultat de manière synchrone avec block()

ResponseDto responseDto = [Link](wiDocDto,
token).block();

if (responseDto != null) {
[Link]([Link]);
[Link](updoc);
[Link]("UploadWidoc response: {}",
[Link]());
} else {
[Link]("Error UploadWidoc: No response received");
}
// ... votre code suivant ...

Explication :

●​ block() : Cette méthode bloque l'exécution du thread actuel jusqu'à ce que le Mono
émette une valeur ou qu'il complète. Cela permet d'obtenir le résultat de manière
synchrone. Attention, cependant, cela bloque le thread, ce qui peut aller à l'encontre
des principes réactifs et de la non-bloquance. Il est donc à utiliser avec précaution,
surtout dans des environnements où la performance est cruciale.

Important :

●​ Non-bloquant vs bloquant : Si votre application est conçue pour être non-bloquante

(comme avec Spring WebFlux), utiliser block() pourrait aller à l'encontre de ce
design. Il est souvent préférable de continuer à utiliser une approche réactive avec
subscribe() ou d'utiliser block() dans des cas bien spécifiques, comme dans
des tests ou des parties de code où la performance n'est pas critique.