Pause café #217. Comment initialiser List en Java. 7 astuces simples pour améliorer la productivité Java : conseils et exemples

Comment initialiser la liste en Java

Source : FreeCodeCamp Cet article couvre diverses méthodes d'initialisation de liste en Java avec des exemples pratiques. L'une des structures de données de base du langage Java est la List . Il permet aux développeurs de stocker et de gérer un ensemble d'éléments. L'initialisation d'une liste en Java est une étape importante dans le processus de développement car elle définit l'état initial de la liste et la prépare à des opérations ultérieures. Il existe différentes manières d'initialiser une liste en Java, le choix dépend des exigences spécifiques du projet :

• Utilisation du constructeur ArrayList .
• Utilisation de la méthode add() .
• Utilisation de la méthode Arrays.asList() .
• Utilisation de la méthode Stream.of() .

Examinons de plus près ces méthodes.

Comment initialiser une liste à l'aide du constructeur ArrayList

En Java, la classe ArrayList est une implémentation de l'interface de tableau dynamique List , vous permettant d'ajouter et de supprimer des éléments d'une liste selon vos besoins. La classe ArrayList fournit plusieurs constructeurs pour créer une instance de la classe. La syntaxe pour créer un objet ArrayList sans capacité initiale est :

ArrayList<Object> list = new ArrayList<Object>();

Le constructeur sans argument crée une liste vide ( List ) d'une capacité initiale de 10 éléments. Si la liste dépasse cette capacité, la classe ArrayList augmente automatiquement la capacité en créant un nouveau tableau plus grand et en copiant les éléments de l'ancien tableau vers le nouveau tableau. Alternativement, nous pouvons créer un objet ArrayList avec une capacité initiale en utilisant un constructeur avec un argument entier, où capacité est la capacité initiale de la liste :

ArrayList<Object> list = new ArrayList<Object>(capacity);

Pour initialiser une List avec des valeurs, nous pouvons utiliser un constructeur qui prend une Collection comme argument. Vous pouvez transmettre n'importe quel objet de collection qui implémente l' interface Collection à ce constructeur , comme un autre ArrayList ou LinkedList . Les éléments de la collection sont ajoutés à la nouvelle ArrayList dans l'ordre dans lequel ils apparaissent dans la collection. Voici un exemple de la façon de créer une ArrayList et de l'initialiser avec des valeurs à l'aide d'un constructeur qui prend une Collection :

import java.util.ArrayList;
import java.util.Arrays;

public class Example {
    public static void main(String[] args) {
        // создаем массив целых чисел
        Integer[] array = {1, 2, 3, 4, 5};

        // создаем список из массива
        ArrayList<Integer> list = new ArrayList<Integer>(Arrays.asList(array));

        // печатаем список
        System.out.println(list); // [1, 2, 3, 4, 5]
    }
}

Dans cet exemple, nous créons un tableau d'entiers, puis le transmettons à la méthode Arrays.asList() pour créer un objet List . Nous transmettons ensuite cet objet List au constructeur ArrayList pour créer une nouvelle ArrayList avec les mêmes éléments que le tableau d'origine. Enfin, nous imprimons le contenu de la liste en utilisant la méthode System.out.println() .

Comment initialiser la liste à l'aide de la méthode add()

La méthode add() est largement utilisée en Java pour ajouter des éléments à une collection ou une liste. Cette méthode est disponible pour plusieurs types de collections en Java, notamment List , Set et Map . La méthode add() prend un argument : l'élément à ajouter à la collection. Lorsqu'il s'agit d'ajouter des éléments à une vList , la méthode add() est particulièrement utile car les listes en Java sont des collections ordonnées qui peuvent contenir des doublons. La méthode add() peut être utilisée pour ajouter des éléments à la fin d'une liste, ce qui en fait un moyen pratique d'initialiser une liste avec quelques valeurs initiales. Voici un exemple d'utilisation de la méthode add() pour initialiser une liste en Java :

