Pausa caffè #196. Come leggere correttamente i file in Java 8 e Java 11. Come ordinare una lista in Java, vari metodi per ordinare le liste in Java

Come leggere correttamente i file in Java 8 e Java 11

Fonte: Medium Con questo tutorial imparerai diversi suggerimenti utili durante l'elaborazione e la lettura di file di grandi dimensioni in Java 8 e Java 11. Leggere un file che si trova sul disco del tuo computer è abbastanza semplice in Java. In Java 8 e versioni successive, puoi utilizzare la classe Files per questo file . Fa parte del pacchetto java.nio.file , introdotto per la prima volta in Java 7 per fornire un modo più efficiente di lavorare con file e directory. Di seguito è riportato un esempio di come è possibile utilizzare la classe Files per leggere un file in Java 8.

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class FileReader {
    public static void main(String[] args) {
        try {
            Path path = Paths.get("file.txt");
            String content = Files.readString(path);
            System.out.println(content);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Questo esempio utilizza il metodo Files.readAllLines() per leggere tutte le righe di un file e memorizzarle in un file List<String> . Il metodo Paths.get() viene utilizzato per creare un oggetto Path che rappresenta il file. Inoltre puoi usare Files.lines :

import java.io.IOException;
import java.nio.file.Paths;
import java.nio.file.Files;

public class FileReader {
    public static void main(String[] args) {
        try {
            Files.lines(Paths.get("file.txt"))
                .forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

In Java 11, per leggere i file puoi utilizzare il metodo readString() , legge l'intero file come una stringa. Ecco un esempio di come utilizzarlo.

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class FileReader {
    public static void main(String[] args) {
        try {
            Path path = Paths.get("file.txt");
            String content = Files.readString(path);
            System.out.println(content);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Quando si lavora con file di grandi dimensioni in Java, è importante tenere a mente alcune linee guida:

1. Utilizzare un lettore bufferizzato . Ti consente di leggere grandi quantità di dati alla volta, invece di leggere un carattere o una riga alla volta.
2. Utilizza una dimensione del buffer più piccola : quando si utilizza un lettore con buffer, una dimensione del buffer più piccola può aiutare a ridurre l'utilizzo della memoria.
3. Utilizza l'API di streaming . Invece di caricare l'intero file in memoria, l'API di streaming ti consente di leggere il file in parti.
4. Utilizza un thread parallelo per elaborare il file , soprattutto se il file è di grandi dimensioni.
5. Chiudi il file dopo la lettura: questo aiuterà a liberare risorse.
6. Utilizza l' istruzione try-with-resources per chiudere automaticamente un file dopo averlo letto. Ciò garantisce che il file venga chiuso anche se si verifica un'eccezione durante la lettura.

Di seguito è riportato un esempio dell'utilizzo dell'istruzione try-with-resources per leggere un file.

import java.io.IOException;
import java.nio.file.Paths;
import java.nio.file.Files;
import java.util.List;

public class FileReader {
    public static void main(String[] args) {
        try (BufferedReader reader = Files.newBufferedReader(Paths.get("file.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

In questo esempio, un oggetto BufferedReader viene creato all'interno di un'istruzione try-with-resources, che garantisce che venga chiuso automaticamente all'uscita dal blocco, anche se si verifica un'eccezione. Pertanto, quando si leggono file di grandi dimensioni in Java, è meglio utilizzare un lettore con buffer, dimensioni del buffer più piccole, API di streaming, flusso parallelo e chiudere il file dopo averlo letto. Inoltre, l'utilizzo di un'istruzione try-with-resources può contribuire a garantire che il file venga chiuso correttamente in caso di eccezione.

Come ordinare l'elenco in Java. Vari metodi di ordinamento degli elenchi in Java

Fonte: FreeCodeCamp Questo post copre vari metodi di ordinamento degli elenchi in Java: Collections.sort() , stream.sorted() e List.sort() . A volte i dati devono essere organizzati in un ordine specifico per facilitarne la comprensione, la ricerca e l'elaborazione. Chiamiamo questo processo ordinamento. Utilizzando l'ordinamento è possibile organizzare i dati non solo in un ordine specifico, ma anche in base a criteri: ad esempio, per tipo di dati, inclusi numeri, stringhe e oggetti. Il linguaggio Java dispone di metodi incorporati per l'ordinamento, ad esempio nelle classi Collections . L'ordinamento Java viene spesso utilizzato nelle applicazioni di e-commerce in cui l'utente deve visualizzare un elenco di prodotti. I prodotti possono essere ordinati in vari modi a seconda dei requisiti impostati dall'utente, come prezzo, valutazione, marca e così via. Ad esempio, se un utente desidera vedere tutti i prodotti ordinati per prezzo in ordine crescente, l'applicazione può utilizzare un algoritmo di ordinamento per disporre i prodotti in tale ordine. In questo modo, quando un utente esplora i prodotti, sarà in grado di vedere prima i prodotti più economici e prendere una decisione di acquisto di conseguenza.

Come utilizzare il metodo Collections.Sort() in Java

Uno dei modi più comuni per ordinare i dati in Java è utilizzare il metodo Collections.sort() . Per impostazione predefinita, ordina l'elenco in ordine crescente. Ecco un esempio di utilizzo del metodo Collections.sort() per ordinare un elenco di numeri interi:

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

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<Integer>();
        numbers.add(3);
        numbers.add(1);
        numbers.add(4);
        numbers.add(2);

        Collections.sort(numbers);

        System.out.println("Sorted List: " + numbers);
    }
}

Il codice precedente crea un elenco di numeri interi, vi aggiunge quattro numeri, ordina l'elenco e quindi stampa l'elenco ordinato sulla console. Utilizza le classi della Java Standard Library per eseguire operazioni, tra cui java.util.Collections , java.util.List e java.util.ArrayList . L'output è il seguente: Puoi anche ordinare un elenco di oggetti personalizzati utilizzando il metodo Collections.sort() . Per fare ciò, dovrai creare un comparatore e passarlo come argomento al metodo Collections.sort() . Un comparatore è un oggetto che implementa l' interfaccia java.util.Comparator . Ha un unico metodo richiamabile, compare() , che confronta due oggetti e restituisce un numero intero che indica il loro ordine relativo. Ecco un esempio di come utilizzare un comparatore per ordinare un elenco di oggetti personalizzati:

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

public class Main {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("Alice", 25));
        people.add(new Person("Bob", 30));
        people.add(new Person("Charlie", 20));

        Collections.sort(people, new PersonComparator());

        System.out.println("Sorted List: " + people);
    }
}

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return name + " (" + age + ")";
    }
}

class PersonComparator implements java.util.Comparator<Person> {
    @Override
    public int compare(Person a, Person b) {
        return a.getAge() - b.getAge();
    }
}

Il codice mostrato sopra crea un elenco di oggetti Person , aggiunge diversi oggetti Person all'elenco , ordina l'elenco utilizzando un comparatore personalizzato ( PersonComparator ), quindi stampa l'elenco ordinato. La classe Person ha due campi, name ed age , oltre a metodi getter per questi campi. La classe PersonComparator implementa l' interfaccia Comparator ed esegue l'override del metodo di confronto per ordinare gli oggetti Person in base all'età ( age ). L'output di questo programma sarà così: Il metodo Collections.sort() viene utilizzato al meglio quando si dispone di una raccolta di oggetti che si desidera ordinare in base a uno o più campi. Ad esempio, se disponi di una raccolta di oggetti Employee e desideri ordinarli in base al cognome, puoi utilizzare il metodo Collections.sort() e passare un comparatore personalizzato che confronta i cognomi degli oggetti Employee .

Come utilizzare il metodo List.Sort() in Java

Questo metodo ordina l'elenco in ordine crescente. Ecco come funziona:

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(5, 3, 2, 4, 1);
        numbers.sort(null);
        System.out.println(numbers); // prints [1, 2, 3, 4, 5]
    }
}

All'interno del metodo main , Arrays.asList crea un elenco di numeri interi chiamati numeri . Il codice ordina quindi questo elenco di numeri utilizzando il metodo di ordinamento predefinito, poiché null viene passato al metodo di ordinamento . Infine, l'elenco ordinato viene stampato sulla console utilizzando il metodo System.out.println . L'output è [1, 2, 3, 4, 5] . List.sort() è utile quando hai un elenco di elementi che devono essere ordinati. Ad esempio, se hai un elenco di stringhe e desideri ordinarle in ordine alfabetico, puoi utilizzare il metodo List.sort() per farlo . List.sort() è un metodo di istanza della classe List e ordina gli elementi nell'ordine determinato dal loro ordine naturale o dall'implementazione Icomparer specificata .

Come utilizzare il metodo stream.sorted() in Java

In Java 8 e versioni successive, puoi utilizzare l'API Stream per ordinare un elenco. Fornisce il metodo sorted , che può essere utilizzato per ordinare gli elementi di un flusso. Ecco un esempio di come ordinare un elenco di numeri interi utilizzando uno stream:

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {

        List<Integer> numbers = Arrays.asList(5, 3, 2, 4, 1);
        List<Integer> sortedList = numbers.stream().sorted().collect(Collectors.toList());
        System.out.println(sortedList); // prints [1, 2, 3, 4, 5]

    }
}

Come puoi vedere, l'elenco di numeri viene convertito in uno stream utilizzando il metodo stream() . Viene quindi chiamato il metodo sorted() per ordinare gli elementi nello stream . Il metodo Collect(Collectors.toList()) viene utilizzato per raccogliere nuovamente gli elementi ordinati in un elenco. Il risultato è un nuovo elenco contenente gli elementi ordinati. L'output è [1, 2, 3, 4, 5] . stream.sorted() è utilizzato al meglio quando si dispone di un flusso di elementi che devono essere ordinati. Ad esempio, se hai un flusso di numeri interi e desideri ordinarli in ordine crescente, allora è meglio utilizzare il metodo stream.Sorted() per questo .

Conclusione

In questo tutorial hai imparato che esistono diversi modi per ordinare un elenco in Java: il metodo Collections.sort() , il metodo stream.sorted() e il metodo List.sort() . Quale di questi metodi sia meglio utilizzare dipende dai requisiti specifici dell'attività da svolgere. Spero che questo articolo ti abbia fornito le informazioni corrette su come ordinare un elenco in Java. Buona programmazione!