[Java][Débutant] Lire un fichier texte en une seule ligne de code en Java

La manipulation des fichiers textes est une tâche quotidienne. Ainsi, pouvoir lire un fichier texte en une seule ligne de code constitue un plus qu'une plateforme peut offrir à ses développeurs.
Java est l'une des plateformes connues pour compliquer les choses pour ses utilisateurs. En effet, Java est respecté pour être rigoureux, précis et fiable. Mais cela ne vient pas sans prix : pendant les première version, lire un fichier texte en une seule ligne de code était un peu compliqué et impliquait plusieurs objets.
Dans cet exemple, nous allons voir comment lire le contenu d'un fichier texte en une seule ligne de code et cela en utilisant deux API et en obtenant deux formats possibles.
Les deux API sont :

• java.nio : disponible depuis Java 4 mais vraiment efficace depuis Java 8.
• Apache Commons IO : créée pour faciliter les Entrées/Sorites sous Java.

Les deux formats sont :

• Lire tout le contenu dans une seule chaîne (String),
• Lire le contenu ligne par ligne (List<String>).

java.nio :

La lecture se base une méthode "static", cela minimise la création des objets. La classe d'entrée est la classe Files. Cette dernière offre un ensemble de méthodes statiques pour effectuer différentes opérations communes.
Néanmoins, cette classe n'offre pas une méthode pour lire directement en String, ainsi, il faut lire en Byte et faire la conversion. Le code pour la lecture de tout un fichier sous forme d'une seule chaîne de caractères sera :

public static String lireUneChaine(String fichier) throws IOException{
    return new String(Files.readAllBytes(Paths.get(fichier)));
}

La lecture sous forme d'une liste de chaîne de caractères est plus simple grâce à la méthode .readAllLines() :

public static List<String> lirePlusieursChaines(String fichier) throws IOException{
    return Files.readAllLines(Paths.get(fichier));
}

Apache Commons IO :

Apache Commons IO fait partie de la famille Apache Commons qui fournit des outils pour simplifier des tâches fréquentes en Java et que le JDK ne les offre (offrait) pas. La classe d'entrée est IOUtils, et comme pour Files, elle fournit un ensemble de méthodes "static" pour simplifier l'utilisation. Meilleur encore, elle se base sur le package java.io, ainsi, l'ancienne documentation et les anciennes appellations restent valables. Les deux approches de lectures (une seule chaîne ou bien une liste de chaînes) sont offertes par des méthodes dédiées :

public static String lireUneChaine(String fichier) throws IOException{
    return IOUtils.toString(new FileReader(new File(fichier)));
}

public static List<String> lirePlusieursChaines(String fichier) throws IOException{
    return IOUtils.readLines(new FileReader(new File(fichier)));
}

Le résultat d'exécution sera comme suit (un fichier Exemple.txt est fourni avec le code, cette capture montre la moitié exacte de l'exécution, notez la différence entre la première partie qui affiche une seule chaîne de caractères et la deuxième partie qui affiche une liste entre les [ ]) :

Vous pouvez télécharger le code complet, y compris le jar de lApache Commons IO (version actuelle : 2.6) et le fichier Exemple utilisé dans la capture ci-dessus par :

ici

[Java][Débutant] setDefaultCloseOperation vs. la gestion des événements sur les JFrame

[Niveau Débutant][Pour les étudiants (ou personnes) qui prennent leurs premiers pas en Java].

La première chose que nous constatons après la création de notre toute première JFrame en Java est la continuation de l'exécution après la fermeture de l'unique fenêtre et même après la fin de la méthode "main". En effet, en créant une JFrame, nous créons un Thread séparé du Thread principal. En fermant la fenêtre, nous la détruisons mais pas le Thread qui l'a exécutée. Ainsi, il faut préciser à la JFrame qu'il faut quitter l'application lors de sa fermeture.

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class ExempleJFrame extends JFrame {
 
 public ExempleJFrame(){
  setTitle("Exemple");
  setSize(300, 200);
  
  JButton bouton = new JButton("Afficher");
  bouton.addActionListener(new ActionListener(){
   public void actionPerformed(ActionEvent e){
    System.out.println("Thread de la JFrame : " + Thread.currentThread().getName());
   }
  });
  
  getContentPane().setLayout(null);
  bouton.setBounds(100, 85, 100, 25);
  getContentPane().add(bouton);
  
  
 }
 
 public static void main (String args[]) {
  
  (new ExempleJFrame()).setVisible(true);
  System.out.println("Thread principal (méthode main) : " + Thread.currentThread().getName());
  
 }
}

