Comment ajouter du texte à un fichier existant en Java


Réponses:


793

Faites-vous cela à des fins de journalisation? Si c'est le cas, il existe plusieurs bibliothèques pour cela . Deux des plus populaires sont Log4j et Logback .

Java 7+

Si vous avez juste besoin de le faire une seule fois, la classe Files vous facilite la tâche:

try {
    Files.write(Paths.get("myfile.txt"), "the text".getBytes(), StandardOpenOption.APPEND);
}catch (IOException e) {
    //exception handling left as an exercise for the reader
}

Attention : l'approche ci-dessus lancera un NoSuchFileExceptionsi le fichier n'existe pas déjà. Il n'ajoute pas non plus automatiquement une nouvelle ligne (ce que vous souhaitez souvent lors de l'ajout à un fichier texte). La réponse de Steve Chambers couvre comment vous pourriez faire cela avec la Filesclasse.

Cependant, si vous écrivez plusieurs fois dans le même fichier, ce qui précède doit ouvrir et fermer le fichier sur le disque plusieurs fois, ce qui est une opération lente. Dans ce cas, un écrivain tamponné est préférable:

try(FileWriter fw = new FileWriter("myfile.txt", true);
    BufferedWriter bw = new BufferedWriter(fw);
    PrintWriter out = new PrintWriter(bw))
{
    out.println("the text");
    //more code
    out.println("more text");
    //more code
} catch (IOException e) {
    //exception handling left as an exercise for the reader
}

Remarques:

  • Le deuxième paramètre du FileWriterconstructeur lui indiquera de s'ajouter au fichier, plutôt que d'écrire un nouveau fichier. (Si le fichier n'existe pas, il sera créé.)
  • L'utilisation d'un BufferedWriterest recommandée pour un écrivain cher (comme FileWriter).
  • L'utilisation de a PrintWritervous donne accès à la printlnsyntaxe à laquelle vous êtes probablement habitué System.out.
  • Mais les wrappers BufferedWriteret PrintWriterne sont pas strictement nécessaires.

Java plus ancien

try {
    PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("myfile.txt", true)));
    out.println("the text");
    out.close();
} catch (IOException e) {
    //exception handling left as an exercise for the reader
}

Gestion des exceptions

Si vous avez besoin d'une gestion des exceptions robuste pour les anciens Java, cela devient très détaillé:

FileWriter fw = null;
BufferedWriter bw = null;
PrintWriter out = null;
try {
    fw = new FileWriter("myfile.txt", true);
    bw = new BufferedWriter(fw);
    out = new PrintWriter(bw);
    out.println("the text");
    out.close();
} catch (IOException e) {
    //exception handling left as an exercise for the reader
}
finally {
    try {
        if(out != null)
            out.close();
    } catch (IOException e) {
        //exception handling left as an exercise for the reader
    }
    try {
        if(bw != null)
            bw.close();
    } catch (IOException e) {
        //exception handling left as an exercise for the reader
    }
    try {
        if(fw != null)
            fw.close();
    } catch (IOException e) {
        //exception handling left as an exercise for the reader
    }
}

31
Vous devez soit utiliser java7 try-with-resources, soit placer le close () dans un bloc finally, afin de vous assurer que le fichier est fermé en cas d'exception
Svetlin Zarev

1
mis à jour avec la syntaxe Java 7. la gestion des exceptions reste un exercice pour le lecteur, mais a clarifié le commentaire.
Kip

