I have used http://opencsv.sourceforge.net in java

Hi, This is the code to update CSV by specifying row and column

/**
 * Update CSV by row and column
 * 
 * @param fileToUpdate CSV file path to update e.g. D:\\chetan\\test.csv
 * @param replace Replacement for your cell value
 * @param row Row for which need to update 
 * @param col Column for which you need to update
 * @throws IOException
 */
public static void updateCSV(String fileToUpdate, String replace,
    int row, int col) throws IOException {

File inputFile = new File(fileToUpdate);

// Read existing file 
CSVReader reader = new CSVReader(new FileReader(inputFile), ',');
List<String[]> csvBody = reader.readAll();
// get CSV row column  and replace with by using row and column
csvBody.get(row)[col] = replace;
reader.close();

// Write to CSV file which is open
CSVWriter writer = new CSVWriter(new FileWriter(inputFile), ',');
writer.writeAll(csvBody);
writer.flush();
writer.close();
}

This solution worked for me, Cheers!

If you want to create a new file and have the same lines plus comment there, you can do it like this (using java.nio for file system access and java 8 iterations):

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.ArrayList;
import java.util.List;

public class Main {

    public static void main(String[] args) {

        // the path to your source file as a String
        String fileLocation = "Y:\\our\\path\\to\\lain.csv";
        // the path to your source file as a Path object (java.nio)
        Path filePath = Paths.get(fileLocation);
        // a list of Strings for the new lines, those with a comment separated by |
        List<String> updatedLines = new ArrayList<String>();

        try {
            // read all the lines of the csv source file into a list
            List<String> lines = Files.readAllLines(filePath, StandardCharsets.ISO_8859_1);

            System.out.println("————————————————————————————————————————————————————————————————");

            // print each line just to see if everything is properly read (the java 8 way)
            lines.forEach(line -> {
                System.out.println(line);
            });

            System.out.println("————————————————————————————————————————————————————————————————");

            // add a comment to each line and store it in the updatedLines 
            lines.forEach(line -> {
                /*
                 * TODO add some line-depending comment creation logic here,
                 * this just adds "a comment" to every line
                 */
                updatedLines.add(line + "|" + "a comment");
            });

            // print the updated lines
            updatedLines.forEach(updatedLine -> {
                System.out.println(updatedLine);
            });

            System.out.println("————————————————————————————————————————————————————————————————");

            // create a new file
            String updatedFileLocation = "Y:\\our\\path\\to\\lain_updated.csv";
            Path updatedFilePath = Paths.get(updatedFileLocation);
            Files.createFile(updatedFilePath);

            // write the updated lines to a new csv file
            Files.write(updatedFilePath, updatedLines,
                    StandardOpenOption.TRUNCATE_EXISTING);

            // final check: read the new file and print its content:
            Files.readAllLines(updatedFilePath).forEach(writtenUpdatedLine -> {
                System.out.println(writtenUpdatedLine);
            });
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Rather than reinventing the wheel you could have a look at OpenCSV which supports reading and writing of CSV files. Here are examples of reading & writing

Create a class to store the header values, and store it in the list. Iterate over the list to save the results.

The currently used map can only store 2 values (which it is storing the header value (name its corresponding value)

map.put(d[0], d[1]); here d[0] will be header1 and d[1] will be 4 (but we want only 4 from here)

    class Headervalues {
    String[] header = new String[3];
}

public void readLogFile() throws Exception
{
    List<HeaderValues> list = new ArrayList<>();
    String currentLine = "";
    BufferedReader reader = new BufferedReader(new FileReader(file(false)));
    while ((currentLine = reader.readLine()) != null)
    {
        if (currentLine.contains("2016") && currentLine.contains("helloworld"))
        {

                String nextBlock = replaceAll(currentLine.substring(22, currentLine.length());

                String[] data = nextBlock.split(";");
                HeaderValues headerValues = new HeaderValues();
                //Assuming data.length will always be 3.
                for (int i = 0, max = data.length; i < max; i++)
                {
                    String[] d = data[i].split("=");
                    //Assuming split will always have size 2
                   headerValues.header[i] = d[1];
                }
                list.add(headerValues)
            }
        }
    }
    reader.close();
}
public void writeContentToCsv() throws Exception
{
    FileWriter writer = new FileWriter(".../file_new.csv");
    for (HeaderValues value : headerValues)
    {
        writer.append(value.header[0]).append(";").append(value.header[1]).append(";").append(value.header[2]);
    }
    writer.close();
}

java.nio.file package now contains the Watch Service API. This, effectively:

This API enables you to register a directory (or directories) with the watch service. When registering, you tell the service which types of events you are interested in: file creation, file deletion, or file modification. When the service detects an event of interest, it is forwarded to the registered process. The registered process has a thread (or a pool of threads) dedicated to watching for any events it has registered for. When an event comes in, it is handled as needed.

See reference here.

Oh! This API is only available from JDK 7 (onwards).

Not how it works. Think of a disk: It's a bit like a giant, single-floor hotel with a few billion rooms.

Now imagine that in this hotel you have all the olympians signed in, and they're all in consecutive rooms, sorted on country and then name.

And then a new olympian signs in as a late arrival. You can't just 'update' your hotel and give this olympian a room. Nono, you have to tell about half of the olympians to move one room over to the right, to make room.

Disks are the same. If you want to 'overwrite in place' (say, swap one of the olympians out with another one, in disk terms: Change the value of an existing byte within a file with another value), that's possible, and you'd need to use java's RandomAccessFile and a few other rather more specialized classes to do so, it's not a common task.

But for the vast majority of file updates, you don't get to do it in terms of fixed sizing, and then the notion of 'update in place' is out the window, as far as the disk is concerned.

What you CAN do, however, is this somewhat common task, which ensures that other processes running on that hardware always observe consistent data:

Let's say the hotel is represented by a file on disk that just lists the name of the olympian on a line, and then the next olympian on the next line, and so forth.

To add a new olympian so that the rest of the system always gets a consistent view:

• Make a new file named e.g. olympians.txt.new.123981329183 (that number is just randomly generated to avoid conflicts), and start copying the data over from the old file.
• During the copy operation, 'fix' the file, as in, insert the new olympian in the right spot.
• When you're done close the file, and then use Files.move() with the ATOMIC_MOVE flag, in order to ask java to ask the OS to rename olympians.txt.new.123981329183 to olympians.txt, in an atomic fashion: Any process that opens olympians.txt either opens the old file or the new file, and regardless of which one they got, they always get the complete view; it's not possible to see the new file but only halfway through, or what not.

In that model, as far as the harddisk is concerned, you have 2 utterly different files, but paths (filenames) are just pointers to a spot on the disk, that's all they are. As far as software running on that hardware is concerned, there is only ever one file, it is called olympians.txt, if you open it is it always complete and consistent. When new olympians show up, eventually opening that file will include their name, and it'll be in the right place.

Summary:

• If you want to replace values without changing any sizes, this is technically possible but not in an atomic fashion, and requires specialized JDK classes, such as RandomAccessFile.
• If you want to remove or add data (change sizes), what you want is, as far as the harddisk is concerned, impossible.
• You can, however, make it look like there is just the one file that is always consistent and gets updated from time to time, copy the file over and rotate it back into the right name using java.nio.file.Files's move method, making sure you use the StandardCopyOperation.ATOMIC_MOVE flag.

Take a look at OpenCSV.

UPDATE: Here's some (barely) pseudocode to give a general idea of how you would use OpenCSV for this:

CSVReader reader = new CSVReader(new FileReader("old.csv"));
CSVWriter writer = new CSVWriter(new FileWriter("new.csv"));
String [] nextLine;
while ((nextLine = reader.readNext()) != null) {
    List<String> lineAsList = new ArrayList<String>(Arrays.asList(nextLine));
    // Add stuff using linesAsList.add(index, newValue) as many times as you need.
    writer.writeNext(lineAsList.toArray());
}

Hat-tip: @Mark Peters who points out that you can't update the results of Arrays.asList

Personally I would recommend that you open a second CSVWriter to a new file (data3.csv) and as you read from data1 you write to data3 changing what data needs to be modified. This way if you have a failure for whatever reason you still have your original file. And at the end if you want only one file you can delete data1 and rename data3.csv to data1.csv.

There was a previous question where someone was trying to read and write into the same file at the same time (Reading from a CSV file and writing to a new CSV file using openCSV in java) but there again I would advise against that in case of an error.

The task aims to replace certain data in a database table with corresponding values in a CSV file. To use Java directly for doing this requires loading the CSV file to the database and store it as a temporary table. That’s a hassle.

It is easy to do this using Java’s open-source package SPL. You just need one line of code:

SPL offers JDBC driver to be invoked by Java. Just store the above SPL script as update.splx and invoke it in Java as you call a stored procedure:

…

Class.forName("com.esproc.jdbc.InternalDriver");

con = DriverManager.getConnection("jdbc:esproc:local://");

st = con.prepareCall("call update ()");

st.execute();

…

Or execute the SPL string within a Java program as we execute a SQL statement:

…

st = con.prepareStatement("==RDB.update@u(file(\"update_info.csv\").import@ct(),
infotable,link_name,title,browser_title)");

st.execute();

…

View SPL source code.