La méthode la plus simple pour cela est l'utilisation de la méthode setDefaultCloseOperation(). Cette méthode est un bon exemple sur l’appellation des méthode suivie dans la JDK et confirme la réputation du Java sur cet axe par rapport à d'autres langages de programmation.

setDefaultCloseOperation() prend un entier qui précise l'action à prendre lors de la fermeture de la fenêtre. Les options disponibles sont :

• DO_NOTHING_ON_CLOSE : ne rien faire,
• HIDE_ON_CLOSE : chacher la fenêtre,
• DISPOSE_ON_CLOSE : détruire la fenêtre,
• EXIT_ON_CLOSE : quitter l'application.

Ces constants sont définies dans la classe WindowConstants et elles sont dupliquées (pour des raisons de simplification) dans la classe JFrame. ET là encore, le même principe d'une appellation détaillée est respecté.

On ajoute une seule ligne au code précédent :

setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

Maintenant, l'application rend la main au système après sa fermeture; il n'est plus nécessaire de forcer l'arrêt de l'application par la commande arrêt dans les EDI (un bouton rouge) ou bien Ctrl+C à partir de la ligne de commande.

Java offre aussi la possibilité de personnaliser l'action à prendre lors de la fermeture de la JFrame. Il est aussi possible de détecter tout sorte d'événements sur la fenêtre (modification de la taille, réduction, etc.). Cela est garanti par l'utilisation d'un écouteur pour la fenêtre : WindowListener.

Cet écouteur était l'unique méthode pour définir les actions à prendre lors de la fermeture dans AWT. setDefaultCloseOperation() n'a été introduite que plus tard avec Swing.

WindowListener est, comme tout autre écouteur,  une interface qui définit les méthodes de réception des événement. Et si ActionListener ne propose qu'une seule méthode (actionPerformed) parce qu'il n'écoute qu'un seul événement (le clique), WindowListener de son côté définit sept (07) fonctions. Son code source (officiel mais sans Javadoc) :

package java.awt.event; 
 
import java.util.EventListener; 
 
public interface WindowListener extends EventListener { 
 
    public void windowOpened(WindowEvent e); 
 
    public void windowClosing(WindowEvent e); 
 
    public void windowClosed(WindowEvent e); 
  
    public void windowIconified(WindowEvent e); 
  
    public void windowDeiconified(WindowEvent e); 
 
    public void windowActivated(WindowEvent e); 
 
    public void windowDeactivated(WindowEvent e); 

} 

Vous pouvez lire le code complet avec les commentaires Javadoc :

WindwListener source code

Ainsi, pour définir l'action à exécuter au moment de la fermeture, il faut implémenter les sept méthodes, laisser toutes les méthodes vides et remplir la méthode windowClosing().

Ainsi, le code de notre fenêtre devient :

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class ExempleJFrame extends JFrame {
 
 public ExempleJFrame(){
  setTitle("Exemple");
  setSize(300, 200);
  
  addWindowListener(new MonWindowListener());
 }
 
 public static void main (String args[]) {
  (new ExempleJFrame()).setVisible(true);
 }
}

class MonWindowListener implements WindowListener {
 
    public void windowOpened(WindowEvent e){} 
 
    public void windowClosing(WindowEvent e){
  System.out.println("La fenêtre a été fermée");
  System.exit(0);
 } 
 
    public void windowClosed(WindowEvent e){}
  
    public void windowIconified(WindowEvent e){} 
  
    public void windowDeiconified(WindowEvent e){} 
 
    public void windowActivated(WindowEvent e){}
 
    public void windowDeactivated(WindowEvent e){} 

}

Avant la fermeture

