Algorithmes Java
Algorithmes Java
Dans ce didacticiel, nous découvrirons différents algorithmes fournis par le framework de collections Java à l'aide d'exemples.
Le framework de collections Java fournit divers algorithmes qui peuvent être utilisés pour manipuler des éléments stockés dans des structures de données.
Les algorithmes en Java sont des méthodes statiques qui peuvent être utilisées pour effectuer diverses opérations sur les collections.
Étant donné que les algorithmes peuvent être utilisés sur diverses collections, ils sont également appelés algorithmes génériques .
Voyons l'implémentation des différentes méthodes disponibles dans le framework des collections.
1. Trier avec sort()
Le sort() La méthode fournie par le framework de collections est utilisée pour trier les éléments. Par exemple,
import java.util.ArrayList;
import java.util.Collections;
class Main {
public static void main(String[] args) {
// Creating an array list
ArrayList<Integer> numbers = new ArrayList<>();
// Add elements
numbers.add(4);
numbers.add(2);
numbers.add(3);
System.out.println("Unsorted ArrayList: " + numbers);
// Using the sort() method
Collections.sort(numbers);
System.out.println("Sorted ArrayList: " + numbers);
}
}
Sortie
Unsorted ArrayList: [4, 2, 3] Sorted ArrayList: [2, 3, 4]
Ici, le tri s'effectue dans l'ordre naturel (ordre croissant). Cependant, nous pouvons personnaliser l'ordre de tri des sort() méthode utilisant l'interface Comparator .
Pour en savoir plus, consultez Tri Java.
2. Mélanger avec shuffle()
Le shuffle() La méthode du framework de collections Java est utilisée pour détruire tout type d'ordre présent dans la structure de données. Il fait exactement le contraire du tri. Par exemple,
import java.util.ArrayList;
import java.util.Collections;
class Main {
public static void main(String[] args) {
// Creating an array list
ArrayList<Integer> numbers = new ArrayList<>();
// Add elements
numbers.add(1);
numbers.add(2);
numbers.add(3);
System.out.println("Sorted ArrayList: " + numbers);
// Using the shuffle() method
Collections.shuffle(numbers);
System.out.println("ArrayList using shuffle: " + numbers);
}
}
Sortie
Sorted ArrayList: [1, 2, 3] ArrayList using shuffle: [2, 1, 3]
Lorsque nous exécutons le programme, le shuffle() renverra une sortie aléatoire.
L'algorithme de brassage est principalement utilisé dans les jeux où nous voulons une sortie aléatoire.
3. Manipulation de données de routine
En Java, le framework des collections fournit différentes méthodes qui peuvent être utilisées pour manipuler les données.
reverse()- inverse l'ordre des élémentsfill()- remplacer chaque élément d'une collection par la valeur spécifiéecopy()- crée une copie des éléments de la source spécifiée vers la destinationswap()- échange la position de deux éléments dans une collectionaddAll()- ajoute tous les éléments d'une collection à une autre collection
Par exemple,
import java.util.Collections;
import java.util.ArrayList;
class Main {
public static void main(String[] args) {
// Creating an ArrayList
ArrayList<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);
System.out.println("ArrayList1: " + numbers);
// Using reverse()
Collections.reverse(numbers);
System.out.println("Reversed ArrayList1: " + numbers);
// Using swap()
Collections.swap(numbers, 0, 1);
System.out.println("ArrayList1 using swap(): " + numbers);
ArrayList<Integer> newNumbers = new ArrayList<>();
// Using addAll
newNumbers.addAll(numbers);
System.out.println("ArrayList2 using addAll(): " + newNumbers);
// Using fill()
Collections.fill(numbers, 0);
System.out.println("ArrayList1 using fill(): " + numbers);
// Using copy()
Collections.copy(newNumbers, numbers);
System.out.println("ArrayList2 using copy(): " + newNumbers);
}
}
Sortie
ArrayList1: [1, 2] Reversed ArrayList1: [2, 1] ArrayList1 Using swap(): [1, 2] ArrayList2 using addALl(): [1, 2] ArrayList1 using fill(): [0, 0] ArrayList2 using copy(): [0, 0]
Remarque :Pendant l'exécution du copy() méthode les deux listes doivent être de la même taille.
4. Recherche à l'aide de binarySearch()
Le binarySearch() méthode du framework de collections Java recherche l'élément spécifié. Elle renvoie la position de l'élément dans les collections spécifiées. Par exemple,
import java.util.Collections;
import java.util.ArrayList;
class Main {
public static void main(String[] args) {
// Creating an ArrayList
ArrayList<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
// Using binarySearch()
int pos = Collections.binarySearch(numbers, 3);
System.out.println("The position of 3 is " + pos);
}
}
Sortie
The position of 3 is 2.
Remarque :La collection doit être triée avant d'effectuer le binarySearch() méthode.
Pour en savoir plus, visitez Java Binary Search.
5. Composition
frequency()- renvoie le nombre de fois qu'un élément est présent dans la collectiondisjoint()- vérifie si deux collections contiennent un élément commun
Par exemple,
import java.util.Collections;
import java.util.ArrayList;
class Main {
public static void main(String[] args) {
// Creating an ArrayList
ArrayList<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(2);
System.out.println("ArrayList1: " + numbers);
int count = Collections.frequency(numbers, 2);
System.out.println("Count of 2: " + count);
ArrayList<Integer> newNumbers = new ArrayList<>();
newNumbers.add(5);
newNumbers.add(6);
System.out.println("ArrayList2: " + newNumbers);
boolean value = Collections.disjoint(numbers, newNumbers);
System.out.println("Two lists are disjoint: " + value);
}
}
Sortie
ArrayList1: [1, 2, 3, 2] Count of 2: 2 ArrayList2: [5, 6] Two lists are disjoint: true
6. Trouver des valeurs extrêmes
Le min() et max() Les méthodes du framework de collections Java sont utilisées pour trouver respectivement les éléments minimum et maximum. Par exemple,
import java.util.Collections;
import java.util.ArrayList;
class Main {
public static void main(String[] args) {
// Creating an ArrayList
ArrayList<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
// Using min()
int min = Collections.min(numbers);
System.out.println("Minimum Element: " + min);
// Using max()
int max = Collections.max(numbers);
System.out.println("Maximum Element: " + max);
}
}
Sortie
Minimum Element: 1 Maximum Element: 3
Java