Java-Algorithmen
Java-Algorithmen
In diesem Tutorial lernen wir anhand von Beispielen verschiedene Algorithmen kennen, die vom Java Collections Framework bereitgestellt werden.
Das Java Collections Framework bietet verschiedene Algorithmen, die verwendet werden können, um in Datenstrukturen gespeicherte Elemente zu manipulieren.
Algorithmen in Java sind statische Methoden, die verwendet werden können, um verschiedene Operationen auf Sammlungen auszuführen.
Da Algorithmen auf verschiedene Sammlungen angewendet werden können, werden diese auch als generische Algorithmen bezeichnet .
Sehen wir uns die Implementierung verschiedener Methoden an, die im Collections-Framework verfügbar sind.
1. Sortieren mit sort()
Der sort() Die vom Collections-Framework bereitgestellte Methode wird zum Sortieren von Elementen verwendet. Zum Beispiel
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);
}
}
Ausgabe
Unsorted ArrayList: [4, 2, 3] Sorted ArrayList: [2, 3, 4]
Hier erfolgt die Sortierung in natürlicher Reihenfolge (aufsteigende Reihenfolge). Wir können jedoch die Sortierreihenfolge der sort() anpassen Methode mit der Comparator-Schnittstelle .
Um mehr zu erfahren, besuchen Sie die Java-Sortierung.
2. Mischen mit shuffle()
Die shuffle() -Methode des Java Collections Framework wird verwendet, um jede Art von Ordnung zu zerstören, die in der Datenstruktur vorhanden ist. Es macht genau das Gegenteil der Sortierung. Zum Beispiel
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);
}
}
Ausgabe
Sorted ArrayList: [1, 2, 3] ArrayList using shuffle: [2, 1, 3]
Wenn wir das Programm ausführen, wird der shuffle() Methode gibt eine zufällige Ausgabe zurück.
Der Mischalgorithmus wird hauptsächlich in Spielen verwendet, in denen wir eine zufällige Ausgabe wünschen.
3. Routinemäßige Datenmanipulation
In Java stellt das Sammlungs-Framework verschiedene Methoden bereit, die zum Manipulieren von Daten verwendet werden können.
reverse()- kehrt die Reihenfolge der Elemente umfill()- Ersetzen Sie jedes Element in einer Sammlung durch den angegebenen Wertcopy()- Erstellt eine Kopie der Elemente von der angegebenen Quelle zum Zielswap()- vertauscht die Position zweier Elemente in einer SammlungaddAll()- fügt alle Elemente einer Sammlung zu einer anderen Sammlung hinzu
Zum Beispiel
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);
}
}
Ausgabe
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]
Hinweis :Beim Ausführen von copy() Methode sollten beide Listen die gleiche Größe haben.
4. Suchen mit binarySearch()
Die binarySearch() -Methode des Java Collections Framework sucht nach dem angegebenen Element. Es gibt die Position des Elements in den angegebenen Sammlungen zurück. Zum Beispiel
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);
}
}
Ausgabe
The position of 3 is 2.
Hinweis :Die Sammlung sollte sortiert werden, bevor binarySearch() ausgeführt wird Methode.
Um mehr zu erfahren, besuchen Sie Java Binary Search.
5. Zusammensetzung
frequency()- gibt die Anzahl zurück, wie oft ein Element in der Sammlung vorhanden istdisjoint()- prüft, ob zwei Sammlungen ein gemeinsames Element enthalten
Zum Beispiel
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);
}
}
Ausgabe
ArrayList1: [1, 2, 3, 2] Count of 2: 2 ArrayList2: [5, 6] Two lists are disjoint: true
6. Extremwerte finden
Die min() und max() Methoden des Java Collections Framework werden verwendet, um die minimalen bzw. maximalen Elemente zu finden. Zum Beispiel
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);
}
}
Ausgabe
Minimum Element: 1 Maximum Element: 3
Java