Exercice Java Corrigé sur les Collections – Arraylist – Partie 4

import java.util.ArrayList;
import java.util.Collections;

public class Main
{
	public static void main(String[] args)
	{
		ArrayList arr = new ArrayList();
		arr.add("15");
		arr.add("11");
		arr.add("99");
		arr.add("50");
		arr.add("44");
		Object max_nbr = Collections.max(arr);
		System.out.println("Le max est: "+ max_nbr);
	}
}

Sortie:

Le max est: 99

import java.util.ArrayList;
import java.util.Collections;

public class Main
{
	public static void main(String[] args)
	{
		ArrayList arr = new ArrayList();
		arr.add("15");
		arr.add("11");
		arr.add("99");
		arr.add("50");
		arr.add("44");
		Object max_nbr = Collections.min(arr);
		System.out.println("Le min est: "+ max_nbr);
	}
}

Sortie:

Le min est: 11

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

public class Main
{
	public static void main(String[] args)
	{
        List<User> users = new ArrayList<>();
        users.add(new User("Alex", 15));
        users.add(new User("Bob", 35));
        users.add(new User("Emily", 18));
        users.add(new User("Olivier", 22));
 
        users.forEach(user -> {
            System.out.println("Nom: "+ user.getName() + "\nAge: "+ user.getAge());
        });
    }
}

class User {
    private String name;
    private int age;
 
    public User(String n, int a)
    {
        name = n;
        age = a;
    }
 
    public String getName()
    {
        return name;
    }
 
    public void setName(String n)
    {
        name = n;
    }
 
    public int getAge()
    {
        return age;
    }
 
    public void setAge(int age)
    {
        this.age = age;
    }
}

Sortie:

Nom: Alex
Age: 15
Nom: Bob
Age: 35
Nom: Emily
Age: 18
Nom: Olivier
Age: 22

Explication:

La classe User est définie avec deux variables d’instance privées, name et age, et un constructeur qui prend en compte les paramètres name et age et les définit. Elle contient également des méthodes getter et setter pour accéder aux variables d’instance privées et les modifier respectivement.

Dans la classe Main, une liste de tableaux nommée users est créée pour contenir les objets User. Quatre objets User sont créés à l’aide du constructeur de la classe User et ajoutés à la liste des utilisateurs à l’aide de la méthode add().

La méthode forEach() est ensuite utilisée pour parcourir en boucle la liste des utilisateurs et afficher le nom et l’âge de chaque objet Utilisateur à l’aide d’expressions lambda. Les méthodes getName() et getAge() de la classe User sont utilisées pour récupérer les valeurs de nom et d’âge de chaque objet User.

En général, ce code montre comment créer une classe personnalisée, instancier des objets de cette classe et stocker ces objets dans une ArrayList.

import java.util.ArrayList;

public class Main
{
    public static void main(String[] args)
    {
		ArrayList<String> arr = new ArrayList<String>();
		arr.ensureCapacity(20); 
		arr.add("Alex");
		arr.add("Bob");
		arr.add("Jean");
		arr.add("Emily");
		arr.add("Olivier");
		arr.add("Juillet"); 
		// réduire la capacité actuelle à la taille actuelle  
		arr.trimToSize();
		System.out.println("Après avoir réduit la taille du ArrayList: "+arr.size());
    }
}

Sortie:

Après avoir réduit la taille du ArrayList: 6

Explication:

Ce code Java définit une classe appelée Main avec une méthode main qui crée une liste de chaînes de caractères (ArrayList) appelée arr. La méthode ensureCapacity est utilisée pour définir la capacité initiale de la liste de tableaux à 20. La méthode add est ensuite utilisée pour ajouter plusieurs éléments String à la liste.

La méthode trimToSize est ensuite appelée sur arr pour réduire la capacité de la liste au nombre actuel d’éléments dans la liste. Cette méthode peut s’avérer utile pour réduire l’utilisation de la mémoire de la liste en cas de surallocation.

import java.util.ArrayList;
import java.util.HashSet;

public class Main
{
	public static void main(String args[])
	{
		ArrayList arr = new ArrayList();
		arr.add("Alex");
		arr.add("Bob");
		arr.add("Jean");
		arr.add("Emily");
		arr.add("Olivier");
		arr.add("Juillet"); 
		System.out.println("Avant la conversion du ArrayList...");
		System.out.println("ArrayList original:"+arr);
		System.out.println("Taille du ArrayList: " + arr.size());
 
		//Convertir ArrayList en une HashSet
		HashSet hset = new HashSet(arr);
 
		System.out.println("\nAvant la conversion du HashSet...");
		System.out.println("Taille du HashSet: " + arr.size());
		System.out.println("HashSet : "+hset);
	}
}

Sortie:

Avant la conversion du ArrayList...
ArrayList original:[Alex, Bob, Jean, Emily, Olivier, Juillet]
Taille du ArrayList: 6

Avant la conversion du HashSet...
Taille du HashSet: 6
HashSet : [Alex, Emily, Juillet, Bob, Olivier, Jean]

Explication:

Ce programme Java convertit un ArrayList de chaînes de caractères en un HashSet de chaînes de caractères. Voici comment fonctionne le code:

• Tout d’abord, une ArrayList nommée arr est créée et plusieurs chaînes de caractères y sont ajoutées à l’aide de la méthode add().
• La taille du ArrayList est affichée à l’aide de la méthode size().
• L’ArrayList est ensuite convertie en une HashSet nommé hset à l’aide du constructeur HashSet qui prend une collection existante comme argument.
• La taille du HashSet est affichée à l’aide de la méthode size().
• Le HashSet est affiché à l’aide de la méthode toString(), qui est implicitement appelée lorsqu’un objet est transmis à System.out.println().
• La sortie montre l’ArrayList et le HashSet avant et après la conversion, ainsi que leurs tailles.