3
Imaginons que new BufferedWriter(...)lève une exception; Sera-t- FileWriteril fermé? Je suppose qu'il ne sera pas fermé, car la close()méthode (dans des conditions normales) sera invoquée sur l' outobjet, qui dans ce cas ne sera pas initialisé - donc en fait la close()méthode ne sera pas invoquée -> le fichier sera ouvert, mais ne sera pas fermé. Donc, à mon humble avis, la trydéclaration devrait ressembler à ceci try(FileWriter fw = new FileWriter("myFile.txt")){ Print writer = new ....//code goes here } Et il devrait flush()l'écrivain avant de quitter le trybloc !!!
Svetlin Zarev

5
Attention, l'exemple "Older java" ne fermera pas correctement le flux si une exception est levée à l'intérieur du bloc try.
Emily L.

1
Quelques "pièges" possibles avec la méthode Java 7: (1) Si le fichier n'existe pas déjà, StandardOpenOption.APPENDne le créera pas - un peu comme un échec silencieux car il ne lèvera pas non plus d'exception. (2) L'utilisation .getBytes()signifie qu'il n'y a pas de caractère de retour avant ou après le texte ajouté. Ont ajouté une réponse alternative pour y remédier.
Steve Chambers

166

Vous pouvez utiliser fileWriteravec un indicateur défini sur true, pour l'ajout.

try
{
    String filename= "MyFile.txt";
    FileWriter fw = new FileWriter(filename,true); //the true will append the new data
    fw.write("add a line\n");//appends the string to the file
    fw.close();
}
catch(IOException ioe)
{
    System.err.println("IOException: " + ioe.getMessage());
}

9
closedevrait être placé dans le finallybloc comme indiqué dans la réponse de @ etech au cas où une exception serait levée entre la création de FileWriter et l'invocation de close.
Pshemo

5
Bonne réponse, bien qu'il soit préférable d'utiliser System.getProperty ("line.separator") pour une nouvelle ligne plutôt que "\ n".
Henry Zhu

@ Décodé J'ai annulé votre modification sur cette réponse, car elle ne se compile pas.
Kip

@Kip, quel était le problème? Je dois avoir entré une "faute de frappe".
Décodé

2
Que diriez-vous d'essayer avec des ressources? try(FileWriter fw = new FileWriter(filename,true)){ // Whatever }catch(IOException ex){ ex.printStackTrace(); }
php_coder_3809625

72

Toutes les réponses ici avec les blocs try / catch ne devraient-elles pas avoir les pièces .close () contenues dans un bloc finally?

Exemple de réponse marquée:

PrintWriter out = null;
try {
    out = new PrintWriter(new BufferedWriter(new FileWriter("writePath", true)));
    out.println("the text");
} catch (IOException e) {
    System.err.println(e);
} finally {
    if (out != null) {
        out.close();
    }
} 

De plus, à partir de Java 7, vous pouvez utiliser une instruction try-with-resources . Aucun bloc enfin n'est requis pour fermer la ou les ressources déclarées car elles sont gérées automatiquement et sont également moins verbeuses:

try(PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("writePath", true)))) {
    out.println("the text");
} catch (IOException e) {
    System.err.println(e);
}

