Pause café #144. Comment convertir un tableau en liste (ArrayList) en Java. Injection de dépendances en Java

Comment convertir un tableau en liste (ArrayList) en Java

Source : Rrtutors Aujourd'hui, vous découvrirez différentes façons de convertir un tableau en liste (ArrayList) et examinerez des exemples de code dans chacune d'elles. Bien que les tableaux soient simples et faciles à utiliser, ils présentent de nombreuses limitations, telles que la taille fixe. Cela rend difficile l'ajout d'un nouvel élément au début et la réorganisation des éléments. Grâce au Collections Framework, nous pouvons implémenter List, Set et Queue de différentes manières. Par exemple, en utilisant une liste de tableaux universelle et flexible (ArrayList). Il existe trois méthodes que vous pouvez utiliser lors de la conversion d'un tableau en Java. Ces méthodes comprennent :

1. Méthode naïve ou force brute.
2. Méthode Arrays.asList() .
3. Méthodes Collections.addAll() .

Utiliser une méthode naïve ou par force brute

Dans cette méthode, une liste est créée à partir d’un tableau vide et chaque élément du tableau y est ajouté un par un. La méthode fonctionne après avoir effectué ce qui suit :

• Obtenez le tableau.
• Créez une liste vide.
• Parcourez les éléments du tableau.
• Ajoutez maintenant chaque élément au tableau.
• Renvoyez la liste complète.

Cet exemple convertit un tableau de fruits en une liste de fruits :

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

public class NaivemethodExample {

    public static <T> List<T> convertArrayToList(T array[])

    {

        List<T> list = new ArrayList<>();

        for (T t : array) {

            list.add(t);

        }

        return list;

    }

    public static void main(String args[])

    {

        String array[]

            = { "Mangoes", "Oranges", "berries" };

        System.out.println("Array: "

                           + Arrays.toString(array));

        List<String> list = convertArrayToList(array);

        System.out.println("List: " + list);

    }

}

Méthode Arrays.asList()

À l'aide de la méthode Arrays.asList() , un tableau est transmis au constructeur List en tant que paramètre du constructeur. Pour convertir un tableau en liste ici, vous devez suivre les étapes suivantes :

• Obtenez le tableau.
• Créez une liste en passant le tableau en tant que paramètre dans le constructeur de liste.
• Renvoyez la liste complète.

Voici un exemple d'utilisation de la méthode Arrays.asList() pour convertir un tableau de fruits en liste :

package asList;

import java.util.Arrays;

import java.util.List;

public class asListExample {

    public static <T> List<T> convertArrayToList(T array[])

    {

        List<T> list = Arrays.asList(array);

        return list;

    }

    public static void main(String args[])

    {

        String array[]

            = { "Mangoes", "Oranges", "berries" };

        System.out.println("Array: "

                          + Arrays.toString(array));

        List<String> list = convertArrayToList(array);

        System.out.println("List: " + list);

    }

}

Méthode Collections.addAll()

Étant donné que les listes font partie du package Collection en Java, vous pouvez convertir un tableau en liste à l'aide de la méthode Collections.addAll() . Cette méthode convertit un tableau en liste en procédant comme suit :

• Nous obtenons un tableau.
• Créez une liste vide.
• Convertissons le tableau en liste à l'aide de la méthode collections.addAll() .
• Nous renvoyons une liste.

Exemple:

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.List;

public class collectionsall {

    public static <T> List<T> convertArrayToList(T array[])

    {

        List<T> list = new ArrayList<>();

        Collections.addAll(list, array);

        return list;

    }

 

    public static void main(String args[])

    {

        String array[]

            = { "peas", "tomatoes", "water melons" };

        System.out.println("Array: "

                           + Arrays.toString(array));

        List<String> list = convertArrayToList(array);

        System.out.println("List: " + list);

    }

}

Conclusion:

Injection de dépendances en Java

Source : Medium Dans cet article, vous apprendrez ce qu'est l'injection de dépendances en Java, où elle est utilisée et quels avantages elle apporte au développeur. L'injection de dépendances (DI) est le processus consistant à fournir une dépendance externe à un composant logiciel. L'injection de dépendances vise à séparer les problèmes de création d'objets de leur utilisation. Le principe d'intégration suppose qu'un objet ou une fonction qui souhaite utiliser un service donné n'a pas besoin de savoir comment le créer. Au lieu de cela, le « client » récepteur (objet ou fonction) reçoit ses dépendances d'un code externe (un « injecteur ») dont il ignore l'existence. Voici un bon exemple. Lorsqu'une classe X utilise certaines fonctionnalités d'une classe Y, nous disons que la classe X a une dépendance sur la classe Y. L'injection de dépendances vous permet de créer des objets dépendants en dehors de la classe et d'exposer ces objets à la classe de différentes manières. Dans ce cas, la création et la liaison des objets dépendants sont déplacées en dehors de la classe qui en dépend. Le modèle d'injection de dépendances comprend trois types de classes :

1. Classe de service qui fournit des services à une classe client.
2. Classe client : une classe qui dépend de la classe de service.
3. Injector Class est une classe qui injecte un objet de classe de service dans une classe client.

Types d’injection de dépendance

Il existe trois types d'injection de dépendances :

1. Injection de constructeur - Lorsque l'injection de constructeur se produit, l'injecteur fournit un service (dépendance) via le constructeur de la classe client.
2. Setter Injection - Dans ce type d'injection (également connu sous le nom d'injection de propriété), l'injecteur expose une dépendance via une propriété publique de la classe client.
3. Injection de méthode - Dans ce type d'injection, la classe client implémente une interface qui déclare la ou les méthodes pour fournir la dépendance. L'injecteur utilise cette interface pour fournir la dépendance à la classe client.

Avantages de l’injection de dépendances

La mise en œuvre de l'injection de dépendances nous offre les avantages suivants :

• Réutilisation du code.
• Facilité de refactorisation.
• Facilité de test.