Après la fermeture, l'application rend la main au système
( avec le code 0 passé comme paramètre à la fonction System.exit(0) )

Pour simplifier l'utilisation, une autre classe a été introduite, c'est la classe WindowAdapter. Cette classe ne fait rein de particulier; elle implémente toutes les méthodes des differentes interface liées aux JFrame (et Frame) mais avec des corps de méthodes vides. Son code (sans les Javadoc) :

public abstract class WindowAdapter 
    implements WindowListener, WindowStateListener, WindowFocusListener 
{ 
    public void windowOpened(WindowEvent e) {} 
 
    public void windowClosing(WindowEvent e) {} 
 
    public void windowClosed(WindowEvent e) {} 
 
    public void windowIconified(WindowEvent e) {} 

    public void windowDeiconified(WindowEvent e) {} 
 
    public void windowActivated(WindowEvent e) {} 

    public void windowDeactivated(WindowEvent e) {} 
 
    public void windowStateChanged(WindowEvent e) {} 
 
    public void windowGainedFocus(WindowEvent e) {} 

    public void windowLostFocus(WindowEvent e) {} 
} 

Son code source complet :

WindowAdapter source code

Ainsi, le code de la fenêtre devient (avec une exécution identique) :

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class ExempleJFrame extends JFrame {
 
 public ExempleJFrame(){
  setTitle("Exemple");
  setSize(300, 200);
  
  addWindowListener(new MonWindowAdapter());
 }
 
 public static void main (String args[]) {
  (new ExempleJFrame()).setVisible(true);
 }
}

class MonWindowAdapter extends WindowAdapter {

 @Override
 public void windowClosing(WindowEvent e){
  System.out.println("La fenêtre a été fermée");
  System.exit(0);
 } 

}

L'utilisation des modèles associés aux composants Swing : JList comme exemple

Contrairement aux composants AWT, les composants Swing sépare la représentation (Vue) des données (Modèle) dans une approche très similaire à l'approche (MVC). Cette série vise à mettre l'accent sur séparation et démontrer quelques possibilités offertes par l'hiérarchie des classes Java pour les composants Swing.

La série se compose de quatre (04) articles :

• JList (1) : un premier exemple simple,
• JList (2) : Exemple avec écouteur (Listener) sur la liste elle-même,
• JList (3) : utilisation d'un écouteur (Listener) sur le modèle,
• JList (4) : exemple d'un ListModel minimal.

Bonne lecture.

JList (4) : exemple d'un ListModel minimal

Ce code démontre l'utilisation de la classe AbstractListModel (ou même l'interface ListModel) pour implémenter un modèle personnalisé pour la JList.

Les trois exemples précédents (1, 2 et 3) se basaient sur l'utilisation de DefaultListModel. Cette dernière classe est une extension de la classe AbstractListModel qui utilise un Vector pour stocker le contenu de la liste. Il est possible de construire un modèle de données qui stocke le contenu dans une structure personnalisée.

ListModel

AbstractListModel

DefaultListModel

Le problème avec cette approche est la duplication du référence. Les objets contenants les données seront doublement référencés. Ainsi, il est possible dans des cas particulier de définir un modèle qui ne stocke et qui ne garde aucune référence. Il va déléguer ces opérations à une structure déjà disponible dans l'application.

Ce cas est un cas extrême et est présenté ici juste pour donner exemple sur les possibilités obtenues si on opte pour l'utilisation de AbstractListModel au lieu de DefaultListModel.

La classe de donnée utilisée dans cet exemple est une classe très simple qui définit trois attributs (id, nom, prénom) et qui offre une méthode toString pour permettre l'affichage. Une petite méthode "static" est ajoutée pour simuler une source de données externe.

class Donnee {
  
 int id;
 String nom;
 String prenom;
 
 public Donnee(int id, String nom, String prenom){
  this.id = id;
  this.nom = nom;
  this.prenom = prenom;
 }
 
 public int getId(){ return id; }
 public String getNom(){ return nom; }
 public String getPrenom(){ return prenom; }
 
 public String toString(){
  return "(" + id + ") " + nom + " " + prenom;
 }
 