1
Quand outsort de la portée, il est automatiquement fermé lorsqu'il est récupéré, non? Dans votre exemple avec le finallybloc, je pense que vous avez réellement besoin d'un autre essai / rattrapage imbriqué out.close()si je me souviens bien. La solution Java 7 est assez simple! (Je n'ai fait aucun développement Java depuis Java 6, donc je ne connaissais pas ce changement.)
Kip

1
@Kip Nope, sortir du champ d'application ne fait rien en Java. Le fichier sera fermé à un moment aléatoire dans le futur. (probablement à la fermeture du programme)
Navin

@etech La seconde approche aura-t-elle besoin de la flushméthode?
syfantid

43

Modifier - à partir d'Apache Commons 2.1, la bonne façon de le faire est:

FileUtils.writeStringToFile(file, "String to append", true);

J'ai adapté la solution de @ Kip pour inclure la fermeture correcte du fichier enfin:

public static void appendToFile(String targetFile, String s) throws IOException {
    appendToFile(new File(targetFile), s);
}

public static void appendToFile(File targetFile, String s) throws IOException {
    PrintWriter out = null;
    try {
        out = new PrintWriter(new BufferedWriter(new FileWriter(targetFile, true)));
        out.println(s);
    } finally {
        if (out != null) {
            out.close();
        }
    }
}


5
Oh merci. J'ai été amusé par la complexité de toutes les autres réponses. Je ne comprends vraiment pas pourquoi les gens aiment compliquer leur vie (de développeur).
Alphaaa

Le problème avec cette approche est qu'elle ouvre et ferme le flux de sortie à chaque fois. Selon ce que vous écrivez dans votre fichier et à quelle fréquence, cela peut entraîner des frais généraux ridicules.
Buffalo

@Buffalo a raison. Mais vous pouvez toujours utiliser StringBuilder pour construire de gros morceaux (qui valent la peine d'être écrits) avant de les écrire dans un fichier.
Konstantin K

32

Pour développer légèrement la réponse de Kip , voici une méthode Java 7+ simple pour ajouter une nouvelle ligne à un fichier, en la créant si elle n'existe pas déjà :

try {
    final Path path = Paths.get("path/to/filename.txt");
    Files.write(path, Arrays.asList("New line to append"), StandardCharsets.UTF_8,
        Files.exists(path) ? StandardOpenOption.APPEND : StandardOpenOption.CREATE);
} catch (final IOException ioe) {
    // Add your own exception handling...
}

Remarque: ce qui précède utilise la Files.writesurcharge qui écrit des lignes de texte dans un fichier (c'est-à-dire similaire à une printlncommande). Pour simplement écrire du texte à la fin (c'est-à-dire similaire à une printcommande), une Files.writesurcharge alternative peut être utilisée, en passant dans un tableau d'octets (par exemple "mytext".getBytes(StandardCharsets.UTF_8)).


Avez-vous besoin de vérifier si le fichier existe? Je pensais .CREATEfaire le travail pour toi.
LearningToJava

22

Assurez-vous que le flux est correctement fermé dans tous les scénarios.

Il est un peu alarmant de savoir combien de ces réponses laissent le descripteur de fichier ouvert en cas d'erreur. La réponse https://stackoverflow.com/a/15053443/2498188 est sur l'argent mais seulement parce BufferedWriter()qu'il ne peut pas lancer. Si c'était le cas, une exception laisserait l' FileWriterobjet ouvert.

Une façon plus générale de faire cela, peu importe si BufferedWriter()peut lancer:

  PrintWriter out = null;
  BufferedWriter bw = null;
  FileWriter fw = null;
  try{
     fw = new FileWriter("outfilename", true);
     bw = new BufferedWriter(fw);
     out = new PrintWriter(bw);
     out.println("the text");
  }
  catch( IOException e ){
     // File writing/opening failed at some stage.
  }
  finally{
     try{
        if( out != null ){
           out.close(); // Will close bw and fw too
        }
        else if( bw != null ){
           bw.close(); // Will close fw too
        }
        else if( fw != null ){
           fw.close();
        }
        else{
           // Oh boy did it fail hard! :3
        }
     }
     catch( IOException e ){
        // Closing the file writers failed for some obscure reason
     }
  }

Éditer:

Depuis Java 7, la méthode recommandée consiste à utiliser "essayer avec les ressources" et à laisser la JVM s'en occuper:

  try(    FileWriter fw = new FileWriter("outfilename", true);
          BufferedWriter bw = new BufferedWriter(fw);
          PrintWriter out = new PrintWriter(bw)){
     out.println("the text");
  }  
  catch( IOException e ){
      // File writing/opening failed at some stage.
  }

+1 pour ARM correct avec Java 7. Voici une bonne question sur ce thème délicat: stackoverflow.com/questions/12552863/… .
Vadzim

1
Hmm, pour une raison quelconque, PrintWriter.close()n'est pas déclaré comme throws IOExceptiondans les documents . En regardant sa source , la close()méthode, en effet, ne peut pas lancer IOException, car elle l'attrape du flux sous-jacent et définit un indicateur. Donc, si vous travaillez sur le code de la prochaine navette spatiale ou d'un système de mesure de dose de rayons X, vous devez l'utiliser PrintWriter.checkError()après avoir essayé out.close(). Cela aurait vraiment dû être documenté.
Evgeni Sergeev

Si nous allons être super paranoïaques à propos de la fermeture, chacun de ceux-ci XX.close()devrait être dans son propre try / catch, non? Par exemple, out.close()pourrait lever une exception, auquel cas bw.close()et fw.close()ne serait jamais appelé, et fwc'est celle qui est la plus critique à fermer.
Kip

13

En Java-7, cela peut également être fait de la sorte:

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

// ---------------------

Path filePath = Paths.get("someFile.txt");
if (!Files.exists(filePath)) {
    Files.createFile(filePath);
}
Files.write(filePath, "Text to be added".getBytes(), StandardOpenOption.APPEND);

2
Quelles sont les importations requises? Quelle bibliothèque ces choses utilisent-elles?
Chetan Bhasin

9

java 7+

À mon humble avis puisque je suis fan de java ordinaire, je dirais que c'est une combinaison des réponses susmentionnées. Je suis peut-être en retard pour la fête. Voici le code:

 String sampleText = "test" +  System.getProperty("line.separator");
 Files.write(Paths.get(filePath), sampleText.getBytes(StandardCharsets.UTF_8), 
 StandardOpenOption.CREATE, StandardOpenOption.APPEND);

Si le fichier n'existe pas, il le crée et s'il existe déjà, il ajoute le sampleText au fichier existant. Cela vous évite d'ajouter des bibliothèques inutiles à votre chemin de classe.


8

Cela peut être fait sur une seule ligne de code. J'espère que cela t'aides :)

Files.write(Paths.get(fileName), msg.getBytes(), StandardOpenOption.APPEND);

1
sa peut ne pas suffire :) la meilleure version est Files.write (Paths.get (fileName), msg.getBytes (), StandardOpenOption.APPEND, StandardOpenOption.CREATE);
evg345

