Java Algorithms (algorithm)

Dans ce tutoriel, nous allons apprendre à utiliser les différents algorithmes fournis par le cadre de collections Java à l'aide d'exemples.

Le cadre de collections Java fournit divers algorithmes, utilisables pour traiter les éléments stockés dans les structures de données.

Les algorithmes en Java sont des méthodes statiques, utilisables pour exécuter diverses opérations sur les jeux.

Les algorithmes étant utilisables pour divers jeux, ils sont également appelésalgorithmes généraux.

Voyons les implémentations des différentes méthodes disponibles dans le cadre de collection.

1.utilisez sort() pour trier

Les méthodes fournies par le cadre de tri des collections sont utilisées pour trier les éléments. Par exemple,

import java.util.ArrayList;
import java.util.Collections;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//créez une liste d'arrays
　　　　　　　　ArrayList<Integer> numbers = new ArrayList<>();
　　　　　　　　//ajoutez des éléments
　　　　　　　　numbers.add(4);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　System.out.println("ArrayList non trié: "　+　numbers);
　　　　　　　　//　utilisez la méthode sort()
　　　　　　　　Collections.sort(numbers);
　　　　　　　　System.out.println("ArrayList trié: "　+　numbers);
　　　　}
}

Output result

ArrayList non trié: [4,　2,　3]
ArrayList trié: [2,　3,　4]

Ici, le tri est effectué dans l'ordre naturel (croissant). Mais, nous pouvons utiliser l'interface Comparator pour personnaliser l'ordre de tri de la méthode sort().

Pour plus d'informations, veuillez visiterTri Java.

2.utilisez shuffle pour désorganiser

La méthode shuffle() du cadre Collections de Java est utilisée pour désorganiser toute séquence apparue dans la structure de données. Son effet est l'inverse de celui du tri. Par exemple

import java.util.ArrayList;
import java.util.Collections;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//créez une liste d'arrays
　　　　　　　　ArrayList<Integer> numbers = new ArrayList<>();
　　　　　　　　//ajoutez des éléments
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　System.out.println("ArrayList trié: "　+　numbers);
　　　　　　　　//utilisez la méthode shuffle()
　　　　　　　　Collections.shuffle(numbers);
　　　　　　　　System.out.println("ArrayList utilisant shuffle: "　+　numbers);
　　　　}
}

Output result

ArrayList trié: [1,　2,　3]
ArrayList utilisant shuffle: [2,　1,　3]

lorsque nous exécutons le programme, la méthode shuffle() retourne une sortie aléatoire.

l'algorithme de洗牌 est principalement utilisé dans les jeux nécessitant une sortie aléatoire.

3.traitement des données courantes

Dans Java, le cadre de collection fournit différentes méthodes utilisables pour traiter les données.

• reverse() - inverser l'ordre des éléments

• fill() - remplacez chaque élément du jeu par une valeur spécifiée

• copy() - créez une copie des éléments de la source vers la destination

• swap() - échangez la position de deux éléments dans le jeu

• addAll() - ajoutez tous les éléments du jeu à un autre jeu

par exemple,

import java.util.Collections;
import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Create an ArrayList
　　　　　　　　ArrayList<Integer> numbers = new ArrayList<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　System.out.println("ArrayList1: \　+　numbers);
　　　　　　　　//　utilisez reverse()
　　　　　　　　Collections.reverse(numbers);
　　　　　　　　System.out.println("inverser ArrayList1: \　+　numbers);
　　　　　　　　//　utilisez swap()
　　　　　　　　Collections.swap(numbers, 0,　1);
　　　　　　　　System.out.println("ArrayList1　utilisez swap(): "　+　numbers);
　　　　　　　　ArrayList<Integer> newNumbers = new ArrayList<>();
　　　　　　　　//　utilisez addAll
　　　　　　　　newNumbers.addAll(numbers);
　　　　　　　　System.out.println("ArrayList2　en utilisant addAll(): \　+　newNumbers);
　　　　　　　　//　en utilisant fill()
　　　　　　　　Collections.fill(numbers, 0);
　　　　　　　　System.out.println("ArrayList1　en utilisant fill(): \　+　numbers);
　　　　　　　　//　en utilisant copy()
　　　　　　　　Collections.copy(newNumbers, numbers);
　　　　　　　　System.out.println("ArrayList2　en utilisant copy(): \　+　newNumbers);
　　　　}
}

Output result

ArrayList1: [1,　2]
inverser ArrayList1: [2,　1]
ArrayList1　en utilisant swap(): [1,　2]
ArrayList2　en utilisant addALl(): [1,　2]
ArrayList1　en utilisant fill(): [0, 0]
ArrayList2　en utilisant copy(): [0, 0]

Remarque：lors de l'exécution de la méthode copy(), la taille des deux listes doit être la même.

4.recherche en utilisant binarySearch()

La méthode binarySearch() de la framework de collections Java recherche l'élément spécifié. Elle retourne la position de l'élément dans l'ensemble spécifié. Par exemple,

import java.util.Collections;
import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Create an ArrayList
　　　　　　　　ArrayList<Integer> numbers = new ArrayList<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　//　en utilisant binarySearch()
　　　　　　　　int pos = Collections.binarySearch(numbers,　3);
　　　　　　　　System.out.println("3la position est \　+　pos);
　　　　}
}

Output result

3la position est　2

Remarque：avant d'exécuter la méthode binarySearch(), le jeu de données doit être trié.

Pour plus d'informations, veuillez visiterRecherche binaire Java.

5.composition

• frequency() - retourne le nombre de fois que l'élément existe dans l'ensemble

• disjoint() - vérifier si deux ensembles contiennent des éléments communs

par exemple,

import java.util.Collections;
import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Create 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("Nombre de　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("deux listes sont-elles incompatibles? ",　+　value);
　　　　}
}

Output result

ArrayList1: [1,　2,　3,　2]
Nombre de　2:　2
ArrayList2: [5,　6]
deux listes sont-elles incompatibles? true

6recherche des éléments max et min

Les méthodes min() et max() de la framework de collections Java sont utilisées respectivement pour trouver l'élément le plus petit et le plus grand. Par exemple,

import java.util.Collections;
import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Create 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);
　　　　}
}

Output result

Minimum element:　1
Maximum element:　3