 public static List<Donnee> creerDonnees(){
  ...
 }
 
}

Les données sont exposées, par la suite, dans une liste "static" accessible pour tout le monde (comme j'ai précisé, c'est un cas extrême pour montrer les fonctionnalités possibles).

 public static List<Donnee> DONNEES = Donnee.creerDonnees();

Le modèle développé va déléguer ses fonctionnalités à cette liste

class MonModele extends AbstractListModel<Donnee> {
 
 public int getSize(){
  return ExempleSimpleListModel.DONNEES.size();
 }
 
 public Donnee getElementAt(int indice){
  return ExempleSimpleListModel.DONNEES.get(indice);
 } 
}

Le code complet sera :

import javax.swing.*;
import java.awt.event.*;
import javax.swing.event.*;
import java.util.*;

public class ExempleSimpleListModel {
 
 public static List<Donnee> DONNEES = Donnee.creerDonnees();
 
 public static void main (String args[]) {
  
  (new MaFrame()).setVisible(true);
  
 }
}

class Donnee {
  
 int id;
 String nom;
 String prenom;
 
 public Donnee(int id, String nom, String prenom){
  this.id = id;
  this.nom = nom;
  this.prenom = prenom;
 }
 
 public int getId(){ return id; }
 public String getNom(){ return nom; }
 public String getPrenom(){ return prenom; }
 
 public String toString(){
  return "(" + id + ") " + nom + " " + prenom;
 }
 
 public static List<Donnee> creerDonnees(){
  List<Donnee> liste = new ArrayList<>();
  liste.add(new Donnee(1, "Wilhelm", "Conrad Röntgen"));
  liste.add(new Donnee(2, "Hendrik", "Lorentz"));
  liste.add(new Donnee(3, "Pieter", "Zeeman"));
  liste.add(new Donnee(4, "Antoine Henri", "Becquerel"));
  liste.add(new Donnee(5, "Piere", "Curie"));
  liste.add(new Donnee(6, "Marie", "Curie"));
  return liste;
 }
 
}

class MaFrame extends JFrame {
 
 JList liste;
 MonModele modele;
 
 public MaFrame(){
  
  setTitle("Exemple JList");
  setSize(250, 400);
  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  
  modele = new MonModele();
  liste = new JList(modele);
  
  getContentPane().add(new JScrollPane(liste));
  
 }
  
}

class MonModele extends AbstractListModel<Donnee> {
 
 public int getSize(){
  return ExempleSimpleListModel.DONNEES.size();
 }
 
 public Donnee getElementAt(int indice){
  return ExempleSimpleListModel.DONNEES.get(indice);
 } 
}

Résultat :

JList (2) : Exemple avec écouteur (Listener) sur la liste elle-même

Ce code montre l'utilisation d'un écouteur (Listener) sur la liste elle-même pour détecter et gérer l'interaction entre cette dernière et l'utilisateur.

Ce code est le deuxième dans une série d'articles qui montrent l'utilité u modèle MVC respecté par les composants Swing et qui devient nécessaire pour les composants qui affichent plusieurs données.

