Pause café #196. Comment lire correctement les fichiers en Java 8 et Java 11. Comment trier une liste en Java, diverses méthodes de tri des listes en Java

Comment lire correctement les fichiers dans Java 8 et Java 11

Source : Medium Avec ce tutoriel, vous apprendrez plusieurs astuces utiles lors du traitement et de la lecture de fichiers volumineux en Java 8 et Java 11. La lecture d'un fichier qui se trouve sur le disque de votre ordinateur est assez simple en Java. Dans Java 8 et versions ultérieures, vous pouvez utiliser la classe Files pour cela . Il fait partie du package java.nio.file , qui a été introduit pour la première fois dans Java 7 pour fournir un moyen plus efficace de travailler avec des fichiers et des répertoires. Vous trouverez ci-dessous un exemple de la façon dont vous pouvez utiliser la classe Files pour lire un fichier dans 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();
        }
    }
}

Cet exemple utilise la méthode Files.readAllLines() pour lire toutes les lignes d'un fichier et les stocker dans un fichier List<String> . La méthode Paths.get() est utilisée pour créer un objet Path représentant le fichier. Vous pouvez également utiliser 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();
        }
    }
}

Dans Java 11, pour lire des fichiers, vous pouvez utiliser la méthode readString() , elle lit l'intégralité du fichier sous forme de chaîne. Voici un exemple de la façon de l'utiliser.

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();
        }
    }
}

Lorsque vous travaillez avec des fichiers volumineux en Java, il est important de garder quelques directives à l'esprit :

1. Utilisez un lecteur tamponné . Il vous permet de lire de gros morceaux de données à la fois, plutôt que de lire un caractère ou une ligne à la fois.
2. Utiliser une taille de tampon plus petite : lors de l'utilisation d'un lecteur avec mémoire tampon, une taille de tampon plus petite peut aider à réduire l'utilisation de la mémoire.
3. Utilisez l'API de diffusion en continu . Au lieu de charger l'intégralité du fichier en mémoire, l'API de streaming vous permet de lire le fichier en plusieurs parties.
4. Utilisez un thread parallèle pour traiter le fichier , surtout si le fichier est volumineux.
5. Fermez le fichier après lecture : cela permettra de libérer des ressources.
6. Utilisez l' instruction try-with-resources pour fermer automatiquement un fichier après l'avoir lu. Cela garantit que le fichier est fermé même si une exception se produit lors de sa lecture.

Vous trouverez ci-dessous un exemple d'utilisation de l'instruction try-with-resources pour lire un fichier.

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();
        }
    }
}

Dans cet exemple, un objet BufferedReader est créé dans une instruction try-with-resources, qui garantit qu'il est automatiquement fermé à la sortie du bloc, même si une exception se produit. Ainsi, lors de la lecture de fichiers volumineux en Java, il est préférable d'utiliser un lecteur avec tampon, une taille de tampon plus petite, une API de streaming, un flux parallèle et de fermer le fichier après l'avoir lu. De plus, l'utilisation d'une instruction try-with-resources peut contribuer à garantir que le fichier est correctement fermé en cas d'exception.

Comment trier une liste en Java. Diverses méthodes de tri de liste en Java

Source : FreeCodeCamp Cet article couvre diverses méthodes de tri de liste en Java : Collections.sort() , stream.sorted() et List.sort() . Parfois, les données doivent être organisées dans un ordre spécifique pour faciliter leur compréhension, leur recherche et leur traitement. Nous appelons ce processus le tri. Grâce au tri, vous pouvez organiser les données non seulement dans un ordre spécifique, mais également selon des critères : par exemple, par type de données, y compris les nombres, les chaînes et les objets. Le langage Java possède des méthodes intégrées de tri, par exemple dans les classes Collections . Le tri Java est souvent utilisé dans les applications de commerce électronique où l'utilisateur doit afficher une liste de produits. Les produits peuvent être triés de différentes manières en fonction des exigences définies par l'utilisateur, telles que le prix, la note, la marque, etc. Par exemple, si un utilisateur souhaite voir tous les produits triés par prix par ordre croissant, l'application peut utiliser un algorithme de tri pour organiser les produits dans cet ordre. De cette façon, lorsqu’un utilisateur parcourt les produits, il pourra d’abord voir les produits les moins chers et prendre une décision d’achat en conséquence.