Notez que la conversion de ArrayList en HashSet supprime tout élément dupliqué dans la liste et modifie également l’ordre des éléments puisque HashSet ne maintient pas l’ordre des éléments.

import java.util.ArrayList;
public class Main
{
	public static void main(String[] args)
	{
		ArrayList<String> arr = new ArrayList<>();
		int s = arr.size();
		System.out.println("Après la création du ArrayList. Taille: "+ s);
		arr.add("Alex");
		arr.add("Bob");
		arr.add("Jean");
		arr.add("Emily");
		arr.add("Olivier");
		arr.add("Juillet"); 
		s = arr.size();
		System.out.println("Taille du ArrayList après l'ajout d'éléments: "+ s);
	}
}

Sortie:

Après la création du ArrayList. Taille: 0
Taille du ArrayList après l'ajout d'éléments: 6

Explication:

Notez que la méthode size() renvoie le nombre d’éléments du ArrayList, qui est un entier.

import java.util.*;

public class Main
{
	public static void main(String args[])
	{
		List<Integer> arr = new ArrayList<Integer>();
		arr.add(15);
		arr.add(15);
		arr.add(15);
		arr.add(20);
		arr.add(32);
		arr.add(44);
		arr.add(12);
		arr.add(44);
		System.out.println("Liste des nombres: "+ arr);
		Set<Integer> res = new LinkedHashSet<Integer>(arr);
		arr.clear();
		arr.addAll(res);
 
		System.out.println("Liste de nombres sans doublons: "+ arr);
	}
}

Sortie:

Liste des nombres: [15, 15, 15, 20, 32, 44, 12, 44]
Liste de nombres sans doublons: [15, 20, 32, 44, 12]

Explication:

Ce programme Java montre comment supprimer les doublons d’une liste de tableaux à l’aide d’un Set. Voici comment fonctionne le code :

• Une ArrayList nommée arr de type Integer est créée et plusieurs entiers y sont ajoutés à l’aide de la méthode add().
• Les éléments de la liste originale sont affichés à l’aide de la méthode println().
• Un Set nommé res de type Integer est créé à l’aide de la classe LinkedHashSet. Le constructeur de LinkedHashSet prend un ArrayList comme argument et crée un Set contenant les mêmes éléments, mais sans doublons.
• L’ArrayList originale est effacée à l’aide de la méthode clear().
• Les éléments du Set sont ajoutés à la ArrayList d’origine à l’aide de la méthode addAll().
• Les éléments de la ArrayList sans doublons sont affichés à l’aide de la méthode println().

Notez que la classe LinkedHashSet est utilisée à la place de la classe HashSet pour maintenir l’ordre des éléments dans la ArrayList d’origine. Si l’ordre des éléments n’est pas important, la classe HashSet peut être utilisée à la place.

import java.util.ArrayList;

public class Main
{
    public static void main(String[] args)
    {
		ArrayList<String> arrLst = new ArrayList<String>();
		arrLst.add("Alex");
		arrLst.add("Bob");
		arrLst.add("Jean");
		arrLst.add("Emily"); 
		System.out.println("ArrayList: "+arrLst);
		System.out.println("\nConvertir ArrayList en tableau...");
 
		Object[] arr = arrLst.toArray();
 
		for (Object obj : arr)
		{
			System.out.println(obj);
		}
    }
}

Sortie:

ArrayList: [Alex, Bob, Jean, Emily]

Convertir ArrayList en tableau...
Alex
Bob
Jean
Emily

Explication:

Ce programme Java montre comment convertir une ArrayList en un tableau. Voici comment fonctionne le code :

• Un ArrayList nommé arrLst de type String est créé et plusieurs noms y sont ajoutés à l’aide de la méthode add().
• Les éléments de la liste sont affichés à l’aide de la méthode println().
• Un tableau vide de type Object est créé.
• La méthode toArray() de la liste de tableaux est appelée, ce qui renvoie un tableau contenant tous les éléments de la liste de tableaux.
• Les éléments du tableau sont affichés à l’aide d’une boucle for-each.

Notez que la méthode toArray() renvoie un tableau de type Object. Par conséquent, si la liste contient des éléments d’un type spécifique, vous devrez convertir les éléments dans ce type après avoir converti la liste en tableau.

import java.util.ArrayList;
public class Main
{
    public static void main(String[] args)
    {
		ArrayList<String> arr = new ArrayList<String>();
		arr.add("Alex");
		arr.add("Bob");
		arr.add("Jean");
		arr.add("Emily"); 
		System.out.println("ArrayList orginale: "+arr);
 
		//Insérer 'Ali' à l'index 1 
		arr.add(1, "Ali");
 
		//Insérer 'Olivier' à l'index 4 
		arr.add(4, "Olivier");
 
		System.out.println("Résultat:");
		System.out.println(arr);
    }
}

Sortie:

ArrayList orginale: [Alex, Bob, Jean, Emily]
Résultat:
[Alex, Ali, Bob, Jean, Olivier, Emily]

Explication:

Ce code montre comment insérer des éléments à une position particulière dans une ArrayList en Java. La liste est d’abord créée avec quelques éléments initiaux, puis deux nouveaux éléments sont insérés aux positions 1 et 4 à l’aide de la méthode add() avec le paramètre index. Voici comment fonctionne le code:

• Créez une ArrayList appelée arr et ajoutez-y des éléments à l’aide de la méthode add().
• Affichez la ArrayList originale.
• Utilisez la méthode add() pour insérer l’élément « Ali » à la position 1 et l’élément « Olivier » à la position 4.
• Affichez la ArrayList mise à jour.