Algoritmi Java (algoritmi)

In questo tutorial, impareremo grazie a esempi le diverse metodologie fornite dalla collection framework di Java.

La Java collection framework fornisce vari algoritmi che possono essere utilizzati per gestire gli elementi memorizzati nelle strutture dei dati.

Gli algoritmi in Java sono metodi statici e possono essere utilizzati per eseguire varie operazioni sui set.

Poiché gli algoritmi sono utilizzabili per vari set, sono anche chiamatiAlgoritmi generali.

Vediamo come vengono implementate le diverse metodologie disponibili nella collection framework.

1. Utilizzo di sort() per ordinare

Metodi di sort() della collection framework vengono utilizzati per ordinare gli elementi. Ad esempio:

import java.util.ArrayList;
import java.util.Collections;
class Main {}}
　　　　public static void main(String[] args) {
　　　　　　　　//创建数组列表
　　　　　　　　ArrayList<Integer> numbers = new ArrayList<>();
　　　　　　　　//添加元素
　　　　　　　　numbers.add(4);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　System.out.println("ArrayList non ordinata: " + numbers);
　　　　　　　　//Utilizzo di sort() metodo
　　　　　　　　Collections.sort(numbers);
　　　　　　　　System.out.println("ArrayList ordinata: " + numbers);
　　　　}
}

Risultato di output

ArrayList non ordinata: [4, 2, 3]
ArrayList ordinata: [2, 3, 4]

In questo caso, l'ordinamento avviene in ordine naturale (crescente). Ma possiamo utilizzare l'interfaccia Comparator per personalizzare l'ordine di sort().

Per ulteriori informazioni, visitareJava Sorting.

2. Utilizzo di shuffle per mescolare

La metodologia shuffle() della Java Collections framework viene utilizzata per mescolare qualsiasi sequenza che si verifica nella struttura dei dati. Il suo effetto è l'opposto della ordinazione. Ad esempio

import java.util.ArrayList;
import java.util.Collections;
class Main {}}
　　　　public static void main(String[] args) {
　　　　　　　　//创建数组列表
　　　　　　　　ArrayList<Integer> numbers = new ArrayList<>();
　　　　　　　　//添加元素
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　System.out.println("Sorted ArrayList: " + numbers);
　　　　　　　　//使用shuffle()方法
　　　　　　　　Collections.shuffle(numbers)
　　　　　　　　System.out.println("ArrayList utilizzando shuffle: " + numbers)
　　　　}
}

Risultato di output

ArrayList ordinato: [1, 2, 3]
ArrayList utilizzando shuffle: [2, 1, 3]

Quando eseguiamo il programma, il metodo shuffle() restituirà un output casuale.

L'algoritmo di shuffle viene principalmente utilizzato nei giochi che richiedono output casuale.

3. Elaborazione dati regolari

In Java, la struttura dei set fornisce diversi metodi per gestire i dati.

• reverse() - Inverte l'ordine degli elementi

• fill() - Sostituisce ogni elemento del set con un valore specificato

• copy() - Crea una copia degli elementi da una sorgente a una destinazione

• swap() - Scambia la posizione di due elementi in un set

• addAll() - Aggiunge tutti gli elementi di un set a un altro set

Ad esempio,

import java.util.Collections;
import java.util.ArrayList;
class Main {}}
　　　　public static void main(String[] args) {
　　　　　　　　// Creazione di un ArrayList
　　　　　　　　ArrayList<Integer> numbers = new ArrayList<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　System.out.println("ArrayList1: " + numbers);
　　　　　　　　// Utilizzo di reverse()
　　　　　　　　Collections.reverse(numbers)
　　　　　　　　System.out.println("Inversione ArrayList1: " + numbers)
　　　　　　　　// Utilizzo di swap()
　　　　　　　　Collections.swap(numbers, 0, 1)
　　　　　　　　System.out.println("ArrayList1 utilizza swap(): " + numbers)
　　　　　　　　ArrayList<Integer> newNumbers = new ArrayList<>();
　　　　　　　　// Utilizzo di addAll
　　　　　　　　newNumbers.addAll(numbers)
　　　　　　　　System.out.println("ArrayList2 utilizza addAll(): " + newNumbers)
　　　　　　　　// Utilizzo di fill()
　　　　　　　　Collections.fill(numbers, 0)
　　　　　　　　System.out.println("ArrayList1 utilizza fill(): " + numbers)
　　　　　　　　// Utilizzo di copy()
　　　　　　　　Collections.copy(newNumbers, numbers)
　　　　　　　　System.out.println("ArrayList2 utilizza copy(): " + newNumbers)
　　　　}
}

Risultato di output

ArrayList1: [1, 2]
Inversione ArrayList1: [2, 1]
ArrayList1 utilizza swap(): [1, 2]
ArrayList2 utilizza addALl(): [1, 2]
ArrayList1 usa fill(): [0, 0]
ArrayList2 usa copy(): [0, 0]

Attenzione：Quando si esegue il metodo copy(), la dimensione delle due liste deve essere la stessa.

4. Usa binarySearch() per cercare

Il metodo binarySearch() del framework delle collection Java cerca l'elemento specificato. Restituisce la posizione dell'elemento nell'insieme specificato. Ad esempio,

import java.util.Collections;
import java.util.ArrayList;
class Main {}}
　　　　public static void main(String[] args) {
　　　　　　　　// Creazione di un ArrayList
　　　　　　　　ArrayList<Integer> numbers = new ArrayList<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　// Usa binarySearch()
　　　　　　　　int pos = Collections.binarySearch(numbers, 3);
　　　　　　　　System.out.println("La posizione di 3 è " + pos);
　　　　}
}

Risultato di output

La posizione di 3 è 2

Attenzione：Prima di eseguire il metodo binarySearch(), l'insieme deve essere ordinato.

Per ulteriori informazioni, visitareRicerca binaria Java.

5. Combinazione

• frequency() - Restituisce il conteggio delle volte in cui un elemento esiste nell'insieme

• disjoint() - Controlla se due insieme contengono alcuni elementi comuni

Ad esempio,

import java.util.Collections;
import java.util.ArrayList;
class Main {}}
　　　　public static void main(String[] args) {
　　　　　　　　// Creazione di un 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("Conteggio di 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("Due liste sono inintersecate? " + value);
　　　　}
}

Risultato di output

ArrayList1: [1, 2, 3, 2]
Conteggio di 2: 2
ArrayList2: [5, 6]
Due liste sono inintersecate? true

6. Cerca l'elemento minimo e massimo

Il metodo min() e max() del framework delle collection Java vengono utilizzati rispettivamente per trovare l'elemento minimo e massimo. Ad esempio,

import java.util.Collections;
import java.util.ArrayList;
class Main {}}
　　　　public static void main(String[] args) {
　　　　　　　　// Creazione di un ArrayList
　　　　　　　　ArrayList<Integer> numbers = new ArrayList<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　// Utilizzo di min()
　　　　　　　　int min = Collections.min(numbers);
　　　　　　　　System.out.println("Elemento minimo: " + min);
　　　　　　　　// Utilizzo di max()
　　　　　　　　int max = Collections.max(numbers);
　　　　　　　　System.out.println("Elemento massimo: " + max);
　　　　}
}

Risultato di output

Elemento minimo: 1
Elemento massimo: 3