fichier écrivain ne fonctionne pas

- Je utiliser un FileWriter et un BufferWriter d'écrire dans un fichier. Le fichier "test.txt" est créé, mais rien n'est écrit à l'intérieur.

Le fichier doit être écrit dans la ActionEvent de mon bouton. Est-ce la raison pourquoi ?

C'est mon 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;  
}  
}  
}

OriginalL'auteur giovedy | 2012-08-09

file java

11

Ici,
```
try 
{
FileWriter fw = new FileWriter("test.txt");
BufferedWriter out = new BufferedWriter(fw);
out.write("aString");
} 
catch (IOException e) 
{
e.printStackTrace();
}
```
Vous enveloppé dans un BufferedWriter qui a une taille par défaut du tampon de 8 KO. Donc, tant que vous n'écrivez pas plus de 8 KO et ne pas rincer à/près d'elle, alors elle n'apparaît pas dans le fichier cible.

Vous devez fermer l'écrivain lorsque vous avez terminé avec elle. Cela permettra de vider les tampons et la libération de tous les verrous sur les fichiers. La normale de l'idiome est de la fermer dans le finally bloc de la même try bloc où il a été créé. De cette façon, vous garantie que c'est aussi en cas de fermeture des exceptions, par la présente, la prévention de la ressource de fuite et pour toujours les fichiers verrouillés.
```
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) {}
}
```
Alternativement, si vous êtes déjà sur Java 7, alors vous pouvez aussi utiliser la nouvelle try-with-resources déclaration. Il va automatiquement fermer la ressource lorsque vous quittez le try bloc, ce qui entraîne moins de code réutilisable.
```
try (Writer writer = new BufferedWriter(new FileWriter("test.txt"))) {
writer.write("aString");
} catch (IOException e) {
e.printStackTrace();
}
```
En passant, j'ai travaillé sur la gestion des exceptions. Plutôt d'affichage de l'utilisateur final certaines sensible message d'erreur au lieu de la plaine de l'impression à la sortie standard (stdout) et de l'ignorer encore.

OriginalL'auteur BalusC

Près ou de chasse de l'auteur:

FileWriter fw = new FileWriter("test.txt");
BufferedWriter out = new BufferedWriter(fw);
out.write("aString");
out.close();

OriginalL'auteur tibtof

2

vous devez rincer votre écrivain.
```
out.flush();
out.close();
```
mettre ces deux lignes après tout, l'écriture est terminé pour fermer le fichier

À proximité se rincer l'écrivain.

OriginalL'auteur reggaemuffin
2

Suivez ces séquences pour réussir à écrire dans un fichier....
```
File f = new File("d:\\test.txt");
FileWriter fw = new FileWriter(f);
BufferedWriter bw = new BufferedWriter(fw);
bw.write("Hello........");        //Writing to the file
bw.close();                       //Close the BufferedWriter
fw.close();                       //Close the FileWriter
```
De fermeture de Flux sont importants....

Le bw.close() déjà près fw.close(), de sorte que votre argument est invalide. Voir aussi, entre autres stackoverflow.com/questions/6366385/decorator-pattern-for-io
Ouais, c'est vrai la fermeture de l'Emballage Tampon va fermer le Flux de données à l'intérieur, mais j'ai donné un énoncé général ici, il n'est pas nécessaire que toujours un tampon sera utilisé. Alors avant de vous la marque de quelqu'un d'autre argument invalide, veuillez lire attentivement, pour qui le contexte de son dit

OriginalL'auteur Kumar Vivek Mitra

    import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class TestAndDelete {
public static void main(String[] args) throws IOException {
String test="hi how are you";
File file =new File("D:/abcd/ravi.json");
FileWriter fw=new FileWriter(file.getAbsoluteFile());
BufferedWriter bw=new BufferedWriter(fw);
bw.append(test);
bw.close();
}
}

OriginalL'auteur Ravi Kumar

Vous devez vous connecter pour publier un commentaire.