import java.util.ArrayList;
import java.util.List;

public class ListExample {
    public static void main(String[] args) {
        // создаем новый ArrayList
        List<String> myList = new ArrayList<>();

        // добавляем элементы в список, используя метод the add()
        myList.add("apple");
        myList.add("banana");
        myList.add("cherry");

        // печатаем содержимое списка
        System.out.println(myList);
    }
}

Dans cet exemple, nous créons d’abord une nouvelle ArrayList nommée myList . Nous utilisons ensuite la méthode add() pour ajouter trois chaînes (« pomme », « banane » et « cerise ») à la fin de la liste. Nous imprimons ensuite le contenu de la liste en utilisant la méthode System.out.println() . Lorsque nous exécutons le programme, le résultat ressemblera à ceci :

Comment initialiser List à l'aide de la méthode Arrays.asList()

La méthode Arrays.asList() intégrée à Java convertit un tableau en liste. Cette méthode prend un tableau comme argument et renvoie un objet List . L'objet renvoyé par la méthode Arrays.asList() est une liste de taille fixe, ce qui signifie que nous ne pouvons pas y ajouter ou supprimer d'éléments. Pour utiliser la méthode Arrays.asList() pour initialiser une liste en Java, nous devons suivre les étapes suivantes : Tout d'abord, déclarons un tableau d'éléments avec lequel nous voulons initialiser la liste. Par exemple, supposons que nous souhaitions initialiser une liste avec trois éléments : « pomme », « banane » et « orange ». Ici, nous pouvons déclarer un tableau comme celui-ci :

String[] fruits = {"apple", "banana", "orange"};

Ensuite, nous appelons la méthode Arrays.asList() et passons le tableau en argument. Cela renverra un objet List contenant les éléments du tableau.

List<String> fruitList = Arrays.asList(fruits);

Nous pouvons maintenant utiliser l' objet fruitList pour accéder aux éléments de la liste. Par exemple, nous pouvons parcourir une liste et imprimer chaque élément :

for (String fruit : fruitList) {
    System.out.println(fruit);
}

Conclusion: Il est important de noter que la méthode Arrays.asList() ne crée pas de nouvel objet List , mais renvoie plutôt une représentation d'objet List du tableau d'origine . Cela signifie que si nous modifions le tableau d'origine, les modifications seront également reflétées dans l' objet List . Par exemple:

fruits[0] = "pear";
System.out.println(fruitList.get(0)); // Вывод: pear

Dans l'exemple ci-dessus, nous avons changé le premier élément du tableau fruits en "poire". Lorsque nous accédons au premier élément de l' objet fruitList , nous obtenons également "poire" car fruitList est simplement une représentation du tableau fruits .

Comment initialiser List à l'aide de la méthode Stream.of()

Stream.of() est une méthode pratique fournie par Java 8 et versions ultérieures dans le package java.util.stream . Il est utilisé pour créer un flux d'éléments de tout type, y compris des types primitifs, des tableaux et des objets. Cette méthode prend un ou plusieurs arguments et renvoie un flux composé de ces arguments. Syntaxe de la méthode Stream.of() :

Stream<T> stream = Stream.of(t1, t2, t3, ..., tn);

Ici, T est le type d'éléments dans le flux, et t1 et jusqu'à tn sont les éléments qui doivent être inclus dans le flux. Pour initialiser une liste en Java à l'aide de la méthode Stream.of() , vous devez procéder comme suit :

1. Importez d’abord le package java.util.stream .

2. Utilisez ensuite le constructeur pour créer une liste du type ArrayList souhaité, par exemple :

   List<String> myList = new ArrayList<>();

3. Initialisez la liste à l'aide de la méthode Stream.of() , en passant les éléments souhaités comme arguments, puis utilisez la méthode collect() pour collecter les éléments du flux dans une liste, par exemple :

   myList = Stream.of("Apple", "Banana", "Cherry", "Date")
                 .collect(Collectors.toList());