6

Utilisation de java.nio. Fichiers avec java.nio.file. StandardOpenOption

    PrintWriter out = null;
    BufferedWriter bufWriter;

    try{
        bufWriter =
            Files.newBufferedWriter(
                Paths.get("log.txt"),
                Charset.forName("UTF8"),
                StandardOpenOption.WRITE, 
                StandardOpenOption.APPEND,
                StandardOpenOption.CREATE);
        out = new PrintWriter(bufWriter, true);
    }catch(IOException e){
        //Oh, no! Failed to create PrintWriter
    }

    //After successful creation of PrintWriter
    out.println("Text to be appended");

    //After done writing, remember to close!
    out.close();

Cela crée un BufferedWriterfichier à l'aide, qui accepte les StandardOpenOptionparamètres, et un vidage automatique PrintWriterde la résultante BufferedWriter. PrintWriterde » println()la méthode, peut être appelé à écrire dans le fichier.

Les StandardOpenOptionparamètres utilisés dans ce code: ouvre le fichier pour l'écriture, l'ajoute uniquement au fichier et crée le fichier s'il n'existe pas.

Paths.get("path here")peut être remplacé par new File("path here").toPath(). Et Charset.forName("charset name")peut être modifié pour accueillir le souhaité Charset.


5

J'ajoute juste un petit détail:

    new FileWriter("outfilename", true)

