file writer doesn't work

Question

I use a FileWriter and a BufferWriter to write in a file. The file "test.txt" is created but nothing is written inside.

The file should be written in the ActionEvent of my button. Is that the reason why ?

That's my code :

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;  
import java.util.UUID;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JTextField;

class Cadre_fenetreA2 extends JFrame            
{
    JLabel phrase = new JLabel("Veuillez indiquer le nom de chaque groupe de generalisation pour chaque Niveau");
    JButton boutonOK = new JButton ("OK");
    public Cadre_fenetreA2 (String nom,int X, int Y, int lo, int la, int Na, int [] nbGrpGen,int maxnbGrpGen, File file)        
    {
        super(nom);                     
        setBounds(X,Y,lo,la);       
        setVisible(true);                   


        JTextField[][] allField = new JTextField [Na][maxnbGrpGen];
        JLabel phrases[] = new JLabel [Na];
        String[][] nomGrpGen = new String [Na][maxnbGrpGen];



        setLayout(null);
        for(int i = 0;i < Na;i++)
        {
            for(int j = 0;j<nbGrpGen[i];j++)
            {
                String uuid = UUID.randomUUID().toString();

                 allField[i][j] = new JTextField(uuid.substring(0,8));
                 allField[i][j].setBounds(150+j * 60, 75 + i * 25, 50, 20);
                 add(allField[i][j]);
            }

           phrases[i] = new JLabel("Niveau "+String.valueOf(i+1));
           phrases[i].setBounds(5, 75 + i * 25, 200, 20);

           add( phrases[i]);
        }
        phrase.setBounds(0,0,1000,50);
        add(phrase);
        boutonOK.setBounds(250+maxnbGrpGen*50,25*(Na),60,60);
        add(boutonOK);
        boutonOK.addActionListener(new ecout(Na,nbGrpGen,allField,nomGrpGen, file));
    }

    class ecout implements ActionListener 
    {   
        private int Na;
        private String [][] nomGrpGen ;
        private JTextField[][] allField;
        boolean correct=true;
        private int[] nbGrpGen;
        String chaine;
        File file;


        public ecout(int Na,int[] nbGrpGen, JTextField[][] allField, String[][] nomGrpGen, File file)
        {
            this.file = file;
            this.Na = Na;
            this.nbGrpGen =nbGrpGen;
            this.allField =allField;
            this.nomGrpGen =nomGrpGen;
        }

        public void actionPerformed(ActionEvent evt)
        {
            for(int i = 0;i < Na ;i++)
            {
                for(int j = 0;j < nbGrpGen[i] ;j++)
                {
                nomGrpGen[i][j] = allField[i][j].getText();
                    //chaine=allField[i][j].getText();
                    //nomGrpGen[i][j] ="A";
                  if(nomGrpGen[i][j]=="")
                  {
                      correct=false;
                  }
                }
            } 
            if(correct)
            {
                int i=0;
                int j=0;
                int nbElement;
                JOptionPane jop = new JOptionPane();
                String res;
                do
                {
                    res= jop.showInputDialog(null, "Veuillez indiquer le nombre d'attribut present au depart", "nombre d'attribut",JOptionPane.QUESTION_MESSAGE);
                }
                while(! isInteger(res));
                nbElement =Integer.parseInt(res); 


                int largeur=150+nbElement*30+80;
                int hauteur=30*(nbGrpGen[i])+100;
                if(largeur<600)
                {
                    largeur=600;
                }

                try 
                {
                    FileWriter fw = new FileWriter("test.txt");
                            BufferedWriter out = new BufferedWriter(fw);
                            out.write("aString");
                } 
                catch (IOException e) 
                {
                    e.printStackTrace();
                }
                dispose();
                i=0;
                j=0;
                new Cadre_fenetreA3 ("initialisation du groupe"+nomGrpGen[i][j],5,5,largeur, hauteur, nbGrpGen[i], nbElement,nomGrpGen[i], i+1); 
            }
        }
    }
    public boolean isInteger( String input )  
    {  
       try  
       {  
          Integer.parseInt( input );  
          return true;  
       }  
       catch( Exception e)  
       {  
          return false;  
       }  
    }  

}

Answer 1

Here,

try 
{
    FileWriter fw = new FileWriter("test.txt");
            BufferedWriter out = new BufferedWriter(fw);
            out.write("aString");
} 
catch (IOException e) 
{
    e.printStackTrace();
}

You wrapped it in a BufferedWriter which has a default buffer size of 8KB. So as long as you don't write more than 8KB and don't flush/close it, then it won't appear in the target file.

You need to close the writer when you're done with it. This will flush any buffers and release any locks on the file. The normal idiom is to close it in the finally block of the very same try block as where it was been created. This way you guarantee that it's also closed in case of exceptions, hereby preventing resource leaking and forever locked files.

Writer writer = null;

try {
    writer = new BufferedWriter(new FileWriter("test.txt"));
    writer.write("aString");
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (writer != null) try { writer.close(); } catch (IOException ignore) {}
}

Alternatively, if you're already on Java 7, then you can also use the new try-with-resources statement. It'll automatically close the resource when you leave the try block, resulting in less boilerplate code.

try (Writer writer = new BufferedWriter(new FileWriter("test.txt"))) {
    writer.write("aString");
} catch (IOException e) {
    e.printStackTrace();
}

By the way, I'd work on exception handling as well. Rather display the enduser some sensible error message instead of plain printing it to the stdout and ignoring it further.