4. Nous pouvons ensuite imprimer la liste pour vérifier son contenu.

   System.out.println(myList);

   Conclusion:

   [Pomme, Banane, Cerise, Date]

Conclusion

L'initialisation d'une liste en Java est une tâche de programmation assez courante et il existe plusieurs façons de la réaliser. En suivant les étapes décrites dans cet article, nous pouvons facilement créer et initialiser une liste avec les éléments souhaités à l'aide de la méthode Stream.of() . Cette approche est concise et flexible, et peut être particulièrement utile lorsque nous devons initialiser une liste avec un petit nombre d'éléments. Bon codage !

7 astuces simples pour améliorer la productivité Java : conseils et exemples

Source : Medium Voici une sélection de sept conseils pratiques qui, s'ils sont suivis, contribueront à améliorer la productivité d'un développeur Java. Vous pouvez améliorer les performances de vos applications Java en suivant quelques conseils simples.

1. Utilisez des types primitifs au lieu d'objets :

// Плохо: использование an object Integer
Integer count = 0;
for (int i = 0; i < 1000000; i++) {
    count++;
}

// Хорошо: использование примитива int
int count = 0;
for (int i = 0; i < 1000000; i++) {
    count++;
}

2. Évitez de créer des objets inutiles :

// Плохо: использование конкатенации строк с помощью '+'
String str = "";
for (int i = 0; i < 10000; i++) {
    str += i;
}

// Хорошо: использование StringBuilder
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
    sb.append(i);
}
String str = sb.toString();

3. Utilisez la bonne structure de données :

// Плохо: использование List для частого поиска
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");
// ...
if (names.contains("Charlie")) {
    // ...
}

// Хорошо: использование HashSet для частого поиска
Set<String> names = new HashSet<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");
// ...
if (names.contains("Charlie")) {
    // ...
}

4. Réduisez les appels de méthode :

// Плохо: вызов метода внутри цикла
for (int i = 0; i < 1000000; i++) {
    doSomething(i);
}

// Хорошо: выносим метод за пределы цикла
for (int i = 0; i < 1000000; i++) {
    // ...
}
doSomething(i);

5. Utilisez des modificateurs statiques et finaux :

// Плохо: создание ненужных экземпляров an objectов
public class MyClass {
    private int value;
    public void setValue(int value) {
        this.value = value;
    }
    public int getValue() {
        return value;
    }
}
MyClass obj = new MyClass();
obj.setValue(10);
int value = obj.getValue();

// Хорошо: использование статических и финальных модификаторов
public class MyClass {
    private static final int DEFAULT_VALUE = 0;
    private final int value;
    public MyClass(int value) {
        this.value = value;
    }
    public int getValue() {
        return value;
    }
}
MyClass obj = new MyClass(10);
int value = obj.getValue();

6. Utilisez un algorithme adapté à la situation :

// Плохо: использовать линейный поиск для большой коллекции
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// ...
int target = 7;
for (int i = 0; i < nums.size(); i++) {
    if (nums.get(i) == target) {
        // ...
    }
}
// Хорошо: использование бинарного поиска для большой коллекции
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// ...
int target = 7;
int index = Collections.binarySearch(nums, target);
if (index >= 0) {
    // ...
}

7. Optimisez vos cycles :

// Плохо: вызов метода внутри цикла
for (int i = 0; i< 1000000; i++) {
    String str = getString(i);
    // ...
}

// Хорошо: минимизация вызовов методов в цикле
for (int i = 0; i < 1000000; i++) {
    String str = "String " + i;
    // ...
}

Ce ne sont là que quelques astuces Java simples qui peuvent améliorer votre productivité. Gardez à l’esprit que l’optimisation des performances peut être difficile et qu’un développeur devra souvent analyser son code pour identifier les goulots d’étranglement des performances.