Un premier exemple (avec une explication détaillée sur la création d'une JList avec un DefaultListModel) se trouve ici.

Dans ce deuxième code, la liste est associée à un écouteur pour surveiller les actions de sélection et de désélection des éléments de la liste.

Trois mode de sélection peuvent être définis pour une liste. La méthode setSelectionMode() prend un entier qui détermine le mode. Pour simplifier l'utilisation, les trois valeurs sont déclarées comme des constantes dans la classe ListSelectionModel avec des noms assez parlants. Elles sont :

• ListSelectionModel.SINGLE_SELECTION 
• ListSelectionModel.SINGLE_INTERVAL_SELECTION
• ListSelectionModel.MULTIPLE_INTERVAL_SELECTION

ListSelectionMode (JDK 7)

Dans cet exemple, deux modes seront démontrés.

Pour pouvoir récupérer les changements dans la sélection, il suffit d'ajouter un ListSelectionListener. Ce dernier définit une seule méthode : public void valueChanged(ListSelectionEvent e). Malgré que l’événement ListSelectionEvent permet de récupérer toutes les informations utiles sur le changement dans la sélection, il est possible de faire appel à des méthodes dans la classe JList directement.

ListSelectionEvent

Néanmoins, les méthodes à appeler dépendent du modèle de sélection utilisé. En effet, si le mode de sélection est "SINGLE_SELECTION" alors il n'est pas pratique de faire appel aux méthodes qui récupèrent "la liste des éléments sélectionnés".

Pour basculer entre les deux modes de sélection démontrer, deux JRadioButton sont utilisés. Les deux sont associés à un écouteur (ChangeListener) pour surveiller le changement de la sélection et ainsi changer le mode de sélection de la liste.

ChangeListener

JRadioButton

Ainsi la partie la plus importante du code est :

 public void valueChanged(ListSelectionEvent e){
  if(uniqueSelection){
   
   int indice = liste.getSelectedIndex();
   
   if(indice != -1){
    String valeur = (String)liste.getSelectedValue();
    lblSelection.setText(valeur + "(" + indice + ")");
   }
   
  }else{
   
   int[] indices = liste.getSelectedIndices();
   List<String> valeurs = liste.getSelectedValuesList();
   
   String message = "";
   for(int i = 0; i < valeurs.size(); i++){ 
    message += valeurs.get(i) + "(" + indices[i] + ") ";
   }
   lblSelection.setText(message);
   
  }
 }

Le code complet :

import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import java.awt.event.*;
import java.util.List;

public class ExempleSelectionJList 
  extends JFrame 
   implements ChangeListener, ListSelectionListener{
 
 JList liste;
 DefaultListModel<String> modele;
 
 String[] quelquesDonnees = new String[]{"Alfa",
  "Bravo", "Charlie", "Delta", "Echo", "Foxtrot", "Golf",
  "Hotel", "India", "Juliett", "Kilo", "Lima", "Mike",
  "November", "Oscar", "Papa", "Quebec", "Romeo", "Sierra",
  "Tango", "Uniform", "Victor", "Whiskey", "X-ray", "Yankee",
  "Zulu"};
 
 JRadioButton rdoUnique, rdoMultiple;
 ButtonGroup groupe;
 boolean uniqueSelection;
 
 JLabel lblSelection;
 JPanel pnlAjouter;
 
 public ExempleSelectionJList(){
  
  setTitle("Exemple Simple JList");
  setSize(800, 400);
  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  
  modele = new DefaultListModel();
  liste = new JList(modele);
  liste.addListSelectionListener(this);
  
  creerFormulaire();
  remplirListe();
  
  getContentPane().add(pnlAjouter, BorderLayout.CENTER);
  getContentPane().add(new JScrollPane(liste), BorderLayout.WEST);
  
 }
 
 public void creerFormulaire(){
  
  rdoUnique = new JRadioButton("Choix Unique");
  rdoUnique.setBounds(20, 20, 150, 30);
  rdoMultiple = new JRadioButton("Choix Multiple");
  rdoMultiple.setBounds(190, 20, 150, 30);
  
  rdoUnique.addChangeListener(this);
  rdoMultiple.addChangeListener(this);
  
  groupe = new ButtonGroup();
  groupe.add(rdoUnique);
  groupe.add(rdoMultiple);
  
  rdoUnique.setSelected(true);
  uniqueSelection = true;
  
  lblSelection = new JLabel("La sélection s'affiche ici");
  lblSelection.setBounds(20, 70, 450, 30);
  
  
  pnlAjouter = new JPanel();
  pnlAjouter.setLayout(null);
  pnlAjouter.add(rdoUnique);
  pnlAjouter.add(rdoMultiple);
  pnlAjouter.add(lblSelection);
  
 }
 
 public void remplirListe(){
  for(int i = 0; i < quelquesDonnees.length; i++)
   modele.addElement(quelquesDonnees[i]);
 }
 
 public void valueChanged(ListSelectionEvent e){
  if(uniqueSelection){
   
   int indice = liste.getSelectedIndex();
   
   if(indice != -1){
    String valeur = (String)liste.getSelectedValue();
    lblSelection.setText(valeur + "(" + indice + ")");
   }
   
  }else{
   
   int[] indices = liste.getSelectedIndices();
   List<String> valeurs = liste.getSelectedValuesList();
   
   String message = "";
   for(int i = 0; i < valeurs.size(); i++){ 
    message += valeurs.get(i) + "(" + indices[i] + ") ";
   }
   lblSelection.setText(message);
   
  }
 }
 
 public void stateChanged(ChangeEvent e){
  uniqueSelection = rdoUnique.isSelected();
  if(uniqueSelection)
   liste.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
  else
   liste.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
 }
 
 public static void main (String args[]) {
  
  (new ExempleSelectionJList()).setVisible(true);
 }
}

Quelques résultats :

JList (1) : un premier exemple simple

Ce code présente un exemple très simple pour créer et ajouter des éléments à une JList.

Ce code a été créé comme un premier code dans une (petite) série pour mettre l'accent sur l'utilisation des modèles tels que définis par  l'approche MVC, cette dernière qui est respectée par les composants Swing en comparaison avec les composants AWT.

Si la manipulation du modèle (donnée) associé à un composant simple comme JTextField, ce n'est pas de même pour les composants qui affichent plusieurs données tels que JComboBox, JList et JTable.

Dans cette série, JList sera choisie pour démontrer quelques fonctionnalités.

Dans cet premier code, une JList est créé en se basant sur DefaultListModel. En effet, les différents modèles sont disponibles comme des interfaces.

ListModel (JDK 7)

Pour simplifier leur utilisation (garantir les fonctionnalités de base communes), une classe abstraite qui implémente le minimum des fonctionnalités est livrée. Cela est valide pour tous les modèles des données pour les autres composants. Pour le cas de la JList, la classe abstraite est AbstractListModel :

AbstractListModel (JDK 7)

Néanmoins, l'interface et la classe abstraite ne donnent aucune implémentation réelle qui supportent la sauvegarde des données et qui est prête pour être utilisée. C'est pourquoi, une implémentation par défaut est livrée. Cela aussi est valide pour les autres modèles des données des autres composants Swing. Pour la JList, la classe par défaut est DefaultListModel (c'est très explicit comme noms de classes) :

DefaultListModel (JDK 7)

Cette dernière utilise un Vector pour stocker les données :

private Vector delegate = new Vector();

Code source de DefaultListModel

Le code suivant, montre comment créer une JList avec un DefaultListModel. Le code de création des autres composants graphiques est séparé. Le bouton permet d'ajouter la valeur saisie dans le champs à la liste (à gauche) :

Code source :

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class ExempleSimpleJList extends JFrame implements ActionListener {
 
 JList liste;
 DefaultListModel modele;
 
 JLabel lblNouveau;
 JTextField txtNouveau;
 JButton btnAjouter;
 JPanel pnlAjouter;
 
 public ExempleSimpleJList(){
  
  setTitle("Exemple Simple JList");
  setSize(800, 400);
  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  
  modele = new DefaultListModel();
  liste = new JList(modele);
  
  creerFormulaire();
  
  getContentPane().add(pnlAjouter, BorderLayout.CENTER);
  getContentPane().add(new JScrollPane(liste), BorderLayout.WEST);
  
 }
 
 public void actionPerformed(ActionEvent e){
  modele.addElement(txtNouveau.getText());
 }
 
 public void creerFormulaire(){
  
  lblNouveau = new JLabel("Nouveau Element :");
  lblNouveau.setBounds(20, 20, 150, 30);
  txtNouveau = new JTextField();
  txtNouveau.setBounds(190, 20, 150, 30);
  btnAjouter = new JButton("Ajouter");
  btnAjouter.setBounds(20, 70, 150, 30);
  btnAjouter.addActionListener(this);
  
  pnlAjouter = new JPanel();
  pnlAjouter.setLayout(null);
  pnlAjouter.add(lblNouveau);
  pnlAjouter.add(txtNouveau);
  pnlAjouter.add(btnAjouter);
  
 }
 
 public static void main (String args[]) {
  
  (new ExempleSimpleJList()).setVisible(true);
 }
}

Résultat :