Comment utiliser la méthode Collections.Sort() en Java

L'un des moyens les plus courants de trier les données en Java consiste à utiliser la méthode Collections.sort() . Par défaut, il trie la liste par ordre croissant. Voici un exemple d'utilisation de la méthode Collections.sort() pour trier une liste d'entiers :

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);
    }
}

Le code ci-dessus crée une liste d'entiers, y ajoute quatre nombres, trie la liste, puis imprime la liste triée sur la console. Il utilise des classes de la bibliothèque standard Java pour effectuer des opérations, notamment java.util.Collections , java.util.List et java.util.ArrayList . Le résultat est le suivant : Vous pouvez également trier une liste d'objets personnalisés à l'aide de la méthode Collections.sort() . Pour ce faire, vous devrez créer un comparateur et le passer en argument à la méthode Collections.sort() . Un comparateur est un objet qui implémente l' interface java.util.Comparator . Il possède une seule méthode appelable, compare() , qui compare deux objets et renvoie un entier indiquant leur ordre relatif. Voici un exemple d'utilisation d'un comparateur pour trier une liste d'objets personnalisés :

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();
    }
}

Le code présenté ci-dessus crée une liste d' objets Person , ajoute plusieurs objets Person à la liste , trie la liste à l'aide d'un comparateur personnalisé ( PersonComparator ), puis imprime la liste triée. La classe Person comporte deux champs, name et age , ainsi que des méthodes getter pour ces champs. La classe PersonComparator implémente l' interface Comparator et remplace la méthode de comparaison pour trier les objets Person par âge ( age ). Le résultat de ce programme ressemblera à ceci : La méthode Collections.sort() est mieux utilisée lorsque vous disposez d’une collection d’objets que vous souhaitez trier selon un ou plusieurs champs. Par exemple, si vous disposez d'une collection d' objets Employee et que vous souhaitez les trier par nom de famille, vous pouvez utiliser la méthode Collections.sort() et transmettre un comparateur personnalisé qui compare les noms de famille des objets Employee .

Comment utiliser la méthode List.Sort() en Java

Cette méthode trie la liste par ordre croissant. Voici comment cela fonctionne:

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]
    }
}

À l'intérieur de la méthode principale , Arrays.asList crée une liste d'entiers appelés nombres . Le code trie ensuite cette liste de nombres en utilisant la méthode de tri par défaut, puisque null est transmis à la méthode de tri . Enfin, la liste triée est imprimée sur la console à l'aide de la méthode System.out.println . La sortie est [1, 2, 3, 4, 5] . List.sort() est utile lorsque vous disposez d'une liste d'éléments qui doivent être triés. Par exemple, si vous avez une liste de chaînes et que vous souhaitez les trier par ordre alphabétique, vous pouvez utiliser la méthode List.sort() pour ce faire . List.sort() est une méthode d'instance de la classe List et trie les éléments dans l'ordre déterminé par leur ordre naturel ou par l' implémentation Icomparer donnée .

Comment utiliser la méthode stream.sorted() en Java

Dans Java 8 et versions ultérieures, vous pouvez utiliser l'API Stream pour trier une liste. Il fournit la méthode sorted , qui peut être utilisée pour trier les éléments d'un flux. Voici un exemple de comment trier une liste d'entiers à l'aide d'un flux :

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]

    }
}

Comme vous pouvez le voir, la liste de nombres est convertie en flux à l'aide de la méthode stream() . La méthode sorted() est ensuite appelée pour trier les éléments du flux . La méthode collect(Collectors.toList()) est utilisée pour collecter les éléments triés dans une liste. Le résultat est une nouvelle liste contenant les éléments triés. La sortie est [1, 2, 3, 4, 5] . stream.sorted() est mieux utilisé lorsque vous disposez d’un flux d’éléments qui doivent être triés. Par exemple, si vous avez un flux d'entiers et que vous souhaitez les trier par ordre croissant, il est préférable d'utiliser la méthode stream.Sorted() pour cela .

Conclusion

Dans ce didacticiel, vous avez appris qu'il existe plusieurs façons de trier une liste en Java : la méthode Collections.sort() , la méthode stream.sorted() et la méthode List.sort() . La méthode à utiliser dépend des exigences spécifiques de la tâche à accomplir. J'espère que cet article vous a donné les informations correctes sur la façon de trier une liste en Java. Bon codage !