2. Le paramètre (true) est une fonctionnalité (ou interface) appelée appendable ( http://docs.oracle.com/javase/7/docs/api/java/lang/Appendable.html ). Il est responsable de pouvoir ajouter du contenu à la fin d'un fichier / flux particulier. Cette interface est implémentée depuis Java 1.5. Chaque objet (c.-à-d. BufferedWriter, CharArrayWriter, CharBuffer, FileWriter, FilterWriter, LogStream, OutputStreamWriter, PipedWriter, PrintStream, PrintWriter, StringBuffer, StringBuilder, StringWriter, Writer ) avec cette interface peut être utilisé pour ajouter du contenu

En d'autres termes, vous pouvez ajouter du contenu à votre fichier compressé ou un processus http


4

Exemple, en utilisant la goyave:

File to = new File("C:/test/test.csv");

for (int i = 0; i < 42; i++) {
    CharSequence from = "some string" + i + "\n";
    Files.append(from, to, Charsets.UTF_8);
}

13
C'est un conseil horrible. Vous ouvrez un flux vers le fichier 42 fois au lieu d'une fois.
xehpuk

3
@xehpuk bien, cela dépend. 42 est toujours correct, s'il rend le code beaucoup plus lisible. 42k ne serait pas acceptable.
dantuch

4

Essayez avec bufferFileWriter.append, cela fonctionne avec moi.

FileWriter fileWriter;
try {
    fileWriter = new FileWriter(file,true);
    BufferedWriter bufferFileWriter = new BufferedWriter(fileWriter);
    bufferFileWriter.append(obj.toJSONString());
    bufferFileWriter.newLine();
    bufferFileWriter.close();
} catch (IOException ex) {
    Logger.getLogger(JsonTest.class.getName()).log(Level.SEVERE, null, ex);
}

qu'est-ce que obj.toJSONString () ici?
Bhaskara Arani du

@BhaskaraArani Ce n'est qu'une chaîne, il a mis un exemple d'un objet JSON converti en chaîne mais l'idée est que ce pourrait être n'importe quelle chaîne.
Gherbi Hicham

3
    String str;
    String path = "C:/Users/...the path..../iin.txt"; // you can input also..i created this way :P

    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    PrintWriter pw = new PrintWriter(new FileWriter(path, true));

    try 
    {
       while(true)
        {
            System.out.println("Enter the text : ");
            str = br.readLine();
            if(str.equalsIgnoreCase("exit"))
                break;
            else
                pw.println(str);
        }
    } 
    catch (Exception e) 
    {
        //oh noes!
    }
    finally
    {
        pw.close();         
    }

cela fera ce que vous avez l'intention de faire ..


3

Mieux vaut essayer avec des ressources que tout ce qui précède enfin Java 7

static void appendStringToFile(Path file, String s) throws IOException  {
    try (BufferedWriter out = Files.newBufferedWriter(file, StandardCharsets.UTF_8, StandardOpenOption.APPEND)) {
        out.append(s);
        out.newLine();
    }
}

3

Si nous utilisons Java 7 et supérieur et connaissons également le contenu à ajouter (ajouté) au fichier, nous pouvons utiliser la méthode newBufferedWriter dans le package NIO.

public static void main(String[] args) {
    Path FILE_PATH = Paths.get("C:/temp", "temp.txt");
    String text = "\n Welcome to Java 8";

    //Writing to the file temp.txt
    try (BufferedWriter writer = Files.newBufferedWriter(FILE_PATH, StandardCharsets.UTF_8, StandardOpenOption.APPEND)) {
        writer.write(text);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Il y a quelques points à noter:

  1. C'est toujours une bonne habitude de spécifier le codage du jeu de caractères et pour cela nous avons une constante en classe StandardCharsets.
  2. Le code utilise une try-with-resourceinstruction dans laquelle les ressources sont automatiquement fermées après l'essai.

Bien que OP ne l'ait pas demandé, mais juste au cas où nous souhaiterions rechercher des lignes ayant un mot clé spécifique, par exemple, confidentialnous pouvons utiliser des API de flux en Java:

//Reading from the file the first line which contains word "confidential"
try {
    Stream<String> lines = Files.lines(FILE_PATH);
    Optional<String> containsJava = lines.filter(l->l.contains("confidential")).findFirst();
    if(containsJava.isPresent()){
        System.out.println(containsJava.get());
    }
} catch (IOException e) {
    e.printStackTrace();
}

une mise en garde: lors de l'utilisation de BufferedWriter write(String string)si l'on s'attend à une nouvelle ligne après chaque chaîne écrite, newLine()doit être appelée
yongtw123

3
FileOutputStream fos = new FileOutputStream("File_Name", true);
fos.write(data);

le vrai permet d'ajouter les données dans le fichier existant. Si nous écrivons

FileOutputStream fos = new FileOutputStream("File_Name");

Il écrasera le fichier existant. Alors optez pour la première approche.


3
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class Writer {


    public static void main(String args[]){
        doWrite("output.txt","Content to be appended to file");
    }

    public static void doWrite(String filePath,String contentToBeAppended){

       try(
            FileWriter fw = new FileWriter(filePath, true);
            BufferedWriter bw = new BufferedWriter(fw);
            PrintWriter out = new PrintWriter(bw)
          )
          {
            out.println(contentToBeAppended);
          }  
        catch( IOException e ){
        // File writing/opening failed at some stage.
        }

    }

}

Ce qui précède n'est qu'un exemple rapide de mise en œuvre de la solution présentée sur ce lien . Ainsi, vous pouvez copier et exécuter le code et voir immédiatement comment cela fonctionne, assurez-vous que le fichier output.out se trouve dans le même répertoire que le fichier Writer.java
David Charles

2
FileOutputStream stream = new FileOutputStream(path, true);
try {

    stream.write(

        string.getBytes("UTF-8") // Choose your encoding.

    );

} finally {
    stream.close();
}

Attrapez ensuite une IOException quelque part en amont.


2

Créez une fonction n'importe où dans votre projet et appelez simplement cette fonction là où vous en avez besoin.

Les gars, vous devez vous rappeler que vous appelez les threads actifs que vous n'appelez pas de manière asynchrone et que ce serait probablement de 5 à 10 pages pour le faire correctement. Pourquoi ne pas consacrer plus de temps à votre projet et oublier d'écrire tout ce qui a déjà été écrit. Correctement

    //Adding a static modifier would make this accessible anywhere in your app

    public Logger getLogger()
    {
       return java.util.logging.Logger.getLogger("MyLogFileName");
    }
    //call the method anywhere and append what you want to log 
    //Logger class will take care of putting timestamps for you
    //plus the are ansychronously done so more of the 
    //processing power will go into your application

    //from inside a function body in the same class ...{...

    getLogger().log(Level.INFO,"the text you want to append");

    ...}...
    /*********log file resides in server root log files********/

trois lignes de code deux vraiment depuis la troisième ajoute réellement du texte. : P


2

Bibliothèque

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

Code

public void append()
{
    try
    {
        String path = "D:/sample.txt";

        File file = new File(path);

        FileWriter fileWriter = new FileWriter(file,true);

        BufferedWriter bufferFileWriter  = new BufferedWriter(fileWriter);

        fileWriter.append("Sample text in the file to append");

        bufferFileWriter.close();

        System.out.println("User Registration Completed");

    }catch(Exception ex)
    {
        System.out.println(ex);
    }
}

2

Vous pouvez également essayer ceci:

JFileChooser c= new JFileChooser();
c.showOpenDialog(c);
File write_file = c.getSelectedFile();
String Content = "Writing into file"; //what u would like to append to the file



try 
{
    RandomAccessFile raf = new RandomAccessFile(write_file, "rw");
    long length = raf.length();
    //System.out.println(length);
    raf.setLength(length + 1); //+ (integer value) for spacing
    raf.seek(raf.length());
    raf.writeBytes(Content);
    raf.close();
} 
catch (Exception e) {
    //any exception handling method of ur choice
}

1

Je pourrais suggérer le projet Apache Commons . Ce projet fournit déjà un cadre pour faire ce dont vous avez besoin (c'est-à-dire un filtrage flexible des collections).


1

La méthode suivante vous permet d'ajouter du texte à un fichier:

private void appendToFile(String filePath, String text)
{
    PrintWriter fileWriter = null;

    try
    {
        fileWriter = new PrintWriter(new BufferedWriter(new FileWriter(
                filePath, true)));

        fileWriter.println(text);
    } catch (IOException ioException)
    {
        ioException.printStackTrace();
    } finally
    {
        if (fileWriter != null)
        {
            fileWriter.close();
        }
    }
}

Vous pouvez également utiliser FileUtils:

public static void appendToFile(String filePath, String text) throws IOException
{
    File file = new File(filePath);

    if(!file.exists())
    {
        file.createNewFile();
    }

    String fileContents = FileUtils.readFileToString(file);

    if(file.length() != 0)
    {
        fileContents = fileContents.concat(System.lineSeparator());
    }

    fileContents = fileContents.concat(text);

    FileUtils.writeStringToFile(file, fileContents);
}

Ce n'est pas efficace mais fonctionne bien. Les sauts de ligne sont traités correctement et un nouveau fichier est créé s'il n'en existe pas encore.



1

Dans le cas où vous souhaitez AJOUTER QUELQUE TEXTE DANS DES LIGNES SPÉCIFIQUES, vous pouvez d'abord lire le fichier entier, ajouter le texte où vous voulez, puis écraser tout comme dans le code ci-dessous:

public static void addDatatoFile(String data1, String data2){


    String fullPath = "/home/user/dir/file.csv";

    File dir = new File(fullPath);
    List<String> l = new LinkedList<String>();

    try (BufferedReader br = new BufferedReader(new FileReader(dir))) {
        String line;
        int count = 0;

        while ((line = br.readLine()) != null) {
            if(count == 1){
                //add data at the end of second line                    
                line += data1;
            }else if(count == 2){
                //add other data at the end of third line
                line += data2;
            }
            l.add(line);
            count++;
        }
        br.close();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }       
    createFileFromList(l, dir);
}

public static void createFileFromList(List<String> list, File f){

    PrintWriter writer;
    try {
        writer = new PrintWriter(f, "UTF-8");
        for (String d : list) {
            writer.println(d.toString());
        }
        writer.close();             
    } catch (FileNotFoundException | UnsupportedEncodingException e) {
        e.printStackTrace();
    }
}

0

Ma réponse:

JFileChooser chooser= new JFileChooser();
chooser.showOpenDialog(chooser);
File file = chooser.getSelectedFile();
String Content = "What you want to append to file";

try 
{
    RandomAccessFile random = new RandomAccessFile(file, "rw");
    long length = random.length();
    random.setLength(length + 1);
    random.seek(random.length());
    random.writeBytes(Content);
    random.close();
} 
catch (Exception exception) {
    //exception handling
}

0
/**********************************************************************
 * it will write content to a specified  file
 * 
 * @param keyString
 * @throws IOException
 *********************************************************************/
public static void writeToFile(String keyString,String textFilePAth) throws IOException {
    // For output to file
    File a = new File(textFilePAth);

    if (!a.exists()) {
        a.createNewFile();
    }
    FileWriter fw = new FileWriter(a.getAbsoluteFile(), true);
    BufferedWriter bw = new BufferedWriter(fw);
    bw.append(keyString);
    bw.newLine();
    bw.close();
}// end of writeToFile()

-1

Vous pouvez utiliser le code suivant pour ajouter le contenu dans le fichier:

 String fileName="/home/shriram/Desktop/Images/"+"test.txt";
  FileWriter fw=new FileWriter(fileName,true);    
  fw.write("here will be you content to insert or append in file");    
  fw.close(); 
  FileWriter fw1=new FileWriter(fileName,true);    
 fw1.write("another content will be here to be append in the same file");    
 fw1.close(); 

-1

1.7 Approche:

void appendToFile(String filePath, String content) throws IOException{

    Path path = Paths.get(filePath);

    try (BufferedWriter writer = 
            Files.newBufferedWriter(path, 
                    StandardOpenOption.APPEND)) {
        writer.newLine();
        writer.append(content);
    }

    /*
    //Alternative:
    try (BufferedWriter bWriter = 
            Files.newBufferedWriter(path, 
                    StandardOpenOption.WRITE, StandardOpenOption.APPEND);
            PrintWriter pWriter = new PrintWriter(bWriter)
            ) {
        pWriter.println();//to have println() style instead of newLine();   
        pWriter.append(content);//Also, bWriter.append(content);
    }*/
}
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.